pax_global_header00006660000000000000000000000064131647121140014512gustar00rootroot0000000000000052 comment=4dc7be5d2d12881735283bcab7352178e190fc71 golang-github-go-kit-kit-0.6.0/000077500000000000000000000000001316471211400162215ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/.gitignore000066400000000000000000000012441316471211400202120ustar00rootroot00000000000000examples/addsvc/addsvc examples/addsvc/client/client examples/apigateway/apigateway examples/profilesvc/profilesvc examples/stringsvc1/stringsvc1 examples/stringsvc2/stringsvc2 examples/stringsvc3/stringsvc3 *.coverprofile # Compiled Object files, Static and Dynamic libs (Shared Objects) *.o *.a *.so # Folders _obj _test _old* # Architecture specific extensions/prefixes *.[568vq] [568vq].out *.cgo1.go *.cgo2.c _cgo_defun.c _cgo_gotypes.go _cgo_export.* _testmain.go *.exe # https://github.com/github/gitignore/blob/master/Global/Vim.gitignore # swap [._]*.s[a-w][a-z] [._]s[a-w][a-z] # session Session.vim # temporary .netrwhist *~ # auto-generated tag files tags golang-github-go-kit-kit-0.6.0/.travis.yml000066400000000000000000000003661316471211400203370ustar00rootroot00000000000000language: go env: - COVERALLS_TOKEN=MYSkSqcsWXd6DmP6TnSeiDhtvuL4u6ndp before_install: - go get github.com/mattn/goveralls - go get github.com/modocache/gover script: - go test -race -v ./... - ./coveralls.bash go: - 1.9.x - tip golang-github-go-kit-kit-0.6.0/CONTRIBUTING.md000066400000000000000000000015071316471211400204550ustar00rootroot00000000000000# Contributing First, thank you for contributing! We love and encourage pull requests from everyone. Before submitting major changes, here are a few guidelines to follow: 1. Check the [open issues][issues] and [pull requests][prs] for existing discussions. 1. Open an [issue][issues] first, to discuss a new feature or enhancement. 1. Write tests, and make sure the test suite passes locally and on CI. 1. Open a pull request, and reference the relevant issue(s). 1. After receiving feedback, [squash your commits][squash] and add a [great commit message][message]. 1. Have fun! [issues]: https://github.com/go-kit/kit/issues [prs]: https://github.com/go-kit/kit/pulls [squash]: http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html [message]: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html golang-github-go-kit-kit-0.6.0/LICENSE000066400000000000000000000020711316471211400172260ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2015 Peter Bourgon Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. golang-github-go-kit-kit-0.6.0/README.md000066400000000000000000000154051316471211400175050ustar00rootroot00000000000000# Go kit [![Circle CI](https://circleci.com/gh/go-kit/kit.svg?style=shield)](https://circleci.com/gh/go-kit/kit) [![Travis CI](https://travis-ci.org/go-kit/kit.svg?branch=master)](https://travis-ci.org/go-kit/kit) [![GoDoc](https://godoc.org/github.com/go-kit/kit?status.svg)](https://godoc.org/github.com/go-kit/kit) [![Coverage Status](https://coveralls.io/repos/go-kit/kit/badge.svg?branch=master&service=github)](https://coveralls.io/github/go-kit/kit?branch=master) [![Go Report Card](https://goreportcard.com/badge/go-kit/kit)](https://goreportcard.com/report/go-kit/kit) [![Sourcegraph](https://sourcegraph.com/github.com/go-kit/kit/-/badge.svg)](https://sourcegraph.com/github.com/go-kit/kit?badge) **Go kit** is a **programming toolkit** for building microservices (or elegant monoliths) in Go. We solve common problems in distributed systems and application architecture so you can focus on delivering business value. - Website: [gokit.io](https://gokit.io) - Mailing list: [go-kit](https://groups.google.com/forum/#!forum/go-kit) - Slack: [gophers.slack.com](https://gophers.slack.com) **#go-kit** ([invite](https://gophersinvite.herokuapp.com/)) ## Motivation Go has emerged as the language of the server, but it remains underrepresented in so-called "modern enterprise" companies like Facebook, Twitter, Netflix, and SoundCloud. Many of these organizations have turned to JVM-based stacks for their business logic, owing in large part to libraries and ecosystems that directly support their microservice architectures. To reach its next level of success, Go needs more than simple primitives and idioms. It needs a comprehensive toolkit, for coherent distributed programming in the large. Go kit is a set of packages and best practices, which provide a comprehensive, robust, and trustable way of building microservices for organizations of any size. For more details, see [the website](https://gokit.io), [the motivating blog post](http://peter.bourgon.org/go-kit/) and [the video of the talk](https://www.youtube.com/watch?v=iFR_7AKkJFU). See also the [Go kit talk at GopherCon 2015](https://www.youtube.com/watch?v=1AjaZi4QuGo). ## Goals - Operate in a heterogeneous SOA — expect to interact with mostly non-Go-kit services - RPC as the primary messaging pattern - Pluggable serialization and transport — not just JSON over HTTP - Operate within existing infrastructures — no mandates for specific tools or technologies ## Non-goals - Supporting messaging patterns other than RPC (for now) — e.g. MPI, pub/sub, CQRS, etc. - Re-implementing functionality that can be provided by adapting existing software - Having opinions on operational concerns: deployment, configuration, process supervision, orchestration, etc. ## Contributing Please see [CONTRIBUTING.md](/CONTRIBUTING.md). Thank you, [contributors](https://github.com/go-kit/kit/graphs/contributors)! ## Dependency management Go kit is a library, designed to be imported into a binary package. Vendoring is currently the best way for binary package authors to ensure reliable, reproducible builds. Therefore, we strongly recommend our users use vendoring for all of their dependencies, including Go kit. To avoid compatibility and availability issues, Go kit doesn't vendor its own dependencies, and doesn't recommend use of third-party import proxies. There are several tools which make vendoring easier, including [dep](https://github.com/golang/dep), [gb](http://getgb.io), [glide](https://github.com/Masterminds/glide), [gvt](https://github.com/FiloSottile/gvt), and [govendor](https://github.com/kardianos/govendor). In addition, Go kit uses a variety of continuous integration providers to find and fix compatibility problems as soon as they occur. ## Related projects Projects with a ★ have had particular influence on Go kit's design (or vice-versa). ### Service frameworks - [gizmo](https://github.com/nytimes/gizmo), a microservice toolkit from The New York Times ★ - [go-micro](https://github.com/myodc/go-micro), a microservices client/server library ★ - [gotalk](https://github.com/rsms/gotalk), async peer communication protocol & library - [Kite](https://github.com/koding/kite), a micro-service framework - [gocircuit](https://github.com/gocircuit/circuit), dynamic cloud orchestration ### Individual components - [afex/hystrix-go](https://github.com/afex/hystrix-go), client-side latency and fault tolerance library - [armon/go-metrics](https://github.com/armon/go-metrics), library for exporting performance and runtime metrics to external metrics systems - [codahale/lunk](https://github.com/codahale/lunk), structured logging in the style of Google's Dapper or Twitter's Zipkin - [eapache/go-resiliency](https://github.com/eapache/go-resiliency), resiliency patterns - [sasbury/logging](https://github.com/sasbury/logging), a tagged style of logging - [grpc/grpc-go](https://github.com/grpc/grpc-go), HTTP/2 based RPC - [inconshreveable/log15](https://github.com/inconshreveable/log15), simple, powerful logging for Go ★ - [mailgun/vulcand](https://github.com/vulcand/vulcand), programmatic load balancer backed by etcd - [mattheath/phosphor](https://github.com/mondough/phosphor), distributed system tracing - [pivotal-golang/lager](https://github.com/pivotal-golang/lager), an opinionated logging library - [rubyist/circuitbreaker](https://github.com/rubyist/circuitbreaker), circuit breaker library - [Sirupsen/logrus](https://github.com/Sirupsen/logrus), structured, pluggable logging for Go ★ - [sourcegraph/appdash](https://github.com/sourcegraph/appdash), application tracing system based on Google's Dapper - [spacemonkeygo/monitor](https://github.com/spacemonkeygo/monitor), data collection, monitoring, instrumentation, and Zipkin client library - [streadway/handy](https://github.com/streadway/handy), net/http handler filters - [vitess/rpcplus](https://godoc.org/github.com/youtube/vitess/go/rpcplus), package rpc + context.Context - [gdamore/mangos](https://github.com/gdamore/mangos), nanomsg implementation in pure Go ### Web frameworks - [Gorilla](http://www.gorillatoolkit.org) - [Gin](https://gin-gonic.github.io/gin/) - [Negroni](https://github.com/codegangsta/negroni) - [Goji](https://github.com/zenazn/goji) - [Martini](https://github.com/go-martini/martini) - [Beego](http://beego.me/) - [Revel](https://revel.github.io/) (considered [harmful](https://github.com/go-kit/kit/issues/350)) ## Additional reading - [Architecting for the Cloud](http://fr.slideshare.net/stonse/architecting-for-the-cloud-using-netflixoss-codemash-workshop-29852233) — Netflix - [Dapper, a Large-Scale Distributed Systems Tracing Infrastructure](http://research.google.com/pubs/pub36356.html) — Google - [Your Server as a Function](http://monkey.org/~marius/funsrv.pdf) (PDF) — Twitter --- Development supported by [DigitalOcean](https://digitalocean.com). golang-github-go-kit-kit-0.6.0/ROADMAP.md000066400000000000000000000007331316471211400176310ustar00rootroot00000000000000# Roadmap This is a coarse-grained roadmap of Go kit development direction in the short to mid-term future. It will be kept reasonably up-to-date by the project maintainers. Suggest new ideas, enhancements, and features using the standard [issues](https://github.com/go-kit/kit/issues) model. ## Prioritized 1. kitgen code generation (#308, #70) 1. package pubsub (#298, #295) ## Unprioritized - package log/levels refactor (#250, #269, #252) - package auth/jwt (#255) golang-github-go-kit-kit-0.6.0/auth/000077500000000000000000000000001316471211400171625ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/auth/basic/000077500000000000000000000000001316471211400202435ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/auth/basic/README.md000066400000000000000000000015621316471211400215260ustar00rootroot00000000000000This package provides a Basic Authentication middleware. It'll try to compare credentials from Authentication request header to a username/password pair in middleware constructor. More details about this type of authentication can be found in [Mozilla article](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). ## Usage ```go import httptransport "github.com/go-kit/kit/transport/http" httptransport.NewServer( AuthMiddleware(cfg.auth.user, cfg.auth.password, "Example Realm")(makeUppercaseEndpoint()), decodeMappingsRequest, httptransport.EncodeJSONResponse, httptransport.ServerBefore(httptransport.PopulateRequestContext), ) ``` For AuthMiddleware to be able to pick up the Authentication header from an HTTP request we need to pass it through the context with something like ```httptransport.ServerBefore(httptransport.PopulateRequestContext)```.golang-github-go-kit-kit-0.6.0/auth/basic/middleware.go000066400000000000000000000047671316471211400227250ustar00rootroot00000000000000package basic import ( "bytes" "context" "crypto/sha256" "crypto/subtle" "encoding/base64" "fmt" "net/http" "strings" "github.com/go-kit/kit/endpoint" httptransport "github.com/go-kit/kit/transport/http" ) // AuthError represents an authorization error. type AuthError struct { Realm string } // StatusCode is an implementation of the StatusCoder interface in go-kit/http. func (AuthError) StatusCode() int { return http.StatusUnauthorized } // Error is an implementation of the Error interface. func (AuthError) Error() string { return http.StatusText(http.StatusUnauthorized) } // Headers is an implementation of the Headerer interface in go-kit/http. func (e AuthError) Headers() http.Header { return http.Header{ "Content-Type": []string{"text/plain; charset=utf-8"}, "X-Content-Type-Options": []string{"nosniff"}, "WWW-Authenticate": []string{fmt.Sprintf(`Basic realm=%q`, e.Realm)}, } } // parseBasicAuth parses an HTTP Basic Authentication string. // "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==" returns ([]byte("Aladdin"), []byte("open sesame"), true). func parseBasicAuth(auth string) (username, password []byte, ok bool) { const prefix = "Basic " if !strings.HasPrefix(auth, prefix) { return } c, err := base64.StdEncoding.DecodeString(auth[len(prefix):]) if err != nil { return } s := bytes.IndexByte(c, ':') if s < 0 { return } return c[:s], c[s+1:], true } // Returns a hash of a given slice. func toHashSlice(s []byte) []byte { hash := sha256.Sum256(s) return hash[:] } // AuthMiddleware returns a Basic Authentication middleware for a particular user and password. func AuthMiddleware(requiredUser, requiredPassword, realm string) endpoint.Middleware { requiredUserBytes := toHashSlice([]byte(requiredUser)) requiredPasswordBytes := toHashSlice([]byte(requiredPassword)) return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { auth, ok := ctx.Value(httptransport.ContextKeyRequestAuthorization).(string) if !ok { return nil, AuthError{realm} } givenUser, givenPassword, ok := parseBasicAuth(auth) if !ok { return nil, AuthError{realm} } givenUserBytes := toHashSlice(givenUser) givenPasswordBytes := toHashSlice(givenPassword) if subtle.ConstantTimeCompare(givenUserBytes, requiredUserBytes) == 0 || subtle.ConstantTimeCompare(givenPasswordBytes, requiredPasswordBytes) == 0 { return nil, AuthError{realm} } return next(ctx, request) } } } golang-github-go-kit-kit-0.6.0/auth/basic/middleware_test.go000066400000000000000000000032761316471211400237560ustar00rootroot00000000000000package basic import ( "context" "encoding/base64" "fmt" "testing" httptransport "github.com/go-kit/kit/transport/http" ) func TestWithBasicAuth(t *testing.T) { requiredUser := "test-user" requiredPassword := "test-pass" realm := "test realm" type want struct { result interface{} err error } tests := []struct { name string authHeader interface{} want want }{ {"Isn't valid with nil header", nil, want{nil, AuthError{realm}}}, {"Isn't valid with non-string header", 42, want{nil, AuthError{realm}}}, {"Isn't valid without authHeader", "", want{nil, AuthError{realm}}}, {"Isn't valid for wrong user", makeAuthString("wrong-user", requiredPassword), want{nil, AuthError{realm}}}, {"Isn't valid for wrong password", makeAuthString(requiredUser, "wrong-password"), want{nil, AuthError{realm}}}, {"Is valid for correct creds", makeAuthString(requiredUser, requiredPassword), want{true, nil}}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { ctx := context.WithValue(context.TODO(), httptransport.ContextKeyRequestAuthorization, tt.authHeader) result, err := AuthMiddleware(requiredUser, requiredPassword, realm)(passedValidation)(ctx, nil) if result != tt.want.result || err != tt.want.err { t.Errorf("WithBasicAuth() = result: %v, err: %v, want result: %v, want error: %v", result, err, tt.want.result, tt.want.err) } }) } } func makeAuthString(user string, password string) string { data := []byte(fmt.Sprintf("%s:%s", user, password)) return fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString(data)) } func passedValidation(ctx context.Context, request interface{}) (response interface{}, err error) { return true, nil } golang-github-go-kit-kit-0.6.0/auth/jwt/000077500000000000000000000000001316471211400177665ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/auth/jwt/README.md000066400000000000000000000062451316471211400212540ustar00rootroot00000000000000# package auth/jwt `package auth/jwt` provides a set of interfaces for service authorization through [JSON Web Tokens](https://jwt.io/). ## Usage NewParser takes a key function and an expected signing method and returns an `endpoint.Middleware`. The middleware will parse a token passed into the context via the `jwt.JWTTokenContextKey`. If the token is valid, any claims will be added to the context via the `jwt.JWTClaimsContextKey`. ```go import ( stdjwt "github.com/dgrijalva/jwt-go" "github.com/go-kit/kit/auth/jwt" "github.com/go-kit/kit/endpoint" ) func main() { var exampleEndpoint endpoint.Endpoint { kf := func(token *stdjwt.Token) (interface{}, error) { return []byte("SigningString"), nil } exampleEndpoint = MakeExampleEndpoint(service) exampleEndpoint = jwt.NewParser(kf, stdjwt.SigningMethodHS256, jwt.StandardClaimsFactory)(exampleEndpoint) } } ``` NewSigner takes a JWT key ID header, the signing key, signing method, and a claims object. It returns an `endpoint.Middleware`. The middleware will build the token string and add it to the context via the `jwt.JWTTokenContextKey`. ```go import ( stdjwt "github.com/dgrijalva/jwt-go" "github.com/go-kit/kit/auth/jwt" "github.com/go-kit/kit/endpoint" ) func main() { var exampleEndpoint endpoint.Endpoint { exampleEndpoint = grpctransport.NewClient(...).Endpoint() exampleEndpoint = jwt.NewSigner( "kid-header", []byte("SigningString"), stdjwt.SigningMethodHS256, jwt.Claims{}, )(exampleEndpoint) } } ``` In order for the parser and the signer to work, the authorization headers need to be passed between the request and the context. `ToHTTPContext()`, `FromHTTPContext()`, `ToGRPCContext()`, and `FromGRPCContext()` are given as helpers to do this. These functions implement the correlating transport's RequestFunc interface and can be passed as ClientBefore or ServerBefore options. Example of use in a client: ```go import ( stdjwt "github.com/dgrijalva/jwt-go" grpctransport "github.com/go-kit/kit/transport/grpc" "github.com/go-kit/kit/auth/jwt" "github.com/go-kit/kit/endpoint" ) func main() { options := []httptransport.ClientOption{} var exampleEndpoint endpoint.Endpoint { exampleEndpoint = grpctransport.NewClient(..., grpctransport.ClientBefore(jwt.FromGRPCContext())).Endpoint() exampleEndpoint = jwt.NewSigner( "kid-header", []byte("SigningString"), stdjwt.SigningMethodHS256, jwt.Claims{}, )(exampleEndpoint) } } ``` Example of use in a server: ```go import ( "context" "github.com/go-kit/kit/auth/jwt" "github.com/go-kit/kit/log" grpctransport "github.com/go-kit/kit/transport/grpc" ) func MakeGRPCServer(ctx context.Context, endpoints Endpoints, logger log.Logger) pb.ExampleServer { options := []grpctransport.ServerOption{grpctransport.ServerErrorLogger(logger)} return &grpcServer{ createUser: grpctransport.NewServer( ctx, endpoints.CreateUserEndpoint, DecodeGRPCCreateUserRequest, EncodeGRPCCreateUserResponse, append(options, grpctransport.ServerBefore(jwt.ToGRPCContext()))..., ), getUser: grpctransport.NewServer( ctx, endpoints.GetUserEndpoint, DecodeGRPCGetUserRequest, EncodeGRPCGetUserResponse, options..., ), } } ``` golang-github-go-kit-kit-0.6.0/auth/jwt/middleware.go000066400000000000000000000113661316471211400224410ustar00rootroot00000000000000package jwt import ( "context" "errors" jwt "github.com/dgrijalva/jwt-go" "github.com/go-kit/kit/endpoint" ) type contextKey string const ( // JWTTokenContextKey holds the key used to store a JWT Token in the // context. JWTTokenContextKey contextKey = "JWTToken" // JWTClaimsContextKey holds the key used to store the JWT Claims in the // context. JWTClaimsContextKey contextKey = "JWTClaims" ) var ( // ErrTokenContextMissing denotes a token was not passed into the parsing // middleware's context. ErrTokenContextMissing = errors.New("token up for parsing was not passed through the context") // ErrTokenInvalid denotes a token was not able to be validated. ErrTokenInvalid = errors.New("JWT Token was invalid") // ErrTokenExpired denotes a token's expire header (exp) has since passed. ErrTokenExpired = errors.New("JWT Token is expired") // ErrTokenMalformed denotes a token was not formatted as a JWT token. ErrTokenMalformed = errors.New("JWT Token is malformed") // ErrTokenNotActive denotes a token's not before header (nbf) is in the // future. ErrTokenNotActive = errors.New("token is not valid yet") // ErrUnexpectedSigningMethod denotes a token was signed with an unexpected // signing method. ErrUnexpectedSigningMethod = errors.New("unexpected signing method") ) // NewSigner creates a new JWT token generating middleware, specifying key ID, // signing string, signing method and the claims you would like it to contain. // Tokens are signed with a Key ID header (kid) which is useful for determining // the key to use for parsing. Particularly useful for clients. func NewSigner(kid string, key []byte, method jwt.SigningMethod, claims jwt.Claims) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { token := jwt.NewWithClaims(method, claims) token.Header["kid"] = kid // Sign and get the complete encoded token as a string using the secret tokenString, err := token.SignedString(key) if err != nil { return nil, err } ctx = context.WithValue(ctx, JWTTokenContextKey, tokenString) return next(ctx, request) } } } // ClaimsFactory is a factory for jwt.Claims. // Useful in NewParser middleware. type ClaimsFactory func() jwt.Claims // MapClaimsFactory is a ClaimsFactory that returns // an empty jwt.MapClaims. func MapClaimsFactory() jwt.Claims { return jwt.MapClaims{} } // StandardClaimsFactory is a ClaimsFactory that returns // an empty jwt.StandardClaims. func StandardClaimsFactory() jwt.Claims { return &jwt.StandardClaims{} } // NewParser creates a new JWT token parsing middleware, specifying a // jwt.Keyfunc interface, the signing method and the claims type to be used. NewParser // adds the resulting claims to endpoint context or returns error on invalid token. // Particularly useful for servers. func NewParser(keyFunc jwt.Keyfunc, method jwt.SigningMethod, newClaims ClaimsFactory) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { // tokenString is stored in the context from the transport handlers. tokenString, ok := ctx.Value(JWTTokenContextKey).(string) if !ok { return nil, ErrTokenContextMissing } // Parse takes the token string and a function for looking up the // key. The latter is especially useful if you use multiple keys // for your application. The standard is to use 'kid' in the head // of the token to identify which key to use, but the parsed token // (head and claims) is provided to the callback, providing // flexibility. token, err := jwt.ParseWithClaims(tokenString, newClaims(), func(token *jwt.Token) (interface{}, error) { // Don't forget to validate the alg is what you expect: if token.Method != method { return nil, ErrUnexpectedSigningMethod } return keyFunc(token) }) if err != nil { if e, ok := err.(*jwt.ValidationError); ok { switch { case e.Errors&jwt.ValidationErrorMalformed != 0: // Token is malformed return nil, ErrTokenMalformed case e.Errors&jwt.ValidationErrorExpired != 0: // Token is expired return nil, ErrTokenExpired case e.Errors&jwt.ValidationErrorNotValidYet != 0: // Token is not active yet return nil, ErrTokenNotActive case e.Inner != nil: // report e.Inner return nil, e.Inner } // We have a ValidationError but have no specific Go kit error for it. // Fall through to return original error. } return nil, err } if !token.Valid { return nil, ErrTokenInvalid } ctx = context.WithValue(ctx, JWTClaimsContextKey, token.Claims) return next(ctx, request) } } } golang-github-go-kit-kit-0.6.0/auth/jwt/middleware_test.go000066400000000000000000000171671316471211400235050ustar00rootroot00000000000000package jwt import ( "context" "sync" "testing" "time" "crypto/subtle" jwt "github.com/dgrijalva/jwt-go" "github.com/go-kit/kit/endpoint" ) type customClaims struct { MyProperty string `json:"my_property"` jwt.StandardClaims } func (c customClaims) VerifyMyProperty(p string) bool { return subtle.ConstantTimeCompare([]byte(c.MyProperty), []byte(p)) != 0 } var ( kid = "kid" key = []byte("test_signing_key") myProperty = "some value" method = jwt.SigningMethodHS256 invalidMethod = jwt.SigningMethodRS256 mapClaims = jwt.MapClaims{"user": "go-kit"} standardClaims = jwt.StandardClaims{Audience: "go-kit"} myCustomClaims = customClaims{MyProperty: myProperty, StandardClaims: standardClaims} // Signed tokens generated at https://jwt.io/ signedKey = "eyJhbGciOiJIUzI1NiIsImtpZCI6ImtpZCIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjoiZ28ta2l0In0.14M2VmYyApdSlV_LZ88ajjwuaLeIFplB8JpyNy0A19E" standardSignedKey = "eyJhbGciOiJIUzI1NiIsImtpZCI6ImtpZCIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJnby1raXQifQ.L5ypIJjCOOv3jJ8G5SelaHvR04UJuxmcBN5QW3m_aoY" customSignedKey = "eyJhbGciOiJIUzI1NiIsImtpZCI6ImtpZCIsInR5cCI6IkpXVCJ9.eyJteV9wcm9wZXJ0eSI6InNvbWUgdmFsdWUiLCJhdWQiOiJnby1raXQifQ.s8F-IDrV4WPJUsqr7qfDi-3GRlcKR0SRnkTeUT_U-i0" invalidKey = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.e30.vKVCKto-Wn6rgz3vBdaZaCBGfCBDTXOENSo_X2Gq7qA" malformedKey = "malformed.jwt.token" ) func signingValidator(t *testing.T, signer endpoint.Endpoint, expectedKey string) { ctx, err := signer(context.Background(), struct{}{}) if err != nil { t.Fatalf("Signer returned error: %s", err) } token, ok := ctx.(context.Context).Value(JWTTokenContextKey).(string) if !ok { t.Fatal("Token did not exist in context") } if token != expectedKey { t.Fatalf("JWT tokens did not match: expecting %s got %s", expectedKey, token) } } func TestNewSigner(t *testing.T) { e := func(ctx context.Context, i interface{}) (interface{}, error) { return ctx, nil } signer := NewSigner(kid, key, method, mapClaims)(e) signingValidator(t, signer, signedKey) signer = NewSigner(kid, key, method, standardClaims)(e) signingValidator(t, signer, standardSignedKey) signer = NewSigner(kid, key, method, myCustomClaims)(e) signingValidator(t, signer, customSignedKey) } func TestJWTParser(t *testing.T) { e := func(ctx context.Context, i interface{}) (interface{}, error) { return ctx, nil } keys := func(token *jwt.Token) (interface{}, error) { return key, nil } parser := NewParser(keys, method, MapClaimsFactory)(e) // No Token is passed into the parser _, err := parser(context.Background(), struct{}{}) if err == nil { t.Error("Parser should have returned an error") } if err != ErrTokenContextMissing { t.Errorf("unexpected error returned, expected: %s got: %s", ErrTokenContextMissing, err) } // Invalid Token is passed into the parser ctx := context.WithValue(context.Background(), JWTTokenContextKey, invalidKey) _, err = parser(ctx, struct{}{}) if err == nil { t.Error("Parser should have returned an error") } // Invalid Method is used in the parser badParser := NewParser(keys, invalidMethod, MapClaimsFactory)(e) ctx = context.WithValue(context.Background(), JWTTokenContextKey, signedKey) _, err = badParser(ctx, struct{}{}) if err == nil { t.Error("Parser should have returned an error") } if err != ErrUnexpectedSigningMethod { t.Errorf("unexpected error returned, expected: %s got: %s", ErrUnexpectedSigningMethod, err) } // Invalid key is used in the parser invalidKeys := func(token *jwt.Token) (interface{}, error) { return []byte("bad"), nil } badParser = NewParser(invalidKeys, method, MapClaimsFactory)(e) ctx = context.WithValue(context.Background(), JWTTokenContextKey, signedKey) _, err = badParser(ctx, struct{}{}) if err == nil { t.Error("Parser should have returned an error") } // Correct token is passed into the parser ctx = context.WithValue(context.Background(), JWTTokenContextKey, signedKey) ctx1, err := parser(ctx, struct{}{}) if err != nil { t.Fatalf("Parser returned error: %s", err) } cl, ok := ctx1.(context.Context).Value(JWTClaimsContextKey).(jwt.MapClaims) if !ok { t.Fatal("Claims were not passed into context correctly") } if cl["user"] != mapClaims["user"] { t.Fatalf("JWT Claims.user did not match: expecting %s got %s", mapClaims["user"], cl["user"]) } // Test for malformed token error response parser = NewParser(keys, method, StandardClaimsFactory)(e) ctx = context.WithValue(context.Background(), JWTTokenContextKey, malformedKey) ctx1, err = parser(ctx, struct{}{}) if want, have := ErrTokenMalformed, err; want != have { t.Fatalf("Expected %+v, got %+v", want, have) } // Test for expired token error response parser = NewParser(keys, method, StandardClaimsFactory)(e) expired := jwt.NewWithClaims(method, jwt.StandardClaims{ExpiresAt: time.Now().Unix() - 100}) token, err := expired.SignedString(key) if err != nil { t.Fatalf("Unable to Sign Token: %+v", err) } ctx = context.WithValue(context.Background(), JWTTokenContextKey, token) ctx1, err = parser(ctx, struct{}{}) if want, have := ErrTokenExpired, err; want != have { t.Fatalf("Expected %+v, got %+v", want, have) } // Test for not activated token error response parser = NewParser(keys, method, StandardClaimsFactory)(e) notactive := jwt.NewWithClaims(method, jwt.StandardClaims{NotBefore: time.Now().Unix() + 100}) token, err = notactive.SignedString(key) if err != nil { t.Fatalf("Unable to Sign Token: %+v", err) } ctx = context.WithValue(context.Background(), JWTTokenContextKey, token) ctx1, err = parser(ctx, struct{}{}) if want, have := ErrTokenNotActive, err; want != have { t.Fatalf("Expected %+v, got %+v", want, have) } // test valid standard claims token parser = NewParser(keys, method, StandardClaimsFactory)(e) ctx = context.WithValue(context.Background(), JWTTokenContextKey, standardSignedKey) ctx1, err = parser(ctx, struct{}{}) if err != nil { t.Fatalf("Parser returned error: %s", err) } stdCl, ok := ctx1.(context.Context).Value(JWTClaimsContextKey).(*jwt.StandardClaims) if !ok { t.Fatal("Claims were not passed into context correctly") } if !stdCl.VerifyAudience("go-kit", true) { t.Fatalf("JWT jwt.StandardClaims.Audience did not match: expecting %s got %s", standardClaims.Audience, stdCl.Audience) } // test valid customized claims token parser = NewParser(keys, method, func() jwt.Claims { return &customClaims{} })(e) ctx = context.WithValue(context.Background(), JWTTokenContextKey, customSignedKey) ctx1, err = parser(ctx, struct{}{}) if err != nil { t.Fatalf("Parser returned error: %s", err) } custCl, ok := ctx1.(context.Context).Value(JWTClaimsContextKey).(*customClaims) if !ok { t.Fatal("Claims were not passed into context correctly") } if !custCl.VerifyAudience("go-kit", true) { t.Fatalf("JWT customClaims.Audience did not match: expecting %s got %s", standardClaims.Audience, custCl.Audience) } if !custCl.VerifyMyProperty(myProperty) { t.Fatalf("JWT customClaims.MyProperty did not match: expecting %s got %s", myProperty, custCl.MyProperty) } } func TestIssue562(t *testing.T) { var ( kf = func(token *jwt.Token) (interface{}, error) { return []byte("secret"), nil } e = NewParser(kf, jwt.SigningMethodHS256, MapClaimsFactory)(endpoint.Nop) key = JWTTokenContextKey val = "eyJhbGciOiJIUzI1NiIsImtpZCI6ImtpZCIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjoiZ28ta2l0In0.14M2VmYyApdSlV_LZ88ajjwuaLeIFplB8JpyNy0A19E" ctx = context.WithValue(context.Background(), key, val) ) wg := sync.WaitGroup{} for i := 0; i < 100; i++ { wg.Add(1) go func() { defer wg.Done() e(ctx, struct{}{}) // fatal error: concurrent map read and map write }() } wg.Wait() } golang-github-go-kit-kit-0.6.0/auth/jwt/transport.go000066400000000000000000000043121316471211400223510ustar00rootroot00000000000000package jwt import ( "context" "fmt" stdhttp "net/http" "strings" "google.golang.org/grpc/metadata" "github.com/go-kit/kit/transport/grpc" "github.com/go-kit/kit/transport/http" ) const ( bearer string = "bearer" bearerFormat string = "Bearer %s" ) // HTTPToContext moves a JWT from request header to context. Particularly // useful for servers. func HTTPToContext() http.RequestFunc { return func(ctx context.Context, r *stdhttp.Request) context.Context { token, ok := extractTokenFromAuthHeader(r.Header.Get("Authorization")) if !ok { return ctx } return context.WithValue(ctx, JWTTokenContextKey, token) } } // ContextToHTTP moves a JWT from context to request header. Particularly // useful for clients. func ContextToHTTP() http.RequestFunc { return func(ctx context.Context, r *stdhttp.Request) context.Context { token, ok := ctx.Value(JWTTokenContextKey).(string) if ok { r.Header.Add("Authorization", generateAuthHeaderFromToken(token)) } return ctx } } // GRPCToContext moves a JWT from grpc metadata to context. Particularly // userful for servers. func GRPCToContext() grpc.ServerRequestFunc { return func(ctx context.Context, md metadata.MD) context.Context { // capital "Key" is illegal in HTTP/2. authHeader, ok := md["authorization"] if !ok { return ctx } token, ok := extractTokenFromAuthHeader(authHeader[0]) if ok { ctx = context.WithValue(ctx, JWTTokenContextKey, token) } return ctx } } // ContextToGRPC moves a JWT from context to grpc metadata. Particularly // useful for clients. func ContextToGRPC() grpc.ClientRequestFunc { return func(ctx context.Context, md *metadata.MD) context.Context { token, ok := ctx.Value(JWTTokenContextKey).(string) if ok { // capital "Key" is illegal in HTTP/2. (*md)["authorization"] = []string{generateAuthHeaderFromToken(token)} } return ctx } } func extractTokenFromAuthHeader(val string) (token string, ok bool) { authHeaderParts := strings.Split(val, " ") if len(authHeaderParts) != 2 || strings.ToLower(authHeaderParts[0]) != bearer { return "", false } return authHeaderParts[1], true } func generateAuthHeaderFromToken(token string) string { return fmt.Sprintf(bearerFormat, token) } golang-github-go-kit-kit-0.6.0/auth/jwt/transport_test.go000066400000000000000000000064641316471211400234220ustar00rootroot00000000000000package jwt import ( "context" "fmt" "net/http" "testing" "google.golang.org/grpc/metadata" ) func TestHTTPToContext(t *testing.T) { reqFunc := HTTPToContext() // When the header doesn't exist ctx := reqFunc(context.Background(), &http.Request{}) if ctx.Value(JWTTokenContextKey) != nil { t.Error("Context shouldn't contain the encoded JWT") } // Authorization header value has invalid format header := http.Header{} header.Set("Authorization", "no expected auth header format value") ctx = reqFunc(context.Background(), &http.Request{Header: header}) if ctx.Value(JWTTokenContextKey) != nil { t.Error("Context shouldn't contain the encoded JWT") } // Authorization header is correct header.Set("Authorization", generateAuthHeaderFromToken(signedKey)) ctx = reqFunc(context.Background(), &http.Request{Header: header}) token := ctx.Value(JWTTokenContextKey).(string) if token != signedKey { t.Errorf("Context doesn't contain the expected encoded token value; expected: %s, got: %s", signedKey, token) } } func TestContextToHTTP(t *testing.T) { reqFunc := ContextToHTTP() // No JWT Token is passed in the context ctx := context.Background() r := http.Request{} reqFunc(ctx, &r) token := r.Header.Get("Authorization") if token != "" { t.Error("authorization key should not exist in metadata") } // Correct JWT Token is passed in the context ctx = context.WithValue(context.Background(), JWTTokenContextKey, signedKey) r = http.Request{Header: http.Header{}} reqFunc(ctx, &r) token = r.Header.Get("Authorization") expected := generateAuthHeaderFromToken(signedKey) if token != expected { t.Errorf("Authorization header does not contain the expected JWT token; expected %s, got %s", expected, token) } } func TestGRPCToContext(t *testing.T) { md := metadata.MD{} reqFunc := GRPCToContext() // No Authorization header is passed ctx := reqFunc(context.Background(), md) token := ctx.Value(JWTTokenContextKey) if token != nil { t.Error("Context should not contain a JWT Token") } // Invalid Authorization header is passed md["authorization"] = []string{fmt.Sprintf("%s", signedKey)} ctx = reqFunc(context.Background(), md) token = ctx.Value(JWTTokenContextKey) if token != nil { t.Error("Context should not contain a JWT Token") } // Authorization header is correct md["authorization"] = []string{fmt.Sprintf("Bearer %s", signedKey)} ctx = reqFunc(context.Background(), md) token, ok := ctx.Value(JWTTokenContextKey).(string) if !ok { t.Fatal("JWT Token not passed to context correctly") } if token != signedKey { t.Errorf("JWT tokens did not match: expecting %s got %s", signedKey, token) } } func TestContextToGRPC(t *testing.T) { reqFunc := ContextToGRPC() // No JWT Token is passed in the context ctx := context.Background() md := metadata.MD{} reqFunc(ctx, &md) _, ok := md["authorization"] if ok { t.Error("authorization key should not exist in metadata") } // Correct JWT Token is passed in the context ctx = context.WithValue(context.Background(), JWTTokenContextKey, signedKey) md = metadata.MD{} reqFunc(ctx, &md) token, ok := md["authorization"] if !ok { t.Fatal("JWT Token not passed to metadata correctly") } if token[0] != generateAuthHeaderFromToken(signedKey) { t.Errorf("JWT tokens did not match: expecting %s got %s", signedKey, token[0]) } } golang-github-go-kit-kit-0.6.0/circle.yml000066400000000000000000000021411316471211400202030ustar00rootroot00000000000000machine: pre: - curl -sSL https://s3.amazonaws.com/circle-downloads/install-circleci-docker.sh | bash -s -- 1.10.0 - sudo rm -rf /usr/local/go - curl -sSL https://storage.googleapis.com/golang/go1.9.linux-amd64.tar.gz | sudo tar xz -C /usr/local services: - docker dependencies: pre: - sudo curl -L "https://github.com/docker/compose/releases/download/1.10.0/docker-compose-linux-x86_64" -o /usr/local/bin/docker-compose - sudo chmod +x /usr/local/bin/docker-compose - docker-compose -f docker-compose-integration.yml up -d --force-recreate test: pre: - mkdir -p /home/ubuntu/.go_workspace/src/github.com/go-kit - mv /home/ubuntu/kit /home/ubuntu/.go_workspace/src/github.com/go-kit - ln -s /home/ubuntu/.go_workspace/src/github.com/go-kit/kit /home/ubuntu/kit - go get -t github.com/go-kit/kit/... override: - go test -v -race -tags integration github.com/go-kit/kit/...: environment: ETCD_ADDR: http://localhost:2379 CONSUL_ADDR: localhost:8500 ZK_ADDR: localhost:2181 EUREKA_ADDR: http://localhost:8761/eureka golang-github-go-kit-kit-0.6.0/circuitbreaker/000077500000000000000000000000001316471211400212175ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/circuitbreaker/doc.go000066400000000000000000000007221316471211400223140ustar00rootroot00000000000000// Package circuitbreaker implements the circuit breaker pattern. // // Circuit breakers prevent thundering herds, and improve resiliency against // intermittent errors. Every client-side endpoint should be wrapped in a // circuit breaker. // // We provide several implementations in this package, but if you're looking // for guidance, Gobreaker is probably the best place to start. It has a // simple and intuitive API, and is well-tested. package circuitbreaker golang-github-go-kit-kit-0.6.0/circuitbreaker/gobreaker.go000066400000000000000000000012751316471211400235140ustar00rootroot00000000000000package circuitbreaker import ( "context" "github.com/sony/gobreaker" "github.com/go-kit/kit/endpoint" ) // Gobreaker returns an endpoint.Middleware that implements the circuit // breaker pattern using the sony/gobreaker package. Only errors returned by // the wrapped endpoint count against the circuit breaker's error count. // // See http://godoc.org/github.com/sony/gobreaker for more information. func Gobreaker(cb *gobreaker.CircuitBreaker) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { return cb.Execute(func() (interface{}, error) { return next(ctx, request) }) } } } golang-github-go-kit-kit-0.6.0/circuitbreaker/gobreaker_test.go000066400000000000000000000010331316471211400245430ustar00rootroot00000000000000package circuitbreaker_test import ( "testing" "github.com/sony/gobreaker" "github.com/go-kit/kit/circuitbreaker" ) func TestGobreaker(t *testing.T) { var ( breaker = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{})) primeWith = 100 shouldPass = func(n int) bool { return n <= 5 } // https://github.com/sony/gobreaker/blob/bfa846d/gobreaker.go#L76 circuitOpenError = "circuit breaker is open" ) testFailingEndpoint(t, breaker, primeWith, shouldPass, 0, circuitOpenError) } golang-github-go-kit-kit-0.6.0/circuitbreaker/handy_breaker.go000066400000000000000000000016601316471211400243470ustar00rootroot00000000000000package circuitbreaker import ( "context" "time" "github.com/streadway/handy/breaker" "github.com/go-kit/kit/endpoint" ) // HandyBreaker returns an endpoint.Middleware that implements the circuit // breaker pattern using the streadway/handy/breaker package. Only errors // returned by the wrapped endpoint count against the circuit breaker's error // count. // // See http://godoc.org/github.com/streadway/handy/breaker for more // information. func HandyBreaker(cb breaker.Breaker) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { if !cb.Allow() { return nil, breaker.ErrCircuitOpen } defer func(begin time.Time) { if err == nil { cb.Success(time.Since(begin)) } else { cb.Failure(time.Since(begin)) } }(time.Now()) response, err = next(ctx, request) return } } } golang-github-go-kit-kit-0.6.0/circuitbreaker/handy_breaker_test.go000066400000000000000000000011361316471211400254040ustar00rootroot00000000000000package circuitbreaker_test import ( "testing" handybreaker "github.com/streadway/handy/breaker" "github.com/go-kit/kit/circuitbreaker" ) func TestHandyBreaker(t *testing.T) { var ( failureRatio = 0.05 breaker = circuitbreaker.HandyBreaker(handybreaker.NewBreaker(failureRatio)) primeWith = handybreaker.DefaultMinObservations * 10 shouldPass = func(n int) bool { return (float64(n) / float64(primeWith+n)) <= failureRatio } openCircuitError = handybreaker.ErrCircuitOpen.Error() ) testFailingEndpoint(t, breaker, primeWith, shouldPass, 0, openCircuitError) } golang-github-go-kit-kit-0.6.0/circuitbreaker/hystrix.go000066400000000000000000000014761316471211400232700ustar00rootroot00000000000000package circuitbreaker import ( "context" "github.com/afex/hystrix-go/hystrix" "github.com/go-kit/kit/endpoint" ) // Hystrix returns an endpoint.Middleware that implements the circuit // breaker pattern using the afex/hystrix-go package. // // When using this circuit breaker, please configure your commands separately. // // See https://godoc.org/github.com/afex/hystrix-go/hystrix for more // information. func Hystrix(commandName string) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { var resp interface{} if err := hystrix.Do(commandName, func() (err error) { resp, err = next(ctx, request) return err }, nil); err != nil { return nil, err } return resp, nil } } } golang-github-go-kit-kit-0.6.0/circuitbreaker/hystrix_test.go000066400000000000000000000021671316471211400243250ustar00rootroot00000000000000package circuitbreaker_test import ( "io/ioutil" stdlog "log" "testing" "time" "github.com/afex/hystrix-go/hystrix" "github.com/go-kit/kit/circuitbreaker" ) func TestHystrix(t *testing.T) { stdlog.SetOutput(ioutil.Discard) const ( commandName = "my-endpoint" errorPercent = 5 maxConcurrent = 1000 ) hystrix.ConfigureCommand(commandName, hystrix.CommandConfig{ ErrorPercentThreshold: errorPercent, MaxConcurrentRequests: maxConcurrent, }) var ( breaker = circuitbreaker.Hystrix(commandName) primeWith = hystrix.DefaultVolumeThreshold * 2 shouldPass = func(n int) bool { return (float64(n) / float64(primeWith+n)) <= (float64(errorPercent-1) / 100.0) } openCircuitError = hystrix.ErrCircuitOpen.Error() ) // hystrix-go uses buffered channels to receive reports on request success/failure, // and so is basically impossible to test deterministically. We have to make sure // the report buffer is emptied, by injecting a sleep between each invocation. requestDelay := 5 * time.Millisecond testFailingEndpoint(t, breaker, primeWith, shouldPass, requestDelay, openCircuitError) } golang-github-go-kit-kit-0.6.0/circuitbreaker/util_test.go000066400000000000000000000033731316471211400235700ustar00rootroot00000000000000package circuitbreaker_test import ( "context" "errors" "fmt" "path/filepath" "runtime" "testing" "time" "github.com/go-kit/kit/endpoint" ) func testFailingEndpoint( t *testing.T, breaker endpoint.Middleware, primeWith int, shouldPass func(int) bool, requestDelay time.Duration, openCircuitError string, ) { _, file, line, _ := runtime.Caller(1) caller := fmt.Sprintf("%s:%d", filepath.Base(file), line) // Create a mock endpoint and wrap it with the breaker. m := mock{} var e endpoint.Endpoint e = m.endpoint e = breaker(e) // Prime the endpoint with successful requests. for i := 0; i < primeWith; i++ { if _, err := e(context.Background(), struct{}{}); err != nil { t.Fatalf("%s: during priming, got error: %v", caller, err) } time.Sleep(requestDelay) } // Switch the endpoint to start throwing errors. m.err = errors.New("tragedy+disaster") m.through = 0 // The first several should be allowed through and yield our error. for i := 0; shouldPass(i); i++ { if _, err := e(context.Background(), struct{}{}); err != m.err { t.Fatalf("%s: want %v, have %v", caller, m.err, err) } time.Sleep(requestDelay) } through := m.through // But the rest should be blocked by an open circuit. for i := 0; i < 10; i++ { if _, err := e(context.Background(), struct{}{}); err.Error() != openCircuitError { t.Fatalf("%s: want %q, have %q", caller, openCircuitError, err.Error()) } time.Sleep(requestDelay) } // Make sure none of those got through. if want, have := through, m.through; want != have { t.Errorf("%s: want %d, have %d", caller, want, have) } } type mock struct { through int err error } func (m *mock) endpoint(context.Context, interface{}) (interface{}, error) { m.through++ return struct{}{}, m.err } golang-github-go-kit-kit-0.6.0/coveralls.bash000077500000000000000000000011051316471211400210520ustar00rootroot00000000000000#!/usr/bin/env bash if ! type -P gover then echo gover missing: go get github.com/modocache/gover exit 1 fi if ! type -P goveralls then echo goveralls missing: go get github.com/mattn/goveralls exit 1 fi if [[ "$COVERALLS_TOKEN" == "" ]] then echo COVERALLS_TOKEN not set exit 1 fi go list ./... | grep -v '/examples/' | cut -d'/' -f 4- | while read d do cd $d go test -covermode count -coverprofile coverage.coverprofile cd - done gover goveralls -coverprofile gover.coverprofile -service travis-ci -repotoken $COVERALLS_TOKEN find . -name '*.coverprofile' -delete golang-github-go-kit-kit-0.6.0/docker-compose-integration.yml000066400000000000000000000010511316471211400241740ustar00rootroot00000000000000version: '2' services: etcd: image: quay.io/coreos/etcd ports: - "2379:2379" command: /usr/local/bin/etcd -advertise-client-urls http://0.0.0.0:2379,http://0.0.0.0:4001 -listen-client-urls "http://0.0.0.0:2379,http://0.0.0.0:4001" consul: image: progrium/consul ports: - "8500:8500" command: -server -bootstrap zk: image: zookeeper ports: - "2181:2181" eureka: image: springcloud/eureka environment: eureka.server.responseCacheUpdateIntervalMs: 1000 ports: - "8761:8761" golang-github-go-kit-kit-0.6.0/endpoint/000077500000000000000000000000001316471211400200415ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/endpoint/doc.go000066400000000000000000000003231316471211400211330ustar00rootroot00000000000000// Package endpoint defines an abstraction for RPCs. // // Endpoints are a fundamental building block for many Go kit components. // Endpoints are implemented by servers, and called by clients. package endpoint golang-github-go-kit-kit-0.6.0/endpoint/endpoint.go000066400000000000000000000016361316471211400222160ustar00rootroot00000000000000package endpoint import ( "context" ) // Endpoint is the fundamental building block of servers and clients. // It represents a single RPC method. type Endpoint func(ctx context.Context, request interface{}) (response interface{}, err error) // Nop is an endpoint that does nothing and returns a nil error. // Useful for tests. func Nop(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil } // Middleware is a chainable behavior modifier for endpoints. type Middleware func(Endpoint) Endpoint // Chain is a helper function for composing middlewares. Requests will // traverse them in the order they're declared. That is, the first middleware // is treated as the outermost middleware. func Chain(outer Middleware, others ...Middleware) Middleware { return func(next Endpoint) Endpoint { for i := len(others) - 1; i >= 0; i-- { // reverse next = others[i](next) } return outer(next) } } golang-github-go-kit-kit-0.6.0/endpoint/endpoint_example_test.go000066400000000000000000000015171316471211400247660ustar00rootroot00000000000000package endpoint_test import ( "context" "fmt" "github.com/go-kit/kit/endpoint" ) func ExampleChain() { e := endpoint.Chain( annotate("first"), annotate("second"), annotate("third"), )(myEndpoint) if _, err := e(ctx, req); err != nil { panic(err) } // Output: // first pre // second pre // third pre // my endpoint! // third post // second post // first post } var ( ctx = context.Background() req = struct{}{} ) func annotate(s string) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { fmt.Println(s, "pre") defer fmt.Println(s, "post") return next(ctx, request) } } } func myEndpoint(context.Context, interface{}) (interface{}, error) { fmt.Println("my endpoint!") return struct{}{}, nil } golang-github-go-kit-kit-0.6.0/examples/000077500000000000000000000000001316471211400200375ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/README.md000066400000000000000000000002371316471211400213200ustar00rootroot00000000000000# Examples For more information about these examples, including a walkthrough of the stringsvc example, see [gokit.io/examples](https://gokit.io/examples). golang-github-go-kit-kit-0.6.0/examples/addsvc/000077500000000000000000000000001316471211400213035ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/README.md000066400000000000000000000017641316471211400225720ustar00rootroot00000000000000# addsvc addsvc is an example microservice which takes full advantage of most of Go kit's features, including both service- and transport-level middlewares, speaking multiple transports simultaneously, distributed tracing, and rich error definitions. The server binary is available in cmd/addsvc. The client binary is available in cmd/addcli. Finally, the addtransport package provides both server and clients for each supported transport. The client structs bake-in certain middlewares, in order to demonstrate the _client library pattern_. But beware: client libraries are generally a bad idea, because they easily lead to the [distributed monolith antipattern](https://www.microservices.com/talks/dont-build-a-distributed-monolith/). If you don't _know_ you need to use one in your organization, it's probably best avoided: prefer moving that logic to consumers, and relying on [contract testing](https://docs.pact.io/best_practices/contract_tests_not_functional_tests.html) to detect incompatibilities. golang-github-go-kit-kit-0.6.0/examples/addsvc/cmd/000077500000000000000000000000001316471211400220465ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/cmd/addcli/000077500000000000000000000000001316471211400232665ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/cmd/addcli/addcli.go000066400000000000000000000145611316471211400250440ustar00rootroot00000000000000package main import ( "context" "flag" "fmt" "os" "strconv" "text/tabwriter" "time" "google.golang.org/grpc" "github.com/apache/thrift/lib/go/thrift" lightstep "github.com/lightstep/lightstep-tracer-go" stdopentracing "github.com/opentracing/opentracing-go" zipkin "github.com/openzipkin/zipkin-go-opentracing" "sourcegraph.com/sourcegraph/appdash" appdashot "sourcegraph.com/sourcegraph/appdash/opentracing" "github.com/go-kit/kit/log" "github.com/go-kit/kit/examples/addsvc/pkg/addservice" "github.com/go-kit/kit/examples/addsvc/pkg/addtransport" addthrift "github.com/go-kit/kit/examples/addsvc/thrift/gen-go/addsvc" ) func main() { // The addcli presumes no service discovery system, and expects users to // provide the direct address of an addsvc. This presumption is reflected in // the addcli binary and the client packages: the -transport.addr flags // and various client constructors both expect host:port strings. For an // example service with a client built on top of a service discovery system, // see profilesvc. fs := flag.NewFlagSet("addcli", flag.ExitOnError) var ( httpAddr = fs.String("http-addr", "", "HTTP address of addsvc") grpcAddr = fs.String("grpc-addr", "", "gRPC address of addsvc") thriftAddr = fs.String("thrift-addr", "", "Thrift address of addsvc") thriftProtocol = fs.String("thrift-protocol", "binary", "binary, compact, json, simplejson") thriftBuffer = fs.Int("thrift-buffer", 0, "0 for unbuffered") thriftFramed = fs.Bool("thrift-framed", false, "true to enable framing") zipkinURL = fs.String("zipkin-url", "", "Enable Zipkin tracing via a collector URL e.g. http://localhost:9411/api/v1/spans") lightstepToken = flag.String("lightstep-token", "", "Enable LightStep tracing via a LightStep access token") appdashAddr = flag.String("appdash-addr", "", "Enable Appdash tracing via an Appdash server host:port") method = fs.String("method", "sum", "sum, concat") ) fs.Usage = usageFor(fs, os.Args[0]+" [flags] ") fs.Parse(os.Args[1:]) if len(fs.Args()) != 2 { fs.Usage() os.Exit(1) } // This is a demonstration client, which supports multiple tracers. // Your clients will probably just use one tracer. var tracer stdopentracing.Tracer { if *zipkinURL != "" { collector, err := zipkin.NewHTTPCollector(*zipkinURL) if err != nil { fmt.Fprintln(os.Stderr, err.Error()) os.Exit(1) } defer collector.Close() var ( debug = false hostPort = "localhost:80" serviceName = "addsvc" ) recorder := zipkin.NewRecorder(collector, debug, hostPort, serviceName) tracer, err = zipkin.NewTracer(recorder) if err != nil { fmt.Fprintln(os.Stderr, err.Error()) os.Exit(1) } } else if *lightstepToken != "" { tracer = lightstep.NewTracer(lightstep.Options{ AccessToken: *lightstepToken, }) defer lightstep.FlushLightStepTracer(tracer) } else if *appdashAddr != "" { tracer = appdashot.NewTracer(appdash.NewRemoteCollector(*appdashAddr)) } else { tracer = stdopentracing.GlobalTracer() // no-op } } // This is a demonstration client, which supports multiple transports. // Your clients will probably just define and stick with 1 transport. var ( svc addservice.Service err error ) if *httpAddr != "" { svc, err = addtransport.NewHTTPClient(*httpAddr, tracer, log.NewNopLogger()) } else if *grpcAddr != "" { conn, err := grpc.Dial(*grpcAddr, grpc.WithInsecure(), grpc.WithTimeout(time.Second)) if err != nil { fmt.Fprintf(os.Stderr, "error: %v", err) os.Exit(1) } defer conn.Close() svc = addtransport.NewGRPCClient(conn, tracer, log.NewNopLogger()) } else if *thriftAddr != "" { // It's necessary to do all of this construction in the func main, // because (among other reasons) we need to control the lifecycle of the // Thrift transport, i.e. close it eventually. var protocolFactory thrift.TProtocolFactory switch *thriftProtocol { case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() case "json": protocolFactory = thrift.NewTJSONProtocolFactory() case "binary", "": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() default: fmt.Fprintf(os.Stderr, "error: invalid protocol %q\n", *thriftProtocol) os.Exit(1) } var transportFactory thrift.TTransportFactory if *thriftBuffer > 0 { transportFactory = thrift.NewTBufferedTransportFactory(*thriftBuffer) } else { transportFactory = thrift.NewTTransportFactory() } if *thriftFramed { transportFactory = thrift.NewTFramedTransportFactory(transportFactory) } transportSocket, err := thrift.NewTSocket(*thriftAddr) if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } transport, err := transportFactory.GetTransport(transportSocket) if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } if err := transport.Open(); err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } defer transport.Close() client := addthrift.NewAddServiceClientFactory(transport, protocolFactory) svc = addtransport.NewThriftClient(client) } else { fmt.Fprintf(os.Stderr, "error: no remote address specified\n") os.Exit(1) } if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } switch *method { case "sum": a, _ := strconv.ParseInt(fs.Args()[0], 10, 64) b, _ := strconv.ParseInt(fs.Args()[1], 10, 64) v, err := svc.Sum(context.Background(), int(a), int(b)) if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } fmt.Fprintf(os.Stdout, "%d + %d = %d\n", a, b, v) case "concat": a := fs.Args()[0] b := fs.Args()[1] v, err := svc.Concat(context.Background(), a, b) if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } fmt.Fprintf(os.Stdout, "%q + %q = %q\n", a, b, v) default: fmt.Fprintf(os.Stderr, "error: invalid method %q\n", method) os.Exit(1) } } func usageFor(fs *flag.FlagSet, short string) func() { return func() { fmt.Fprintf(os.Stderr, "USAGE\n") fmt.Fprintf(os.Stderr, " %s\n", short) fmt.Fprintf(os.Stderr, "\n") fmt.Fprintf(os.Stderr, "FLAGS\n") w := tabwriter.NewWriter(os.Stderr, 0, 2, 2, ' ', 0) fs.VisitAll(func(f *flag.Flag) { fmt.Fprintf(w, "\t-%s %s\t%s\n", f.Name, f.DefValue, f.Usage) }) w.Flush() fmt.Fprintf(os.Stderr, "\n") } } golang-github-go-kit-kit-0.6.0/examples/addsvc/cmd/addsvc/000077500000000000000000000000001316471211400233125ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/cmd/addsvc/addsvc.go000066400000000000000000000233431316471211400251120ustar00rootroot00000000000000package main import ( "flag" "fmt" "net" "net/http" "os" "os/signal" "syscall" "text/tabwriter" "github.com/apache/thrift/lib/go/thrift" lightstep "github.com/lightstep/lightstep-tracer-go" "github.com/oklog/oklog/pkg/group" stdopentracing "github.com/opentracing/opentracing-go" zipkin "github.com/openzipkin/zipkin-go-opentracing" stdprometheus "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promhttp" "google.golang.org/grpc" "sourcegraph.com/sourcegraph/appdash" appdashot "sourcegraph.com/sourcegraph/appdash/opentracing" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/prometheus" addpb "github.com/go-kit/kit/examples/addsvc/pb" "github.com/go-kit/kit/examples/addsvc/pkg/addendpoint" "github.com/go-kit/kit/examples/addsvc/pkg/addservice" "github.com/go-kit/kit/examples/addsvc/pkg/addtransport" addthrift "github.com/go-kit/kit/examples/addsvc/thrift/gen-go/addsvc" ) func main() { // Define our flags. Your service probably won't need to bind listeners for // *all* supported transports, or support both Zipkin and LightStep, and so // on, but we do it here for demonstration purposes. fs := flag.NewFlagSet("addsvc", flag.ExitOnError) var ( debugAddr = fs.String("debug.addr", ":8080", "Debug and metrics listen address") httpAddr = fs.String("http-addr", ":8081", "HTTP listen address") grpcAddr = fs.String("grpc-addr", ":8082", "gRPC listen address") thriftAddr = fs.String("thrift-addr", ":8083", "Thrift listen address") thriftProtocol = fs.String("thrift-protocol", "binary", "binary, compact, json, simplejson") thriftBuffer = fs.Int("thrift-buffer", 0, "0 for unbuffered") thriftFramed = fs.Bool("thrift-framed", false, "true to enable framing") zipkinURL = fs.String("zipkin-url", "", "Enable Zipkin tracing via a collector URL e.g. http://localhost:9411/api/v1/spans") lightstepToken = flag.String("lightstep-token", "", "Enable LightStep tracing via a LightStep access token") appdashAddr = flag.String("appdash-addr", "", "Enable Appdash tracing via an Appdash server host:port") ) fs.Usage = usageFor(fs, os.Args[0]+" [flags]") fs.Parse(os.Args[1:]) // Create a single logger, which we'll use and give to other components. var logger log.Logger { logger = log.NewLogfmtLogger(os.Stderr) logger = log.With(logger, "ts", log.DefaultTimestampUTC) logger = log.With(logger, "caller", log.DefaultCaller) } // Determine which tracer to use. We'll pass the tracer to all the // components that use it, as a dependency. var tracer stdopentracing.Tracer { if *zipkinURL != "" { logger.Log("tracer", "Zipkin", "URL", *zipkinURL) collector, err := zipkin.NewHTTPCollector(*zipkinURL) if err != nil { logger.Log("err", err) os.Exit(1) } defer collector.Close() var ( debug = false hostPort = "localhost:80" serviceName = "addsvc" ) recorder := zipkin.NewRecorder(collector, debug, hostPort, serviceName) tracer, err = zipkin.NewTracer(recorder) if err != nil { logger.Log("err", err) os.Exit(1) } } else if *lightstepToken != "" { logger.Log("tracer", "LightStep") // probably don't want to print out the token :) tracer = lightstep.NewTracer(lightstep.Options{ AccessToken: *lightstepToken, }) defer lightstep.FlushLightStepTracer(tracer) } else if *appdashAddr != "" { logger.Log("tracer", "Appdash", "addr", *appdashAddr) tracer = appdashot.NewTracer(appdash.NewRemoteCollector(*appdashAddr)) } else { logger.Log("tracer", "none") tracer = stdopentracing.GlobalTracer() // no-op } } // Create the (sparse) metrics we'll use in the service. They, too, are // dependencies that we pass to components that use them. var ints, chars metrics.Counter { // Business-level metrics. ints = prometheus.NewCounterFrom(stdprometheus.CounterOpts{ Namespace: "example", Subsystem: "addsvc", Name: "integers_summed", Help: "Total count of integers summed via the Sum method.", }, []string{}) chars = prometheus.NewCounterFrom(stdprometheus.CounterOpts{ Namespace: "example", Subsystem: "addsvc", Name: "characters_concatenated", Help: "Total count of characters concatenated via the Concat method.", }, []string{}) } var duration metrics.Histogram { // Endpoint-level metrics. duration = prometheus.NewSummaryFrom(stdprometheus.SummaryOpts{ Namespace: "example", Subsystem: "addsvc", Name: "request_duration_seconds", Help: "Request duration in seconds.", }, []string{"method", "success"}) } http.DefaultServeMux.Handle("/metrics", promhttp.Handler()) // Build the layers of the service "onion" from the inside out. First, the // business logic service; then, the set of endpoints that wrap the service; // and finally, a series of concrete transport adapters. The adapters, like // the HTTP handler or the gRPC server, are the bridge between Go kit and // the interfaces that the transports expect. Note that we're not binding // them to ports or anything yet; we'll do that next. var ( service = addservice.New(logger, ints, chars) endpoints = addendpoint.New(service, logger, duration, tracer) httpHandler = addtransport.NewHTTPHandler(endpoints, tracer, logger) grpcServer = addtransport.NewGRPCServer(endpoints, tracer, logger) thriftServer = addtransport.NewThriftServer(endpoints) ) // Now we're to the part of the func main where we want to start actually // running things, like servers bound to listeners to receive connections. // // The method is the same for each component: add a new actor to the group // struct, which is a combination of 2 anonymous functions: the first // function actually runs the component, and the second function should // interrupt the first function and cause it to return. It's in these // functions that we actually bind the Go kit server/handler structs to the // concrete transports and run them. // // Putting each component into its own block is mostly for aesthetics: it // clearly demarcates the scope in which each listener/socket may be used. var g group.Group { // The debug listener mounts the http.DefaultServeMux, and serves up // stuff like the Prometheus metrics route, the Go debug and profiling // routes, and so on. debugListener, err := net.Listen("tcp", *debugAddr) if err != nil { logger.Log("transport", "debug/HTTP", "during", "Listen", "err", err) os.Exit(1) } g.Add(func() error { logger.Log("transport", "debug/HTTP", "addr", *debugAddr) return http.Serve(debugListener, http.DefaultServeMux) }, func(error) { debugListener.Close() }) } { // The HTTP listener mounts the Go kit HTTP handler we created. httpListener, err := net.Listen("tcp", *httpAddr) if err != nil { logger.Log("transport", "HTTP", "during", "Listen", "err", err) os.Exit(1) } g.Add(func() error { logger.Log("transport", "HTTP", "addr", *httpAddr) return http.Serve(httpListener, httpHandler) }, func(error) { httpListener.Close() }) } { // The gRPC listener mounts the Go kit gRPC server we created. grpcListener, err := net.Listen("tcp", *grpcAddr) if err != nil { logger.Log("transport", "gRPC", "during", "Listen", "err", err) os.Exit(1) } g.Add(func() error { logger.Log("transport", "gRPC", "addr", *grpcAddr) baseServer := grpc.NewServer() addpb.RegisterAddServer(baseServer, grpcServer) return baseServer.Serve(grpcListener) }, func(error) { grpcListener.Close() }) } { // The Thrift socket mounts the Go kit Thrift server we created earlier. // There's a lot of boilerplate involved here, related to configuring // the protocol and transport; blame Thrift. thriftSocket, err := thrift.NewTServerSocket(*thriftAddr) if err != nil { logger.Log("transport", "Thrift", "during", "Listen", "err", err) os.Exit(1) } g.Add(func() error { logger.Log("transport", "Thrift", "addr", *thriftAddr) var protocolFactory thrift.TProtocolFactory switch *thriftProtocol { case "binary": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() case "json": protocolFactory = thrift.NewTJSONProtocolFactory() case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() default: return fmt.Errorf("invalid Thrift protocol %q", *thriftProtocol) } var transportFactory thrift.TTransportFactory if *thriftBuffer > 0 { transportFactory = thrift.NewTBufferedTransportFactory(*thriftBuffer) } else { transportFactory = thrift.NewTTransportFactory() } if *thriftFramed { transportFactory = thrift.NewTFramedTransportFactory(transportFactory) } return thrift.NewTSimpleServer4( addthrift.NewAddServiceProcessor(thriftServer), thriftSocket, transportFactory, protocolFactory, ).Serve() }, func(error) { thriftSocket.Close() }) } { // This function just sits and waits for ctrl-C. cancelInterrupt := make(chan struct{}) g.Add(func() error { c := make(chan os.Signal, 1) signal.Notify(c, syscall.SIGINT, syscall.SIGTERM) select { case sig := <-c: return fmt.Errorf("received signal %s", sig) case <-cancelInterrupt: return nil } }, func(error) { close(cancelInterrupt) }) } logger.Log("exit", g.Run()) } func usageFor(fs *flag.FlagSet, short string) func() { return func() { fmt.Fprintf(os.Stderr, "USAGE\n") fmt.Fprintf(os.Stderr, " %s\n", short) fmt.Fprintf(os.Stderr, "\n") fmt.Fprintf(os.Stderr, "FLAGS\n") w := tabwriter.NewWriter(os.Stderr, 0, 2, 2, ' ', 0) fs.VisitAll(func(f *flag.Flag) { fmt.Fprintf(w, "\t-%s %s\t%s\n", f.Name, f.DefValue, f.Usage) }) w.Flush() fmt.Fprintf(os.Stderr, "\n") } } golang-github-go-kit-kit-0.6.0/examples/addsvc/cmd/addsvc/pact_test.go000066400000000000000000000023361316471211400256330ustar00rootroot00000000000000package main import ( "fmt" "net/http" "os" "strings" "testing" "github.com/pact-foundation/pact-go/dsl" ) func TestPactStringsvcUppercase(t *testing.T) { if os.Getenv("WRITE_PACTS") == "" { t.Skip("skipping Pact contracts; set WRITE_PACTS environment variable to enable") } pact := dsl.Pact{ Port: 6666, Consumer: "addsvc", Provider: "stringsvc", } defer pact.Teardown() pact.AddInteraction(). UponReceiving("stringsvc uppercase"). WithRequest(dsl.Request{ Headers: map[string]string{"Content-Type": "application/json; charset=utf-8"}, Method: "POST", Path: "/uppercase", Body: `{"s":"foo"}`, }). WillRespondWith(dsl.Response{ Status: 200, Headers: map[string]string{"Content-Type": "application/json; charset=utf-8"}, Body: `{"v":"FOO"}`, }) if err := pact.Verify(func() error { u := fmt.Sprintf("http://localhost:%d/uppercase", pact.Server.Port) req, err := http.NewRequest("POST", u, strings.NewReader(`{"s":"foo"}`)) if err != nil { return err } req.Header.Set("Content-Type", "application/json; charset=utf-8") if _, err = http.DefaultClient.Do(req); err != nil { return err } return nil }); err != nil { t.Fatal(err) } pact.WritePact() } golang-github-go-kit-kit-0.6.0/examples/addsvc/cmd/addsvc/wiring_test.go000066400000000000000000000024301316471211400261760ustar00rootroot00000000000000package main import ( "io/ioutil" "net/http" "net/http/httptest" "strings" "testing" "github.com/opentracing/opentracing-go" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics/discard" "github.com/go-kit/kit/examples/addsvc/pkg/addendpoint" "github.com/go-kit/kit/examples/addsvc/pkg/addservice" "github.com/go-kit/kit/examples/addsvc/pkg/addtransport" ) func TestHTTP(t *testing.T) { svc := addservice.New(log.NewNopLogger(), discard.NewCounter(), discard.NewCounter()) eps := addendpoint.New(svc, log.NewNopLogger(), discard.NewHistogram(), opentracing.GlobalTracer()) mux := addtransport.NewHTTPHandler(eps, opentracing.GlobalTracer(), log.NewNopLogger()) srv := httptest.NewServer(mux) defer srv.Close() for _, testcase := range []struct { method, url, body, want string }{ {"GET", srv.URL + "/concat", `{"a":"1","b":"2"}`, `{"v":"12"}`}, {"GET", srv.URL + "/sum", `{"a":1,"b":2}`, `{"v":3}`}, } { req, _ := http.NewRequest(testcase.method, testcase.url, strings.NewReader(testcase.body)) resp, _ := http.DefaultClient.Do(req) body, _ := ioutil.ReadAll(resp.Body) if want, have := testcase.want, strings.TrimSpace(string(body)); want != have { t.Errorf("%s %s %s: want %q, have %q", testcase.method, testcase.url, testcase.body, want, have) } } } golang-github-go-kit-kit-0.6.0/examples/addsvc/pb/000077500000000000000000000000001316471211400217045ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/pb/addsvc.pb.go000066400000000000000000000177211316471211400241070ustar00rootroot00000000000000// Code generated by protoc-gen-go. DO NOT EDIT. // source: addsvc.proto /* Package pb is a generated protocol buffer package. It is generated from these files: addsvc.proto It has these top-level messages: SumRequest SumReply ConcatRequest ConcatReply */ package pb import proto "github.com/golang/protobuf/proto" import fmt "fmt" import math "math" import ( context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package // The sum request contains two parameters. type SumRequest struct { A int64 `protobuf:"varint,1,opt,name=a" json:"a,omitempty"` B int64 `protobuf:"varint,2,opt,name=b" json:"b,omitempty"` } func (m *SumRequest) Reset() { *m = SumRequest{} } func (m *SumRequest) String() string { return proto.CompactTextString(m) } func (*SumRequest) ProtoMessage() {} func (*SumRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } func (m *SumRequest) GetA() int64 { if m != nil { return m.A } return 0 } func (m *SumRequest) GetB() int64 { if m != nil { return m.B } return 0 } // The sum response contains the result of the calculation. type SumReply struct { V int64 `protobuf:"varint,1,opt,name=v" json:"v,omitempty"` Err string `protobuf:"bytes,2,opt,name=err" json:"err,omitempty"` } func (m *SumReply) Reset() { *m = SumReply{} } func (m *SumReply) String() string { return proto.CompactTextString(m) } func (*SumReply) ProtoMessage() {} func (*SumReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } func (m *SumReply) GetV() int64 { if m != nil { return m.V } return 0 } func (m *SumReply) GetErr() string { if m != nil { return m.Err } return "" } // The Concat request contains two parameters. type ConcatRequest struct { A string `protobuf:"bytes,1,opt,name=a" json:"a,omitempty"` B string `protobuf:"bytes,2,opt,name=b" json:"b,omitempty"` } func (m *ConcatRequest) Reset() { *m = ConcatRequest{} } func (m *ConcatRequest) String() string { return proto.CompactTextString(m) } func (*ConcatRequest) ProtoMessage() {} func (*ConcatRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } func (m *ConcatRequest) GetA() string { if m != nil { return m.A } return "" } func (m *ConcatRequest) GetB() string { if m != nil { return m.B } return "" } // The Concat response contains the result of the concatenation. type ConcatReply struct { V string `protobuf:"bytes,1,opt,name=v" json:"v,omitempty"` Err string `protobuf:"bytes,2,opt,name=err" json:"err,omitempty"` } func (m *ConcatReply) Reset() { *m = ConcatReply{} } func (m *ConcatReply) String() string { return proto.CompactTextString(m) } func (*ConcatReply) ProtoMessage() {} func (*ConcatReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } func (m *ConcatReply) GetV() string { if m != nil { return m.V } return "" } func (m *ConcatReply) GetErr() string { if m != nil { return m.Err } return "" } func init() { proto.RegisterType((*SumRequest)(nil), "pb.SumRequest") proto.RegisterType((*SumReply)(nil), "pb.SumReply") proto.RegisterType((*ConcatRequest)(nil), "pb.ConcatRequest") proto.RegisterType((*ConcatReply)(nil), "pb.ConcatReply") } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // Client API for Add service type AddClient interface { // Sums two integers. Sum(ctx context.Context, in *SumRequest, opts ...grpc.CallOption) (*SumReply, error) // Concatenates two strings Concat(ctx context.Context, in *ConcatRequest, opts ...grpc.CallOption) (*ConcatReply, error) } type addClient struct { cc *grpc.ClientConn } func NewAddClient(cc *grpc.ClientConn) AddClient { return &addClient{cc} } func (c *addClient) Sum(ctx context.Context, in *SumRequest, opts ...grpc.CallOption) (*SumReply, error) { out := new(SumReply) err := grpc.Invoke(ctx, "/pb.Add/Sum", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } func (c *addClient) Concat(ctx context.Context, in *ConcatRequest, opts ...grpc.CallOption) (*ConcatReply, error) { out := new(ConcatReply) err := grpc.Invoke(ctx, "/pb.Add/Concat", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } // Server API for Add service type AddServer interface { // Sums two integers. Sum(context.Context, *SumRequest) (*SumReply, error) // Concatenates two strings Concat(context.Context, *ConcatRequest) (*ConcatReply, error) } func RegisterAddServer(s *grpc.Server, srv AddServer) { s.RegisterService(&_Add_serviceDesc, srv) } func _Add_Sum_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(SumRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(AddServer).Sum(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pb.Add/Sum", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AddServer).Sum(ctx, req.(*SumRequest)) } return interceptor(ctx, in, info, handler) } func _Add_Concat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ConcatRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(AddServer).Concat(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pb.Add/Concat", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AddServer).Concat(ctx, req.(*ConcatRequest)) } return interceptor(ctx, in, info, handler) } var _Add_serviceDesc = grpc.ServiceDesc{ ServiceName: "pb.Add", HandlerType: (*AddServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Sum", Handler: _Add_Sum_Handler, }, { MethodName: "Concat", Handler: _Add_Concat_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "addsvc.proto", } func init() { proto.RegisterFile("addsvc.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ // 189 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x49, 0x4c, 0x49, 0x29, 0x2e, 0x4b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2a, 0x48, 0x52, 0xd2, 0xe0, 0xe2, 0x0a, 0x2e, 0xcd, 0x0d, 0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x11, 0xe2, 0xe1, 0x62, 0x4c, 0x94, 0x60, 0x54, 0x60, 0xd4, 0x60, 0x0e, 0x62, 0x4c, 0x04, 0xf1, 0x92, 0x24, 0x98, 0x20, 0xbc, 0x24, 0x25, 0x2d, 0x2e, 0x0e, 0xb0, 0xca, 0x82, 0x9c, 0x4a, 0x90, 0x4c, 0x19, 0x4c, 0x5d, 0x99, 0x90, 0x00, 0x17, 0x73, 0x6a, 0x51, 0x11, 0x58, 0x25, 0x67, 0x10, 0x88, 0xa9, 0xa4, 0xcd, 0xc5, 0xeb, 0x9c, 0x9f, 0x97, 0x9c, 0x58, 0x82, 0x61, 0x30, 0x27, 0x8a, 0xc1, 0x9c, 0x20, 0x83, 0x75, 0xb9, 0xb8, 0x61, 0x8a, 0x51, 0xcc, 0xe6, 0xc4, 0x6a, 0xb6, 0x51, 0x0c, 0x17, 0xb3, 0x63, 0x4a, 0x8a, 0x90, 0x2a, 0x17, 0x73, 0x70, 0x69, 0xae, 0x10, 0x9f, 0x5e, 0x41, 0x92, 0x1e, 0xc2, 0x07, 0x52, 0x3c, 0x70, 0x7e, 0x41, 0x4e, 0xa5, 0x12, 0x83, 0x90, 0x1e, 0x17, 0x1b, 0xc4, 0x70, 0x21, 0x41, 0x90, 0x0c, 0x8a, 0xab, 0xa4, 0xf8, 0x91, 0x85, 0xc0, 0xea, 0x93, 0xd8, 0xc0, 0x41, 0x63, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x37, 0x81, 0x99, 0x2a, 0x01, 0x00, 0x00, } golang-github-go-kit-kit-0.6.0/examples/addsvc/pb/addsvc.proto000066400000000000000000000012451316471211400242370ustar00rootroot00000000000000syntax = "proto3"; package pb; // The Add service definition. service Add { // Sums two integers. rpc Sum (SumRequest) returns (SumReply) {} // Concatenates two strings rpc Concat (ConcatRequest) returns (ConcatReply) {} } // The sum request contains two parameters. message SumRequest { int64 a = 1; int64 b = 2; } // The sum response contains the result of the calculation. message SumReply { int64 v = 1; string err = 2; } // The Concat request contains two parameters. message ConcatRequest { string a = 1; string b = 2; } // The Concat response contains the result of the concatenation. message ConcatReply { string v = 1; string err = 2; } golang-github-go-kit-kit-0.6.0/examples/addsvc/pb/compile.sh000077500000000000000000000006201316471211400236710ustar00rootroot00000000000000#!/usr/bin/env sh # Install proto3 from source # brew install autoconf automake libtool # git clone https://github.com/google/protobuf # ./autogen.sh ; ./configure ; make ; make install # # Update protoc Go bindings via # go get -u github.com/golang/protobuf/{proto,protoc-gen-go} # # See also # https://github.com/grpc/grpc-go/tree/master/examples protoc addsvc.proto --go_out=plugins=grpc:. golang-github-go-kit-kit-0.6.0/examples/addsvc/pkg/000077500000000000000000000000001316471211400220645ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/pkg/addendpoint/000077500000000000000000000000001316471211400243555ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/pkg/addendpoint/middleware.go000066400000000000000000000024411316471211400270220ustar00rootroot00000000000000package addendpoint import ( "context" "fmt" "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics" ) // InstrumentingMiddleware returns an endpoint middleware that records // the duration of each invocation to the passed histogram. The middleware adds // a single field: "success", which is "true" if no error is returned, and // "false" otherwise. func InstrumentingMiddleware(duration metrics.Histogram) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { defer func(begin time.Time) { duration.With("success", fmt.Sprint(err == nil)).Observe(time.Since(begin).Seconds()) }(time.Now()) return next(ctx, request) } } } // LoggingMiddleware returns an endpoint middleware that logs the // duration of each invocation, and the resulting error, if any. func LoggingMiddleware(logger log.Logger) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { defer func(begin time.Time) { logger.Log("transport_error", err, "took", time.Since(begin)) }(time.Now()) return next(ctx, request) } } } golang-github-go-kit-kit-0.6.0/examples/addsvc/pkg/addendpoint/set.go000066400000000000000000000106571316471211400255100ustar00rootroot00000000000000package addendpoint import ( "context" rl "github.com/juju/ratelimit" stdopentracing "github.com/opentracing/opentracing-go" "github.com/sony/gobreaker" "github.com/go-kit/kit/circuitbreaker" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/ratelimit" "github.com/go-kit/kit/tracing/opentracing" "github.com/go-kit/kit/examples/addsvc/pkg/addservice" ) // Set collects all of the endpoints that compose an add service. It's meant to // be used as a helper struct, to collect all of the endpoints into a single // parameter. type Set struct { SumEndpoint endpoint.Endpoint ConcatEndpoint endpoint.Endpoint } // New returns a Set that wraps the provided server, and wires in all of the // expected endpoint middlewares via the various parameters. func New(svc addservice.Service, logger log.Logger, duration metrics.Histogram, trace stdopentracing.Tracer) Set { var sumEndpoint endpoint.Endpoint { sumEndpoint = MakeSumEndpoint(svc) sumEndpoint = ratelimit.NewTokenBucketLimiter(rl.NewBucketWithRate(1, 1))(sumEndpoint) sumEndpoint = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{}))(sumEndpoint) sumEndpoint = opentracing.TraceServer(trace, "Sum")(sumEndpoint) sumEndpoint = LoggingMiddleware(log.With(logger, "method", "Sum"))(sumEndpoint) sumEndpoint = InstrumentingMiddleware(duration.With("method", "Sum"))(sumEndpoint) } var concatEndpoint endpoint.Endpoint { concatEndpoint = MakeConcatEndpoint(svc) concatEndpoint = ratelimit.NewTokenBucketLimiter(rl.NewBucketWithRate(100, 100))(concatEndpoint) concatEndpoint = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{}))(concatEndpoint) concatEndpoint = opentracing.TraceServer(trace, "Concat")(concatEndpoint) concatEndpoint = LoggingMiddleware(log.With(logger, "method", "Concat"))(concatEndpoint) concatEndpoint = InstrumentingMiddleware(duration.With("method", "Concat"))(concatEndpoint) } return Set{ SumEndpoint: sumEndpoint, ConcatEndpoint: concatEndpoint, } } // Sum implements the service interface, so Set may be used as a service. // This is primarily useful in the context of a client library. func (s Set) Sum(ctx context.Context, a, b int) (int, error) { resp, err := s.SumEndpoint(ctx, SumRequest{A: a, B: b}) if err != nil { return 0, err } response := resp.(SumResponse) return response.V, response.Err } // Concat implements the service interface, so Set may be used as a // service. This is primarily useful in the context of a client library. func (s Set) Concat(ctx context.Context, a, b string) (string, error) { resp, err := s.ConcatEndpoint(ctx, ConcatRequest{A: a, B: b}) if err != nil { return "", err } response := resp.(ConcatResponse) return response.V, response.Err } // MakeSumEndpoint constructs a Sum endpoint wrapping the service. func MakeSumEndpoint(s addservice.Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { req := request.(SumRequest) v, err := s.Sum(ctx, req.A, req.B) return SumResponse{V: v, Err: err}, nil } } // MakeConcatEndpoint constructs a Concat endpoint wrapping the service. func MakeConcatEndpoint(s addservice.Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { req := request.(ConcatRequest) v, err := s.Concat(ctx, req.A, req.B) return ConcatResponse{V: v, Err: err}, nil } } // Failer is an interface that should be implemented by response types. // Response encoders can check if responses are Failer, and if so if they've // failed, and if so encode them using a separate write path based on the error. type Failer interface { Failed() error } // SumRequest collects the request parameters for the Sum method. type SumRequest struct { A, B int } // SumResponse collects the response values for the Sum method. type SumResponse struct { V int `json:"v"` Err error `json:"-"` // should be intercepted by Failed/errorEncoder } // Failed implements Failer. func (r SumResponse) Failed() error { return r.Err } // ConcatRequest collects the request parameters for the Concat method. type ConcatRequest struct { A, B string } // ConcatResponse collects the response values for the Concat method. type ConcatResponse struct { V string `json:"v"` Err error `json:"-"` } // Failed implements Failer. func (r ConcatResponse) Failed() error { return r.Err } golang-github-go-kit-kit-0.6.0/examples/addsvc/pkg/addservice/000077500000000000000000000000001316471211400241755ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/pkg/addservice/middleware.go000066400000000000000000000033351316471211400266450ustar00rootroot00000000000000package addservice import ( "context" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics" ) // Middleware describes a service (as opposed to endpoint) middleware. type Middleware func(Service) Service // LoggingMiddleware takes a logger as a dependency // and returns a ServiceMiddleware. func LoggingMiddleware(logger log.Logger) Middleware { return func(next Service) Service { return loggingMiddleware{logger, next} } } type loggingMiddleware struct { logger log.Logger next Service } func (mw loggingMiddleware) Sum(ctx context.Context, a, b int) (v int, err error) { defer func() { mw.logger.Log("method", "Sum", "a", a, "b", b, "v", v, "err", err) }() return mw.next.Sum(ctx, a, b) } func (mw loggingMiddleware) Concat(ctx context.Context, a, b string) (v string, err error) { defer func() { mw.logger.Log("method", "Concat", "a", a, "b", b, "v", v, "err", err) }() return mw.next.Concat(ctx, a, b) } // InstrumentingMiddleware returns a service middleware that instruments // the number of integers summed and characters concatenated over the lifetime of // the service. func InstrumentingMiddleware(ints, chars metrics.Counter) Middleware { return func(next Service) Service { return instrumentingMiddleware{ ints: ints, chars: chars, next: next, } } } type instrumentingMiddleware struct { ints metrics.Counter chars metrics.Counter next Service } func (mw instrumentingMiddleware) Sum(ctx context.Context, a, b int) (int, error) { v, err := mw.next.Sum(ctx, a, b) mw.ints.Add(float64(v)) return v, err } func (mw instrumentingMiddleware) Concat(ctx context.Context, a, b string) (string, error) { v, err := mw.next.Concat(ctx, a, b) mw.chars.Add(float64(len(v))) return v, err } golang-github-go-kit-kit-0.6.0/examples/addsvc/pkg/addservice/service.go000066400000000000000000000034701316471211400261700ustar00rootroot00000000000000package addservice import ( "context" "errors" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics" ) // Service describes a service that adds things together. type Service interface { Sum(ctx context.Context, a, b int) (int, error) Concat(ctx context.Context, a, b string) (string, error) } // New returns a basic Service with all of the expected middlewares wired in. func New(logger log.Logger, ints, chars metrics.Counter) Service { var svc Service { svc = NewBasicService() svc = LoggingMiddleware(logger)(svc) svc = InstrumentingMiddleware(ints, chars)(svc) } return svc } var ( // ErrTwoZeroes is an arbitrary business rule for the Add method. ErrTwoZeroes = errors.New("can't sum two zeroes") // ErrIntOverflow protects the Add method. We've decided that this error // indicates a misbehaving service and should count against e.g. circuit // breakers. So, we return it directly in endpoints, to illustrate the // difference. In a real service, this probably wouldn't be the case. ErrIntOverflow = errors.New("integer overflow") // ErrMaxSizeExceeded protects the Concat method. ErrMaxSizeExceeded = errors.New("result exceeds maximum size") ) // NewBasicService returns a naïve, stateless implementation of Service. func NewBasicService() Service { return basicService{} } type basicService struct{} const ( intMax = 1<<31 - 1 intMin = -(intMax + 1) maxLen = 10 ) func (s basicService) Sum(_ context.Context, a, b int) (int, error) { if a == 0 && b == 0 { return 0, ErrTwoZeroes } if (b > 0 && a > (intMax-b)) || (b < 0 && a < (intMin-b)) { return 0, ErrIntOverflow } return a + b, nil } // Concat implements Service. func (s basicService) Concat(_ context.Context, a, b string) (string, error) { if len(a)+len(b) > maxLen { return "", ErrMaxSizeExceeded } return a + b, nil } golang-github-go-kit-kit-0.6.0/examples/addsvc/pkg/addtransport/000077500000000000000000000000001316471211400245715ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/pkg/addtransport/grpc.go000066400000000000000000000172231316471211400260600ustar00rootroot00000000000000package addtransport import ( "context" "errors" "time" "google.golang.org/grpc" jujuratelimit "github.com/juju/ratelimit" stdopentracing "github.com/opentracing/opentracing-go" "github.com/sony/gobreaker" oldcontext "golang.org/x/net/context" "github.com/go-kit/kit/circuitbreaker" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" "github.com/go-kit/kit/ratelimit" "github.com/go-kit/kit/tracing/opentracing" grpctransport "github.com/go-kit/kit/transport/grpc" "github.com/go-kit/kit/examples/addsvc/pb" "github.com/go-kit/kit/examples/addsvc/pkg/addendpoint" "github.com/go-kit/kit/examples/addsvc/pkg/addservice" ) type grpcServer struct { sum grpctransport.Handler concat grpctransport.Handler } // NewGRPCServer makes a set of endpoints available as a gRPC AddServer. func NewGRPCServer(endpoints addendpoint.Set, tracer stdopentracing.Tracer, logger log.Logger) pb.AddServer { options := []grpctransport.ServerOption{ grpctransport.ServerErrorLogger(logger), } return &grpcServer{ sum: grpctransport.NewServer( endpoints.SumEndpoint, decodeGRPCSumRequest, encodeGRPCSumResponse, append(options, grpctransport.ServerBefore(opentracing.GRPCToContext(tracer, "Sum", logger)))..., ), concat: grpctransport.NewServer( endpoints.ConcatEndpoint, decodeGRPCConcatRequest, encodeGRPCConcatResponse, append(options, grpctransport.ServerBefore(opentracing.GRPCToContext(tracer, "Concat", logger)))..., ), } } func (s *grpcServer) Sum(ctx oldcontext.Context, req *pb.SumRequest) (*pb.SumReply, error) { _, rep, err := s.sum.ServeGRPC(ctx, req) if err != nil { return nil, err } return rep.(*pb.SumReply), nil } func (s *grpcServer) Concat(ctx oldcontext.Context, req *pb.ConcatRequest) (*pb.ConcatReply, error) { _, rep, err := s.concat.ServeGRPC(ctx, req) if err != nil { return nil, err } return rep.(*pb.ConcatReply), nil } // NewGRPCClient returns an AddService backed by a gRPC server at the other end // of the conn. The caller is responsible for constructing the conn, and // eventually closing the underlying transport. We bake-in certain middlewares, // implementing the client library pattern. func NewGRPCClient(conn *grpc.ClientConn, tracer stdopentracing.Tracer, logger log.Logger) addservice.Service { // We construct a single ratelimiter middleware, to limit the total outgoing // QPS from this client to all methods on the remote instance. We also // construct per-endpoint circuitbreaker middlewares to demonstrate how // that's done, although they could easily be combined into a single breaker // for the entire remote instance, too. limiter := ratelimit.NewTokenBucketLimiter(jujuratelimit.NewBucketWithRate(100, 100)) // Each individual endpoint is an http/transport.Client (which implements // endpoint.Endpoint) that gets wrapped with various middlewares. If you // made your own client library, you'd do this work there, so your server // could rely on a consistent set of client behavior. var sumEndpoint endpoint.Endpoint { sumEndpoint = grpctransport.NewClient( conn, "pb.Add", "Sum", encodeGRPCSumRequest, decodeGRPCSumResponse, pb.SumReply{}, grpctransport.ClientBefore(opentracing.ContextToGRPC(tracer, logger)), ).Endpoint() sumEndpoint = opentracing.TraceClient(tracer, "Sum")(sumEndpoint) sumEndpoint = limiter(sumEndpoint) sumEndpoint = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{ Name: "Sum", Timeout: 30 * time.Second, }))(sumEndpoint) } // The Concat endpoint is the same thing, with slightly different // middlewares to demonstrate how to specialize per-endpoint. var concatEndpoint endpoint.Endpoint { concatEndpoint = grpctransport.NewClient( conn, "pb.Add", "Concat", encodeGRPCConcatRequest, decodeGRPCConcatResponse, pb.ConcatReply{}, grpctransport.ClientBefore(opentracing.ContextToGRPC(tracer, logger)), ).Endpoint() concatEndpoint = opentracing.TraceClient(tracer, "Concat")(concatEndpoint) concatEndpoint = limiter(concatEndpoint) concatEndpoint = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{ Name: "Concat", Timeout: 10 * time.Second, }))(concatEndpoint) } // Returning the endpoint.Set as a service.Service relies on the // endpoint.Set implementing the Service methods. That's just a simple bit // of glue code. return addendpoint.Set{ SumEndpoint: sumEndpoint, ConcatEndpoint: concatEndpoint, } } // decodeGRPCSumRequest is a transport/grpc.DecodeRequestFunc that converts a // gRPC sum request to a user-domain sum request. Primarily useful in a server. func decodeGRPCSumRequest(_ context.Context, grpcReq interface{}) (interface{}, error) { req := grpcReq.(*pb.SumRequest) return addendpoint.SumRequest{A: int(req.A), B: int(req.B)}, nil } // decodeGRPCConcatRequest is a transport/grpc.DecodeRequestFunc that converts a // gRPC concat request to a user-domain concat request. Primarily useful in a // server. func decodeGRPCConcatRequest(_ context.Context, grpcReq interface{}) (interface{}, error) { req := grpcReq.(*pb.ConcatRequest) return addendpoint.ConcatRequest{A: req.A, B: req.B}, nil } // decodeGRPCSumResponse is a transport/grpc.DecodeResponseFunc that converts a // gRPC sum reply to a user-domain sum response. Primarily useful in a client. func decodeGRPCSumResponse(_ context.Context, grpcReply interface{}) (interface{}, error) { reply := grpcReply.(*pb.SumReply) return addendpoint.SumResponse{V: int(reply.V), Err: str2err(reply.Err)}, nil } // decodeGRPCConcatResponse is a transport/grpc.DecodeResponseFunc that converts // a gRPC concat reply to a user-domain concat response. Primarily useful in a // client. func decodeGRPCConcatResponse(_ context.Context, grpcReply interface{}) (interface{}, error) { reply := grpcReply.(*pb.ConcatReply) return addendpoint.ConcatResponse{V: reply.V, Err: str2err(reply.Err)}, nil } // encodeGRPCSumResponse is a transport/grpc.EncodeResponseFunc that converts a // user-domain sum response to a gRPC sum reply. Primarily useful in a server. func encodeGRPCSumResponse(_ context.Context, response interface{}) (interface{}, error) { resp := response.(addendpoint.SumResponse) return &pb.SumReply{V: int64(resp.V), Err: err2str(resp.Err)}, nil } // encodeGRPCConcatResponse is a transport/grpc.EncodeResponseFunc that converts // a user-domain concat response to a gRPC concat reply. Primarily useful in a // server. func encodeGRPCConcatResponse(_ context.Context, response interface{}) (interface{}, error) { resp := response.(addendpoint.ConcatResponse) return &pb.ConcatReply{V: resp.V, Err: err2str(resp.Err)}, nil } // encodeGRPCSumRequest is a transport/grpc.EncodeRequestFunc that converts a // user-domain sum request to a gRPC sum request. Primarily useful in a client. func encodeGRPCSumRequest(_ context.Context, request interface{}) (interface{}, error) { req := request.(addendpoint.SumRequest) return &pb.SumRequest{A: int64(req.A), B: int64(req.B)}, nil } // encodeGRPCConcatRequest is a transport/grpc.EncodeRequestFunc that converts a // user-domain concat request to a gRPC concat request. Primarily useful in a // client. func encodeGRPCConcatRequest(_ context.Context, request interface{}) (interface{}, error) { req := request.(addendpoint.ConcatRequest) return &pb.ConcatRequest{A: req.A, B: req.B}, nil } // These annoying helper functions are required to translate Go error types to // and from strings, which is the type we use in our IDLs to represent errors. // There is special casing to treat empty strings as nil errors. func str2err(s string) error { if s == "" { return nil } return errors.New(s) } func err2str(err error) string { if err == nil { return "" } return err.Error() } golang-github-go-kit-kit-0.6.0/examples/addsvc/pkg/addtransport/http.go000066400000000000000000000170641316471211400261070ustar00rootroot00000000000000package addtransport import ( "bytes" "context" "encoding/json" "errors" "io/ioutil" "net/http" "net/url" "strings" "time" jujuratelimit "github.com/juju/ratelimit" stdopentracing "github.com/opentracing/opentracing-go" "github.com/sony/gobreaker" "github.com/go-kit/kit/circuitbreaker" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" "github.com/go-kit/kit/ratelimit" "github.com/go-kit/kit/tracing/opentracing" httptransport "github.com/go-kit/kit/transport/http" "github.com/go-kit/kit/examples/addsvc/pkg/addendpoint" "github.com/go-kit/kit/examples/addsvc/pkg/addservice" ) // NewHTTPHandler returns an HTTP handler that makes a set of endpoints // available on predefined paths. func NewHTTPHandler(endpoints addendpoint.Set, tracer stdopentracing.Tracer, logger log.Logger) http.Handler { options := []httptransport.ServerOption{ httptransport.ServerErrorEncoder(errorEncoder), httptransport.ServerErrorLogger(logger), } m := http.NewServeMux() m.Handle("/sum", httptransport.NewServer( endpoints.SumEndpoint, decodeHTTPSumRequest, encodeHTTPGenericResponse, append(options, httptransport.ServerBefore(opentracing.HTTPToContext(tracer, "Sum", logger)))..., )) m.Handle("/concat", httptransport.NewServer( endpoints.ConcatEndpoint, decodeHTTPConcatRequest, encodeHTTPGenericResponse, append(options, httptransport.ServerBefore(opentracing.HTTPToContext(tracer, "Concat", logger)))..., )) return m } // NewHTTPClient returns an AddService backed by an HTTP server living at the // remote instance. We expect instance to come from a service discovery system, // so likely of the form "host:port". We bake-in certain middlewares, // implementing the client library pattern. func NewHTTPClient(instance string, tracer stdopentracing.Tracer, logger log.Logger) (addservice.Service, error) { // Quickly sanitize the instance string. if !strings.HasPrefix(instance, "http") { instance = "http://" + instance } u, err := url.Parse(instance) if err != nil { return nil, err } // We construct a single ratelimiter middleware, to limit the total outgoing // QPS from this client to all methods on the remote instance. We also // construct per-endpoint circuitbreaker middlewares to demonstrate how // that's done, although they could easily be combined into a single breaker // for the entire remote instance, too. limiter := ratelimit.NewTokenBucketLimiter(jujuratelimit.NewBucketWithRate(100, 100)) // Each individual endpoint is an http/transport.Client (which implements // endpoint.Endpoint) that gets wrapped with various middlewares. If you // made your own client library, you'd do this work there, so your server // could rely on a consistent set of client behavior. var sumEndpoint endpoint.Endpoint { sumEndpoint = httptransport.NewClient( "POST", copyURL(u, "/sum"), encodeHTTPGenericRequest, decodeHTTPSumResponse, httptransport.ClientBefore(opentracing.ContextToHTTP(tracer, logger)), ).Endpoint() sumEndpoint = opentracing.TraceClient(tracer, "Sum")(sumEndpoint) sumEndpoint = limiter(sumEndpoint) sumEndpoint = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{ Name: "Sum", Timeout: 30 * time.Second, }))(sumEndpoint) } // The Concat endpoint is the same thing, with slightly different // middlewares to demonstrate how to specialize per-endpoint. var concatEndpoint endpoint.Endpoint { concatEndpoint = httptransport.NewClient( "POST", copyURL(u, "/concat"), encodeHTTPGenericRequest, decodeHTTPConcatResponse, httptransport.ClientBefore(opentracing.ContextToHTTP(tracer, logger)), ).Endpoint() concatEndpoint = opentracing.TraceClient(tracer, "Concat")(concatEndpoint) concatEndpoint = limiter(concatEndpoint) concatEndpoint = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{ Name: "Concat", Timeout: 10 * time.Second, }))(concatEndpoint) } // Returning the endpoint.Set as a service.Service relies on the // endpoint.Set implementing the Service methods. That's just a simple bit // of glue code. return addendpoint.Set{ SumEndpoint: sumEndpoint, ConcatEndpoint: concatEndpoint, }, nil } func copyURL(base *url.URL, path string) *url.URL { next := *base next.Path = path return &next } func errorEncoder(_ context.Context, err error, w http.ResponseWriter) { w.WriteHeader(err2code(err)) json.NewEncoder(w).Encode(errorWrapper{Error: err.Error()}) } func err2code(err error) int { switch err { case addservice.ErrTwoZeroes, addservice.ErrMaxSizeExceeded, addservice.ErrIntOverflow: return http.StatusBadRequest } return http.StatusInternalServerError } func errorDecoder(r *http.Response) error { var w errorWrapper if err := json.NewDecoder(r.Body).Decode(&w); err != nil { return err } return errors.New(w.Error) } type errorWrapper struct { Error string `json:"error"` } // decodeHTTPSumRequest is a transport/http.DecodeRequestFunc that decodes a // JSON-encoded sum request from the HTTP request body. Primarily useful in a // server. func decodeHTTPSumRequest(_ context.Context, r *http.Request) (interface{}, error) { var req addendpoint.SumRequest err := json.NewDecoder(r.Body).Decode(&req) return req, err } // decodeHTTPConcatRequest is a transport/http.DecodeRequestFunc that decodes a // JSON-encoded concat request from the HTTP request body. Primarily useful in a // server. func decodeHTTPConcatRequest(_ context.Context, r *http.Request) (interface{}, error) { var req addendpoint.ConcatRequest err := json.NewDecoder(r.Body).Decode(&req) return req, err } // decodeHTTPSumResponse is a transport/http.DecodeResponseFunc that decodes a // JSON-encoded sum response from the HTTP response body. If the response has a // non-200 status code, we will interpret that as an error and attempt to decode // the specific error message from the response body. Primarily useful in a // client. func decodeHTTPSumResponse(_ context.Context, r *http.Response) (interface{}, error) { if r.StatusCode != http.StatusOK { return nil, errors.New(r.Status) } var resp addendpoint.SumResponse err := json.NewDecoder(r.Body).Decode(&resp) return resp, err } // decodeHTTPConcatResponse is a transport/http.DecodeResponseFunc that decodes // a JSON-encoded concat response from the HTTP response body. If the response // has a non-200 status code, we will interpret that as an error and attempt to // decode the specific error message from the response body. Primarily useful in // a client. func decodeHTTPConcatResponse(_ context.Context, r *http.Response) (interface{}, error) { if r.StatusCode != http.StatusOK { return nil, errors.New(r.Status) } var resp addendpoint.ConcatResponse err := json.NewDecoder(r.Body).Decode(&resp) return resp, err } // encodeHTTPGenericRequest is a transport/http.EncodeRequestFunc that // JSON-encodes any request to the request body. Primarily useful in a client. func encodeHTTPGenericRequest(_ context.Context, r *http.Request, request interface{}) error { var buf bytes.Buffer if err := json.NewEncoder(&buf).Encode(request); err != nil { return err } r.Body = ioutil.NopCloser(&buf) return nil } // encodeHTTPGenericResponse is a transport/http.EncodeResponseFunc that encodes // the response as JSON to the response writer. Primarily useful in a server. func encodeHTTPGenericResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error { if f, ok := response.(addendpoint.Failer); ok && f.Failed() != nil { errorEncoder(ctx, f.Failed(), w) return nil } w.Header().Set("Content-Type", "application/json; charset=utf-8") return json.NewEncoder(w).Encode(response) } golang-github-go-kit-kit-0.6.0/examples/addsvc/pkg/addtransport/thrift.go000066400000000000000000000107031316471211400264210ustar00rootroot00000000000000package addtransport import ( "context" "time" jujuratelimit "github.com/juju/ratelimit" "github.com/sony/gobreaker" "github.com/go-kit/kit/circuitbreaker" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/ratelimit" "github.com/go-kit/kit/examples/addsvc/pkg/addendpoint" "github.com/go-kit/kit/examples/addsvc/pkg/addservice" addthrift "github.com/go-kit/kit/examples/addsvc/thrift/gen-go/addsvc" ) type thriftServer struct { ctx context.Context endpoints addendpoint.Set } // NewThriftServer makes a set of endpoints available as a Thrift service. func NewThriftServer(endpoints addendpoint.Set) addthrift.AddService { return &thriftServer{ endpoints: endpoints, } } func (s *thriftServer) Sum(ctx context.Context, a int64, b int64) (*addthrift.SumReply, error) { request := addendpoint.SumRequest{A: int(a), B: int(b)} response, err := s.endpoints.SumEndpoint(ctx, request) if err != nil { return nil, err } resp := response.(addendpoint.SumResponse) return &addthrift.SumReply{Value: int64(resp.V), Err: err2str(resp.Err)}, nil } func (s *thriftServer) Concat(ctx context.Context, a string, b string) (*addthrift.ConcatReply, error) { request := addendpoint.ConcatRequest{A: a, B: b} response, err := s.endpoints.ConcatEndpoint(ctx, request) if err != nil { return nil, err } resp := response.(addendpoint.ConcatResponse) return &addthrift.ConcatReply{Value: resp.V, Err: err2str(resp.Err)}, nil } // NewThriftClient returns an AddService backed by a Thrift server described by // the provided client. The caller is responsible for constructing the client, // and eventually closing the underlying transport. We bake-in certain middlewares, // implementing the client library pattern. func NewThriftClient(client *addthrift.AddServiceClient) addservice.Service { // We construct a single ratelimiter middleware, to limit the total outgoing // QPS from this client to all methods on the remote instance. We also // construct per-endpoint circuitbreaker middlewares to demonstrate how // that's done, although they could easily be combined into a single breaker // for the entire remote instance, too. limiter := ratelimit.NewTokenBucketLimiter(jujuratelimit.NewBucketWithRate(100, 100)) // Each individual endpoint is an http/transport.Client (which implements // endpoint.Endpoint) that gets wrapped with various middlewares. If you // could rely on a consistent set of client behavior. var sumEndpoint endpoint.Endpoint { sumEndpoint = MakeThriftSumEndpoint(client) sumEndpoint = limiter(sumEndpoint) sumEndpoint = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{ Name: "Sum", Timeout: 30 * time.Second, }))(sumEndpoint) } // The Concat endpoint is the same thing, with slightly different // middlewares to demonstrate how to specialize per-endpoint. var concatEndpoint endpoint.Endpoint { concatEndpoint = MakeThriftConcatEndpoint(client) concatEndpoint = limiter(concatEndpoint) concatEndpoint = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{ Name: "Concat", Timeout: 10 * time.Second, }))(concatEndpoint) } // Returning the endpoint.Set as a service.Service relies on the // endpoint.Set implementing the Service methods. That's just a simple bit // of glue code. return addendpoint.Set{ SumEndpoint: sumEndpoint, ConcatEndpoint: concatEndpoint, } } // MakeThriftSumEndpoint returns an endpoint that invokes the passed Thrift client. // Useful only in clients, and only until a proper transport/thrift.Client exists. func MakeThriftSumEndpoint(client *addthrift.AddServiceClient) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(addendpoint.SumRequest) reply, err := client.Sum(ctx, int64(req.A), int64(req.B)) if err == addservice.ErrIntOverflow { return nil, err // special case; see comment on ErrIntOverflow } return addendpoint.SumResponse{V: int(reply.Value), Err: err}, nil } } // MakeThriftConcatEndpoint returns an endpoint that invokes the passed Thrift // client. Useful only in clients, and only until a proper // transport/thrift.Client exists. func MakeThriftConcatEndpoint(client *addthrift.AddServiceClient) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(addendpoint.ConcatRequest) reply, err := client.Concat(ctx, req.A, req.B) return addendpoint.ConcatResponse{V: reply.Value, Err: err}, nil } } golang-github-go-kit-kit-0.6.0/examples/addsvc/thrift/000077500000000000000000000000001316471211400226035ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/thrift/addsvc.thrift000066400000000000000000000003211316471211400252650ustar00rootroot00000000000000struct SumReply { 1: i64 value 2: string err } struct ConcatReply { 1: string value 2: string err } service AddService { SumReply Sum(1: i64 a, 2: i64 b) ConcatReply Concat(1: string a, 2: string b) } golang-github-go-kit-kit-0.6.0/examples/addsvc/thrift/compile.sh000077500000000000000000000003411316471211400245700ustar00rootroot00000000000000#!/usr/bin/env sh # See also https://thrift.apache.org/tutorial/go thrift -r --gen "go:package_prefix=github.com/go-kit/kit/examples/addsvc/thrift/gen-go/,thrift_import=github.com/apache/thrift/lib/go/thrift" addsvc.thrift golang-github-go-kit-kit-0.6.0/examples/addsvc/thrift/gen-go/000077500000000000000000000000001316471211400237575ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/thrift/gen-go/addsvc/000077500000000000000000000000001316471211400252235ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/thrift/gen-go/addsvc/GoUnusedProtection__.go000066400000000000000000000002441316471211400316500ustar00rootroot00000000000000// Autogenerated by Thrift Compiler (1.0.0-dev) // DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING package addsvc var GoUnusedProtection__ int; golang-github-go-kit-kit-0.6.0/examples/addsvc/thrift/gen-go/addsvc/add_service-remote/000077500000000000000000000000001316471211400307645ustar00rootroot00000000000000add_service-remote.go000077500000000000000000000104071316471211400350020ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/addsvc/thrift/gen-go/addsvc/add_service-remote// Autogenerated by Thrift Compiler (1.0.0-dev) // DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING package main import ( "context" "flag" "fmt" "math" "net" "net/url" "os" "strconv" "strings" "github.com/apache/thrift/lib/go/thrift" "github.com/go-kit/kit/examples/addsvc/thrift/gen-go/addsvc" ) func Usage() { fmt.Fprintln(os.Stderr, "Usage of ", os.Args[0], " [-h host:port] [-u url] [-f[ramed]] function [arg1 [arg2...]]:") flag.PrintDefaults() fmt.Fprintln(os.Stderr, "\nFunctions:") fmt.Fprintln(os.Stderr, " SumReply Sum(i64 a, i64 b)") fmt.Fprintln(os.Stderr, " ConcatReply Concat(string a, string b)") fmt.Fprintln(os.Stderr) os.Exit(0) } func main() { flag.Usage = Usage var host string var port int var protocol string var urlString string var framed bool var useHttp bool var parsedUrl url.URL var trans thrift.TTransport _ = strconv.Atoi _ = math.Abs flag.Usage = Usage flag.StringVar(&host, "h", "localhost", "Specify host and port") flag.IntVar(&port, "p", 9090, "Specify port") flag.StringVar(&protocol, "P", "binary", "Specify the protocol (binary, compact, simplejson, json)") flag.StringVar(&urlString, "u", "", "Specify the url") flag.BoolVar(&framed, "framed", false, "Use framed transport") flag.BoolVar(&useHttp, "http", false, "Use http") flag.Parse() if len(urlString) > 0 { parsedUrl, err := url.Parse(urlString) if err != nil { fmt.Fprintln(os.Stderr, "Error parsing URL: ", err) flag.Usage() } host = parsedUrl.Host useHttp = len(parsedUrl.Scheme) <= 0 || parsedUrl.Scheme == "http" } else if useHttp { _, err := url.Parse(fmt.Sprint("http://", host, ":", port)) if err != nil { fmt.Fprintln(os.Stderr, "Error parsing URL: ", err) flag.Usage() } } cmd := flag.Arg(0) var err error if useHttp { trans, err = thrift.NewTHttpClient(parsedUrl.String()) } else { portStr := fmt.Sprint(port) if strings.Contains(host, ":") { host, portStr, err = net.SplitHostPort(host) if err != nil { fmt.Fprintln(os.Stderr, "error with host:", err) os.Exit(1) } } trans, err = thrift.NewTSocket(net.JoinHostPort(host, portStr)) if err != nil { fmt.Fprintln(os.Stderr, "error resolving address:", err) os.Exit(1) } if framed { trans = thrift.NewTFramedTransport(trans) } } if err != nil { fmt.Fprintln(os.Stderr, "Error creating transport", err) os.Exit(1) } defer trans.Close() var protocolFactory thrift.TProtocolFactory switch protocol { case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() break case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() break case "json": protocolFactory = thrift.NewTJSONProtocolFactory() break case "binary", "": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() break default: fmt.Fprintln(os.Stderr, "Invalid protocol specified: ", protocol) Usage() os.Exit(1) } client := addsvc.NewAddServiceClientFactory(trans, protocolFactory) if err := trans.Open(); err != nil { fmt.Fprintln(os.Stderr, "Error opening socket to ", host, ":", port, " ", err) os.Exit(1) } switch cmd { case "Sum": if flag.NArg() - 1 != 2 { fmt.Fprintln(os.Stderr, "Sum requires 2 args") flag.Usage() } argvalue0, err6 := (strconv.ParseInt(flag.Arg(1), 10, 64)) if err6 != nil { Usage() return } value0 := argvalue0 argvalue1, err7 := (strconv.ParseInt(flag.Arg(2), 10, 64)) if err7 != nil { Usage() return } value1 := argvalue1 fmt.Print(client.Sum(context.Background(), value0, value1)) fmt.Print("\n") break case "Concat": if flag.NArg() - 1 != 2 { fmt.Fprintln(os.Stderr, "Concat requires 2 args") flag.Usage() } argvalue0 := flag.Arg(1) value0 := argvalue0 argvalue1 := flag.Arg(2) value1 := argvalue1 fmt.Print(client.Concat(context.Background(), value0, value1)) fmt.Print("\n") break case "": Usage() break default: fmt.Fprintln(os.Stderr, "Invalid function ", cmd) } } golang-github-go-kit-kit-0.6.0/examples/addsvc/thrift/gen-go/addsvc/addsvc-consts.go000066400000000000000000000006541316471211400303320ustar00rootroot00000000000000// Autogenerated by Thrift Compiler (1.0.0-dev) // DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING package addsvc import ( "bytes" "reflect" "context" "fmt" "github.com/apache/thrift/lib/go/thrift" ) // (needed to ensure safety because of naive import list construction.) var _ = thrift.ZERO var _ = fmt.Printf var _ = context.Background var _ = reflect.DeepEqual var _ = bytes.Equal func init() { } golang-github-go-kit-kit-0.6.0/examples/addsvc/thrift/gen-go/addsvc/addsvc.go000066400000000000000000000751501316471211400270260ustar00rootroot00000000000000// Autogenerated by Thrift Compiler (1.0.0-dev) // DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING package addsvc import ( "bytes" "reflect" "context" "fmt" "github.com/apache/thrift/lib/go/thrift" ) // (needed to ensure safety because of naive import list construction.) var _ = thrift.ZERO var _ = fmt.Printf var _ = context.Background var _ = reflect.DeepEqual var _ = bytes.Equal // Attributes: // - Value // - Err type SumReply struct { Value int64 `thrift:"value,1" db:"value" json:"value"` Err string `thrift:"err,2" db:"err" json:"err"` } func NewSumReply() *SumReply { return &SumReply{} } func (p *SumReply) GetValue() int64 { return p.Value } func (p *SumReply) GetErr() string { return p.Err } func (p *SumReply) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break; } switch fieldId { case 1: if fieldTypeId == thrift.I64 { if err := p.ReadField1(iprot); err != nil { return err } } else { if err := iprot.Skip(fieldTypeId); err != nil { return err } } case 2: if fieldTypeId == thrift.STRING { if err := p.ReadField2(iprot); err != nil { return err } } else { if err := iprot.Skip(fieldTypeId); err != nil { return err } } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } func (p *SumReply) ReadField1(iprot thrift.TProtocol) error { if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { p.Value = v } return nil } func (p *SumReply) ReadField2(iprot thrift.TProtocol) error { if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 2: ", err) } else { p.Err = v } return nil } func (p *SumReply) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("SumReply"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { if err := p.writeField1(oprot); err != nil { return err } if err := p.writeField2(oprot); err != nil { return err } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *SumReply) writeField1(oprot thrift.TProtocol) (err error) { if err := oprot.WriteFieldBegin("value", thrift.I64, 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:value: ", p), err) } if err := oprot.WriteI64(int64(p.Value)); err != nil { return thrift.PrependError(fmt.Sprintf("%T.value (1) field write error: ", p), err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 1:value: ", p), err) } return err } func (p *SumReply) writeField2(oprot thrift.TProtocol) (err error) { if err := oprot.WriteFieldBegin("err", thrift.STRING, 2); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:err: ", p), err) } if err := oprot.WriteString(string(p.Err)); err != nil { return thrift.PrependError(fmt.Sprintf("%T.err (2) field write error: ", p), err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 2:err: ", p), err) } return err } func (p *SumReply) String() string { if p == nil { return "" } return fmt.Sprintf("SumReply(%+v)", *p) } // Attributes: // - Value // - Err type ConcatReply struct { Value string `thrift:"value,1" db:"value" json:"value"` Err string `thrift:"err,2" db:"err" json:"err"` } func NewConcatReply() *ConcatReply { return &ConcatReply{} } func (p *ConcatReply) GetValue() string { return p.Value } func (p *ConcatReply) GetErr() string { return p.Err } func (p *ConcatReply) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break; } switch fieldId { case 1: if fieldTypeId == thrift.STRING { if err := p.ReadField1(iprot); err != nil { return err } } else { if err := iprot.Skip(fieldTypeId); err != nil { return err } } case 2: if fieldTypeId == thrift.STRING { if err := p.ReadField2(iprot); err != nil { return err } } else { if err := iprot.Skip(fieldTypeId); err != nil { return err } } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } func (p *ConcatReply) ReadField1(iprot thrift.TProtocol) error { if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { p.Value = v } return nil } func (p *ConcatReply) ReadField2(iprot thrift.TProtocol) error { if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 2: ", err) } else { p.Err = v } return nil } func (p *ConcatReply) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("ConcatReply"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { if err := p.writeField1(oprot); err != nil { return err } if err := p.writeField2(oprot); err != nil { return err } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *ConcatReply) writeField1(oprot thrift.TProtocol) (err error) { if err := oprot.WriteFieldBegin("value", thrift.STRING, 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:value: ", p), err) } if err := oprot.WriteString(string(p.Value)); err != nil { return thrift.PrependError(fmt.Sprintf("%T.value (1) field write error: ", p), err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 1:value: ", p), err) } return err } func (p *ConcatReply) writeField2(oprot thrift.TProtocol) (err error) { if err := oprot.WriteFieldBegin("err", thrift.STRING, 2); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:err: ", p), err) } if err := oprot.WriteString(string(p.Err)); err != nil { return thrift.PrependError(fmt.Sprintf("%T.err (2) field write error: ", p), err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 2:err: ", p), err) } return err } func (p *ConcatReply) String() string { if p == nil { return "" } return fmt.Sprintf("ConcatReply(%+v)", *p) } type AddService interface { // Parameters: // - A // - B Sum(ctx context.Context, a int64, b int64) (r *SumReply, err error) // Parameters: // - A // - B Concat(ctx context.Context, a string, b string) (r *ConcatReply, err error) } type AddServiceClient struct { Transport thrift.TTransport ProtocolFactory thrift.TProtocolFactory InputProtocol thrift.TProtocol OutputProtocol thrift.TProtocol SeqId int32 } func NewAddServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *AddServiceClient { return &AddServiceClient{Transport: t, ProtocolFactory: f, InputProtocol: f.GetProtocol(t), OutputProtocol: f.GetProtocol(t), SeqId: 0, } } func NewAddServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *AddServiceClient { return &AddServiceClient{Transport: t, ProtocolFactory: nil, InputProtocol: iprot, OutputProtocol: oprot, SeqId: 0, } } // Parameters: // - A // - B func (p *AddServiceClient) Sum(ctx context.Context, a int64, b int64) (r *SumReply, err error) { if err = p.sendSum(a, b); err != nil { return } return p.recvSum() } func (p *AddServiceClient) sendSum(a int64, b int64)(err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ if err = oprot.WriteMessageBegin("Sum", thrift.CALL, p.SeqId); err != nil { return } args := AddServiceSumArgs{ A : a, B : b, } if err = args.Write(oprot); err != nil { return } if err = oprot.WriteMessageEnd(); err != nil { return } return oprot.Flush() } func (p *AddServiceClient) recvSum() (value *SumReply, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) p.InputProtocol = iprot } method, mTypeId, seqId, err := iprot.ReadMessageBegin() if err != nil { return } if method != "Sum" { err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "Sum failed: wrong method name") return } if p.SeqId != seqId { err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "Sum failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { error0 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") var error1 error error1, err = error0.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } err = error1 return } if mTypeId != thrift.REPLY { err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "Sum failed: invalid message type") return } result := AddServiceSumResult{} if err = result.Read(iprot); err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } value = result.GetSuccess() return } // Parameters: // - A // - B func (p *AddServiceClient) Concat(ctx context.Context, a string, b string) (r *ConcatReply, err error) { if err = p.sendConcat(a, b); err != nil { return } return p.recvConcat() } func (p *AddServiceClient) sendConcat(a string, b string)(err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ if err = oprot.WriteMessageBegin("Concat", thrift.CALL, p.SeqId); err != nil { return } args := AddServiceConcatArgs{ A : a, B : b, } if err = args.Write(oprot); err != nil { return } if err = oprot.WriteMessageEnd(); err != nil { return } return oprot.Flush() } func (p *AddServiceClient) recvConcat() (value *ConcatReply, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) p.InputProtocol = iprot } method, mTypeId, seqId, err := iprot.ReadMessageBegin() if err != nil { return } if method != "Concat" { err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "Concat failed: wrong method name") return } if p.SeqId != seqId { err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "Concat failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { error2 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") var error3 error error3, err = error2.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } err = error3 return } if mTypeId != thrift.REPLY { err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "Concat failed: invalid message type") return } result := AddServiceConcatResult{} if err = result.Read(iprot); err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } value = result.GetSuccess() return } type AddServiceProcessor struct { processorMap map[string]thrift.TProcessorFunction handler AddService } func (p *AddServiceProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) { p.processorMap[key] = processor } func (p *AddServiceProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) { processor, ok = p.processorMap[key] return processor, ok } func (p *AddServiceProcessor) ProcessorMap() map[string]thrift.TProcessorFunction { return p.processorMap } func NewAddServiceProcessor(handler AddService) *AddServiceProcessor { self4 := &AddServiceProcessor{handler:handler, processorMap:make(map[string]thrift.TProcessorFunction)} self4.processorMap["Sum"] = &addServiceProcessorSum{handler:handler} self4.processorMap["Concat"] = &addServiceProcessorConcat{handler:handler} return self4 } func (p *AddServiceProcessor) Process(ctx context.Context, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { name, _, seqId, err := iprot.ReadMessageBegin() if err != nil { return false, err } if processor, ok := p.GetProcessorFunction(name); ok { return processor.Process(ctx, seqId, iprot, oprot) } iprot.Skip(thrift.STRUCT) iprot.ReadMessageEnd() x5 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function " + name) oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId) x5.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return false, x5 } type addServiceProcessorSum struct { handler AddService } func (p *addServiceProcessorSum) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { args := AddServiceSumArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) oprot.WriteMessageBegin("Sum", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return false, err } iprot.ReadMessageEnd() result := AddServiceSumResult{} var retval *SumReply var err2 error if retval, err2 = p.handler.Sum(ctx, args.A, args.B); err2 != nil { x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing Sum: " + err2.Error()) oprot.WriteMessageBegin("Sum", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } else { result.Success = retval } if err2 = oprot.WriteMessageBegin("Sum", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { err = err2 } if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { err = err2 } if err2 = oprot.Flush(); err == nil && err2 != nil { err = err2 } if err != nil { return } return true, err } type addServiceProcessorConcat struct { handler AddService } func (p *addServiceProcessorConcat) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { args := AddServiceConcatArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) oprot.WriteMessageBegin("Concat", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return false, err } iprot.ReadMessageEnd() result := AddServiceConcatResult{} var retval *ConcatReply var err2 error if retval, err2 = p.handler.Concat(ctx, args.A, args.B); err2 != nil { x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing Concat: " + err2.Error()) oprot.WriteMessageBegin("Concat", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } else { result.Success = retval } if err2 = oprot.WriteMessageBegin("Concat", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { err = err2 } if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { err = err2 } if err2 = oprot.Flush(); err == nil && err2 != nil { err = err2 } if err != nil { return } return true, err } // HELPER FUNCTIONS AND STRUCTURES // Attributes: // - A // - B type AddServiceSumArgs struct { A int64 `thrift:"a,1" db:"a" json:"a"` B int64 `thrift:"b,2" db:"b" json:"b"` } func NewAddServiceSumArgs() *AddServiceSumArgs { return &AddServiceSumArgs{} } func (p *AddServiceSumArgs) GetA() int64 { return p.A } func (p *AddServiceSumArgs) GetB() int64 { return p.B } func (p *AddServiceSumArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break; } switch fieldId { case 1: if fieldTypeId == thrift.I64 { if err := p.ReadField1(iprot); err != nil { return err } } else { if err := iprot.Skip(fieldTypeId); err != nil { return err } } case 2: if fieldTypeId == thrift.I64 { if err := p.ReadField2(iprot); err != nil { return err } } else { if err := iprot.Skip(fieldTypeId); err != nil { return err } } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } func (p *AddServiceSumArgs) ReadField1(iprot thrift.TProtocol) error { if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { p.A = v } return nil } func (p *AddServiceSumArgs) ReadField2(iprot thrift.TProtocol) error { if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 2: ", err) } else { p.B = v } return nil } func (p *AddServiceSumArgs) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("Sum_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { if err := p.writeField1(oprot); err != nil { return err } if err := p.writeField2(oprot); err != nil { return err } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *AddServiceSumArgs) writeField1(oprot thrift.TProtocol) (err error) { if err := oprot.WriteFieldBegin("a", thrift.I64, 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:a: ", p), err) } if err := oprot.WriteI64(int64(p.A)); err != nil { return thrift.PrependError(fmt.Sprintf("%T.a (1) field write error: ", p), err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 1:a: ", p), err) } return err } func (p *AddServiceSumArgs) writeField2(oprot thrift.TProtocol) (err error) { if err := oprot.WriteFieldBegin("b", thrift.I64, 2); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:b: ", p), err) } if err := oprot.WriteI64(int64(p.B)); err != nil { return thrift.PrependError(fmt.Sprintf("%T.b (2) field write error: ", p), err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 2:b: ", p), err) } return err } func (p *AddServiceSumArgs) String() string { if p == nil { return "" } return fmt.Sprintf("AddServiceSumArgs(%+v)", *p) } // Attributes: // - Success type AddServiceSumResult struct { Success *SumReply `thrift:"success,0" db:"success" json:"success,omitempty"` } func NewAddServiceSumResult() *AddServiceSumResult { return &AddServiceSumResult{} } var AddServiceSumResult_Success_DEFAULT *SumReply func (p *AddServiceSumResult) GetSuccess() *SumReply { if !p.IsSetSuccess() { return AddServiceSumResult_Success_DEFAULT } return p.Success } func (p *AddServiceSumResult) IsSetSuccess() bool { return p.Success != nil } func (p *AddServiceSumResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break; } switch fieldId { case 0: if fieldTypeId == thrift.STRUCT { if err := p.ReadField0(iprot); err != nil { return err } } else { if err := iprot.Skip(fieldTypeId); err != nil { return err } } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } func (p *AddServiceSumResult) ReadField0(iprot thrift.TProtocol) error { p.Success = &SumReply{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } func (p *AddServiceSumResult) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("Sum_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { if err := p.writeField0(oprot); err != nil { return err } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *AddServiceSumResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) } if err := p.Success.Write(oprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) } } return err } func (p *AddServiceSumResult) String() string { if p == nil { return "" } return fmt.Sprintf("AddServiceSumResult(%+v)", *p) } // Attributes: // - A // - B type AddServiceConcatArgs struct { A string `thrift:"a,1" db:"a" json:"a"` B string `thrift:"b,2" db:"b" json:"b"` } func NewAddServiceConcatArgs() *AddServiceConcatArgs { return &AddServiceConcatArgs{} } func (p *AddServiceConcatArgs) GetA() string { return p.A } func (p *AddServiceConcatArgs) GetB() string { return p.B } func (p *AddServiceConcatArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break; } switch fieldId { case 1: if fieldTypeId == thrift.STRING { if err := p.ReadField1(iprot); err != nil { return err } } else { if err := iprot.Skip(fieldTypeId); err != nil { return err } } case 2: if fieldTypeId == thrift.STRING { if err := p.ReadField2(iprot); err != nil { return err } } else { if err := iprot.Skip(fieldTypeId); err != nil { return err } } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } func (p *AddServiceConcatArgs) ReadField1(iprot thrift.TProtocol) error { if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { p.A = v } return nil } func (p *AddServiceConcatArgs) ReadField2(iprot thrift.TProtocol) error { if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 2: ", err) } else { p.B = v } return nil } func (p *AddServiceConcatArgs) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("Concat_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { if err := p.writeField1(oprot); err != nil { return err } if err := p.writeField2(oprot); err != nil { return err } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *AddServiceConcatArgs) writeField1(oprot thrift.TProtocol) (err error) { if err := oprot.WriteFieldBegin("a", thrift.STRING, 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:a: ", p), err) } if err := oprot.WriteString(string(p.A)); err != nil { return thrift.PrependError(fmt.Sprintf("%T.a (1) field write error: ", p), err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 1:a: ", p), err) } return err } func (p *AddServiceConcatArgs) writeField2(oprot thrift.TProtocol) (err error) { if err := oprot.WriteFieldBegin("b", thrift.STRING, 2); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:b: ", p), err) } if err := oprot.WriteString(string(p.B)); err != nil { return thrift.PrependError(fmt.Sprintf("%T.b (2) field write error: ", p), err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 2:b: ", p), err) } return err } func (p *AddServiceConcatArgs) String() string { if p == nil { return "" } return fmt.Sprintf("AddServiceConcatArgs(%+v)", *p) } // Attributes: // - Success type AddServiceConcatResult struct { Success *ConcatReply `thrift:"success,0" db:"success" json:"success,omitempty"` } func NewAddServiceConcatResult() *AddServiceConcatResult { return &AddServiceConcatResult{} } var AddServiceConcatResult_Success_DEFAULT *ConcatReply func (p *AddServiceConcatResult) GetSuccess() *ConcatReply { if !p.IsSetSuccess() { return AddServiceConcatResult_Success_DEFAULT } return p.Success } func (p *AddServiceConcatResult) IsSetSuccess() bool { return p.Success != nil } func (p *AddServiceConcatResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break; } switch fieldId { case 0: if fieldTypeId == thrift.STRUCT { if err := p.ReadField0(iprot); err != nil { return err } } else { if err := iprot.Skip(fieldTypeId); err != nil { return err } } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } func (p *AddServiceConcatResult) ReadField0(iprot thrift.TProtocol) error { p.Success = &ConcatReply{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } func (p *AddServiceConcatResult) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("Concat_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { if err := p.writeField0(oprot); err != nil { return err } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *AddServiceConcatResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) } if err := p.Success.Write(oprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) } } return err } func (p *AddServiceConcatResult) String() string { if p == nil { return "" } return fmt.Sprintf("AddServiceConcatResult(%+v)", *p) } golang-github-go-kit-kit-0.6.0/examples/apigateway/000077500000000000000000000000001316471211400221725ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/apigateway/main.go000066400000000000000000000215721316471211400234540ustar00rootroot00000000000000package main import ( "bytes" "context" "encoding/json" "flag" "fmt" "io" "io/ioutil" "net/http" "net/url" "os" "os/signal" "strings" "syscall" "time" consulsd "github.com/go-kit/kit/sd/consul" "github.com/gorilla/mux" "github.com/hashicorp/consul/api" stdopentracing "github.com/opentracing/opentracing-go" "google.golang.org/grpc" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" "github.com/go-kit/kit/sd/lb" httptransport "github.com/go-kit/kit/transport/http" "github.com/go-kit/kit/examples/addsvc/pkg/addendpoint" "github.com/go-kit/kit/examples/addsvc/pkg/addservice" "github.com/go-kit/kit/examples/addsvc/pkg/addtransport" ) func main() { var ( httpAddr = flag.String("http.addr", ":8000", "Address for HTTP (JSON) server") consulAddr = flag.String("consul.addr", "", "Consul agent address") retryMax = flag.Int("retry.max", 3, "per-request retries to different instances") retryTimeout = flag.Duration("retry.timeout", 500*time.Millisecond, "per-request timeout, including retries") ) flag.Parse() // Logging domain. var logger log.Logger { logger = log.NewLogfmtLogger(os.Stderr) logger = log.With(logger, "ts", log.DefaultTimestampUTC) logger = log.With(logger, "caller", log.DefaultCaller) } // Service discovery domain. In this example we use Consul. var client consulsd.Client { consulConfig := api.DefaultConfig() if len(*consulAddr) > 0 { consulConfig.Address = *consulAddr } consulClient, err := api.NewClient(consulConfig) if err != nil { logger.Log("err", err) os.Exit(1) } client = consulsd.NewClient(consulClient) } // Transport domain. tracer := stdopentracing.GlobalTracer() // no-op ctx := context.Background() r := mux.NewRouter() // Now we begin installing the routes. Each route corresponds to a single // method: sum, concat, uppercase, and count. // addsvc routes. { // Each method gets constructed with a factory. Factories take an // instance string, and return a specific endpoint. In the factory we // dial the instance string we get from Consul, and then leverage an // addsvc client package to construct a complete service. We can then // leverage the addsvc.Make{Sum,Concat}Endpoint constructors to convert // the complete service to specific endpoint. var ( tags = []string{} passingOnly = true endpoints = addendpoint.Set{} instancer = consulsd.NewInstancer(client, logger, "addsvc", tags, passingOnly) ) { factory := addsvcFactory(addendpoint.MakeSumEndpoint, tracer, logger) endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(*retryMax, *retryTimeout, balancer) endpoints.SumEndpoint = retry } { factory := addsvcFactory(addendpoint.MakeConcatEndpoint, tracer, logger) endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(*retryMax, *retryTimeout, balancer) endpoints.ConcatEndpoint = retry } // Here we leverage the fact that addsvc comes with a constructor for an // HTTP handler, and just install it under a particular path prefix in // our router. r.PathPrefix("/addsvc").Handler(http.StripPrefix("/addsvc", addtransport.NewHTTPHandler(endpoints, tracer, logger))) } // stringsvc routes. { // addsvc had lots of nice importable Go packages we could leverage. // With stringsvc we are not so fortunate, it just has some endpoints // that we assume will exist. So we have to write that logic here. This // is by design, so you can see two totally different methods of // proxying to a remote service. var ( tags = []string{} passingOnly = true uppercase endpoint.Endpoint count endpoint.Endpoint instancer = consulsd.NewInstancer(client, logger, "stringsvc", tags, passingOnly) ) { factory := stringsvcFactory(ctx, "GET", "/uppercase") endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(*retryMax, *retryTimeout, balancer) uppercase = retry } { factory := stringsvcFactory(ctx, "GET", "/count") endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(*retryMax, *retryTimeout, balancer) count = retry } // We can use the transport/http.Server to act as our handler, all we // have to do provide it with the encode and decode functions for our // stringsvc methods. r.Handle("/stringsvc/uppercase", httptransport.NewServer(uppercase, decodeUppercaseRequest, encodeJSONResponse)) r.Handle("/stringsvc/count", httptransport.NewServer(count, decodeCountRequest, encodeJSONResponse)) } // Interrupt handler. errc := make(chan error) go func() { c := make(chan os.Signal) signal.Notify(c, syscall.SIGINT, syscall.SIGTERM) errc <- fmt.Errorf("%s", <-c) }() // HTTP transport. go func() { logger.Log("transport", "HTTP", "addr", *httpAddr) errc <- http.ListenAndServe(*httpAddr, r) }() // Run! logger.Log("exit", <-errc) } func addsvcFactory(makeEndpoint func(addservice.Service) endpoint.Endpoint, tracer stdopentracing.Tracer, logger log.Logger) sd.Factory { return func(instance string) (endpoint.Endpoint, io.Closer, error) { // We could just as easily use the HTTP or Thrift client package to make // the connection to addsvc. We've chosen gRPC arbitrarily. Note that // the transport is an implementation detail: it doesn't leak out of // this function. Nice! conn, err := grpc.Dial(instance, grpc.WithInsecure()) if err != nil { return nil, nil, err } service := addtransport.NewGRPCClient(conn, tracer, logger) endpoint := makeEndpoint(service) // Notice that the addsvc gRPC client converts the connection to a // complete addsvc, and we just throw away everything except the method // we're interested in. A smarter factory would mux multiple methods // over the same connection. But that would require more work to manage // the returned io.Closer, e.g. reference counting. Since this is for // the purposes of demonstration, we'll just keep it simple. return endpoint, conn, nil } } func stringsvcFactory(ctx context.Context, method, path string) sd.Factory { return func(instance string) (endpoint.Endpoint, io.Closer, error) { if !strings.HasPrefix(instance, "http") { instance = "http://" + instance } tgt, err := url.Parse(instance) if err != nil { return nil, nil, err } tgt.Path = path // Since stringsvc doesn't have any kind of package we can import, or // any formal spec, we are forced to just assert where the endpoints // live, and write our own code to encode and decode requests and // responses. Ideally, if you write the service, you will want to // provide stronger guarantees to your clients. var ( enc httptransport.EncodeRequestFunc dec httptransport.DecodeResponseFunc ) switch path { case "/uppercase": enc, dec = encodeJSONRequest, decodeUppercaseResponse case "/count": enc, dec = encodeJSONRequest, decodeCountResponse default: return nil, nil, fmt.Errorf("unknown stringsvc path %q", path) } return httptransport.NewClient(method, tgt, enc, dec).Endpoint(), nil, nil } } func encodeJSONRequest(_ context.Context, req *http.Request, request interface{}) error { // Both uppercase and count requests are encoded in the same way: // simple JSON serialization to the request body. var buf bytes.Buffer if err := json.NewEncoder(&buf).Encode(request); err != nil { return err } req.Body = ioutil.NopCloser(&buf) return nil } func encodeJSONResponse(_ context.Context, w http.ResponseWriter, response interface{}) error { w.Header().Set("Content-Type", "application/json; charset=utf-8") return json.NewEncoder(w).Encode(response) } // I've just copied these functions from stringsvc3/transport.go, inlining the // struct definitions. func decodeUppercaseResponse(ctx context.Context, resp *http.Response) (interface{}, error) { var response struct { V string `json:"v"` Err string `json:"err,omitempty"` } if err := json.NewDecoder(resp.Body).Decode(&response); err != nil { return nil, err } return response, nil } func decodeCountResponse(ctx context.Context, resp *http.Response) (interface{}, error) { var response struct { V int `json:"v"` } if err := json.NewDecoder(resp.Body).Decode(&response); err != nil { return nil, err } return response, nil } func decodeUppercaseRequest(ctx context.Context, req *http.Request) (interface{}, error) { var request struct { S string `json:"s"` } if err := json.NewDecoder(req.Body).Decode(&request); err != nil { return nil, err } return request, nil } func decodeCountRequest(ctx context.Context, req *http.Request) (interface{}, error) { var request struct { S string `json:"s"` } if err := json.NewDecoder(req.Body).Decode(&request); err != nil { return nil, err } return request, nil } golang-github-go-kit-kit-0.6.0/examples/profilesvc/000077500000000000000000000000001316471211400222135ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/profilesvc/README.md000066400000000000000000000002741316471211400234750ustar00rootroot00000000000000# profilesvc This example demonstrates how to use Go kit to implement a REST-y HTTP service. It leverages the excellent [gorilla mux package](https://github.com/gorilla/mux) for routing. golang-github-go-kit-kit-0.6.0/examples/profilesvc/client/000077500000000000000000000000001316471211400234715ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/profilesvc/client/client.go000066400000000000000000000077131316471211400253060ustar00rootroot00000000000000// Package client provides a profilesvc client based on a predefined Consul // service name and relevant tags. Users must only provide the address of a // Consul server. package client import ( "io" "time" consulapi "github.com/hashicorp/consul/api" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/examples/profilesvc" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" "github.com/go-kit/kit/sd/consul" "github.com/go-kit/kit/sd/lb" ) // New returns a service that's load-balanced over instances of profilesvc found // in the provided Consul server. The mechanism of looking up profilesvc // instances in Consul is hard-coded into the client. func New(consulAddr string, logger log.Logger) (profilesvc.Service, error) { apiclient, err := consulapi.NewClient(&consulapi.Config{ Address: consulAddr, }) if err != nil { return nil, err } // As the implementer of profilesvc, we declare and enforce these // parameters for all of the profilesvc consumers. var ( consulService = "profilesvc" consulTags = []string{"prod"} passingOnly = true retryMax = 3 retryTimeout = 500 * time.Millisecond ) var ( sdclient = consul.NewClient(apiclient) instancer = consul.NewInstancer(sdclient, logger, consulService, consulTags, passingOnly) endpoints profilesvc.Endpoints ) { factory := factoryFor(profilesvc.MakePostProfileEndpoint) endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(retryMax, retryTimeout, balancer) endpoints.PostProfileEndpoint = retry } { factory := factoryFor(profilesvc.MakeGetProfileEndpoint) endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(retryMax, retryTimeout, balancer) endpoints.GetProfileEndpoint = retry } { factory := factoryFor(profilesvc.MakePutProfileEndpoint) endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(retryMax, retryTimeout, balancer) endpoints.PutProfileEndpoint = retry } { factory := factoryFor(profilesvc.MakePatchProfileEndpoint) endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(retryMax, retryTimeout, balancer) endpoints.PatchProfileEndpoint = retry } { factory := factoryFor(profilesvc.MakeDeleteProfileEndpoint) endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(retryMax, retryTimeout, balancer) endpoints.DeleteProfileEndpoint = retry } { factory := factoryFor(profilesvc.MakeGetAddressesEndpoint) endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(retryMax, retryTimeout, balancer) endpoints.GetAddressesEndpoint = retry } { factory := factoryFor(profilesvc.MakeGetAddressEndpoint) endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(retryMax, retryTimeout, balancer) endpoints.GetAddressEndpoint = retry } { factory := factoryFor(profilesvc.MakePostAddressEndpoint) endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(retryMax, retryTimeout, balancer) endpoints.PostAddressEndpoint = retry } { factory := factoryFor(profilesvc.MakeDeleteAddressEndpoint) endpointer := sd.NewEndpointer(instancer, factory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(retryMax, retryTimeout, balancer) endpoints.DeleteAddressEndpoint = retry } return endpoints, nil } func factoryFor(makeEndpoint func(profilesvc.Service) endpoint.Endpoint) sd.Factory { return func(instance string) (endpoint.Endpoint, io.Closer, error) { service, err := profilesvc.MakeClientEndpoints(instance) if err != nil { return nil, nil, err } return makeEndpoint(service), nil, nil } } golang-github-go-kit-kit-0.6.0/examples/profilesvc/cmd/000077500000000000000000000000001316471211400227565ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/profilesvc/cmd/profilesvc/000077500000000000000000000000001316471211400251325ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/profilesvc/cmd/profilesvc/main.go000066400000000000000000000017161316471211400264120ustar00rootroot00000000000000package main import ( "flag" "fmt" "net/http" "os" "os/signal" "syscall" "github.com/go-kit/kit/examples/profilesvc" "github.com/go-kit/kit/log" ) func main() { var ( httpAddr = flag.String("http.addr", ":8080", "HTTP listen address") ) flag.Parse() var logger log.Logger { logger = log.NewLogfmtLogger(os.Stderr) logger = log.With(logger, "ts", log.DefaultTimestampUTC) logger = log.With(logger, "caller", log.DefaultCaller) } var s profilesvc.Service { s = profilesvc.NewInmemService() s = profilesvc.LoggingMiddleware(logger)(s) } var h http.Handler { h = profilesvc.MakeHTTPHandler(s, log.With(logger, "component", "HTTP")) } errs := make(chan error) go func() { c := make(chan os.Signal) signal.Notify(c, syscall.SIGINT, syscall.SIGTERM) errs <- fmt.Errorf("%s", <-c) }() go func() { logger.Log("transport", "HTTP", "addr", *httpAddr) errs <- http.ListenAndServe(*httpAddr, h) }() logger.Log("exit", <-errs) } golang-github-go-kit-kit-0.6.0/examples/profilesvc/endpoints.go000066400000000000000000000323731316471211400245550ustar00rootroot00000000000000package profilesvc import ( "context" "net/url" "strings" "github.com/go-kit/kit/endpoint" httptransport "github.com/go-kit/kit/transport/http" ) // Endpoints collects all of the endpoints that compose a profile service. It's // meant to be used as a helper struct, to collect all of the endpoints into a // single parameter. // // In a server, it's useful for functions that need to operate on a per-endpoint // basis. For example, you might pass an Endpoints to a function that produces // an http.Handler, with each method (endpoint) wired up to a specific path. (It // is probably a mistake in design to invoke the Service methods on the // Endpoints struct in a server.) // // In a client, it's useful to collect individually constructed endpoints into a // single type that implements the Service interface. For example, you might // construct individual endpoints using transport/http.NewClient, combine them // into an Endpoints, and return it to the caller as a Service. type Endpoints struct { PostProfileEndpoint endpoint.Endpoint GetProfileEndpoint endpoint.Endpoint PutProfileEndpoint endpoint.Endpoint PatchProfileEndpoint endpoint.Endpoint DeleteProfileEndpoint endpoint.Endpoint GetAddressesEndpoint endpoint.Endpoint GetAddressEndpoint endpoint.Endpoint PostAddressEndpoint endpoint.Endpoint DeleteAddressEndpoint endpoint.Endpoint } // MakeServerEndpoints returns an Endpoints struct where each endpoint invokes // the corresponding method on the provided service. Useful in a profilesvc // server. func MakeServerEndpoints(s Service) Endpoints { return Endpoints{ PostProfileEndpoint: MakePostProfileEndpoint(s), GetProfileEndpoint: MakeGetProfileEndpoint(s), PutProfileEndpoint: MakePutProfileEndpoint(s), PatchProfileEndpoint: MakePatchProfileEndpoint(s), DeleteProfileEndpoint: MakeDeleteProfileEndpoint(s), GetAddressesEndpoint: MakeGetAddressesEndpoint(s), GetAddressEndpoint: MakeGetAddressEndpoint(s), PostAddressEndpoint: MakePostAddressEndpoint(s), DeleteAddressEndpoint: MakeDeleteAddressEndpoint(s), } } // MakeClientEndpoints returns an Endpoints struct where each endpoint invokes // the corresponding method on the remote instance, via a transport/http.Client. // Useful in a profilesvc client. func MakeClientEndpoints(instance string) (Endpoints, error) { if !strings.HasPrefix(instance, "http") { instance = "http://" + instance } tgt, err := url.Parse(instance) if err != nil { return Endpoints{}, err } tgt.Path = "" options := []httptransport.ClientOption{} // Note that the request encoders need to modify the request URL, changing // the path and method. That's fine: we simply need to provide specific // encoders for each endpoint. return Endpoints{ PostProfileEndpoint: httptransport.NewClient("POST", tgt, encodePostProfileRequest, decodePostProfileResponse, options...).Endpoint(), GetProfileEndpoint: httptransport.NewClient("GET", tgt, encodeGetProfileRequest, decodeGetProfileResponse, options...).Endpoint(), PutProfileEndpoint: httptransport.NewClient("PUT", tgt, encodePutProfileRequest, decodePutProfileResponse, options...).Endpoint(), PatchProfileEndpoint: httptransport.NewClient("PATCH", tgt, encodePatchProfileRequest, decodePatchProfileResponse, options...).Endpoint(), DeleteProfileEndpoint: httptransport.NewClient("DELETE", tgt, encodeDeleteProfileRequest, decodeDeleteProfileResponse, options...).Endpoint(), GetAddressesEndpoint: httptransport.NewClient("GET", tgt, encodeGetAddressesRequest, decodeGetAddressesResponse, options...).Endpoint(), GetAddressEndpoint: httptransport.NewClient("GET", tgt, encodeGetAddressRequest, decodeGetAddressResponse, options...).Endpoint(), PostAddressEndpoint: httptransport.NewClient("POST", tgt, encodePostAddressRequest, decodePostAddressResponse, options...).Endpoint(), DeleteAddressEndpoint: httptransport.NewClient("DELETE", tgt, encodeDeleteAddressRequest, decodeDeleteAddressResponse, options...).Endpoint(), }, nil } // PostProfile implements Service. Primarily useful in a client. func (e Endpoints) PostProfile(ctx context.Context, p Profile) error { request := postProfileRequest{Profile: p} response, err := e.PostProfileEndpoint(ctx, request) if err != nil { return err } resp := response.(postProfileResponse) return resp.Err } // GetProfile implements Service. Primarily useful in a client. func (e Endpoints) GetProfile(ctx context.Context, id string) (Profile, error) { request := getProfileRequest{ID: id} response, err := e.GetProfileEndpoint(ctx, request) if err != nil { return Profile{}, err } resp := response.(getProfileResponse) return resp.Profile, resp.Err } // PutProfile implements Service. Primarily useful in a client. func (e Endpoints) PutProfile(ctx context.Context, id string, p Profile) error { request := putProfileRequest{ID: id, Profile: p} response, err := e.PutProfileEndpoint(ctx, request) if err != nil { return err } resp := response.(putProfileResponse) return resp.Err } // PatchProfile implements Service. Primarily useful in a client. func (e Endpoints) PatchProfile(ctx context.Context, id string, p Profile) error { request := patchProfileRequest{ID: id, Profile: p} response, err := e.PatchProfileEndpoint(ctx, request) if err != nil { return err } resp := response.(patchProfileResponse) return resp.Err } // DeleteProfile implements Service. Primarily useful in a client. func (e Endpoints) DeleteProfile(ctx context.Context, id string) error { request := deleteProfileRequest{ID: id} response, err := e.DeleteProfileEndpoint(ctx, request) if err != nil { return err } resp := response.(deleteProfileResponse) return resp.Err } // GetAddresses implements Service. Primarily useful in a client. func (e Endpoints) GetAddresses(ctx context.Context, profileID string) ([]Address, error) { request := getAddressesRequest{ProfileID: profileID} response, err := e.GetAddressesEndpoint(ctx, request) if err != nil { return nil, err } resp := response.(getAddressesResponse) return resp.Addresses, resp.Err } // GetAddress implements Service. Primarily useful in a client. func (e Endpoints) GetAddress(ctx context.Context, profileID string, addressID string) (Address, error) { request := getAddressRequest{ProfileID: profileID, AddressID: addressID} response, err := e.GetAddressEndpoint(ctx, request) if err != nil { return Address{}, err } resp := response.(getAddressResponse) return resp.Address, resp.Err } // PostAddress implements Service. Primarily useful in a client. func (e Endpoints) PostAddress(ctx context.Context, profileID string, a Address) error { request := postAddressRequest{ProfileID: profileID, Address: a} response, err := e.PostAddressEndpoint(ctx, request) if err != nil { return err } resp := response.(postAddressResponse) return resp.Err } // DeleteAddress implements Service. Primarily useful in a client. func (e Endpoints) DeleteAddress(ctx context.Context, profileID string, addressID string) error { request := deleteAddressRequest{ProfileID: profileID, AddressID: addressID} response, err := e.DeleteAddressEndpoint(ctx, request) if err != nil { return err } resp := response.(deleteAddressResponse) return resp.Err } // MakePostProfileEndpoint returns an endpoint via the passed service. // Primarily useful in a server. func MakePostProfileEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { req := request.(postProfileRequest) e := s.PostProfile(ctx, req.Profile) return postProfileResponse{Err: e}, nil } } // MakeGetProfileEndpoint returns an endpoint via the passed service. // Primarily useful in a server. func MakeGetProfileEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { req := request.(getProfileRequest) p, e := s.GetProfile(ctx, req.ID) return getProfileResponse{Profile: p, Err: e}, nil } } // MakePutProfileEndpoint returns an endpoint via the passed service. // Primarily useful in a server. func MakePutProfileEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { req := request.(putProfileRequest) e := s.PutProfile(ctx, req.ID, req.Profile) return putProfileResponse{Err: e}, nil } } // MakePatchProfileEndpoint returns an endpoint via the passed service. // Primarily useful in a server. func MakePatchProfileEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { req := request.(patchProfileRequest) e := s.PatchProfile(ctx, req.ID, req.Profile) return patchProfileResponse{Err: e}, nil } } // MakeDeleteProfileEndpoint returns an endpoint via the passed service. // Primarily useful in a server. func MakeDeleteProfileEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { req := request.(deleteProfileRequest) e := s.DeleteProfile(ctx, req.ID) return deleteProfileResponse{Err: e}, nil } } // MakeGetAddressesEndpoint returns an endpoint via the passed service. // Primarily useful in a server. func MakeGetAddressesEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { req := request.(getAddressesRequest) a, e := s.GetAddresses(ctx, req.ProfileID) return getAddressesResponse{Addresses: a, Err: e}, nil } } // MakeGetAddressEndpoint returns an endpoint via the passed service. // Primarily useful in a server. func MakeGetAddressEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { req := request.(getAddressRequest) a, e := s.GetAddress(ctx, req.ProfileID, req.AddressID) return getAddressResponse{Address: a, Err: e}, nil } } // MakePostAddressEndpoint returns an endpoint via the passed service. // Primarily useful in a server. func MakePostAddressEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { req := request.(postAddressRequest) e := s.PostAddress(ctx, req.ProfileID, req.Address) return postAddressResponse{Err: e}, nil } } // MakeDeleteAddressEndpoint returns an endpoint via the passed service. // Primarily useful in a server. func MakeDeleteAddressEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (response interface{}, err error) { req := request.(deleteAddressRequest) e := s.DeleteAddress(ctx, req.ProfileID, req.AddressID) return deleteAddressResponse{Err: e}, nil } } // We have two options to return errors from the business logic. // // We could return the error via the endpoint itself. That makes certain things // a little bit easier, like providing non-200 HTTP responses to the client. But // Go kit assumes that endpoint errors are (or may be treated as) // transport-domain errors. For example, an endpoint error will count against a // circuit breaker error count. // // Therefore, it's often better to return service (business logic) errors in the // response object. This means we have to do a bit more work in the HTTP // response encoder to detect e.g. a not-found error and provide a proper HTTP // status code. That work is done with the errorer interface, in transport.go. // Response types that may contain business-logic errors implement that // interface. type postProfileRequest struct { Profile Profile } type postProfileResponse struct { Err error `json:"err,omitempty"` } func (r postProfileResponse) error() error { return r.Err } type getProfileRequest struct { ID string } type getProfileResponse struct { Profile Profile `json:"profile,omitempty"` Err error `json:"err,omitempty"` } func (r getProfileResponse) error() error { return r.Err } type putProfileRequest struct { ID string Profile Profile } type putProfileResponse struct { Err error `json:"err,omitempty"` } func (r putProfileResponse) error() error { return nil } type patchProfileRequest struct { ID string Profile Profile } type patchProfileResponse struct { Err error `json:"err,omitempty"` } func (r patchProfileResponse) error() error { return r.Err } type deleteProfileRequest struct { ID string } type deleteProfileResponse struct { Err error `json:"err,omitempty"` } func (r deleteProfileResponse) error() error { return r.Err } type getAddressesRequest struct { ProfileID string } type getAddressesResponse struct { Addresses []Address `json:"addresses,omitempty"` Err error `json:"err,omitempty"` } func (r getAddressesResponse) error() error { return r.Err } type getAddressRequest struct { ProfileID string AddressID string } type getAddressResponse struct { Address Address `json:"address,omitempty"` Err error `json:"err,omitempty"` } func (r getAddressResponse) error() error { return r.Err } type postAddressRequest struct { ProfileID string Address Address } type postAddressResponse struct { Err error `json:"err,omitempty"` } func (r postAddressResponse) error() error { return r.Err } type deleteAddressRequest struct { ProfileID string AddressID string } type deleteAddressResponse struct { Err error `json:"err,omitempty"` } func (r deleteAddressResponse) error() error { return r.Err } golang-github-go-kit-kit-0.6.0/examples/profilesvc/middlewares.go000066400000000000000000000060321316471211400250430ustar00rootroot00000000000000package profilesvc import ( "context" "time" "github.com/go-kit/kit/log" ) // Middleware describes a service (as opposed to endpoint) middleware. type Middleware func(Service) Service func LoggingMiddleware(logger log.Logger) Middleware { return func(next Service) Service { return &loggingMiddleware{ next: next, logger: logger, } } } type loggingMiddleware struct { next Service logger log.Logger } func (mw loggingMiddleware) PostProfile(ctx context.Context, p Profile) (err error) { defer func(begin time.Time) { mw.logger.Log("method", "PostProfile", "id", p.ID, "took", time.Since(begin), "err", err) }(time.Now()) return mw.next.PostProfile(ctx, p) } func (mw loggingMiddleware) GetProfile(ctx context.Context, id string) (p Profile, err error) { defer func(begin time.Time) { mw.logger.Log("method", "GetProfile", "id", id, "took", time.Since(begin), "err", err) }(time.Now()) return mw.next.GetProfile(ctx, id) } func (mw loggingMiddleware) PutProfile(ctx context.Context, id string, p Profile) (err error) { defer func(begin time.Time) { mw.logger.Log("method", "PutProfile", "id", id, "took", time.Since(begin), "err", err) }(time.Now()) return mw.next.PutProfile(ctx, id, p) } func (mw loggingMiddleware) PatchProfile(ctx context.Context, id string, p Profile) (err error) { defer func(begin time.Time) { mw.logger.Log("method", "PatchProfile", "id", id, "took", time.Since(begin), "err", err) }(time.Now()) return mw.next.PatchProfile(ctx, id, p) } func (mw loggingMiddleware) DeleteProfile(ctx context.Context, id string) (err error) { defer func(begin time.Time) { mw.logger.Log("method", "DeleteProfile", "id", id, "took", time.Since(begin), "err", err) }(time.Now()) return mw.next.DeleteProfile(ctx, id) } func (mw loggingMiddleware) GetAddresses(ctx context.Context, profileID string) (addresses []Address, err error) { defer func(begin time.Time) { mw.logger.Log("method", "GetAddresses", "profileID", profileID, "took", time.Since(begin), "err", err) }(time.Now()) return mw.next.GetAddresses(ctx, profileID) } func (mw loggingMiddleware) GetAddress(ctx context.Context, profileID string, addressID string) (a Address, err error) { defer func(begin time.Time) { mw.logger.Log("method", "GetAddress", "profileID", profileID, "addressID", addressID, "took", time.Since(begin), "err", err) }(time.Now()) return mw.next.GetAddress(ctx, profileID, addressID) } func (mw loggingMiddleware) PostAddress(ctx context.Context, profileID string, a Address) (err error) { defer func(begin time.Time) { mw.logger.Log("method", "PostAddress", "profileID", profileID, "took", time.Since(begin), "err", err) }(time.Now()) return mw.next.PostAddress(ctx, profileID, a) } func (mw loggingMiddleware) DeleteAddress(ctx context.Context, profileID string, addressID string) (err error) { defer func(begin time.Time) { mw.logger.Log("method", "DeleteAddress", "profileID", profileID, "addressID", addressID, "took", time.Since(begin), "err", err) }(time.Now()) return mw.next.DeleteAddress(ctx, profileID, addressID) } golang-github-go-kit-kit-0.6.0/examples/profilesvc/service.go000066400000000000000000000107441316471211400242100ustar00rootroot00000000000000package profilesvc import ( "context" "errors" "sync" ) // Service is a simple CRUD interface for user profiles. type Service interface { PostProfile(ctx context.Context, p Profile) error GetProfile(ctx context.Context, id string) (Profile, error) PutProfile(ctx context.Context, id string, p Profile) error PatchProfile(ctx context.Context, id string, p Profile) error DeleteProfile(ctx context.Context, id string) error GetAddresses(ctx context.Context, profileID string) ([]Address, error) GetAddress(ctx context.Context, profileID string, addressID string) (Address, error) PostAddress(ctx context.Context, profileID string, a Address) error DeleteAddress(ctx context.Context, profileID string, addressID string) error } // Profile represents a single user profile. // ID should be globally unique. type Profile struct { ID string `json:"id"` Name string `json:"name,omitempty"` Addresses []Address `json:"addresses,omitempty"` } // Address is a field of a user profile. // ID should be unique within the profile (at a minimum). type Address struct { ID string `json:"id"` Location string `json:"location,omitempty"` } var ( ErrInconsistentIDs = errors.New("inconsistent IDs") ErrAlreadyExists = errors.New("already exists") ErrNotFound = errors.New("not found") ) type inmemService struct { mtx sync.RWMutex m map[string]Profile } func NewInmemService() Service { return &inmemService{ m: map[string]Profile{}, } } func (s *inmemService) PostProfile(ctx context.Context, p Profile) error { s.mtx.Lock() defer s.mtx.Unlock() if _, ok := s.m[p.ID]; ok { return ErrAlreadyExists // POST = create, don't overwrite } s.m[p.ID] = p return nil } func (s *inmemService) GetProfile(ctx context.Context, id string) (Profile, error) { s.mtx.RLock() defer s.mtx.RUnlock() p, ok := s.m[id] if !ok { return Profile{}, ErrNotFound } return p, nil } func (s *inmemService) PutProfile(ctx context.Context, id string, p Profile) error { if id != p.ID { return ErrInconsistentIDs } s.mtx.Lock() defer s.mtx.Unlock() s.m[id] = p // PUT = create or update return nil } func (s *inmemService) PatchProfile(ctx context.Context, id string, p Profile) error { if p.ID != "" && id != p.ID { return ErrInconsistentIDs } s.mtx.Lock() defer s.mtx.Unlock() existing, ok := s.m[id] if !ok { return ErrNotFound // PATCH = update existing, don't create } // We assume that it's not possible to PATCH the ID, and that it's not // possible to PATCH any field to its zero value. That is, the zero value // means not specified. The way around this is to use e.g. Name *string in // the Profile definition. But since this is just a demonstrative example, // I'm leaving that out. if p.Name != "" { existing.Name = p.Name } if len(p.Addresses) > 0 { existing.Addresses = p.Addresses } s.m[id] = existing return nil } func (s *inmemService) DeleteProfile(ctx context.Context, id string) error { s.mtx.Lock() defer s.mtx.Unlock() if _, ok := s.m[id]; !ok { return ErrNotFound } delete(s.m, id) return nil } func (s *inmemService) GetAddresses(ctx context.Context, profileID string) ([]Address, error) { s.mtx.RLock() defer s.mtx.RUnlock() p, ok := s.m[profileID] if !ok { return []Address{}, ErrNotFound } return p.Addresses, nil } func (s *inmemService) GetAddress(ctx context.Context, profileID string, addressID string) (Address, error) { s.mtx.RLock() defer s.mtx.RUnlock() p, ok := s.m[profileID] if !ok { return Address{}, ErrNotFound } for _, address := range p.Addresses { if address.ID == addressID { return address, nil } } return Address{}, ErrNotFound } func (s *inmemService) PostAddress(ctx context.Context, profileID string, a Address) error { s.mtx.Lock() defer s.mtx.Unlock() p, ok := s.m[profileID] if !ok { return ErrNotFound } for _, address := range p.Addresses { if address.ID == a.ID { return ErrAlreadyExists } } p.Addresses = append(p.Addresses, a) s.m[profileID] = p return nil } func (s *inmemService) DeleteAddress(ctx context.Context, profileID string, addressID string) error { s.mtx.Lock() defer s.mtx.Unlock() p, ok := s.m[profileID] if !ok { return ErrNotFound } newAddresses := make([]Address, 0, len(p.Addresses)) for _, address := range p.Addresses { if address.ID == addressID { continue // delete } newAddresses = append(newAddresses, address) } if len(newAddresses) == len(p.Addresses) { return ErrNotFound } p.Addresses = newAddresses s.m[profileID] = p return nil } golang-github-go-kit-kit-0.6.0/examples/profilesvc/transport.go000066400000000000000000000307531316471211400246060ustar00rootroot00000000000000package profilesvc // The profilesvc is just over HTTP, so we just have a single transport.go. import ( "bytes" "context" "encoding/json" "errors" "io/ioutil" "net/http" "net/url" "github.com/gorilla/mux" "github.com/go-kit/kit/log" httptransport "github.com/go-kit/kit/transport/http" ) var ( // ErrBadRouting is returned when an expected path variable is missing. // It always indicates programmer error. ErrBadRouting = errors.New("inconsistent mapping between route and handler (programmer error)") ) // MakeHTTPHandler mounts all of the service endpoints into an http.Handler. // Useful in a profilesvc server. func MakeHTTPHandler(s Service, logger log.Logger) http.Handler { r := mux.NewRouter() e := MakeServerEndpoints(s) options := []httptransport.ServerOption{ httptransport.ServerErrorLogger(logger), httptransport.ServerErrorEncoder(encodeError), } // POST /profiles/ adds another profile // GET /profiles/:id retrieves the given profile by id // PUT /profiles/:id post updated profile information about the profile // PATCH /profiles/:id partial updated profile information // DELETE /profiles/:id remove the given profile // GET /profiles/:id/addresses/ retrieve addresses associated with the profile // GET /profiles/:id/addresses/:addressID retrieve a particular profile address // POST /profiles/:id/addresses/ add a new address // DELETE /profiles/:id/addresses/:addressID remove an address r.Methods("POST").Path("/profiles/").Handler(httptransport.NewServer( e.PostProfileEndpoint, decodePostProfileRequest, encodeResponse, options..., )) r.Methods("GET").Path("/profiles/{id}").Handler(httptransport.NewServer( e.GetProfileEndpoint, decodeGetProfileRequest, encodeResponse, options..., )) r.Methods("PUT").Path("/profiles/{id}").Handler(httptransport.NewServer( e.PutProfileEndpoint, decodePutProfileRequest, encodeResponse, options..., )) r.Methods("PATCH").Path("/profiles/{id}").Handler(httptransport.NewServer( e.PatchProfileEndpoint, decodePatchProfileRequest, encodeResponse, options..., )) r.Methods("DELETE").Path("/profiles/{id}").Handler(httptransport.NewServer( e.DeleteProfileEndpoint, decodeDeleteProfileRequest, encodeResponse, options..., )) r.Methods("GET").Path("/profiles/{id}/addresses/").Handler(httptransport.NewServer( e.GetAddressesEndpoint, decodeGetAddressesRequest, encodeResponse, options..., )) r.Methods("GET").Path("/profiles/{id}/addresses/{addressID}").Handler(httptransport.NewServer( e.GetAddressEndpoint, decodeGetAddressRequest, encodeResponse, options..., )) r.Methods("POST").Path("/profiles/{id}/addresses/").Handler(httptransport.NewServer( e.PostAddressEndpoint, decodePostAddressRequest, encodeResponse, options..., )) r.Methods("DELETE").Path("/profiles/{id}/addresses/{addressID}").Handler(httptransport.NewServer( e.DeleteAddressEndpoint, decodeDeleteAddressRequest, encodeResponse, options..., )) return r } func decodePostProfileRequest(_ context.Context, r *http.Request) (request interface{}, err error) { var req postProfileRequest if e := json.NewDecoder(r.Body).Decode(&req.Profile); e != nil { return nil, e } return req, nil } func decodeGetProfileRequest(_ context.Context, r *http.Request) (request interface{}, err error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, ErrBadRouting } return getProfileRequest{ID: id}, nil } func decodePutProfileRequest(_ context.Context, r *http.Request) (request interface{}, err error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, ErrBadRouting } var profile Profile if err := json.NewDecoder(r.Body).Decode(&profile); err != nil { return nil, err } return putProfileRequest{ ID: id, Profile: profile, }, nil } func decodePatchProfileRequest(_ context.Context, r *http.Request) (request interface{}, err error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, ErrBadRouting } var profile Profile if err := json.NewDecoder(r.Body).Decode(&profile); err != nil { return nil, err } return patchProfileRequest{ ID: id, Profile: profile, }, nil } func decodeDeleteProfileRequest(_ context.Context, r *http.Request) (request interface{}, err error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, ErrBadRouting } return deleteProfileRequest{ID: id}, nil } func decodeGetAddressesRequest(_ context.Context, r *http.Request) (request interface{}, err error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, ErrBadRouting } return getAddressesRequest{ProfileID: id}, nil } func decodeGetAddressRequest(_ context.Context, r *http.Request) (request interface{}, err error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, ErrBadRouting } addressID, ok := vars["addressID"] if !ok { return nil, ErrBadRouting } return getAddressRequest{ ProfileID: id, AddressID: addressID, }, nil } func decodePostAddressRequest(_ context.Context, r *http.Request) (request interface{}, err error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, ErrBadRouting } var address Address if err := json.NewDecoder(r.Body).Decode(&address); err != nil { return nil, err } return postAddressRequest{ ProfileID: id, Address: address, }, nil } func decodeDeleteAddressRequest(_ context.Context, r *http.Request) (request interface{}, err error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, ErrBadRouting } addressID, ok := vars["addressID"] if !ok { return nil, ErrBadRouting } return deleteAddressRequest{ ProfileID: id, AddressID: addressID, }, nil } func encodePostProfileRequest(ctx context.Context, req *http.Request, request interface{}) error { // r.Methods("POST").Path("/profiles/") req.Method, req.URL.Path = "POST", "/profiles/" return encodeRequest(ctx, req, request) } func encodeGetProfileRequest(ctx context.Context, req *http.Request, request interface{}) error { // r.Methods("GET").Path("/profiles/{id}") r := request.(getProfileRequest) profileID := url.QueryEscape(r.ID) req.Method, req.URL.Path = "GET", "/profiles/"+profileID return encodeRequest(ctx, req, request) } func encodePutProfileRequest(ctx context.Context, req *http.Request, request interface{}) error { // r.Methods("PUT").Path("/profiles/{id}") r := request.(putProfileRequest) profileID := url.QueryEscape(r.ID) req.Method, req.URL.Path = "PUT", "/profiles/"+profileID return encodeRequest(ctx, req, request) } func encodePatchProfileRequest(ctx context.Context, req *http.Request, request interface{}) error { // r.Methods("PATCH").Path("/profiles/{id}") r := request.(patchProfileRequest) profileID := url.QueryEscape(r.ID) req.Method, req.URL.Path = "PATCH", "/profiles/"+profileID return encodeRequest(ctx, req, request) } func encodeDeleteProfileRequest(ctx context.Context, req *http.Request, request interface{}) error { // r.Methods("DELETE").Path("/profiles/{id}") r := request.(deleteProfileRequest) profileID := url.QueryEscape(r.ID) req.Method, req.URL.Path = "DELETE", "/profiles/"+profileID return encodeRequest(ctx, req, request) } func encodeGetAddressesRequest(ctx context.Context, req *http.Request, request interface{}) error { // r.Methods("GET").Path("/profiles/{id}/addresses/") r := request.(getAddressesRequest) profileID := url.QueryEscape(r.ProfileID) req.Method, req.URL.Path = "GET", "/profiles/"+profileID+"/addresses/" return encodeRequest(ctx, req, request) } func encodeGetAddressRequest(ctx context.Context, req *http.Request, request interface{}) error { // r.Methods("GET").Path("/profiles/{id}/addresses/{addressID}") r := request.(getAddressRequest) profileID := url.QueryEscape(r.ProfileID) addressID := url.QueryEscape(r.AddressID) req.Method, req.URL.Path = "GET", "/profiles/"+profileID+"/addresses/"+addressID return encodeRequest(ctx, req, request) } func encodePostAddressRequest(ctx context.Context, req *http.Request, request interface{}) error { // r.Methods("POST").Path("/profiles/{id}/addresses/") r := request.(postAddressRequest) profileID := url.QueryEscape(r.ProfileID) req.Method, req.URL.Path = "POST", "/profiles/"+profileID+"/addresses/" return encodeRequest(ctx, req, request) } func encodeDeleteAddressRequest(ctx context.Context, req *http.Request, request interface{}) error { // r.Methods("DELETE").Path("/profiles/{id}/addresses/{addressID}") r := request.(deleteAddressRequest) profileID := url.QueryEscape(r.ProfileID) addressID := url.QueryEscape(r.AddressID) req.Method, req.URL.Path = "DELETE", "/profiles/"+profileID+"/addresses/"+addressID return encodeRequest(ctx, req, request) } func decodePostProfileResponse(_ context.Context, resp *http.Response) (interface{}, error) { var response postProfileResponse err := json.NewDecoder(resp.Body).Decode(&response) return response, err } func decodeGetProfileResponse(_ context.Context, resp *http.Response) (interface{}, error) { var response getProfileResponse err := json.NewDecoder(resp.Body).Decode(&response) return response, err } func decodePutProfileResponse(_ context.Context, resp *http.Response) (interface{}, error) { var response putProfileResponse err := json.NewDecoder(resp.Body).Decode(&response) return response, err } func decodePatchProfileResponse(_ context.Context, resp *http.Response) (interface{}, error) { var response patchProfileResponse err := json.NewDecoder(resp.Body).Decode(&response) return response, err } func decodeDeleteProfileResponse(_ context.Context, resp *http.Response) (interface{}, error) { var response deleteProfileResponse err := json.NewDecoder(resp.Body).Decode(&response) return response, err } func decodeGetAddressesResponse(_ context.Context, resp *http.Response) (interface{}, error) { var response getAddressesResponse err := json.NewDecoder(resp.Body).Decode(&response) return response, err } func decodeGetAddressResponse(_ context.Context, resp *http.Response) (interface{}, error) { var response getAddressResponse err := json.NewDecoder(resp.Body).Decode(&response) return response, err } func decodePostAddressResponse(_ context.Context, resp *http.Response) (interface{}, error) { var response postAddressResponse err := json.NewDecoder(resp.Body).Decode(&response) return response, err } func decodeDeleteAddressResponse(_ context.Context, resp *http.Response) (interface{}, error) { var response deleteAddressResponse err := json.NewDecoder(resp.Body).Decode(&response) return response, err } // errorer is implemented by all concrete response types that may contain // errors. It allows us to change the HTTP response code without needing to // trigger an endpoint (transport-level) error. For more information, read the // big comment in endpoints.go. type errorer interface { error() error } // encodeResponse is the common method to encode all response types to the // client. I chose to do it this way because, since we're using JSON, there's no // reason to provide anything more specific. It's certainly possible to // specialize on a per-response (per-method) basis. func encodeResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error { if e, ok := response.(errorer); ok && e.error() != nil { // Not a Go kit transport error, but a business-logic error. // Provide those as HTTP errors. encodeError(ctx, e.error(), w) return nil } w.Header().Set("Content-Type", "application/json; charset=utf-8") return json.NewEncoder(w).Encode(response) } // encodeRequest likewise JSON-encodes the request to the HTTP request body. // Don't use it directly as a transport/http.Client EncodeRequestFunc: // profilesvc endpoints require mutating the HTTP method and request path. func encodeRequest(_ context.Context, req *http.Request, request interface{}) error { var buf bytes.Buffer err := json.NewEncoder(&buf).Encode(request) if err != nil { return err } req.Body = ioutil.NopCloser(&buf) return nil } func encodeError(_ context.Context, err error, w http.ResponseWriter) { if err == nil { panic("encodeError with nil error") } w.Header().Set("Content-Type", "application/json; charset=utf-8") w.WriteHeader(codeFrom(err)) json.NewEncoder(w).Encode(map[string]interface{}{ "error": err.Error(), }) } func codeFrom(err error) int { switch err { case ErrNotFound: return http.StatusNotFound case ErrAlreadyExists, ErrInconsistentIDs: return http.StatusBadRequest default: return http.StatusInternalServerError } } golang-github-go-kit-kit-0.6.0/examples/shipping/000077500000000000000000000000001316471211400216605ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/shipping/README.md000066400000000000000000000034601316471211400231420ustar00rootroot00000000000000# shipping This example demonstrates a more real-world application consisting of multiple services. ## Description The implementation is based on the container shipping domain from the [Domain Driven Design](http://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215) book by Eric Evans, which was [originally](http://dddsample.sourceforge.net/) implemented in Java but has since been ported to Go. This example is a somewhat stripped down version to demonstrate the use of Go kit. The [original Go application](https://github.com/marcusolsson/goddd) is maintained separately and accompanied by an [AngularJS application](https://github.com/marcusolsson/dddelivery-angularjs) as well as a mock [routing service](https://github.com/marcusolsson/pathfinder). ### Organization The application consists of three application services, `booking`, `handling` and `tracking`. Each of these is an individual Go kit service as seen in previous examples. - __booking__ - used by the shipping company to book and route cargos. - __handling__ - used by our staff around the world to register whenever the cargo has been received, loaded etc. - __tracking__ - used by the customer to track the cargo along the route There are also a few pure domain packages that contain some intricate business-logic. They provide domain objects and services that are used by each application service to provide interesting use-cases for the user. `inmem` contains in-memory implementations for the repositories found in the domain packages. The `routing` package provides a _domain service_ that is used to query an external application for possible routes. ## Contributing As with all Go kit examples you are more than welcome to contribute. If you do however, please consider contributing back to the original project as well. golang-github-go-kit-kit-0.6.0/examples/shipping/booking/000077500000000000000000000000001316471211400233105ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/shipping/booking/endpoint.go000066400000000000000000000073421316471211400254650ustar00rootroot00000000000000package booking import ( "context" "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/location" ) type bookCargoRequest struct { Origin location.UNLocode Destination location.UNLocode ArrivalDeadline time.Time } type bookCargoResponse struct { ID cargo.TrackingID `json:"tracking_id,omitempty"` Err error `json:"error,omitempty"` } func (r bookCargoResponse) error() error { return r.Err } func makeBookCargoEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(bookCargoRequest) id, err := s.BookNewCargo(req.Origin, req.Destination, req.ArrivalDeadline) return bookCargoResponse{ID: id, Err: err}, nil } } type loadCargoRequest struct { ID cargo.TrackingID } type loadCargoResponse struct { Cargo *Cargo `json:"cargo,omitempty"` Err error `json:"error,omitempty"` } func (r loadCargoResponse) error() error { return r.Err } func makeLoadCargoEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(loadCargoRequest) c, err := s.LoadCargo(req.ID) return loadCargoResponse{Cargo: &c, Err: err}, nil } } type requestRoutesRequest struct { ID cargo.TrackingID } type requestRoutesResponse struct { Routes []cargo.Itinerary `json:"routes,omitempty"` Err error `json:"error,omitempty"` } func (r requestRoutesResponse) error() error { return r.Err } func makeRequestRoutesEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(requestRoutesRequest) itin := s.RequestPossibleRoutesForCargo(req.ID) return requestRoutesResponse{Routes: itin, Err: nil}, nil } } type assignToRouteRequest struct { ID cargo.TrackingID Itinerary cargo.Itinerary } type assignToRouteResponse struct { Err error `json:"error,omitempty"` } func (r assignToRouteResponse) error() error { return r.Err } func makeAssignToRouteEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(assignToRouteRequest) err := s.AssignCargoToRoute(req.ID, req.Itinerary) return assignToRouteResponse{Err: err}, nil } } type changeDestinationRequest struct { ID cargo.TrackingID Destination location.UNLocode } type changeDestinationResponse struct { Err error `json:"error,omitempty"` } func (r changeDestinationResponse) error() error { return r.Err } func makeChangeDestinationEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(changeDestinationRequest) err := s.ChangeDestination(req.ID, req.Destination) return changeDestinationResponse{Err: err}, nil } } type listCargosRequest struct{} type listCargosResponse struct { Cargos []Cargo `json:"cargos,omitempty"` Err error `json:"error,omitempty"` } func (r listCargosResponse) error() error { return r.Err } func makeListCargosEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { _ = request.(listCargosRequest) return listCargosResponse{Cargos: s.Cargos(), Err: nil}, nil } } type listLocationsRequest struct { } type listLocationsResponse struct { Locations []Location `json:"locations,omitempty"` Err error `json:"error,omitempty"` } func makeListLocationsEndpoint(s Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { _ = request.(listLocationsRequest) return listLocationsResponse{Locations: s.Locations(), Err: nil}, nil } } golang-github-go-kit-kit-0.6.0/examples/shipping/booking/instrumenting.go000066400000000000000000000054421316471211400265520ustar00rootroot00000000000000package booking import ( "time" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/location" ) type instrumentingService struct { requestCount metrics.Counter requestLatency metrics.Histogram Service } // NewInstrumentingService returns an instance of an instrumenting Service. func NewInstrumentingService(counter metrics.Counter, latency metrics.Histogram, s Service) Service { return &instrumentingService{ requestCount: counter, requestLatency: latency, Service: s, } } func (s *instrumentingService) BookNewCargo(origin, destination location.UNLocode, deadline time.Time) (cargo.TrackingID, error) { defer func(begin time.Time) { s.requestCount.With("method", "book").Add(1) s.requestLatency.With("method", "book").Observe(time.Since(begin).Seconds()) }(time.Now()) return s.Service.BookNewCargo(origin, destination, deadline) } func (s *instrumentingService) LoadCargo(id cargo.TrackingID) (c Cargo, err error) { defer func(begin time.Time) { s.requestCount.With("method", "load").Add(1) s.requestLatency.With("method", "load").Observe(time.Since(begin).Seconds()) }(time.Now()) return s.Service.LoadCargo(id) } func (s *instrumentingService) RequestPossibleRoutesForCargo(id cargo.TrackingID) []cargo.Itinerary { defer func(begin time.Time) { s.requestCount.With("method", "request_routes").Add(1) s.requestLatency.With("method", "request_routes").Observe(time.Since(begin).Seconds()) }(time.Now()) return s.Service.RequestPossibleRoutesForCargo(id) } func (s *instrumentingService) AssignCargoToRoute(id cargo.TrackingID, itinerary cargo.Itinerary) (err error) { defer func(begin time.Time) { s.requestCount.With("method", "assign_to_route").Add(1) s.requestLatency.With("method", "assign_to_route").Observe(time.Since(begin).Seconds()) }(time.Now()) return s.Service.AssignCargoToRoute(id, itinerary) } func (s *instrumentingService) ChangeDestination(id cargo.TrackingID, l location.UNLocode) (err error) { defer func(begin time.Time) { s.requestCount.With("method", "change_destination").Add(1) s.requestLatency.With("method", "change_destination").Observe(time.Since(begin).Seconds()) }(time.Now()) return s.Service.ChangeDestination(id, l) } func (s *instrumentingService) Cargos() []Cargo { defer func(begin time.Time) { s.requestCount.With("method", "list_cargos").Add(1) s.requestLatency.With("method", "list_cargos").Observe(time.Since(begin).Seconds()) }(time.Now()) return s.Service.Cargos() } func (s *instrumentingService) Locations() []Location { defer func(begin time.Time) { s.requestCount.With("method", "list_locations").Add(1) s.requestLatency.With("method", "list_locations").Observe(time.Since(begin).Seconds()) }(time.Now()) return s.Service.Locations() } golang-github-go-kit-kit-0.6.0/examples/shipping/booking/logging.go000066400000000000000000000046371316471211400252770ustar00rootroot00000000000000package booking import ( "time" "github.com/go-kit/kit/log" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/location" ) type loggingService struct { logger log.Logger Service } // NewLoggingService returns a new instance of a logging Service. func NewLoggingService(logger log.Logger, s Service) Service { return &loggingService{logger, s} } func (s *loggingService) BookNewCargo(origin location.UNLocode, destination location.UNLocode, deadline time.Time) (id cargo.TrackingID, err error) { defer func(begin time.Time) { s.logger.Log( "method", "book", "origin", origin, "destination", destination, "arrival_deadline", deadline, "took", time.Since(begin), "err", err, ) }(time.Now()) return s.Service.BookNewCargo(origin, destination, deadline) } func (s *loggingService) LoadCargo(id cargo.TrackingID) (c Cargo, err error) { defer func(begin time.Time) { s.logger.Log( "method", "load", "tracking_id", id, "took", time.Since(begin), "err", err, ) }(time.Now()) return s.Service.LoadCargo(id) } func (s *loggingService) RequestPossibleRoutesForCargo(id cargo.TrackingID) []cargo.Itinerary { defer func(begin time.Time) { s.logger.Log( "method", "request_routes", "tracking_id", id, "took", time.Since(begin), ) }(time.Now()) return s.Service.RequestPossibleRoutesForCargo(id) } func (s *loggingService) AssignCargoToRoute(id cargo.TrackingID, itinerary cargo.Itinerary) (err error) { defer func(begin time.Time) { s.logger.Log( "method", "assign_to_route", "tracking_id", id, "took", time.Since(begin), "err", err, ) }(time.Now()) return s.Service.AssignCargoToRoute(id, itinerary) } func (s *loggingService) ChangeDestination(id cargo.TrackingID, l location.UNLocode) (err error) { defer func(begin time.Time) { s.logger.Log( "method", "change_destination", "tracking_id", id, "destination", l, "took", time.Since(begin), "err", err, ) }(time.Now()) return s.Service.ChangeDestination(id, l) } func (s *loggingService) Cargos() []Cargo { defer func(begin time.Time) { s.logger.Log( "method", "list_cargos", "took", time.Since(begin), ) }(time.Now()) return s.Service.Cargos() } func (s *loggingService) Locations() []Location { defer func(begin time.Time) { s.logger.Log( "method", "list_locations", "took", time.Since(begin), ) }(time.Now()) return s.Service.Locations() } golang-github-go-kit-kit-0.6.0/examples/shipping/booking/service.go000066400000000000000000000121041316471211400252750ustar00rootroot00000000000000// Package booking provides the use-case of booking a cargo. Used by views // facing an administrator. package booking import ( "errors" "time" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/routing" ) // ErrInvalidArgument is returned when one or more arguments are invalid. var ErrInvalidArgument = errors.New("invalid argument") // Service is the interface that provides booking methods. type Service interface { // BookNewCargo registers a new cargo in the tracking system, not yet // routed. BookNewCargo(origin location.UNLocode, destination location.UNLocode, deadline time.Time) (cargo.TrackingID, error) // LoadCargo returns a read model of a cargo. LoadCargo(id cargo.TrackingID) (Cargo, error) // RequestPossibleRoutesForCargo requests a list of itineraries describing // possible routes for this cargo. RequestPossibleRoutesForCargo(id cargo.TrackingID) []cargo.Itinerary // AssignCargoToRoute assigns a cargo to the route specified by the // itinerary. AssignCargoToRoute(id cargo.TrackingID, itinerary cargo.Itinerary) error // ChangeDestination changes the destination of a cargo. ChangeDestination(id cargo.TrackingID, destination location.UNLocode) error // Cargos returns a list of all cargos that have been booked. Cargos() []Cargo // Locations returns a list of registered locations. Locations() []Location } type service struct { cargos cargo.Repository locations location.Repository handlingEvents cargo.HandlingEventRepository routingService routing.Service } func (s *service) AssignCargoToRoute(id cargo.TrackingID, itinerary cargo.Itinerary) error { if id == "" || len(itinerary.Legs) == 0 { return ErrInvalidArgument } c, err := s.cargos.Find(id) if err != nil { return err } c.AssignToRoute(itinerary) return s.cargos.Store(c) } func (s *service) BookNewCargo(origin, destination location.UNLocode, deadline time.Time) (cargo.TrackingID, error) { if origin == "" || destination == "" || deadline.IsZero() { return "", ErrInvalidArgument } id := cargo.NextTrackingID() rs := cargo.RouteSpecification{ Origin: origin, Destination: destination, ArrivalDeadline: deadline, } c := cargo.New(id, rs) if err := s.cargos.Store(c); err != nil { return "", err } return c.TrackingID, nil } func (s *service) LoadCargo(id cargo.TrackingID) (Cargo, error) { if id == "" { return Cargo{}, ErrInvalidArgument } c, err := s.cargos.Find(id) if err != nil { return Cargo{}, err } return assemble(c, s.handlingEvents), nil } func (s *service) ChangeDestination(id cargo.TrackingID, destination location.UNLocode) error { if id == "" || destination == "" { return ErrInvalidArgument } c, err := s.cargos.Find(id) if err != nil { return err } l, err := s.locations.Find(destination) if err != nil { return err } c.SpecifyNewRoute(cargo.RouteSpecification{ Origin: c.Origin, Destination: l.UNLocode, ArrivalDeadline: c.RouteSpecification.ArrivalDeadline, }) if err := s.cargos.Store(c); err != nil { return err } return nil } func (s *service) RequestPossibleRoutesForCargo(id cargo.TrackingID) []cargo.Itinerary { if id == "" { return nil } c, err := s.cargos.Find(id) if err != nil { return []cargo.Itinerary{} } return s.routingService.FetchRoutesForSpecification(c.RouteSpecification) } func (s *service) Cargos() []Cargo { var result []Cargo for _, c := range s.cargos.FindAll() { result = append(result, assemble(c, s.handlingEvents)) } return result } func (s *service) Locations() []Location { var result []Location for _, v := range s.locations.FindAll() { result = append(result, Location{ UNLocode: string(v.UNLocode), Name: v.Name, }) } return result } // NewService creates a booking service with necessary dependencies. func NewService(cargos cargo.Repository, locations location.Repository, events cargo.HandlingEventRepository, rs routing.Service) Service { return &service{ cargos: cargos, locations: locations, handlingEvents: events, routingService: rs, } } // Location is a read model for booking views. type Location struct { UNLocode string `json:"locode"` Name string `json:"name"` } // Cargo is a read model for booking views. type Cargo struct { ArrivalDeadline time.Time `json:"arrival_deadline"` Destination string `json:"destination"` Legs []cargo.Leg `json:"legs,omitempty"` Misrouted bool `json:"misrouted"` Origin string `json:"origin"` Routed bool `json:"routed"` TrackingID string `json:"tracking_id"` } func assemble(c *cargo.Cargo, events cargo.HandlingEventRepository) Cargo { return Cargo{ TrackingID: string(c.TrackingID), Origin: string(c.Origin), Destination: string(c.RouteSpecification.Destination), Misrouted: c.Delivery.RoutingStatus == cargo.Misrouted, Routed: !c.Itinerary.IsEmpty(), ArrivalDeadline: c.RouteSpecification.ArrivalDeadline, Legs: c.Itinerary.Legs, } } golang-github-go-kit-kit-0.6.0/examples/shipping/booking/transport.go000066400000000000000000000116651316471211400257040ustar00rootroot00000000000000package booking import ( "context" "encoding/json" "errors" "net/http" "time" "github.com/gorilla/mux" kitlog "github.com/go-kit/kit/log" kithttp "github.com/go-kit/kit/transport/http" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/location" ) // MakeHandler returns a handler for the booking service. func MakeHandler(bs Service, logger kitlog.Logger) http.Handler { opts := []kithttp.ServerOption{ kithttp.ServerErrorLogger(logger), kithttp.ServerErrorEncoder(encodeError), } bookCargoHandler := kithttp.NewServer( makeBookCargoEndpoint(bs), decodeBookCargoRequest, encodeResponse, opts..., ) loadCargoHandler := kithttp.NewServer( makeLoadCargoEndpoint(bs), decodeLoadCargoRequest, encodeResponse, opts..., ) requestRoutesHandler := kithttp.NewServer( makeRequestRoutesEndpoint(bs), decodeRequestRoutesRequest, encodeResponse, opts..., ) assignToRouteHandler := kithttp.NewServer( makeAssignToRouteEndpoint(bs), decodeAssignToRouteRequest, encodeResponse, opts..., ) changeDestinationHandler := kithttp.NewServer( makeChangeDestinationEndpoint(bs), decodeChangeDestinationRequest, encodeResponse, opts..., ) listCargosHandler := kithttp.NewServer( makeListCargosEndpoint(bs), decodeListCargosRequest, encodeResponse, opts..., ) listLocationsHandler := kithttp.NewServer( makeListLocationsEndpoint(bs), decodeListLocationsRequest, encodeResponse, opts..., ) r := mux.NewRouter() r.Handle("/booking/v1/cargos", bookCargoHandler).Methods("POST") r.Handle("/booking/v1/cargos", listCargosHandler).Methods("GET") r.Handle("/booking/v1/cargos/{id}", loadCargoHandler).Methods("GET") r.Handle("/booking/v1/cargos/{id}/request_routes", requestRoutesHandler).Methods("GET") r.Handle("/booking/v1/cargos/{id}/assign_to_route", assignToRouteHandler).Methods("POST") r.Handle("/booking/v1/cargos/{id}/change_destination", changeDestinationHandler).Methods("POST") r.Handle("/booking/v1/locations", listLocationsHandler).Methods("GET") return r } var errBadRoute = errors.New("bad route") func decodeBookCargoRequest(_ context.Context, r *http.Request) (interface{}, error) { var body struct { Origin string `json:"origin"` Destination string `json:"destination"` ArrivalDeadline time.Time `json:"arrival_deadline"` } if err := json.NewDecoder(r.Body).Decode(&body); err != nil { return nil, err } return bookCargoRequest{ Origin: location.UNLocode(body.Origin), Destination: location.UNLocode(body.Destination), ArrivalDeadline: body.ArrivalDeadline, }, nil } func decodeLoadCargoRequest(_ context.Context, r *http.Request) (interface{}, error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, errBadRoute } return loadCargoRequest{ID: cargo.TrackingID(id)}, nil } func decodeRequestRoutesRequest(_ context.Context, r *http.Request) (interface{}, error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, errBadRoute } return requestRoutesRequest{ID: cargo.TrackingID(id)}, nil } func decodeAssignToRouteRequest(_ context.Context, r *http.Request) (interface{}, error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, errBadRoute } var itinerary cargo.Itinerary if err := json.NewDecoder(r.Body).Decode(&itinerary); err != nil { return nil, err } return assignToRouteRequest{ ID: cargo.TrackingID(id), Itinerary: itinerary, }, nil } func decodeChangeDestinationRequest(_ context.Context, r *http.Request) (interface{}, error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, errBadRoute } var body struct { Destination string `json:"destination"` } if err := json.NewDecoder(r.Body).Decode(&body); err != nil { return nil, err } return changeDestinationRequest{ ID: cargo.TrackingID(id), Destination: location.UNLocode(body.Destination), }, nil } func decodeListCargosRequest(_ context.Context, r *http.Request) (interface{}, error) { return listCargosRequest{}, nil } func decodeListLocationsRequest(_ context.Context, r *http.Request) (interface{}, error) { return listLocationsRequest{}, nil } func encodeResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error { if e, ok := response.(errorer); ok && e.error() != nil { encodeError(ctx, e.error(), w) return nil } w.Header().Set("Content-Type", "application/json; charset=utf-8") return json.NewEncoder(w).Encode(response) } type errorer interface { error() error } // encode errors from business-logic func encodeError(_ context.Context, err error, w http.ResponseWriter) { w.Header().Set("Content-Type", "application/json; charset=utf-8") switch err { case cargo.ErrUnknown: w.WriteHeader(http.StatusNotFound) case ErrInvalidArgument: w.WriteHeader(http.StatusBadRequest) default: w.WriteHeader(http.StatusInternalServerError) } json.NewEncoder(w).Encode(map[string]interface{}{ "error": err.Error(), }) } golang-github-go-kit-kit-0.6.0/examples/shipping/cargo/000077500000000000000000000000001316471211400227535ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/shipping/cargo/cargo.go000066400000000000000000000065101316471211400243770ustar00rootroot00000000000000// Package cargo contains the heart of the domain model. package cargo import ( "errors" "strings" "time" "github.com/pborman/uuid" "github.com/go-kit/kit/examples/shipping/location" ) // TrackingID uniquely identifies a particular cargo. type TrackingID string // Cargo is the central class in the domain model. type Cargo struct { TrackingID TrackingID Origin location.UNLocode RouteSpecification RouteSpecification Itinerary Itinerary Delivery Delivery } // SpecifyNewRoute specifies a new route for this cargo. func (c *Cargo) SpecifyNewRoute(rs RouteSpecification) { c.RouteSpecification = rs c.Delivery = c.Delivery.UpdateOnRouting(c.RouteSpecification, c.Itinerary) } // AssignToRoute attaches a new itinerary to this cargo. func (c *Cargo) AssignToRoute(itinerary Itinerary) { c.Itinerary = itinerary c.Delivery = c.Delivery.UpdateOnRouting(c.RouteSpecification, c.Itinerary) } // DeriveDeliveryProgress updates all aspects of the cargo aggregate status // based on the current route specification, itinerary and handling of the cargo. func (c *Cargo) DeriveDeliveryProgress(history HandlingHistory) { c.Delivery = DeriveDeliveryFrom(c.RouteSpecification, c.Itinerary, history) } // New creates a new, unrouted cargo. func New(id TrackingID, rs RouteSpecification) *Cargo { itinerary := Itinerary{} history := HandlingHistory{make([]HandlingEvent, 0)} return &Cargo{ TrackingID: id, Origin: rs.Origin, RouteSpecification: rs, Delivery: DeriveDeliveryFrom(rs, itinerary, history), } } // Repository provides access a cargo store. type Repository interface { Store(cargo *Cargo) error Find(id TrackingID) (*Cargo, error) FindAll() []*Cargo } // ErrUnknown is used when a cargo could not be found. var ErrUnknown = errors.New("unknown cargo") // NextTrackingID generates a new tracking ID. // TODO: Move to infrastructure(?) func NextTrackingID() TrackingID { return TrackingID(strings.Split(strings.ToUpper(uuid.New()), "-")[0]) } // RouteSpecification Contains information about a route: its origin, // destination and arrival deadline. type RouteSpecification struct { Origin location.UNLocode Destination location.UNLocode ArrivalDeadline time.Time } // IsSatisfiedBy checks whether provided itinerary satisfies this // specification. func (s RouteSpecification) IsSatisfiedBy(itinerary Itinerary) bool { return itinerary.Legs != nil && s.Origin == itinerary.InitialDepartureLocation() && s.Destination == itinerary.FinalArrivalLocation() } // RoutingStatus describes status of cargo routing. type RoutingStatus int // Valid routing statuses. const ( NotRouted RoutingStatus = iota Misrouted Routed ) func (s RoutingStatus) String() string { switch s { case NotRouted: return "Not routed" case Misrouted: return "Misrouted" case Routed: return "Routed" } return "" } // TransportStatus describes status of cargo transportation. type TransportStatus int // Valid transport statuses. const ( NotReceived TransportStatus = iota InPort OnboardCarrier Claimed Unknown ) func (s TransportStatus) String() string { switch s { case NotReceived: return "Not received" case InPort: return "In port" case OnboardCarrier: return "Onboard carrier" case Claimed: return "Claimed" case Unknown: return "Unknown" } return "" } golang-github-go-kit-kit-0.6.0/examples/shipping/cargo/delivery.go000066400000000000000000000121561316471211400251320ustar00rootroot00000000000000package cargo import ( "time" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/voyage" ) // Delivery is the actual transportation of the cargo, as opposed to the // customer requirement (RouteSpecification) and the plan (Itinerary). type Delivery struct { Itinerary Itinerary RouteSpecification RouteSpecification RoutingStatus RoutingStatus TransportStatus TransportStatus NextExpectedActivity HandlingActivity LastEvent HandlingEvent LastKnownLocation location.UNLocode CurrentVoyage voyage.Number ETA time.Time IsMisdirected bool IsUnloadedAtDestination bool } // UpdateOnRouting creates a new delivery snapshot to reflect changes in // routing, i.e. when the route specification or the itinerary has changed but // no additional handling of the cargo has been performed. func (d Delivery) UpdateOnRouting(rs RouteSpecification, itinerary Itinerary) Delivery { return newDelivery(d.LastEvent, itinerary, rs) } // IsOnTrack checks if the delivery is on track. func (d Delivery) IsOnTrack() bool { return d.RoutingStatus == Routed && !d.IsMisdirected } // DeriveDeliveryFrom creates a new delivery snapshot based on the complete // handling history of a cargo, as well as its route specification and // itinerary. func DeriveDeliveryFrom(rs RouteSpecification, itinerary Itinerary, history HandlingHistory) Delivery { lastEvent, _ := history.MostRecentlyCompletedEvent() return newDelivery(lastEvent, itinerary, rs) } // newDelivery creates a up-to-date delivery based on an handling event, // itinerary and a route specification. func newDelivery(lastEvent HandlingEvent, itinerary Itinerary, rs RouteSpecification) Delivery { var ( routingStatus = calculateRoutingStatus(itinerary, rs) transportStatus = calculateTransportStatus(lastEvent) lastKnownLocation = calculateLastKnownLocation(lastEvent) isMisdirected = calculateMisdirectedStatus(lastEvent, itinerary) isUnloadedAtDestination = calculateUnloadedAtDestination(lastEvent, rs) currentVoyage = calculateCurrentVoyage(transportStatus, lastEvent) ) d := Delivery{ LastEvent: lastEvent, Itinerary: itinerary, RouteSpecification: rs, RoutingStatus: routingStatus, TransportStatus: transportStatus, LastKnownLocation: lastKnownLocation, IsMisdirected: isMisdirected, IsUnloadedAtDestination: isUnloadedAtDestination, CurrentVoyage: currentVoyage, } d.NextExpectedActivity = calculateNextExpectedActivity(d) d.ETA = calculateETA(d) return d } // Below are internal functions used when creating a new delivery. func calculateRoutingStatus(itinerary Itinerary, rs RouteSpecification) RoutingStatus { if itinerary.Legs == nil { return NotRouted } if rs.IsSatisfiedBy(itinerary) { return Routed } return Misrouted } func calculateMisdirectedStatus(event HandlingEvent, itinerary Itinerary) bool { if event.Activity.Type == NotHandled { return false } return !itinerary.IsExpected(event) } func calculateUnloadedAtDestination(event HandlingEvent, rs RouteSpecification) bool { if event.Activity.Type == NotHandled { return false } return event.Activity.Type == Unload && rs.Destination == event.Activity.Location } func calculateTransportStatus(event HandlingEvent) TransportStatus { switch event.Activity.Type { case NotHandled: return NotReceived case Load: return OnboardCarrier case Unload: return InPort case Receive: return InPort case Customs: return InPort case Claim: return Claimed } return Unknown } func calculateLastKnownLocation(event HandlingEvent) location.UNLocode { return event.Activity.Location } func calculateNextExpectedActivity(d Delivery) HandlingActivity { if !d.IsOnTrack() { return HandlingActivity{} } switch d.LastEvent.Activity.Type { case NotHandled: return HandlingActivity{Type: Receive, Location: d.RouteSpecification.Origin} case Receive: l := d.Itinerary.Legs[0] return HandlingActivity{Type: Load, Location: l.LoadLocation, VoyageNumber: l.VoyageNumber} case Load: for _, l := range d.Itinerary.Legs { if l.LoadLocation == d.LastEvent.Activity.Location { return HandlingActivity{Type: Unload, Location: l.UnloadLocation, VoyageNumber: l.VoyageNumber} } } case Unload: for i, l := range d.Itinerary.Legs { if l.UnloadLocation == d.LastEvent.Activity.Location { if i < len(d.Itinerary.Legs)-1 { return HandlingActivity{Type: Load, Location: d.Itinerary.Legs[i+1].LoadLocation, VoyageNumber: d.Itinerary.Legs[i+1].VoyageNumber} } return HandlingActivity{Type: Claim, Location: l.UnloadLocation} } } } return HandlingActivity{} } func calculateCurrentVoyage(transportStatus TransportStatus, event HandlingEvent) voyage.Number { if transportStatus == OnboardCarrier && event.Activity.Type != NotHandled { return event.Activity.VoyageNumber } return voyage.Number("") } func calculateETA(d Delivery) time.Time { if !d.IsOnTrack() { return time.Time{} } return d.Itinerary.FinalArrivalTime() } golang-github-go-kit-kit-0.6.0/examples/shipping/cargo/handling.go000066400000000000000000000062671316471211400251010ustar00rootroot00000000000000package cargo // TODO: It would make sense to have this in its own package. Unfortunately, // then there would be a circular dependency between the cargo and handling // packages since cargo.Delivery would use handling.HandlingEvent and // handling.HandlingEvent would use cargo.TrackingID. Also, // HandlingEventFactory depends on the cargo repository. // // It would make sense not having the cargo package depend on handling. import ( "errors" "time" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/voyage" ) // HandlingActivity represents how and where a cargo can be handled, and can // be used to express predictions about what is expected to happen to a cargo // in the future. type HandlingActivity struct { Type HandlingEventType Location location.UNLocode VoyageNumber voyage.Number } // HandlingEvent is used to register the event when, for instance, a cargo is // unloaded from a carrier at a some location at a given time. type HandlingEvent struct { TrackingID TrackingID Activity HandlingActivity } // HandlingEventType describes type of a handling event. type HandlingEventType int // Valid handling event types. const ( NotHandled HandlingEventType = iota Load Unload Receive Claim Customs ) func (t HandlingEventType) String() string { switch t { case NotHandled: return "Not Handled" case Load: return "Load" case Unload: return "Unload" case Receive: return "Receive" case Claim: return "Claim" case Customs: return "Customs" } return "" } // HandlingHistory is the handling history of a cargo. type HandlingHistory struct { HandlingEvents []HandlingEvent } // MostRecentlyCompletedEvent returns most recently completed handling event. func (h HandlingHistory) MostRecentlyCompletedEvent() (HandlingEvent, error) { if len(h.HandlingEvents) == 0 { return HandlingEvent{}, errors.New("delivery history is empty") } return h.HandlingEvents[len(h.HandlingEvents)-1], nil } // HandlingEventRepository provides access a handling event store. type HandlingEventRepository interface { Store(e HandlingEvent) QueryHandlingHistory(TrackingID) HandlingHistory } // HandlingEventFactory creates handling events. type HandlingEventFactory struct { CargoRepository Repository VoyageRepository voyage.Repository LocationRepository location.Repository } // CreateHandlingEvent creates a validated handling event. func (f *HandlingEventFactory) CreateHandlingEvent(registered time.Time, completed time.Time, id TrackingID, voyageNumber voyage.Number, unLocode location.UNLocode, eventType HandlingEventType) (HandlingEvent, error) { if _, err := f.CargoRepository.Find(id); err != nil { return HandlingEvent{}, err } if _, err := f.VoyageRepository.Find(voyageNumber); err != nil { // TODO: This is pretty ugly, but when creating a Receive event, the voyage number is not known. if len(voyageNumber) > 0 { return HandlingEvent{}, err } } if _, err := f.LocationRepository.Find(unLocode); err != nil { return HandlingEvent{}, err } return HandlingEvent{ TrackingID: id, Activity: HandlingActivity{ Type: eventType, Location: unLocode, VoyageNumber: voyageNumber, }, }, nil } golang-github-go-kit-kit-0.6.0/examples/shipping/cargo/itinerary.go000066400000000000000000000046611316471211400253170ustar00rootroot00000000000000package cargo import ( "time" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/voyage" ) // Leg describes the transportation between two locations on a voyage. type Leg struct { VoyageNumber voyage.Number `json:"voyage_number"` LoadLocation location.UNLocode `json:"from"` UnloadLocation location.UNLocode `json:"to"` LoadTime time.Time `json:"load_time"` UnloadTime time.Time `json:"unload_time"` } // NewLeg creates a new itinerary leg. func NewLeg(voyageNumber voyage.Number, loadLocation, unloadLocation location.UNLocode, loadTime, unloadTime time.Time) Leg { return Leg{ VoyageNumber: voyageNumber, LoadLocation: loadLocation, UnloadLocation: unloadLocation, LoadTime: loadTime, UnloadTime: unloadTime, } } // Itinerary specifies steps required to transport a cargo from its origin to // destination. type Itinerary struct { Legs []Leg `json:"legs"` } // InitialDepartureLocation returns the start of the itinerary. func (i Itinerary) InitialDepartureLocation() location.UNLocode { if i.IsEmpty() { return location.UNLocode("") } return i.Legs[0].LoadLocation } // FinalArrivalLocation returns the end of the itinerary. func (i Itinerary) FinalArrivalLocation() location.UNLocode { if i.IsEmpty() { return location.UNLocode("") } return i.Legs[len(i.Legs)-1].UnloadLocation } // FinalArrivalTime returns the expected arrival time at final destination. func (i Itinerary) FinalArrivalTime() time.Time { return i.Legs[len(i.Legs)-1].UnloadTime } // IsEmpty checks if the itinerary contains at least one leg. func (i Itinerary) IsEmpty() bool { return i.Legs == nil || len(i.Legs) == 0 } // IsExpected checks if the given handling event is expected when executing // this itinerary. func (i Itinerary) IsExpected(event HandlingEvent) bool { if i.IsEmpty() { return true } switch event.Activity.Type { case Receive: return i.InitialDepartureLocation() == event.Activity.Location case Load: for _, l := range i.Legs { if l.LoadLocation == event.Activity.Location && l.VoyageNumber == event.Activity.VoyageNumber { return true } } return false case Unload: for _, l := range i.Legs { if l.UnloadLocation == event.Activity.Location && l.VoyageNumber == event.Activity.VoyageNumber { return true } } return false case Claim: return i.FinalArrivalLocation() == event.Activity.Location } return true } golang-github-go-kit-kit-0.6.0/examples/shipping/handling/000077500000000000000000000000001316471211400234445ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/shipping/handling/endpoint.go000066400000000000000000000016401316471211400256140ustar00rootroot00000000000000package handling import ( "context" "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/voyage" ) type registerIncidentRequest struct { ID cargo.TrackingID Location location.UNLocode Voyage voyage.Number EventType cargo.HandlingEventType CompletionTime time.Time } type registerIncidentResponse struct { Err error `json:"error,omitempty"` } func (r registerIncidentResponse) error() error { return r.Err } func makeRegisterIncidentEndpoint(hs Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(registerIncidentRequest) err := hs.RegisterHandlingEvent(req.CompletionTime, req.ID, req.Voyage, req.Location, req.EventType) return registerIncidentResponse{Err: err}, nil } } golang-github-go-kit-kit-0.6.0/examples/shipping/handling/instrumenting.go000066400000000000000000000021201316471211400266740ustar00rootroot00000000000000package handling import ( "time" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/voyage" ) type instrumentingService struct { requestCount metrics.Counter requestLatency metrics.Histogram Service } // NewInstrumentingService returns an instance of an instrumenting Service. func NewInstrumentingService(counter metrics.Counter, latency metrics.Histogram, s Service) Service { return &instrumentingService{ requestCount: counter, requestLatency: latency, Service: s, } } func (s *instrumentingService) RegisterHandlingEvent(completed time.Time, id cargo.TrackingID, voyageNumber voyage.Number, loc location.UNLocode, eventType cargo.HandlingEventType) error { defer func(begin time.Time) { s.requestCount.With("method", "register_incident").Add(1) s.requestLatency.With("method", "register_incident").Observe(time.Since(begin).Seconds()) }(time.Now()) return s.Service.RegisterHandlingEvent(completed, id, voyageNumber, loc, eventType) } golang-github-go-kit-kit-0.6.0/examples/shipping/handling/logging.go000066400000000000000000000017661316471211400254330ustar00rootroot00000000000000package handling import ( "time" "github.com/go-kit/kit/log" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/voyage" ) type loggingService struct { logger log.Logger Service } // NewLoggingService returns a new instance of a logging Service. func NewLoggingService(logger log.Logger, s Service) Service { return &loggingService{logger, s} } func (s *loggingService) RegisterHandlingEvent(completed time.Time, id cargo.TrackingID, voyageNumber voyage.Number, unLocode location.UNLocode, eventType cargo.HandlingEventType) (err error) { defer func(begin time.Time) { s.logger.Log( "method", "register_incident", "tracking_id", id, "location", unLocode, "voyage", voyageNumber, "event_type", eventType, "completion_time", completed, "took", time.Since(begin), "err", err, ) }(time.Now()) return s.Service.RegisterHandlingEvent(completed, id, voyageNumber, unLocode, eventType) } golang-github-go-kit-kit-0.6.0/examples/shipping/handling/service.go000066400000000000000000000045721316471211400254430ustar00rootroot00000000000000// Package handling provides the use-case for registering incidents. Used by // views facing the people handling the cargo along its route. package handling import ( "errors" "time" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/inspection" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/voyage" ) // ErrInvalidArgument is returned when one or more arguments are invalid. var ErrInvalidArgument = errors.New("invalid argument") // EventHandler provides a means of subscribing to registered handling events. type EventHandler interface { CargoWasHandled(cargo.HandlingEvent) } // Service provides handling operations. type Service interface { // RegisterHandlingEvent registers a handling event in the system, and // notifies interested parties that a cargo has been handled. RegisterHandlingEvent(completed time.Time, id cargo.TrackingID, voyageNumber voyage.Number, unLocode location.UNLocode, eventType cargo.HandlingEventType) error } type service struct { handlingEventRepository cargo.HandlingEventRepository handlingEventFactory cargo.HandlingEventFactory handlingEventHandler EventHandler } func (s *service) RegisterHandlingEvent(completed time.Time, id cargo.TrackingID, voyageNumber voyage.Number, loc location.UNLocode, eventType cargo.HandlingEventType) error { if completed.IsZero() || id == "" || loc == "" || eventType == cargo.NotHandled { return ErrInvalidArgument } e, err := s.handlingEventFactory.CreateHandlingEvent(time.Now(), completed, id, voyageNumber, loc, eventType) if err != nil { return err } s.handlingEventRepository.Store(e) s.handlingEventHandler.CargoWasHandled(e) return nil } // NewService creates a handling event service with necessary dependencies. func NewService(r cargo.HandlingEventRepository, f cargo.HandlingEventFactory, h EventHandler) Service { return &service{ handlingEventRepository: r, handlingEventFactory: f, handlingEventHandler: h, } } type handlingEventHandler struct { InspectionService inspection.Service } func (h *handlingEventHandler) CargoWasHandled(event cargo.HandlingEvent) { h.InspectionService.InspectCargo(event.TrackingID) } // NewEventHandler returns a new instance of a EventHandler. func NewEventHandler(s inspection.Service) EventHandler { return &handlingEventHandler{ InspectionService: s, } } golang-github-go-kit-kit-0.6.0/examples/shipping/handling/transport.go000066400000000000000000000052401316471211400260300ustar00rootroot00000000000000package handling import ( "context" "encoding/json" "net/http" "time" "github.com/gorilla/mux" kitlog "github.com/go-kit/kit/log" kithttp "github.com/go-kit/kit/transport/http" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/voyage" ) // MakeHandler returns a handler for the handling service. func MakeHandler(hs Service, logger kitlog.Logger) http.Handler { r := mux.NewRouter() opts := []kithttp.ServerOption{ kithttp.ServerErrorLogger(logger), kithttp.ServerErrorEncoder(encodeError), } registerIncidentHandler := kithttp.NewServer( makeRegisterIncidentEndpoint(hs), decodeRegisterIncidentRequest, encodeResponse, opts..., ) r.Handle("/handling/v1/incidents", registerIncidentHandler).Methods("POST") return r } func decodeRegisterIncidentRequest(_ context.Context, r *http.Request) (interface{}, error) { var body struct { CompletionTime time.Time `json:"completion_time"` TrackingID string `json:"tracking_id"` VoyageNumber string `json:"voyage"` Location string `json:"location"` EventType string `json:"event_type"` } if err := json.NewDecoder(r.Body).Decode(&body); err != nil { return nil, err } return registerIncidentRequest{ CompletionTime: body.CompletionTime, ID: cargo.TrackingID(body.TrackingID), Voyage: voyage.Number(body.VoyageNumber), Location: location.UNLocode(body.Location), EventType: stringToEventType(body.EventType), }, nil } func stringToEventType(s string) cargo.HandlingEventType { types := map[string]cargo.HandlingEventType{ cargo.Receive.String(): cargo.Receive, cargo.Load.String(): cargo.Load, cargo.Unload.String(): cargo.Unload, cargo.Customs.String(): cargo.Customs, cargo.Claim.String(): cargo.Claim, } return types[s] } func encodeResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error { if e, ok := response.(errorer); ok && e.error() != nil { encodeError(ctx, e.error(), w) return nil } w.Header().Set("Content-Type", "application/json; charset=utf-8") return json.NewEncoder(w).Encode(response) } type errorer interface { error() error } // encode errors from business-logic func encodeError(_ context.Context, err error, w http.ResponseWriter) { w.Header().Set("Content-Type", "application/json; charset=utf-8") switch err { case cargo.ErrUnknown: w.WriteHeader(http.StatusNotFound) case ErrInvalidArgument: w.WriteHeader(http.StatusBadRequest) default: w.WriteHeader(http.StatusInternalServerError) } json.NewEncoder(w).Encode(map[string]interface{}{ "error": err.Error(), }) } golang-github-go-kit-kit-0.6.0/examples/shipping/inmem/000077500000000000000000000000001316471211400227655ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/shipping/inmem/inmem.go000066400000000000000000000074421316471211400244300ustar00rootroot00000000000000// Package inmem provides in-memory implementations of all the domain repositories. package inmem import ( "sync" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/voyage" ) type cargoRepository struct { mtx sync.RWMutex cargos map[cargo.TrackingID]*cargo.Cargo } func (r *cargoRepository) Store(c *cargo.Cargo) error { r.mtx.Lock() defer r.mtx.Unlock() r.cargos[c.TrackingID] = c return nil } func (r *cargoRepository) Find(id cargo.TrackingID) (*cargo.Cargo, error) { r.mtx.RLock() defer r.mtx.RUnlock() if val, ok := r.cargos[id]; ok { return val, nil } return nil, cargo.ErrUnknown } func (r *cargoRepository) FindAll() []*cargo.Cargo { r.mtx.RLock() defer r.mtx.RUnlock() c := make([]*cargo.Cargo, 0, len(r.cargos)) for _, val := range r.cargos { c = append(c, val) } return c } // NewCargoRepository returns a new instance of a in-memory cargo repository. func NewCargoRepository() cargo.Repository { return &cargoRepository{ cargos: make(map[cargo.TrackingID]*cargo.Cargo), } } type locationRepository struct { locations map[location.UNLocode]*location.Location } func (r *locationRepository) Find(locode location.UNLocode) (*location.Location, error) { if l, ok := r.locations[locode]; ok { return l, nil } return nil, location.ErrUnknown } func (r *locationRepository) FindAll() []*location.Location { l := make([]*location.Location, 0, len(r.locations)) for _, val := range r.locations { l = append(l, val) } return l } // NewLocationRepository returns a new instance of a in-memory location repository. func NewLocationRepository() location.Repository { r := &locationRepository{ locations: make(map[location.UNLocode]*location.Location), } r.locations[location.SESTO] = location.Stockholm r.locations[location.AUMEL] = location.Melbourne r.locations[location.CNHKG] = location.Hongkong r.locations[location.JNTKO] = location.Tokyo r.locations[location.NLRTM] = location.Rotterdam r.locations[location.DEHAM] = location.Hamburg return r } type voyageRepository struct { voyages map[voyage.Number]*voyage.Voyage } func (r *voyageRepository) Find(voyageNumber voyage.Number) (*voyage.Voyage, error) { if v, ok := r.voyages[voyageNumber]; ok { return v, nil } return nil, voyage.ErrUnknown } // NewVoyageRepository returns a new instance of a in-memory voyage repository. func NewVoyageRepository() voyage.Repository { r := &voyageRepository{ voyages: make(map[voyage.Number]*voyage.Voyage), } r.voyages[voyage.V100.Number] = voyage.V100 r.voyages[voyage.V300.Number] = voyage.V300 r.voyages[voyage.V400.Number] = voyage.V400 r.voyages[voyage.V0100S.Number] = voyage.V0100S r.voyages[voyage.V0200T.Number] = voyage.V0200T r.voyages[voyage.V0300A.Number] = voyage.V0300A r.voyages[voyage.V0301S.Number] = voyage.V0301S r.voyages[voyage.V0400S.Number] = voyage.V0400S return r } type handlingEventRepository struct { mtx sync.RWMutex events map[cargo.TrackingID][]cargo.HandlingEvent } func (r *handlingEventRepository) Store(e cargo.HandlingEvent) { r.mtx.Lock() defer r.mtx.Unlock() // Make array if it's the first event with this tracking ID. if _, ok := r.events[e.TrackingID]; !ok { r.events[e.TrackingID] = make([]cargo.HandlingEvent, 0) } r.events[e.TrackingID] = append(r.events[e.TrackingID], e) } func (r *handlingEventRepository) QueryHandlingHistory(id cargo.TrackingID) cargo.HandlingHistory { r.mtx.RLock() defer r.mtx.RUnlock() return cargo.HandlingHistory{HandlingEvents: r.events[id]} } // NewHandlingEventRepository returns a new instance of a in-memory handling event repository. func NewHandlingEventRepository() cargo.HandlingEventRepository { return &handlingEventRepository{ events: make(map[cargo.TrackingID][]cargo.HandlingEvent), } } golang-github-go-kit-kit-0.6.0/examples/shipping/inspection/000077500000000000000000000000001316471211400240335ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/shipping/inspection/inspection.go000066400000000000000000000024461316471211400265430ustar00rootroot00000000000000// Package inspection provides means to inspect cargos. package inspection import ( "github.com/go-kit/kit/examples/shipping/cargo" ) // EventHandler provides means of subscribing to inspection events. type EventHandler interface { CargoWasMisdirected(*cargo.Cargo) CargoHasArrived(*cargo.Cargo) } // Service provides cargo inspection operations. type Service interface { // InspectCargo inspects cargo and send relevant notifications to // interested parties, for example if a cargo has been misdirected, or // unloaded at the final destination. InspectCargo(id cargo.TrackingID) } type service struct { cargos cargo.Repository events cargo.HandlingEventRepository handler EventHandler } // TODO: Should be transactional func (s *service) InspectCargo(id cargo.TrackingID) { c, err := s.cargos.Find(id) if err != nil { return } h := s.events.QueryHandlingHistory(id) c.DeriveDeliveryProgress(h) if c.Delivery.IsMisdirected { s.handler.CargoWasMisdirected(c) } if c.Delivery.IsUnloadedAtDestination { s.handler.CargoHasArrived(c) } s.cargos.Store(c) } // NewService creates a inspection service with necessary dependencies. func NewService(cargos cargo.Repository, events cargo.HandlingEventRepository, handler EventHandler) Service { return &service{cargos, events, handler} } golang-github-go-kit-kit-0.6.0/examples/shipping/location/000077500000000000000000000000001316471211400234705ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/shipping/location/location.go000066400000000000000000000014031316471211400256250ustar00rootroot00000000000000// Package location provides the Location aggregate. package location import ( "errors" ) // UNLocode is the United Nations location code that uniquely identifies a // particular location. // // http://www.unece.org/cefact/locode/ // http://www.unece.org/cefact/locode/DocColumnDescription.htm#LOCODE type UNLocode string // Location is a location is our model is stops on a journey, such as cargo // origin or destination, or carrier movement endpoints. type Location struct { UNLocode UNLocode Name string } // ErrUnknown is used when a location could not be found. var ErrUnknown = errors.New("unknown location") // Repository provides access a location store. type Repository interface { Find(locode UNLocode) (*Location, error) FindAll() []*Location } golang-github-go-kit-kit-0.6.0/examples/shipping/location/sample_locations.go000066400000000000000000000012601316471211400273520ustar00rootroot00000000000000package location // Sample UN locodes. var ( SESTO UNLocode = "SESTO" AUMEL UNLocode = "AUMEL" CNHKG UNLocode = "CNHKG" USNYC UNLocode = "USNYC" USCHI UNLocode = "USCHI" JNTKO UNLocode = "JNTKO" DEHAM UNLocode = "DEHAM" NLRTM UNLocode = "NLRTM" FIHEL UNLocode = "FIHEL" ) // Sample locations. var ( Stockholm = &Location{SESTO, "Stockholm"} Melbourne = &Location{AUMEL, "Melbourne"} Hongkong = &Location{CNHKG, "Hongkong"} NewYork = &Location{USNYC, "New York"} Chicago = &Location{USCHI, "Chicago"} Tokyo = &Location{JNTKO, "Tokyo"} Hamburg = &Location{DEHAM, "Hamburg"} Rotterdam = &Location{NLRTM, "Rotterdam"} Helsinki = &Location{FIHEL, "Helsinki"} ) golang-github-go-kit-kit-0.6.0/examples/shipping/main.go000066400000000000000000000131361316471211400231370ustar00rootroot00000000000000package main import ( "context" "flag" "fmt" "net/http" "os" "os/signal" "syscall" "time" stdprometheus "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promhttp" "github.com/go-kit/kit/log" kitprometheus "github.com/go-kit/kit/metrics/prometheus" "github.com/go-kit/kit/examples/shipping/booking" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/handling" "github.com/go-kit/kit/examples/shipping/inmem" "github.com/go-kit/kit/examples/shipping/inspection" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/routing" "github.com/go-kit/kit/examples/shipping/tracking" ) const ( defaultPort = "8080" defaultRoutingServiceURL = "http://localhost:7878" ) func main() { var ( addr = envString("PORT", defaultPort) rsurl = envString("ROUTINGSERVICE_URL", defaultRoutingServiceURL) httpAddr = flag.String("http.addr", ":"+addr, "HTTP listen address") routingServiceURL = flag.String("service.routing", rsurl, "routing service URL") ctx = context.Background() ) flag.Parse() var logger log.Logger logger = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr)) logger = log.With(logger, "ts", log.DefaultTimestampUTC) var ( cargos = inmem.NewCargoRepository() locations = inmem.NewLocationRepository() voyages = inmem.NewVoyageRepository() handlingEvents = inmem.NewHandlingEventRepository() ) // Configure some questionable dependencies. var ( handlingEventFactory = cargo.HandlingEventFactory{ CargoRepository: cargos, VoyageRepository: voyages, LocationRepository: locations, } handlingEventHandler = handling.NewEventHandler( inspection.NewService(cargos, handlingEvents, nil), ) ) // Facilitate testing by adding some cargos. storeTestData(cargos) fieldKeys := []string{"method"} var rs routing.Service rs = routing.NewProxyingMiddleware(ctx, *routingServiceURL)(rs) var bs booking.Service bs = booking.NewService(cargos, locations, handlingEvents, rs) bs = booking.NewLoggingService(log.With(logger, "component", "booking"), bs) bs = booking.NewInstrumentingService( kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{ Namespace: "api", Subsystem: "booking_service", Name: "request_count", Help: "Number of requests received.", }, fieldKeys), kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{ Namespace: "api", Subsystem: "booking_service", Name: "request_latency_microseconds", Help: "Total duration of requests in microseconds.", }, fieldKeys), bs, ) var ts tracking.Service ts = tracking.NewService(cargos, handlingEvents) ts = tracking.NewLoggingService(log.With(logger, "component", "tracking"), ts) ts = tracking.NewInstrumentingService( kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{ Namespace: "api", Subsystem: "tracking_service", Name: "request_count", Help: "Number of requests received.", }, fieldKeys), kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{ Namespace: "api", Subsystem: "tracking_service", Name: "request_latency_microseconds", Help: "Total duration of requests in microseconds.", }, fieldKeys), ts, ) var hs handling.Service hs = handling.NewService(handlingEvents, handlingEventFactory, handlingEventHandler) hs = handling.NewLoggingService(log.With(logger, "component", "handling"), hs) hs = handling.NewInstrumentingService( kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{ Namespace: "api", Subsystem: "handling_service", Name: "request_count", Help: "Number of requests received.", }, fieldKeys), kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{ Namespace: "api", Subsystem: "handling_service", Name: "request_latency_microseconds", Help: "Total duration of requests in microseconds.", }, fieldKeys), hs, ) httpLogger := log.With(logger, "component", "http") mux := http.NewServeMux() mux.Handle("/booking/v1/", booking.MakeHandler(bs, httpLogger)) mux.Handle("/tracking/v1/", tracking.MakeHandler(ts, httpLogger)) mux.Handle("/handling/v1/", handling.MakeHandler(hs, httpLogger)) http.Handle("/", accessControl(mux)) http.Handle("/metrics", promhttp.Handler()) errs := make(chan error, 2) go func() { logger.Log("transport", "http", "address", *httpAddr, "msg", "listening") errs <- http.ListenAndServe(*httpAddr, nil) }() go func() { c := make(chan os.Signal) signal.Notify(c, syscall.SIGINT) errs <- fmt.Errorf("%s", <-c) }() logger.Log("terminated", <-errs) } func accessControl(h http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Access-Control-Allow-Origin", "*") w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS") w.Header().Set("Access-Control-Allow-Headers", "Origin, Content-Type") if r.Method == "OPTIONS" { return } h.ServeHTTP(w, r) }) } func envString(env, fallback string) string { e := os.Getenv(env) if e == "" { return fallback } return e } func storeTestData(r cargo.Repository) { test1 := cargo.New("FTL456", cargo.RouteSpecification{ Origin: location.AUMEL, Destination: location.SESTO, ArrivalDeadline: time.Now().AddDate(0, 0, 7), }) if err := r.Store(test1); err != nil { panic(err) } test2 := cargo.New("ABC123", cargo.RouteSpecification{ Origin: location.SESTO, Destination: location.CNHKG, ArrivalDeadline: time.Now().AddDate(0, 0, 14), }) if err := r.Store(test2); err != nil { panic(err) } } golang-github-go-kit-kit-0.6.0/examples/shipping/routing/000077500000000000000000000000001316471211400233475ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/shipping/routing/proxying.go000066400000000000000000000055371316471211400255670ustar00rootroot00000000000000package routing import ( "context" "encoding/json" "net/http" "net/url" "time" "github.com/go-kit/kit/circuitbreaker" "github.com/go-kit/kit/endpoint" kithttp "github.com/go-kit/kit/transport/http" "github.com/go-kit/kit/examples/shipping/cargo" "github.com/go-kit/kit/examples/shipping/location" "github.com/go-kit/kit/examples/shipping/voyage" ) type proxyService struct { context.Context FetchRoutesEndpoint endpoint.Endpoint Service } func (s proxyService) FetchRoutesForSpecification(rs cargo.RouteSpecification) []cargo.Itinerary { response, err := s.FetchRoutesEndpoint(s.Context, fetchRoutesRequest{ From: string(rs.Origin), To: string(rs.Destination), }) if err != nil { return []cargo.Itinerary{} } resp := response.(fetchRoutesResponse) var itineraries []cargo.Itinerary for _, r := range resp.Paths { var legs []cargo.Leg for _, e := range r.Edges { legs = append(legs, cargo.Leg{ VoyageNumber: voyage.Number(e.Voyage), LoadLocation: location.UNLocode(e.Origin), UnloadLocation: location.UNLocode(e.Destination), LoadTime: e.Departure, UnloadTime: e.Arrival, }) } itineraries = append(itineraries, cargo.Itinerary{Legs: legs}) } return itineraries } // ServiceMiddleware defines a middleware for a routing service. type ServiceMiddleware func(Service) Service // NewProxyingMiddleware returns a new instance of a proxying middleware. func NewProxyingMiddleware(ctx context.Context, proxyURL string) ServiceMiddleware { return func(next Service) Service { var e endpoint.Endpoint e = makeFetchRoutesEndpoint(ctx, proxyURL) e = circuitbreaker.Hystrix("fetch-routes")(e) return proxyService{ctx, e, next} } } type fetchRoutesRequest struct { From string To string } type fetchRoutesResponse struct { Paths []struct { Edges []struct { Origin string `json:"origin"` Destination string `json:"destination"` Voyage string `json:"voyage"` Departure time.Time `json:"departure"` Arrival time.Time `json:"arrival"` } `json:"edges"` } `json:"paths"` } func makeFetchRoutesEndpoint(ctx context.Context, instance string) endpoint.Endpoint { u, err := url.Parse(instance) if err != nil { panic(err) } if u.Path == "" { u.Path = "/paths" } return kithttp.NewClient( "GET", u, encodeFetchRoutesRequest, decodeFetchRoutesResponse, ).Endpoint() } func decodeFetchRoutesResponse(_ context.Context, resp *http.Response) (interface{}, error) { var response fetchRoutesResponse if err := json.NewDecoder(resp.Body).Decode(&response); err != nil { return nil, err } return response, nil } func encodeFetchRoutesRequest(_ context.Context, r *http.Request, request interface{}) error { req := request.(fetchRoutesRequest) vals := r.URL.Query() vals.Add("from", req.From) vals.Add("to", req.To) r.URL.RawQuery = vals.Encode() return nil } golang-github-go-kit-kit-0.6.0/examples/shipping/routing/routing.go000066400000000000000000000007761316471211400253770ustar00rootroot00000000000000// Package routing provides the routing domain service. It does not actually // implement the routing service but merely acts as a proxy for a separate // bounded context. package routing import ( "github.com/go-kit/kit/examples/shipping/cargo" ) // Service provides access to an external routing service. type Service interface { // FetchRoutesForSpecification finds all possible routes that satisfy a // given specification. FetchRoutesForSpecification(rs cargo.RouteSpecification) []cargo.Itinerary } golang-github-go-kit-kit-0.6.0/examples/shipping/tracking/000077500000000000000000000000001316471211400234625ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/shipping/tracking/endpoint.go000066400000000000000000000010571316471211400256340ustar00rootroot00000000000000package tracking import ( "context" "github.com/go-kit/kit/endpoint" ) type trackCargoRequest struct { ID string } type trackCargoResponse struct { Cargo *Cargo `json:"cargo,omitempty"` Err error `json:"error,omitempty"` } func (r trackCargoResponse) error() error { return r.Err } func makeTrackCargoEndpoint(ts Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(trackCargoRequest) c, err := ts.Track(req.ID) return trackCargoResponse{Cargo: &c, Err: err}, nil } } golang-github-go-kit-kit-0.6.0/examples/shipping/tracking/instrumenting.go000066400000000000000000000013511316471211400267170ustar00rootroot00000000000000package tracking import ( "time" "github.com/go-kit/kit/metrics" ) type instrumentingService struct { requestCount metrics.Counter requestLatency metrics.Histogram Service } // NewInstrumentingService returns an instance of an instrumenting Service. func NewInstrumentingService(counter metrics.Counter, latency metrics.Histogram, s Service) Service { return &instrumentingService{ requestCount: counter, requestLatency: latency, Service: s, } } func (s *instrumentingService) Track(id string) (Cargo, error) { defer func(begin time.Time) { s.requestCount.With("method", "track").Add(1) s.requestLatency.With("method", "track").Observe(time.Since(begin).Seconds()) }(time.Now()) return s.Service.Track(id) } golang-github-go-kit-kit-0.6.0/examples/shipping/tracking/logging.go000066400000000000000000000010201316471211400254300ustar00rootroot00000000000000package tracking import ( "time" "github.com/go-kit/kit/log" ) type loggingService struct { logger log.Logger Service } // NewLoggingService returns a new instance of a logging Service. func NewLoggingService(logger log.Logger, s Service) Service { return &loggingService{logger, s} } func (s *loggingService) Track(id string) (c Cargo, err error) { defer func(begin time.Time) { s.logger.Log("method", "track", "tracking_id", id, "took", time.Since(begin), "err", err) }(time.Now()) return s.Service.Track(id) } golang-github-go-kit-kit-0.6.0/examples/shipping/tracking/service.go000066400000000000000000000120011316471211400254430ustar00rootroot00000000000000// Package tracking provides the use-case of tracking a cargo. Used by views // facing the end-user. package tracking import ( "errors" "fmt" "strings" "time" "github.com/go-kit/kit/examples/shipping/cargo" ) // ErrInvalidArgument is returned when one or more arguments are invalid. var ErrInvalidArgument = errors.New("invalid argument") // Service is the interface that provides the basic Track method. type Service interface { // Track returns a cargo matching a tracking ID. Track(id string) (Cargo, error) } type service struct { cargos cargo.Repository handlingEvents cargo.HandlingEventRepository } func (s *service) Track(id string) (Cargo, error) { if id == "" { return Cargo{}, ErrInvalidArgument } c, err := s.cargos.Find(cargo.TrackingID(id)) if err != nil { return Cargo{}, err } return assemble(c, s.handlingEvents), nil } // NewService returns a new instance of the default Service. func NewService(cargos cargo.Repository, events cargo.HandlingEventRepository) Service { return &service{ cargos: cargos, handlingEvents: events, } } // Cargo is a read model for tracking views. type Cargo struct { TrackingID string `json:"tracking_id"` StatusText string `json:"status_text"` Origin string `json:"origin"` Destination string `json:"destination"` ETA time.Time `json:"eta"` NextExpectedActivity string `json:"next_expected_activity"` ArrivalDeadline time.Time `json:"arrival_deadline"` Events []Event `json:"events"` } // Leg is a read model for booking views. type Leg struct { VoyageNumber string `json:"voyage_number"` From string `json:"from"` To string `json:"to"` LoadTime time.Time `json:"load_time"` UnloadTime time.Time `json:"unload_time"` } // Event is a read model for tracking views. type Event struct { Description string `json:"description"` Expected bool `json:"expected"` } func assemble(c *cargo.Cargo, events cargo.HandlingEventRepository) Cargo { return Cargo{ TrackingID: string(c.TrackingID), Origin: string(c.Origin), Destination: string(c.RouteSpecification.Destination), ETA: c.Delivery.ETA, NextExpectedActivity: nextExpectedActivity(c), ArrivalDeadline: c.RouteSpecification.ArrivalDeadline, StatusText: assembleStatusText(c), Events: assembleEvents(c, events), } } func assembleLegs(c cargo.Cargo) []Leg { var legs []Leg for _, l := range c.Itinerary.Legs { legs = append(legs, Leg{ VoyageNumber: string(l.VoyageNumber), From: string(l.LoadLocation), To: string(l.UnloadLocation), LoadTime: l.LoadTime, UnloadTime: l.UnloadTime, }) } return legs } func nextExpectedActivity(c *cargo.Cargo) string { a := c.Delivery.NextExpectedActivity prefix := "Next expected activity is to" switch a.Type { case cargo.Load: return fmt.Sprintf("%s %s cargo onto voyage %s in %s.", prefix, strings.ToLower(a.Type.String()), a.VoyageNumber, a.Location) case cargo.Unload: return fmt.Sprintf("%s %s cargo off of voyage %s in %s.", prefix, strings.ToLower(a.Type.String()), a.VoyageNumber, a.Location) case cargo.NotHandled: return "There are currently no expected activities for this cargo." } return fmt.Sprintf("%s %s cargo in %s.", prefix, strings.ToLower(a.Type.String()), a.Location) } func assembleStatusText(c *cargo.Cargo) string { switch c.Delivery.TransportStatus { case cargo.NotReceived: return "Not received" case cargo.InPort: return fmt.Sprintf("In port %s", c.Delivery.LastKnownLocation) case cargo.OnboardCarrier: return fmt.Sprintf("Onboard voyage %s", c.Delivery.CurrentVoyage) case cargo.Claimed: return "Claimed" default: return "Unknown" } } func assembleEvents(c *cargo.Cargo, handlingEvents cargo.HandlingEventRepository) []Event { h := handlingEvents.QueryHandlingHistory(c.TrackingID) var events []Event for _, e := range h.HandlingEvents { var description string switch e.Activity.Type { case cargo.NotHandled: description = "Cargo has not yet been received." case cargo.Receive: description = fmt.Sprintf("Received in %s, at %s", e.Activity.Location, time.Now().Format(time.RFC3339)) case cargo.Load: description = fmt.Sprintf("Loaded onto voyage %s in %s, at %s.", e.Activity.VoyageNumber, e.Activity.Location, time.Now().Format(time.RFC3339)) case cargo.Unload: description = fmt.Sprintf("Unloaded off voyage %s in %s, at %s.", e.Activity.VoyageNumber, e.Activity.Location, time.Now().Format(time.RFC3339)) case cargo.Claim: description = fmt.Sprintf("Claimed in %s, at %s.", e.Activity.Location, time.Now().Format(time.RFC3339)) case cargo.Customs: description = fmt.Sprintf("Cleared customs in %s, at %s.", e.Activity.Location, time.Now().Format(time.RFC3339)) default: description = "[Unknown status]" } events = append(events, Event{ Description: description, Expected: c.Itinerary.IsExpected(e), }) } return events } golang-github-go-kit-kit-0.6.0/examples/shipping/tracking/transport.go000066400000000000000000000033441316471211400260510ustar00rootroot00000000000000package tracking import ( "context" "encoding/json" "errors" "net/http" "github.com/gorilla/mux" kitlog "github.com/go-kit/kit/log" kithttp "github.com/go-kit/kit/transport/http" "github.com/go-kit/kit/examples/shipping/cargo" ) // MakeHandler returns a handler for the tracking service. func MakeHandler(ts Service, logger kitlog.Logger) http.Handler { r := mux.NewRouter() opts := []kithttp.ServerOption{ kithttp.ServerErrorLogger(logger), kithttp.ServerErrorEncoder(encodeError), } trackCargoHandler := kithttp.NewServer( makeTrackCargoEndpoint(ts), decodeTrackCargoRequest, encodeResponse, opts..., ) r.Handle("/tracking/v1/cargos/{id}", trackCargoHandler).Methods("GET") return r } func decodeTrackCargoRequest(_ context.Context, r *http.Request) (interface{}, error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, errors.New("bad route") } return trackCargoRequest{ID: id}, nil } func encodeResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error { if e, ok := response.(errorer); ok && e.error() != nil { encodeError(ctx, e.error(), w) return nil } w.Header().Set("Content-Type", "application/json; charset=utf-8") return json.NewEncoder(w).Encode(response) } type errorer interface { error() error } // encode errors from business-logic func encodeError(_ context.Context, err error, w http.ResponseWriter) { w.Header().Set("Content-Type", "application/json; charset=utf-8") switch err { case cargo.ErrUnknown: w.WriteHeader(http.StatusNotFound) case ErrInvalidArgument: w.WriteHeader(http.StatusBadRequest) default: w.WriteHeader(http.StatusInternalServerError) } json.NewEncoder(w).Encode(map[string]interface{}{ "error": err.Error(), }) } golang-github-go-kit-kit-0.6.0/examples/shipping/voyage/000077500000000000000000000000001316471211400231525ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/shipping/voyage/sample_voyages.go000066400000000000000000000024431316471211400265220ustar00rootroot00000000000000package voyage import "github.com/go-kit/kit/examples/shipping/location" // A set of sample voyages. var ( V100 = New("V100", Schedule{ []CarrierMovement{ {DepartureLocation: location.CNHKG, ArrivalLocation: location.JNTKO}, {DepartureLocation: location.JNTKO, ArrivalLocation: location.USNYC}, }, }) V300 = New("V300", Schedule{ []CarrierMovement{ {DepartureLocation: location.JNTKO, ArrivalLocation: location.NLRTM}, {DepartureLocation: location.NLRTM, ArrivalLocation: location.DEHAM}, {DepartureLocation: location.DEHAM, ArrivalLocation: location.AUMEL}, {DepartureLocation: location.AUMEL, ArrivalLocation: location.JNTKO}, }, }) V400 = New("V400", Schedule{ []CarrierMovement{ {DepartureLocation: location.DEHAM, ArrivalLocation: location.SESTO}, {DepartureLocation: location.SESTO, ArrivalLocation: location.FIHEL}, {DepartureLocation: location.FIHEL, ArrivalLocation: location.DEHAM}, }, }) ) // These voyages are hard-coded into the current pathfinder. Make sure // they exist. var ( V0100S = New("0100S", Schedule{[]CarrierMovement{}}) V0200T = New("0200T", Schedule{[]CarrierMovement{}}) V0300A = New("0300A", Schedule{[]CarrierMovement{}}) V0301S = New("0301S", Schedule{[]CarrierMovement{}}) V0400S = New("0400S", Schedule{[]CarrierMovement{}}) ) golang-github-go-kit-kit-0.6.0/examples/shipping/voyage/voyage.go000066400000000000000000000020251316471211400247720ustar00rootroot00000000000000// Package voyage provides the Voyage aggregate. package voyage import ( "errors" "time" "github.com/go-kit/kit/examples/shipping/location" ) // Number uniquely identifies a particular Voyage. type Number string // Voyage is a uniquely identifiable series of carrier movements. type Voyage struct { Number Number Schedule Schedule } // New creates a voyage with a voyage number and a provided schedule. func New(n Number, s Schedule) *Voyage { return &Voyage{Number: n, Schedule: s} } // Schedule describes a voyage schedule. type Schedule struct { CarrierMovements []CarrierMovement } // CarrierMovement is a vessel voyage from one location to another. type CarrierMovement struct { DepartureLocation location.UNLocode ArrivalLocation location.UNLocode DepartureTime time.Time ArrivalTime time.Time } // ErrUnknown is used when a voyage could not be found. var ErrUnknown = errors.New("unknown voyage") // Repository provides access a voyage store. type Repository interface { Find(Number) (*Voyage, error) } golang-github-go-kit-kit-0.6.0/examples/stringsvc1/000077500000000000000000000000001316471211400221425ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/stringsvc1/main.go000066400000000000000000000046621316471211400234250ustar00rootroot00000000000000package main import ( "context" "encoding/json" "errors" "log" "net/http" "strings" "github.com/go-kit/kit/endpoint" httptransport "github.com/go-kit/kit/transport/http" ) // StringService provides operations on strings. type StringService interface { Uppercase(string) (string, error) Count(string) int } type stringService struct{} func (stringService) Uppercase(s string) (string, error) { if s == "" { return "", ErrEmpty } return strings.ToUpper(s), nil } func (stringService) Count(s string) int { return len(s) } func main() { svc := stringService{} uppercaseHandler := httptransport.NewServer( makeUppercaseEndpoint(svc), decodeUppercaseRequest, encodeResponse, ) countHandler := httptransport.NewServer( makeCountEndpoint(svc), decodeCountRequest, encodeResponse, ) http.Handle("/uppercase", uppercaseHandler) http.Handle("/count", countHandler) log.Fatal(http.ListenAndServe(":8080", nil)) } func makeUppercaseEndpoint(svc StringService) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(uppercaseRequest) v, err := svc.Uppercase(req.S) if err != nil { return uppercaseResponse{v, err.Error()}, nil } return uppercaseResponse{v, ""}, nil } } func makeCountEndpoint(svc StringService) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(countRequest) v := svc.Count(req.S) return countResponse{v}, nil } } func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) { var request uppercaseRequest if err := json.NewDecoder(r.Body).Decode(&request); err != nil { return nil, err } return request, nil } func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) { var request countRequest if err := json.NewDecoder(r.Body).Decode(&request); err != nil { return nil, err } return request, nil } func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error { return json.NewEncoder(w).Encode(response) } type uppercaseRequest struct { S string `json:"s"` } type uppercaseResponse struct { V string `json:"v"` Err string `json:"err,omitempty"` // errors don't define JSON marshaling } type countRequest struct { S string `json:"s"` } type countResponse struct { V int `json:"v"` } // ErrEmpty is returned when an input string is empty. var ErrEmpty = errors.New("empty string") golang-github-go-kit-kit-0.6.0/examples/stringsvc2/000077500000000000000000000000001316471211400221435ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/stringsvc2/instrumenting.go000066400000000000000000000016601316471211400254030ustar00rootroot00000000000000package main import ( "fmt" "time" "github.com/go-kit/kit/metrics" ) type instrumentingMiddleware struct { requestCount metrics.Counter requestLatency metrics.Histogram countResult metrics.Histogram next StringService } func (mw instrumentingMiddleware) Uppercase(s string) (output string, err error) { defer func(begin time.Time) { lvs := []string{"method", "uppercase", "error", fmt.Sprint(err != nil)} mw.requestCount.With(lvs...).Add(1) mw.requestLatency.With(lvs...).Observe(time.Since(begin).Seconds()) }(time.Now()) output, err = mw.next.Uppercase(s) return } func (mw instrumentingMiddleware) Count(s string) (n int) { defer func(begin time.Time) { lvs := []string{"method", "count", "error", "false"} mw.requestCount.With(lvs...).Add(1) mw.requestLatency.With(lvs...).Observe(time.Since(begin).Seconds()) mw.countResult.Observe(float64(n)) }(time.Now()) n = mw.next.Count(s) return } golang-github-go-kit-kit-0.6.0/examples/stringsvc2/logging.go000066400000000000000000000012471316471211400241240ustar00rootroot00000000000000package main import ( "time" "github.com/go-kit/kit/log" ) type loggingMiddleware struct { logger log.Logger next StringService } func (mw loggingMiddleware) Uppercase(s string) (output string, err error) { defer func(begin time.Time) { _ = mw.logger.Log( "method", "uppercase", "input", s, "output", output, "err", err, "took", time.Since(begin), ) }(time.Now()) output, err = mw.next.Uppercase(s) return } func (mw loggingMiddleware) Count(s string) (n int) { defer func(begin time.Time) { _ = mw.logger.Log( "method", "count", "input", s, "n", n, "took", time.Since(begin), ) }(time.Now()) n = mw.next.Count(s) return } golang-github-go-kit-kit-0.6.0/examples/stringsvc2/main.go000066400000000000000000000033231316471211400234170ustar00rootroot00000000000000package main import ( "net/http" "os" stdprometheus "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promhttp" "github.com/go-kit/kit/log" kitprometheus "github.com/go-kit/kit/metrics/prometheus" httptransport "github.com/go-kit/kit/transport/http" ) func main() { logger := log.NewLogfmtLogger(os.Stderr) fieldKeys := []string{"method", "error"} requestCount := kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{ Namespace: "my_group", Subsystem: "string_service", Name: "request_count", Help: "Number of requests received.", }, fieldKeys) requestLatency := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{ Namespace: "my_group", Subsystem: "string_service", Name: "request_latency_microseconds", Help: "Total duration of requests in microseconds.", }, fieldKeys) countResult := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{ Namespace: "my_group", Subsystem: "string_service", Name: "count_result", Help: "The result of each count method.", }, []string{}) // no fields here var svc StringService svc = stringService{} svc = loggingMiddleware{logger, svc} svc = instrumentingMiddleware{requestCount, requestLatency, countResult, svc} uppercaseHandler := httptransport.NewServer( makeUppercaseEndpoint(svc), decodeUppercaseRequest, encodeResponse, ) countHandler := httptransport.NewServer( makeCountEndpoint(svc), decodeCountRequest, encodeResponse, ) http.Handle("/uppercase", uppercaseHandler) http.Handle("/count", countHandler) http.Handle("/metrics", promhttp.Handler()) logger.Log("msg", "HTTP", "addr", ":8080") logger.Log("err", http.ListenAndServe(":8080", nil)) } golang-github-go-kit-kit-0.6.0/examples/stringsvc2/service.go000066400000000000000000000007701316471211400241360ustar00rootroot00000000000000package main import ( "errors" "strings" ) // StringService provides operations on strings. type StringService interface { Uppercase(string) (string, error) Count(string) int } type stringService struct{} func (stringService) Uppercase(s string) (string, error) { if s == "" { return "", ErrEmpty } return strings.ToUpper(s), nil } func (stringService) Count(s string) int { return len(s) } // ErrEmpty is returned when an input string is empty. var ErrEmpty = errors.New("empty string") golang-github-go-kit-kit-0.6.0/examples/stringsvc2/transport.go000066400000000000000000000027311316471211400245310ustar00rootroot00000000000000package main import ( "context" "encoding/json" "net/http" "github.com/go-kit/kit/endpoint" ) func makeUppercaseEndpoint(svc StringService) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(uppercaseRequest) v, err := svc.Uppercase(req.S) if err != nil { return uppercaseResponse{v, err.Error()}, nil } return uppercaseResponse{v, ""}, nil } } func makeCountEndpoint(svc StringService) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(countRequest) v := svc.Count(req.S) return countResponse{v}, nil } } func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) { var request uppercaseRequest if err := json.NewDecoder(r.Body).Decode(&request); err != nil { return nil, err } return request, nil } func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) { var request countRequest if err := json.NewDecoder(r.Body).Decode(&request); err != nil { return nil, err } return request, nil } func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error { return json.NewEncoder(w).Encode(response) } type uppercaseRequest struct { S string `json:"s"` } type uppercaseResponse struct { V string `json:"v"` Err string `json:"err,omitempty"` } type countRequest struct { S string `json:"s"` } type countResponse struct { V int `json:"v"` } golang-github-go-kit-kit-0.6.0/examples/stringsvc3/000077500000000000000000000000001316471211400221445ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/examples/stringsvc3/instrumenting.go000066400000000000000000000022221316471211400253770ustar00rootroot00000000000000package main import ( "fmt" "time" "github.com/go-kit/kit/metrics" ) func instrumentingMiddleware( requestCount metrics.Counter, requestLatency metrics.Histogram, countResult metrics.Histogram, ) ServiceMiddleware { return func(next StringService) StringService { return instrmw{requestCount, requestLatency, countResult, next} } } type instrmw struct { requestCount metrics.Counter requestLatency metrics.Histogram countResult metrics.Histogram StringService } func (mw instrmw) Uppercase(s string) (output string, err error) { defer func(begin time.Time) { lvs := []string{"method", "uppercase", "error", fmt.Sprint(err != nil)} mw.requestCount.With(lvs...).Add(1) mw.requestLatency.With(lvs...).Observe(time.Since(begin).Seconds()) }(time.Now()) output, err = mw.StringService.Uppercase(s) return } func (mw instrmw) Count(s string) (n int) { defer func(begin time.Time) { lvs := []string{"method", "count", "error", "false"} mw.requestCount.With(lvs...).Add(1) mw.requestLatency.With(lvs...).Observe(time.Since(begin).Seconds()) mw.countResult.Observe(float64(n)) }(time.Now()) n = mw.StringService.Count(s) return } golang-github-go-kit-kit-0.6.0/examples/stringsvc3/logging.go000066400000000000000000000014401316471211400241200ustar00rootroot00000000000000package main import ( "time" "github.com/go-kit/kit/log" ) func loggingMiddleware(logger log.Logger) ServiceMiddleware { return func(next StringService) StringService { return logmw{logger, next} } } type logmw struct { logger log.Logger StringService } func (mw logmw) Uppercase(s string) (output string, err error) { defer func(begin time.Time) { _ = mw.logger.Log( "method", "uppercase", "input", s, "output", output, "err", err, "took", time.Since(begin), ) }(time.Now()) output, err = mw.StringService.Uppercase(s) return } func (mw logmw) Count(s string) (n int) { defer func(begin time.Time) { _ = mw.logger.Log( "method", "count", "input", s, "n", n, "took", time.Since(begin), ) }(time.Now()) n = mw.StringService.Count(s) return } golang-github-go-kit-kit-0.6.0/examples/stringsvc3/main.go000066400000000000000000000040741316471211400234240ustar00rootroot00000000000000package main import ( "context" "flag" "net/http" "os" stdprometheus "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promhttp" "github.com/go-kit/kit/log" kitprometheus "github.com/go-kit/kit/metrics/prometheus" httptransport "github.com/go-kit/kit/transport/http" ) func main() { var ( listen = flag.String("listen", ":8080", "HTTP listen address") proxy = flag.String("proxy", "", "Optional comma-separated list of URLs to proxy uppercase requests") ) flag.Parse() var logger log.Logger logger = log.NewLogfmtLogger(os.Stderr) logger = log.With(logger, "listen", *listen, "caller", log.DefaultCaller) fieldKeys := []string{"method", "error"} requestCount := kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{ Namespace: "my_group", Subsystem: "string_service", Name: "request_count", Help: "Number of requests received.", }, fieldKeys) requestLatency := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{ Namespace: "my_group", Subsystem: "string_service", Name: "request_latency_microseconds", Help: "Total duration of requests in microseconds.", }, fieldKeys) countResult := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{ Namespace: "my_group", Subsystem: "string_service", Name: "count_result", Help: "The result of each count method.", }, []string{}) var svc StringService svc = stringService{} svc = proxyingMiddleware(context.Background(), *proxy, logger)(svc) svc = loggingMiddleware(logger)(svc) svc = instrumentingMiddleware(requestCount, requestLatency, countResult)(svc) uppercaseHandler := httptransport.NewServer( makeUppercaseEndpoint(svc), decodeUppercaseRequest, encodeResponse, ) countHandler := httptransport.NewServer( makeCountEndpoint(svc), decodeCountRequest, encodeResponse, ) http.Handle("/uppercase", uppercaseHandler) http.Handle("/count", countHandler) http.Handle("/metrics", promhttp.Handler()) logger.Log("msg", "HTTP", "addr", *listen) logger.Log("err", http.ListenAndServe(*listen, nil)) } golang-github-go-kit-kit-0.6.0/examples/stringsvc3/proxying.go000066400000000000000000000062711316471211400243600ustar00rootroot00000000000000package main import ( "context" "errors" "fmt" "net/url" "strings" "time" jujuratelimit "github.com/juju/ratelimit" "github.com/sony/gobreaker" "github.com/go-kit/kit/circuitbreaker" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" "github.com/go-kit/kit/ratelimit" "github.com/go-kit/kit/sd" "github.com/go-kit/kit/sd/lb" httptransport "github.com/go-kit/kit/transport/http" ) func proxyingMiddleware(ctx context.Context, instances string, logger log.Logger) ServiceMiddleware { // If instances is empty, don't proxy. if instances == "" { logger.Log("proxy_to", "none") return func(next StringService) StringService { return next } } // Set some parameters for our client. var ( qps = 100 // beyond which we will return an error maxAttempts = 3 // per request, before giving up maxTime = 250 * time.Millisecond // wallclock time, before giving up ) // Otherwise, construct an endpoint for each instance in the list, and add // it to a fixed set of endpoints. In a real service, rather than doing this // by hand, you'd probably use package sd's support for your service // discovery system. var ( instanceList = split(instances) endpointer sd.FixedEndpointer ) logger.Log("proxy_to", fmt.Sprint(instanceList)) for _, instance := range instanceList { var e endpoint.Endpoint e = makeUppercaseProxy(ctx, instance) e = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{}))(e) e = ratelimit.NewTokenBucketLimiter(jujuratelimit.NewBucketWithRate(float64(qps), int64(qps)))(e) endpointer = append(endpointer, e) } // Now, build a single, retrying, load-balancing endpoint out of all of // those individual endpoints. balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(maxAttempts, maxTime, balancer) // And finally, return the ServiceMiddleware, implemented by proxymw. return func(next StringService) StringService { return proxymw{ctx, next, retry} } } // proxymw implements StringService, forwarding Uppercase requests to the // provided endpoint, and serving all other (i.e. Count) requests via the // next StringService. type proxymw struct { ctx context.Context next StringService // Serve most requests via this service... uppercase endpoint.Endpoint // ...except Uppercase, which gets served by this endpoint } func (mw proxymw) Count(s string) int { return mw.next.Count(s) } func (mw proxymw) Uppercase(s string) (string, error) { response, err := mw.uppercase(mw.ctx, uppercaseRequest{S: s}) if err != nil { return "", err } resp := response.(uppercaseResponse) if resp.Err != "" { return resp.V, errors.New(resp.Err) } return resp.V, nil } func makeUppercaseProxy(ctx context.Context, instance string) endpoint.Endpoint { if !strings.HasPrefix(instance, "http") { instance = "http://" + instance } u, err := url.Parse(instance) if err != nil { panic(err) } if u.Path == "" { u.Path = "/uppercase" } return httptransport.NewClient( "GET", u, encodeRequest, decodeUppercaseResponse, ).Endpoint() } func split(s string) []string { a := strings.Split(s, ",") for i := range a { a[i] = strings.TrimSpace(a[i]) } return a } golang-github-go-kit-kit-0.6.0/examples/stringsvc3/service.go000066400000000000000000000011731316471211400241350ustar00rootroot00000000000000package main import ( "errors" "strings" ) // StringService provides operations on strings. type StringService interface { Uppercase(string) (string, error) Count(string) int } type stringService struct{} func (stringService) Uppercase(s string) (string, error) { if s == "" { return "", ErrEmpty } return strings.ToUpper(s), nil } func (stringService) Count(s string) int { return len(s) } // ErrEmpty is returned when an input string is empty. var ErrEmpty = errors.New("empty string") // ServiceMiddleware is a chainable behavior modifier for StringService. type ServiceMiddleware func(StringService) StringService golang-github-go-kit-kit-0.6.0/examples/stringsvc3/transport.go000066400000000000000000000037021316471211400245310ustar00rootroot00000000000000package main import ( "bytes" "context" "encoding/json" "io/ioutil" "net/http" "github.com/go-kit/kit/endpoint" ) func makeUppercaseEndpoint(svc StringService) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(uppercaseRequest) v, err := svc.Uppercase(req.S) if err != nil { return uppercaseResponse{v, err.Error()}, nil } return uppercaseResponse{v, ""}, nil } } func makeCountEndpoint(svc StringService) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(countRequest) v := svc.Count(req.S) return countResponse{v}, nil } } func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) { var request uppercaseRequest if err := json.NewDecoder(r.Body).Decode(&request); err != nil { return nil, err } return request, nil } func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) { var request countRequest if err := json.NewDecoder(r.Body).Decode(&request); err != nil { return nil, err } return request, nil } func decodeUppercaseResponse(_ context.Context, r *http.Response) (interface{}, error) { var response uppercaseResponse if err := json.NewDecoder(r.Body).Decode(&response); err != nil { return nil, err } return response, nil } func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error { return json.NewEncoder(w).Encode(response) } func encodeRequest(_ context.Context, r *http.Request, request interface{}) error { var buf bytes.Buffer if err := json.NewEncoder(&buf).Encode(request); err != nil { return err } r.Body = ioutil.NopCloser(&buf) return nil } type uppercaseRequest struct { S string `json:"s"` } type uppercaseResponse struct { V string `json:"v"` Err string `json:"err,omitempty"` } type countRequest struct { S string `json:"s"` } type countResponse struct { V int `json:"v"` } golang-github-go-kit-kit-0.6.0/lint000077500000000000000000000011141316471211400171120ustar00rootroot00000000000000#!/usr/bin/env bash set -o errexit set -o nounset set -o pipefail if [ ! $(command -v gometalinter) ] then go get github.com/alecthomas/gometalinter gometalinter --update --install fi time gometalinter \ --exclude='error return value not checked.*(Close|Log|Print).*\(errcheck\)$' \ --exclude='.*_test\.go:.*error return value not checked.*\(errcheck\)$' \ --exclude='/thrift/' \ --exclude='/pb/' \ --exclude='no args in Log call \(vet\)' \ --disable=dupl \ --disable=aligncheck \ --disable=gotype \ --cyclo-over=20 \ --tests \ --concurrency=2 \ --deadline=300s \ ./... golang-github-go-kit-kit-0.6.0/log/000077500000000000000000000000001316471211400170025ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/log/README.md000066400000000000000000000111531316471211400202620ustar00rootroot00000000000000# package log `package log` provides a minimal interface for structured logging in services. It may be wrapped to encode conventions, enforce type-safety, provide leveled logging, and so on. It can be used for both typical application log events, and log-structured data streams. ## Structured logging Structured logging is, basically, conceding to the reality that logs are _data_, and warrant some level of schematic rigor. Using a stricter, key/value-oriented message format for our logs, containing contextual and semantic information, makes it much easier to get insight into the operational activity of the systems we build. Consequently, `package log` is of the strong belief that "[the benefits of structured logging outweigh the minimal effort involved](https://www.thoughtworks.com/radar/techniques/structured-logging)". Migrating from unstructured to structured logging is probably a lot easier than you'd expect. ```go // Unstructured log.Printf("HTTP server listening on %s", addr) // Structured logger.Log("transport", "HTTP", "addr", addr, "msg", "listening") ``` ## Usage ### Typical application logging ```go w := log.NewSyncWriter(os.Stderr) logger := log.NewLogfmtLogger(w) logger.Log("question", "what is the meaning of life?", "answer", 42) // Output: // question="what is the meaning of life?" answer=42 ``` ### Contextual Loggers ```go func main() { var logger log.Logger logger = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr)) logger = log.With(logger, "instance_id", 123) logger.Log("msg", "starting") NewWorker(log.With(logger, "component", "worker")).Run() NewSlacker(log.With(logger, "component", "slacker")).Run() } // Output: // instance_id=123 msg=starting // instance_id=123 component=worker msg=running // instance_id=123 component=slacker msg=running ``` ### Interact with stdlib logger Redirect stdlib logger to Go kit logger. ```go import ( "os" stdlog "log" kitlog "github.com/go-kit/kit/log" ) func main() { logger := kitlog.NewJSONLogger(kitlog.NewSyncWriter(os.Stdout)) stdlog.SetOutput(kitlog.NewStdlibAdapter(logger)) stdlog.Print("I sure like pie") } // Output: // {"msg":"I sure like pie","ts":"2016/01/01 12:34:56"} ``` Or, if, for legacy reasons, you need to pipe all of your logging through the stdlib log package, you can redirect Go kit logger to the stdlib logger. ```go logger := kitlog.NewLogfmtLogger(kitlog.StdlibWriter{}) logger.Log("legacy", true, "msg", "at least it's something") // Output: // 2016/01/01 12:34:56 legacy=true msg="at least it's something" ``` ### Timestamps and callers ```go var logger log.Logger logger = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr)) logger = log.With(logger, "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller) logger.Log("msg", "hello") // Output: // ts=2016-01-01T12:34:56Z caller=main.go:15 msg=hello ``` ## Supported output formats - [Logfmt](https://brandur.org/logfmt) ([see also](https://blog.codeship.com/logfmt-a-log-format-thats-easy-to-read-and-write)) - JSON ## Enhancements `package log` is centered on the one-method Logger interface. ```go type Logger interface { Log(keyvals ...interface{}) error } ``` This interface, and its supporting code like is the product of much iteration and evaluation. For more details on the evolution of the Logger interface, see [The Hunt for a Logger Interface](http://go-talks.appspot.com/github.com/ChrisHines/talks/structured-logging/structured-logging.slide#1), a talk by [Chris Hines](https://github.com/ChrisHines). Also, please see [#63](https://github.com/go-kit/kit/issues/63), [#76](https://github.com/go-kit/kit/pull/76), [#131](https://github.com/go-kit/kit/issues/131), [#157](https://github.com/go-kit/kit/pull/157), [#164](https://github.com/go-kit/kit/issues/164), and [#252](https://github.com/go-kit/kit/pull/252) to review historical conversations about package log and the Logger interface. Value-add packages and suggestions, like improvements to [the leveled logger](https://godoc.org/github.com/go-kit/kit/log/level), are of course welcome. Good proposals should - Be composable with [contextual loggers](https://godoc.org/github.com/go-kit/kit/log#With), - Not break the behavior of [log.Caller](https://godoc.org/github.com/go-kit/kit/log#Caller) in any wrapped contextual loggers, and - Be friendly to packages that accept only an unadorned log.Logger. ## Benchmarks & comparisons There are a few Go logging benchmarks and comparisons that include Go kit's package log. - [imkira/go-loggers-bench](https://github.com/imkira/go-loggers-bench) includes kit/log - [uber-common/zap](https://github.com/uber-common/zap), a zero-alloc logging library, includes a comparison with kit/log golang-github-go-kit-kit-0.6.0/log/benchmark_test.go000066400000000000000000000006771316471211400223340ustar00rootroot00000000000000package log_test import ( "testing" "github.com/go-kit/kit/log" ) func benchmarkRunner(b *testing.B, logger log.Logger, f func(log.Logger)) { lc := log.With(logger, "common_key", "common_value") b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { f(lc) } } var ( baseMessage = func(logger log.Logger) { logger.Log("foo_key", "foo_value") } withMessage = func(logger log.Logger) { log.With(logger, "a", "b").Log("c", "d") } ) golang-github-go-kit-kit-0.6.0/log/concurrency_test.go000066400000000000000000000012211316471211400227160ustar00rootroot00000000000000package log_test import ( "math" "testing" "github.com/go-kit/kit/log" ) // These test are designed to be run with the race detector. func testConcurrency(t *testing.T, logger log.Logger, total int) { n := int(math.Sqrt(float64(total))) share := total / n errC := make(chan error, n) for i := 0; i < n; i++ { go func() { errC <- spam(logger, share) }() } for i := 0; i < n; i++ { err := <-errC if err != nil { t.Fatalf("concurrent logging error: %v", err) } } } func spam(logger log.Logger, count int) error { for i := 0; i < count; i++ { err := logger.Log("key", i) if err != nil { return err } } return nil } golang-github-go-kit-kit-0.6.0/log/deprecated_levels/000077500000000000000000000000001316471211400224545ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/log/deprecated_levels/levels.go000066400000000000000000000075671316471211400243140ustar00rootroot00000000000000package levels import "github.com/go-kit/kit/log" // Levels provides a leveled logging wrapper around a logger. It has five // levels: debug, info, warning (warn), error, and critical (crit). If you // want a different set of levels, you can create your own levels type very // easily, and you can elide the configuration. type Levels struct { logger log.Logger levelKey string // We have a choice between storing level values in string fields or // making a separate context for each level. When using string fields the // Log method must combine the base context, the level data, and the // logged keyvals; but the With method only requires updating one context. // If we instead keep a separate context for each level the Log method // must only append the new keyvals; but the With method would have to // update all five contexts. // Roughly speaking, storing multiple contexts breaks even if the ratio of // Log/With calls is more than the number of levels. We have chosen to // make the With method cheap and the Log method a bit more costly because // we do not expect most applications to Log more than five times for each // call to With. debugValue string infoValue string warnValue string errorValue string critValue string } // New creates a new leveled logger, wrapping the passed logger. func New(logger log.Logger, options ...Option) Levels { l := Levels{ logger: logger, levelKey: "level", debugValue: "debug", infoValue: "info", warnValue: "warn", errorValue: "error", critValue: "crit", } for _, option := range options { option(&l) } return l } // With returns a new leveled logger that includes keyvals in all log events. func (l Levels) With(keyvals ...interface{}) Levels { return Levels{ logger: log.With(l.logger, keyvals...), levelKey: l.levelKey, debugValue: l.debugValue, infoValue: l.infoValue, warnValue: l.warnValue, errorValue: l.errorValue, critValue: l.critValue, } } // Debug returns a debug level logger. func (l Levels) Debug() log.Logger { return log.WithPrefix(l.logger, l.levelKey, l.debugValue) } // Info returns an info level logger. func (l Levels) Info() log.Logger { return log.WithPrefix(l.logger, l.levelKey, l.infoValue) } // Warn returns a warning level logger. func (l Levels) Warn() log.Logger { return log.WithPrefix(l.logger, l.levelKey, l.warnValue) } // Error returns an error level logger. func (l Levels) Error() log.Logger { return log.WithPrefix(l.logger, l.levelKey, l.errorValue) } // Crit returns a critical level logger. func (l Levels) Crit() log.Logger { return log.WithPrefix(l.logger, l.levelKey, l.critValue) } // Option sets a parameter for leveled loggers. type Option func(*Levels) // Key sets the key for the field used to indicate log level. By default, // the key is "level". func Key(key string) Option { return func(l *Levels) { l.levelKey = key } } // DebugValue sets the value for the field used to indicate the debug log // level. By default, the value is "debug". func DebugValue(value string) Option { return func(l *Levels) { l.debugValue = value } } // InfoValue sets the value for the field used to indicate the info log level. // By default, the value is "info". func InfoValue(value string) Option { return func(l *Levels) { l.infoValue = value } } // WarnValue sets the value for the field used to indicate the warning log // level. By default, the value is "warn". func WarnValue(value string) Option { return func(l *Levels) { l.warnValue = value } } // ErrorValue sets the value for the field used to indicate the error log // level. By default, the value is "error". func ErrorValue(value string) Option { return func(l *Levels) { l.errorValue = value } } // CritValue sets the value for the field used to indicate the critical log // level. By default, the value is "crit". func CritValue(value string) Option { return func(l *Levels) { l.critValue = value } } golang-github-go-kit-kit-0.6.0/log/deprecated_levels/levels_test.go000066400000000000000000000032771316471211400253450ustar00rootroot00000000000000package levels_test import ( "bytes" "os" "testing" "github.com/go-kit/kit/log" levels "github.com/go-kit/kit/log/deprecated_levels" ) func TestDefaultLevels(t *testing.T) { buf := bytes.Buffer{} logger := levels.New(log.NewLogfmtLogger(&buf)) logger.Debug().Log("msg", "résumé") // of course you'd want to do this if want, have := "level=debug msg=résumé\n", buf.String(); want != have { t.Errorf("want %#v, have %#v", want, have) } buf.Reset() logger.Info().Log("msg", "Åhus") if want, have := "level=info msg=Åhus\n", buf.String(); want != have { t.Errorf("want %#v, have %#v", want, have) } buf.Reset() logger.Error().Log("msg", "© violation") if want, have := "level=error msg=\"© violation\"\n", buf.String(); want != have { t.Errorf("want %#v, have %#v", want, have) } buf.Reset() logger.Crit().Log("msg", " ") if want, have := "level=crit msg=\"\\t\"\n", buf.String(); want != have { t.Errorf("want %#v, have %#v", want, have) } } func TestModifiedLevels(t *testing.T) { buf := bytes.Buffer{} logger := levels.New( log.NewJSONLogger(&buf), levels.Key("l"), levels.DebugValue("dbg"), levels.InfoValue("nfo"), levels.WarnValue("wrn"), levels.ErrorValue("err"), levels.CritValue("crt"), ) logger.With("easter_island", "176°").Debug().Log("msg", "moai") if want, have := `{"easter_island":"176°","l":"dbg","msg":"moai"}`+"\n", buf.String(); want != have { t.Errorf("want %#v, have %#v", want, have) } } func ExampleLevels() { logger := levels.New(log.NewLogfmtLogger(os.Stdout)) logger.Debug().Log("msg", "hello") logger.With("context", "foo").Warn().Log("err", "error") // Output: // level=debug msg=hello // level=warn context=foo err=error } golang-github-go-kit-kit-0.6.0/log/doc.go000066400000000000000000000123351316471211400201020ustar00rootroot00000000000000// Package log provides a structured logger. // // Structured logging produces logs easily consumed later by humans or // machines. Humans might be interested in debugging errors, or tracing // specific requests. Machines might be interested in counting interesting // events, or aggregating information for off-line processing. In both cases, // it is important that the log messages are structured and actionable. // Package log is designed to encourage both of these best practices. // // Basic Usage // // The fundamental interface is Logger. Loggers create log events from // key/value data. The Logger interface has a single method, Log, which // accepts a sequence of alternating key/value pairs, which this package names // keyvals. // // type Logger interface { // Log(keyvals ...interface{}) error // } // // Here is an example of a function using a Logger to create log events. // // func RunTask(task Task, logger log.Logger) string { // logger.Log("taskID", task.ID, "event", "starting task") // ... // logger.Log("taskID", task.ID, "event", "task complete") // } // // The keys in the above example are "taskID" and "event". The values are // task.ID, "starting task", and "task complete". Every key is followed // immediately by its value. // // Keys are usually plain strings. Values may be any type that has a sensible // encoding in the chosen log format. With structured logging it is a good // idea to log simple values without formatting them. This practice allows // the chosen logger to encode values in the most appropriate way. // // Contextual Loggers // // A contextual logger stores keyvals that it includes in all log events. // Building appropriate contextual loggers reduces repetition and aids // consistency in the resulting log output. With and WithPrefix add context to // a logger. We can use With to improve the RunTask example. // // func RunTask(task Task, logger log.Logger) string { // logger = log.With(logger, "taskID", task.ID) // logger.Log("event", "starting task") // ... // taskHelper(task.Cmd, logger) // ... // logger.Log("event", "task complete") // } // // The improved version emits the same log events as the original for the // first and last calls to Log. Passing the contextual logger to taskHelper // enables each log event created by taskHelper to include the task.ID even // though taskHelper does not have access to that value. Using contextual // loggers this way simplifies producing log output that enables tracing the // life cycle of individual tasks. (See the Contextual example for the full // code of the above snippet.) // // Dynamic Contextual Values // // A Valuer function stored in a contextual logger generates a new value each // time an event is logged. The Valuer example demonstrates how this feature // works. // // Valuers provide the basis for consistently logging timestamps and source // code location. The log package defines several valuers for that purpose. // See Timestamp, DefaultTimestamp, DefaultTimestampUTC, Caller, and // DefaultCaller. A common logger initialization sequence that ensures all log // entries contain a timestamp and source location looks like this: // // logger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout)) // logger = log.With(logger, "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller) // // Concurrent Safety // // Applications with multiple goroutines want each log event written to the // same logger to remain separate from other log events. Package log provides // two simple solutions for concurrent safe logging. // // NewSyncWriter wraps an io.Writer and serializes each call to its Write // method. Using a SyncWriter has the benefit that the smallest practical // portion of the logging logic is performed within a mutex, but it requires // the formatting Logger to make only one call to Write per log event. // // NewSyncLogger wraps any Logger and serializes each call to its Log method. // Using a SyncLogger has the benefit that it guarantees each log event is // handled atomically within the wrapped logger, but it typically serializes // both the formatting and output logic. Use a SyncLogger if the formatting // logger may perform multiple writes per log event. // // Error Handling // // This package relies on the practice of wrapping or decorating loggers with // other loggers to provide composable pieces of functionality. It also means // that Logger.Log must return an error because some // implementations—especially those that output log data to an io.Writer—may // encounter errors that cannot be handled locally. This in turn means that // Loggers that wrap other loggers should return errors from the wrapped // logger up the stack. // // Fortunately, the decorator pattern also provides a way to avoid the // necessity to check for errors every time an application calls Logger.Log. // An application required to panic whenever its Logger encounters // an error could initialize its logger as follows. // // fmtlogger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout)) // logger := log.LoggerFunc(func(keyvals ...interface{}) error { // if err := fmtlogger.Log(keyvals...); err != nil { // panic(err) // } // return nil // }) package log golang-github-go-kit-kit-0.6.0/log/example_test.go000066400000000000000000000053371316471211400220330ustar00rootroot00000000000000package log_test import ( "math/rand" "os" "sync" "time" "github.com/go-kit/kit/log" ) func Example_basic() { logger := log.NewLogfmtLogger(os.Stdout) type Task struct { ID int } RunTask := func(task Task, logger log.Logger) { logger.Log("taskID", task.ID, "event", "starting task") logger.Log("taskID", task.ID, "event", "task complete") } RunTask(Task{ID: 1}, logger) // Output: // taskID=1 event="starting task" // taskID=1 event="task complete" } func Example_contextual() { logger := log.NewLogfmtLogger(os.Stdout) type Task struct { ID int Cmd string } taskHelper := func(cmd string, logger log.Logger) { // execute(cmd) logger.Log("cmd", cmd, "dur", 42*time.Millisecond) } RunTask := func(task Task, logger log.Logger) { logger = log.With(logger, "taskID", task.ID) logger.Log("event", "starting task") taskHelper(task.Cmd, logger) logger.Log("event", "task complete") } RunTask(Task{ID: 1, Cmd: "echo Hello, world!"}, logger) // Output: // taskID=1 event="starting task" // taskID=1 cmd="echo Hello, world!" dur=42ms // taskID=1 event="task complete" } func Example_valuer() { logger := log.NewLogfmtLogger(os.Stdout) count := 0 counter := func() interface{} { count++ return count } logger = log.With(logger, "count", log.Valuer(counter)) logger.Log("call", "first") logger.Log("call", "second") // Output: // count=1 call=first // count=2 call=second } func Example_debugInfo() { logger := log.NewLogfmtLogger(os.Stdout) // make time predictable for this test baseTime := time.Date(2015, time.February, 3, 10, 0, 0, 0, time.UTC) mockTime := func() time.Time { baseTime = baseTime.Add(time.Second) return baseTime } logger = log.With(logger, "time", log.Timestamp(mockTime), "caller", log.DefaultCaller) logger.Log("call", "first") logger.Log("call", "second") // ... logger.Log("call", "third") // Output: // time=2015-02-03T10:00:01Z caller=example_test.go:93 call=first // time=2015-02-03T10:00:02Z caller=example_test.go:94 call=second // time=2015-02-03T10:00:03Z caller=example_test.go:98 call=third } func Example_syncWriter() { w := log.NewSyncWriter(os.Stdout) logger := log.NewLogfmtLogger(w) type Task struct { ID int } var wg sync.WaitGroup RunTask := func(task Task, logger log.Logger) { logger.Log("taskID", task.ID, "event", "starting task") time.Sleep(time.Duration(rand.Intn(200)) * time.Millisecond) logger.Log("taskID", task.ID, "event", "task complete") wg.Done() } wg.Add(2) go RunTask(Task{ID: 1}, logger) go RunTask(Task{ID: 2}, logger) wg.Wait() // Unordered output: // taskID=1 event="starting task" // taskID=2 event="starting task" // taskID=1 event="task complete" // taskID=2 event="task complete" } golang-github-go-kit-kit-0.6.0/log/json_logger.go000066400000000000000000000036521316471211400216470ustar00rootroot00000000000000package log import ( "encoding" "encoding/json" "fmt" "io" "reflect" ) type jsonLogger struct { io.Writer } // NewJSONLogger returns a Logger that encodes keyvals to the Writer as a // single JSON object. Each log event produces no more than one call to // w.Write. The passed Writer must be safe for concurrent use by multiple // goroutines if the returned Logger will be used concurrently. func NewJSONLogger(w io.Writer) Logger { return &jsonLogger{w} } func (l *jsonLogger) Log(keyvals ...interface{}) error { n := (len(keyvals) + 1) / 2 // +1 to handle case when len is odd m := make(map[string]interface{}, n) for i := 0; i < len(keyvals); i += 2 { k := keyvals[i] var v interface{} = ErrMissingValue if i+1 < len(keyvals) { v = keyvals[i+1] } merge(m, k, v) } return json.NewEncoder(l.Writer).Encode(m) } func merge(dst map[string]interface{}, k, v interface{}) { var key string switch x := k.(type) { case string: key = x case fmt.Stringer: key = safeString(x) default: key = fmt.Sprint(x) } // We want json.Marshaler and encoding.TextMarshaller to take priority over // err.Error() and v.String(). But json.Marshall (called later) does that by // default so we force a no-op if it's one of those 2 case. switch x := v.(type) { case json.Marshaler: case encoding.TextMarshaler: case error: v = safeError(x) case fmt.Stringer: v = safeString(x) } dst[key] = v } func safeString(str fmt.Stringer) (s string) { defer func() { if panicVal := recover(); panicVal != nil { if v := reflect.ValueOf(str); v.Kind() == reflect.Ptr && v.IsNil() { s = "NULL" } else { panic(panicVal) } } }() s = str.String() return } func safeError(err error) (s interface{}) { defer func() { if panicVal := recover(); panicVal != nil { if v := reflect.ValueOf(err); v.Kind() == reflect.Ptr && v.IsNil() { s = nil } else { panic(panicVal) } } }() s = err.Error() return } golang-github-go-kit-kit-0.6.0/log/json_logger_test.go000066400000000000000000000067331316471211400227110ustar00rootroot00000000000000package log_test import ( "bytes" "errors" "io/ioutil" "testing" "github.com/go-kit/kit/log" ) func TestJSONLoggerCaller(t *testing.T) { t.Parallel() buf := &bytes.Buffer{} logger := log.NewJSONLogger(buf) logger = log.With(logger, "caller", log.DefaultCaller) if err := logger.Log(); err != nil { t.Fatal(err) } if want, have := `{"caller":"json_logger_test.go:18"}`+"\n", buf.String(); want != have { t.Errorf("\nwant %#v\nhave %#v", want, have) } } func TestJSONLogger(t *testing.T) { t.Parallel() buf := &bytes.Buffer{} logger := log.NewJSONLogger(buf) if err := logger.Log("err", errors.New("err"), "m", map[string]int{"0": 0}, "a", []int{1, 2, 3}); err != nil { t.Fatal(err) } if want, have := `{"a":[1,2,3],"err":"err","m":{"0":0}}`+"\n", buf.String(); want != have { t.Errorf("\nwant %#v\nhave %#v", want, have) } } func TestJSONLoggerMissingValue(t *testing.T) { t.Parallel() buf := &bytes.Buffer{} logger := log.NewJSONLogger(buf) if err := logger.Log("k"); err != nil { t.Fatal(err) } if want, have := `{"k":"(MISSING)"}`+"\n", buf.String(); want != have { t.Errorf("\nwant %#v\nhave %#v", want, have) } } func TestJSONLoggerNilStringerKey(t *testing.T) { t.Parallel() buf := &bytes.Buffer{} logger := log.NewJSONLogger(buf) if err := logger.Log((*stringer)(nil), "v"); err != nil { t.Fatal(err) } if want, have := `{"NULL":"v"}`+"\n", buf.String(); want != have { t.Errorf("\nwant %#v\nhave %#v", want, have) } } func TestJSONLoggerNilErrorValue(t *testing.T) { t.Parallel() buf := &bytes.Buffer{} logger := log.NewJSONLogger(buf) if err := logger.Log("err", (*stringError)(nil)); err != nil { t.Fatal(err) } if want, have := `{"err":null}`+"\n", buf.String(); want != have { t.Errorf("\nwant %#v\nhave %#v", want, have) } } // aller implements json.Marshaler, encoding.TextMarshaler, and fmt.Stringer. type aller struct{} func (aller) MarshalJSON() ([]byte, error) { return []byte("\"json\""), nil } func (aller) MarshalText() ([]byte, error) { return []byte("text"), nil } func (aller) String() string { return "string" } func (aller) Error() string { return "error" } // textstringer implements encoding.TextMarshaler and fmt.Stringer. type textstringer struct{} func (textstringer) MarshalText() ([]byte, error) { return []byte("text"), nil } func (textstringer) String() string { return "string" } func TestJSONLoggerStringValue(t *testing.T) { t.Parallel() tests := []struct { v interface{} expected string }{ { v: aller{}, expected: `{"v":"json"}`, }, { v: textstringer{}, expected: `{"v":"text"}`, }, { v: stringer("string"), expected: `{"v":"string"}`, }, } for _, test := range tests { buf := &bytes.Buffer{} logger := log.NewJSONLogger(buf) if err := logger.Log("v", test.v); err != nil { t.Fatal(err) } if want, have := test.expected+"\n", buf.String(); want != have { t.Errorf("\nwant %#v\nhave %#v", want, have) } } } type stringer string func (s stringer) String() string { return string(s) } type stringError string func (s stringError) Error() string { return string(s) } func BenchmarkJSONLoggerSimple(b *testing.B) { benchmarkRunner(b, log.NewJSONLogger(ioutil.Discard), baseMessage) } func BenchmarkJSONLoggerContextual(b *testing.B) { benchmarkRunner(b, log.NewJSONLogger(ioutil.Discard), withMessage) } func TestJSONLoggerConcurrency(t *testing.T) { t.Parallel() testConcurrency(t, log.NewJSONLogger(ioutil.Discard), 10000) } golang-github-go-kit-kit-0.6.0/log/level/000077500000000000000000000000001316471211400201115ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/log/level/benchmark_test.go000066400000000000000000000032151316471211400234320ustar00rootroot00000000000000package level_test import ( "io/ioutil" "testing" "github.com/go-kit/kit/log" "github.com/go-kit/kit/log/level" ) func Benchmark(b *testing.B) { contexts := []struct { name string context func(log.Logger) log.Logger }{ {"NoContext", func(l log.Logger) log.Logger { return l }}, {"TimeContext", func(l log.Logger) log.Logger { return log.With(l, "time", log.DefaultTimestampUTC) }}, {"CallerContext", func(l log.Logger) log.Logger { return log.With(l, "caller", log.DefaultCaller) }}, {"TimeCallerReqIDContext", func(l log.Logger) log.Logger { return log.With(l, "time", log.DefaultTimestampUTC, "caller", log.DefaultCaller, "reqID", 29) }}, } loggers := []struct { name string logger log.Logger }{ {"Nop", log.NewNopLogger()}, {"Logfmt", log.NewLogfmtLogger(ioutil.Discard)}, {"JSON", log.NewJSONLogger(ioutil.Discard)}, } filters := []struct { name string filter func(log.Logger) log.Logger }{ {"Baseline", func(l log.Logger) log.Logger { return l }}, {"DisallowedLevel", func(l log.Logger) log.Logger { return level.NewFilter(l, level.AllowInfo()) }}, {"AllowedLevel", func(l log.Logger) log.Logger { return level.NewFilter(l, level.AllowAll()) }}, } for _, c := range contexts { b.Run(c.name, func(b *testing.B) { for _, f := range filters { b.Run(f.name, func(b *testing.B) { for _, l := range loggers { b.Run(l.name, func(b *testing.B) { logger := c.context(f.filter(l.logger)) b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { level.Debug(logger).Log("foo", "bar") } }) } }) } }) } } golang-github-go-kit-kit-0.6.0/log/level/doc.go000066400000000000000000000016471316471211400212150ustar00rootroot00000000000000// Package level implements leveled logging on top of package log. To use the // level package, create a logger as per normal in your func main, and wrap it // with level.NewFilter. // // var logger log.Logger // logger = log.NewLogfmtLogger(os.Stderr) // logger = level.NewFilter(logger, level.AllowInfoAndAbove()) // <-- // logger = log.With(logger, "ts", log.DefaultTimestampUTC) // // Then, at the callsites, use one of the level.Debug, Info, Warn, or Error // helper methods to emit leveled log events. // // logger.Log("foo", "bar") // as normal, no level // level.Debug(logger).Log("request_id", reqID, "trace_data", trace.Get()) // if value > 100 { // level.Error(logger).Log("value", value) // } // // NewFilter allows precise control over what happens when a log event is // emitted without a level key, or if a squelched level is used. Check the // Option functions for details. package level golang-github-go-kit-kit-0.6.0/log/level/example_test.go000066400000000000000000000012251316471211400231320ustar00rootroot00000000000000package level_test import ( "errors" "os" "github.com/go-kit/kit/log" "github.com/go-kit/kit/log/level" ) func Example_basic() { // setup logger with level filter logger := log.NewLogfmtLogger(os.Stdout) logger = level.NewFilter(logger, level.AllowInfo()) logger = log.With(logger, "caller", log.DefaultCaller) // use level helpers to log at different levels level.Error(logger).Log("err", errors.New("bad data")) level.Info(logger).Log("event", "data saved") level.Debug(logger).Log("next item", 17) // filtered // Output: // level=error caller=example_test.go:18 err="bad data" // level=info caller=example_test.go:19 event="data saved" } golang-github-go-kit-kit-0.6.0/log/level/level.go000066400000000000000000000134341316471211400215540ustar00rootroot00000000000000package level import "github.com/go-kit/kit/log" // Error returns a logger that includes a Key/ErrorValue pair. func Error(logger log.Logger) log.Logger { return log.WithPrefix(logger, Key(), ErrorValue()) } // Warn returns a logger that includes a Key/WarnValue pair. func Warn(logger log.Logger) log.Logger { return log.WithPrefix(logger, Key(), WarnValue()) } // Info returns a logger that includes a Key/InfoValue pair. func Info(logger log.Logger) log.Logger { return log.WithPrefix(logger, Key(), InfoValue()) } // Debug returns a logger that includes a Key/DebugValue pair. func Debug(logger log.Logger) log.Logger { return log.WithPrefix(logger, Key(), DebugValue()) } // NewFilter wraps next and implements level filtering. See the commentary on // the Option functions for a detailed description of how to configure levels. // If no options are provided, all leveled log events created with Debug, // Info, Warn or Error helper methods are squelched and non-leveled log // events are passed to next unmodified. func NewFilter(next log.Logger, options ...Option) log.Logger { l := &logger{ next: next, } for _, option := range options { option(l) } return l } type logger struct { next log.Logger allowed level squelchNoLevel bool errNotAllowed error errNoLevel error } func (l *logger) Log(keyvals ...interface{}) error { var hasLevel, levelAllowed bool for i := 1; i < len(keyvals); i += 2 { if v, ok := keyvals[i].(*levelValue); ok { hasLevel = true levelAllowed = l.allowed&v.level != 0 break } } if !hasLevel && l.squelchNoLevel { return l.errNoLevel } if hasLevel && !levelAllowed { return l.errNotAllowed } return l.next.Log(keyvals...) } // Option sets a parameter for the leveled logger. type Option func(*logger) // AllowAll is an alias for AllowDebug. func AllowAll() Option { return AllowDebug() } // AllowDebug allows error, warn, info and debug level log events to pass. func AllowDebug() Option { return allowed(levelError | levelWarn | levelInfo | levelDebug) } // AllowInfo allows error, warn and info level log events to pass. func AllowInfo() Option { return allowed(levelError | levelWarn | levelInfo) } // AllowWarn allows error and warn level log events to pass. func AllowWarn() Option { return allowed(levelError | levelWarn) } // AllowError allows only error level log events to pass. func AllowError() Option { return allowed(levelError) } // AllowNone allows no leveled log events to pass. func AllowNone() Option { return allowed(0) } func allowed(allowed level) Option { return func(l *logger) { l.allowed = allowed } } // ErrNotAllowed sets the error to return from Log when it squelches a log // event disallowed by the configured Allow[Level] option. By default, // ErrNotAllowed is nil; in this case the log event is squelched with no // error. func ErrNotAllowed(err error) Option { return func(l *logger) { l.errNotAllowed = err } } // SquelchNoLevel instructs Log to squelch log events with no level, so that // they don't proceed through to the wrapped logger. If SquelchNoLevel is set // to true and a log event is squelched in this way, the error value // configured with ErrNoLevel is returned to the caller. func SquelchNoLevel(squelch bool) Option { return func(l *logger) { l.squelchNoLevel = squelch } } // ErrNoLevel sets the error to return from Log when it squelches a log event // with no level. By default, ErrNoLevel is nil; in this case the log event is // squelched with no error. func ErrNoLevel(err error) Option { return func(l *logger) { l.errNoLevel = err } } // NewInjector wraps next and returns a logger that adds a Key/level pair to // the beginning of log events that don't already contain a level. In effect, // this gives a default level to logs without a level. func NewInjector(next log.Logger, level Value) log.Logger { return &injector{ next: next, level: level, } } type injector struct { next log.Logger level interface{} } func (l *injector) Log(keyvals ...interface{}) error { for i := 1; i < len(keyvals); i += 2 { if _, ok := keyvals[i].(*levelValue); ok { return l.next.Log(keyvals...) } } kvs := make([]interface{}, len(keyvals)+2) kvs[0], kvs[1] = key, l.level copy(kvs[2:], keyvals) return l.next.Log(kvs...) } // Value is the interface that each of the canonical level values implement. // It contains unexported methods that prevent types from other packages from // implementing it and guaranteeing that NewFilter can distinguish the levels // defined in this package from all other values. type Value interface { String() string levelVal() } // Key returns the unique key added to log events by the loggers in this // package. func Key() interface{} { return key } // ErrorValue returns the unique value added to log events by Error. func ErrorValue() Value { return errorValue } // WarnValue returns the unique value added to log events by Warn. func WarnValue() Value { return warnValue } // InfoValue returns the unique value added to log events by Info. func InfoValue() Value { return infoValue } // DebugValue returns the unique value added to log events by Warn. func DebugValue() Value { return debugValue } var ( // key is of type interfae{} so that it allocates once during package // initialization and avoids allocating every type the value is added to a // []interface{} later. key interface{} = "level" errorValue = &levelValue{level: levelError, name: "error"} warnValue = &levelValue{level: levelWarn, name: "warn"} infoValue = &levelValue{level: levelInfo, name: "info"} debugValue = &levelValue{level: levelDebug, name: "debug"} ) type level byte const ( levelDebug level = 1 << iota levelInfo levelWarn levelError ) type levelValue struct { name string level } func (v *levelValue) String() string { return v.name } func (v *levelValue) levelVal() {} golang-github-go-kit-kit-0.6.0/log/level/level_test.go000066400000000000000000000140401316471211400226050ustar00rootroot00000000000000package level_test import ( "bytes" "errors" "io" "strings" "testing" "github.com/go-kit/kit/log" "github.com/go-kit/kit/log/level" ) func TestVariousLevels(t *testing.T) { testCases := []struct { name string allowed level.Option want string }{ { "AllowAll", level.AllowAll(), strings.Join([]string{ `{"level":"debug","this is":"debug log"}`, `{"level":"info","this is":"info log"}`, `{"level":"warn","this is":"warn log"}`, `{"level":"error","this is":"error log"}`, }, "\n"), }, { "AllowDebug", level.AllowDebug(), strings.Join([]string{ `{"level":"debug","this is":"debug log"}`, `{"level":"info","this is":"info log"}`, `{"level":"warn","this is":"warn log"}`, `{"level":"error","this is":"error log"}`, }, "\n"), }, { "AllowInfo", level.AllowInfo(), strings.Join([]string{ `{"level":"info","this is":"info log"}`, `{"level":"warn","this is":"warn log"}`, `{"level":"error","this is":"error log"}`, }, "\n"), }, { "AllowWarn", level.AllowWarn(), strings.Join([]string{ `{"level":"warn","this is":"warn log"}`, `{"level":"error","this is":"error log"}`, }, "\n"), }, { "AllowError", level.AllowError(), strings.Join([]string{ `{"level":"error","this is":"error log"}`, }, "\n"), }, { "AllowNone", level.AllowNone(), ``, }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { var buf bytes.Buffer logger := level.NewFilter(log.NewJSONLogger(&buf), tc.allowed) level.Debug(logger).Log("this is", "debug log") level.Info(logger).Log("this is", "info log") level.Warn(logger).Log("this is", "warn log") level.Error(logger).Log("this is", "error log") if want, have := tc.want, strings.TrimSpace(buf.String()); want != have { t.Errorf("\nwant:\n%s\nhave:\n%s", want, have) } }) } } func TestErrNotAllowed(t *testing.T) { myError := errors.New("squelched!") opts := []level.Option{ level.AllowWarn(), level.ErrNotAllowed(myError), } logger := level.NewFilter(log.NewNopLogger(), opts...) if want, have := myError, level.Info(logger).Log("foo", "bar"); want != have { t.Errorf("want %#+v, have %#+v", want, have) } if want, have := error(nil), level.Warn(logger).Log("foo", "bar"); want != have { t.Errorf("want %#+v, have %#+v", want, have) } } func TestErrNoLevel(t *testing.T) { myError := errors.New("no level specified") var buf bytes.Buffer opts := []level.Option{ level.SquelchNoLevel(true), level.ErrNoLevel(myError), } logger := level.NewFilter(log.NewJSONLogger(&buf), opts...) if want, have := myError, logger.Log("foo", "bar"); want != have { t.Errorf("want %v, have %v", want, have) } if want, have := ``, strings.TrimSpace(buf.String()); want != have { t.Errorf("\nwant '%s'\nhave '%s'", want, have) } } func TestAllowNoLevel(t *testing.T) { var buf bytes.Buffer opts := []level.Option{ level.SquelchNoLevel(false), level.ErrNoLevel(errors.New("I should never be returned!")), } logger := level.NewFilter(log.NewJSONLogger(&buf), opts...) if want, have := error(nil), logger.Log("foo", "bar"); want != have { t.Errorf("want %v, have %v", want, have) } if want, have := `{"foo":"bar"}`, strings.TrimSpace(buf.String()); want != have { t.Errorf("\nwant '%s'\nhave '%s'", want, have) } } func TestLevelContext(t *testing.T) { var buf bytes.Buffer // Wrapping the level logger with a context allows users to use // log.DefaultCaller as per normal. var logger log.Logger logger = log.NewLogfmtLogger(&buf) logger = level.NewFilter(logger, level.AllowAll()) logger = log.With(logger, "caller", log.DefaultCaller) level.Info(logger).Log("foo", "bar") if want, have := `level=info caller=level_test.go:149 foo=bar`, strings.TrimSpace(buf.String()); want != have { t.Errorf("\nwant '%s'\nhave '%s'", want, have) } } func TestContextLevel(t *testing.T) { var buf bytes.Buffer // Wrapping a context with the level logger still works, but requires users // to specify a higher callstack depth value. var logger log.Logger logger = log.NewLogfmtLogger(&buf) logger = log.With(logger, "caller", log.Caller(5)) logger = level.NewFilter(logger, level.AllowAll()) level.Info(logger).Log("foo", "bar") if want, have := `caller=level_test.go:165 level=info foo=bar`, strings.TrimSpace(buf.String()); want != have { t.Errorf("\nwant '%s'\nhave '%s'", want, have) } } func TestLevelFormatting(t *testing.T) { testCases := []struct { name string format func(io.Writer) log.Logger output string }{ { name: "logfmt", format: log.NewLogfmtLogger, output: `level=info foo=bar`, }, { name: "JSON", format: log.NewJSONLogger, output: `{"foo":"bar","level":"info"}`, }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { var buf bytes.Buffer logger := tc.format(&buf) level.Info(logger).Log("foo", "bar") if want, have := tc.output, strings.TrimSpace(buf.String()); want != have { t.Errorf("\nwant: '%s'\nhave '%s'", want, have) } }) } } func TestInjector(t *testing.T) { var ( output []interface{} logger log.Logger ) logger = log.LoggerFunc(func(keyvals ...interface{}) error { output = keyvals return nil }) logger = level.NewInjector(logger, level.InfoValue()) logger.Log("foo", "bar") if got, want := len(output), 4; got != want { t.Errorf("missing level not injected: got len==%d, want len==%d", got, want) } if got, want := output[0], level.Key(); got != want { t.Errorf("wrong level key: got %#v, want %#v", got, want) } if got, want := output[1], level.InfoValue(); got != want { t.Errorf("wrong level value: got %#v, want %#v", got, want) } level.Error(logger).Log("foo", "bar") if got, want := len(output), 4; got != want { t.Errorf("leveled record modified: got len==%d, want len==%d", got, want) } if got, want := output[0], level.Key(); got != want { t.Errorf("wrong level key: got %#v, want %#v", got, want) } if got, want := output[1], level.ErrorValue(); got != want { t.Errorf("wrong level value: got %#v, want %#v", got, want) } } golang-github-go-kit-kit-0.6.0/log/log.go000066400000000000000000000115451316471211400201200ustar00rootroot00000000000000package log import "errors" // Logger is the fundamental interface for all log operations. Log creates a // log event from keyvals, a variadic sequence of alternating keys and values. // Implementations must be safe for concurrent use by multiple goroutines. In // particular, any implementation of Logger that appends to keyvals or // modifies or retains any of its elements must make a copy first. type Logger interface { Log(keyvals ...interface{}) error } // ErrMissingValue is appended to keyvals slices with odd length to substitute // the missing value. var ErrMissingValue = errors.New("(MISSING)") // With returns a new contextual logger with keyvals prepended to those passed // to calls to Log. If logger is also a contextual logger created by With or // WithPrefix, keyvals is appended to the existing context. // // The returned Logger replaces all value elements (odd indexes) containing a // Valuer with their generated value for each call to its Log method. func With(logger Logger, keyvals ...interface{}) Logger { if len(keyvals) == 0 { return logger } l := newContext(logger) kvs := append(l.keyvals, keyvals...) if len(kvs)%2 != 0 { kvs = append(kvs, ErrMissingValue) } return &context{ logger: l.logger, // Limiting the capacity of the stored keyvals ensures that a new // backing array is created if the slice must grow in Log or With. // Using the extra capacity without copying risks a data race that // would violate the Logger interface contract. keyvals: kvs[:len(kvs):len(kvs)], hasValuer: l.hasValuer || containsValuer(keyvals), } } // WithPrefix returns a new contextual logger with keyvals prepended to those // passed to calls to Log. If logger is also a contextual logger created by // With or WithPrefix, keyvals is prepended to the existing context. // // The returned Logger replaces all value elements (odd indexes) containing a // Valuer with their generated value for each call to its Log method. func WithPrefix(logger Logger, keyvals ...interface{}) Logger { if len(keyvals) == 0 { return logger } l := newContext(logger) // Limiting the capacity of the stored keyvals ensures that a new // backing array is created if the slice must grow in Log or With. // Using the extra capacity without copying risks a data race that // would violate the Logger interface contract. n := len(l.keyvals) + len(keyvals) if len(keyvals)%2 != 0 { n++ } kvs := make([]interface{}, 0, n) kvs = append(kvs, keyvals...) if len(kvs)%2 != 0 { kvs = append(kvs, ErrMissingValue) } kvs = append(kvs, l.keyvals...) return &context{ logger: l.logger, keyvals: kvs, hasValuer: l.hasValuer || containsValuer(keyvals), } } // context is the Logger implementation returned by With and WithPrefix. It // wraps a Logger and holds keyvals that it includes in all log events. Its // Log method calls bindValues to generate values for each Valuer in the // context keyvals. // // A context must always have the same number of stack frames between calls to // its Log method and the eventual binding of Valuers to their value. This // requirement comes from the functional requirement to allow a context to // resolve application call site information for a Caller stored in the // context. To do this we must be able to predict the number of logging // functions on the stack when bindValues is called. // // Two implementation details provide the needed stack depth consistency. // // 1. newContext avoids introducing an additional layer when asked to // wrap another context. // 2. With and WithPrefix avoid introducing an additional layer by // returning a newly constructed context with a merged keyvals rather // than simply wrapping the existing context. type context struct { logger Logger keyvals []interface{} hasValuer bool } func newContext(logger Logger) *context { if c, ok := logger.(*context); ok { return c } return &context{logger: logger} } // Log replaces all value elements (odd indexes) containing a Valuer in the // stored context with their generated value, appends keyvals, and passes the // result to the wrapped Logger. func (l *context) Log(keyvals ...interface{}) error { kvs := append(l.keyvals, keyvals...) if len(kvs)%2 != 0 { kvs = append(kvs, ErrMissingValue) } if l.hasValuer { // If no keyvals were appended above then we must copy l.keyvals so // that future log events will reevaluate the stored Valuers. if len(keyvals) == 0 { kvs = append([]interface{}{}, l.keyvals...) } bindValues(kvs[:len(l.keyvals)]) } return l.logger.Log(kvs...) } // LoggerFunc is an adapter to allow use of ordinary functions as Loggers. If // f is a function with the appropriate signature, LoggerFunc(f) is a Logger // object that calls f. type LoggerFunc func(...interface{}) error // Log implements Logger by calling f(keyvals...). func (f LoggerFunc) Log(keyvals ...interface{}) error { return f(keyvals...) } golang-github-go-kit-kit-0.6.0/log/log_test.go000066400000000000000000000110711316471211400211510ustar00rootroot00000000000000package log_test import ( "bytes" "fmt" "sync" "testing" "github.com/go-kit/kit/log" "github.com/go-stack/stack" ) func TestContext(t *testing.T) { t.Parallel() buf := &bytes.Buffer{} logger := log.NewLogfmtLogger(buf) kvs := []interface{}{"a", 123} lc := log.With(logger, kvs...) kvs[1] = 0 // With should copy its key values lc = log.With(lc, "b", "c") // With should stack if err := lc.Log("msg", "message"); err != nil { t.Fatal(err) } if want, have := "a=123 b=c msg=message\n", buf.String(); want != have { t.Errorf("\nwant: %shave: %s", want, have) } buf.Reset() lc = log.WithPrefix(lc, "p", "first") if err := lc.Log("msg", "message"); err != nil { t.Fatal(err) } if want, have := "p=first a=123 b=c msg=message\n", buf.String(); want != have { t.Errorf("\nwant: %shave: %s", want, have) } } func TestContextMissingValue(t *testing.T) { t.Parallel() var output []interface{} logger := log.Logger(log.LoggerFunc(func(keyvals ...interface{}) error { output = keyvals return nil })) log.WithPrefix(log.With(logger, "k1"), "k0").Log("k2") if want, have := 6, len(output); want != have { t.Errorf("want len(output) == %v, have %v", want, have) } for i := 1; i < 6; i += 2 { if want, have := log.ErrMissingValue, output[i]; want != have { t.Errorf("want output[%d] == %#v, have %#v", i, want, have) } } } // Test that context.Log has a consistent function stack depth when binding // Valuers, regardless of how many times With has been called. func TestContextStackDepth(t *testing.T) { t.Parallel() fn := fmt.Sprintf("%n", stack.Caller(0)) var output []interface{} logger := log.Logger(log.LoggerFunc(func(keyvals ...interface{}) error { output = keyvals return nil })) stackValuer := log.Valuer(func() interface{} { for i, c := range stack.Trace() { if fmt.Sprintf("%n", c) == fn { return i } } t.Fatal("Test function not found in stack trace.") return nil }) logger = log.With(logger, "stack", stackValuer) // Call through interface to get baseline. logger.Log("k", "v") want := output[1].(int) for len(output) < 10 { logger.Log("k", "v") if have := output[1]; have != want { t.Errorf("%d Withs: have %v, want %v", len(output)/2-1, have, want) } wrapped := log.With(logger) wrapped.Log("k", "v") if have := output[1]; have != want { t.Errorf("%d Withs: have %v, want %v", len(output)/2-1, have, want) } logger = log.With(logger, "k", "v") } } // Test that With returns a Logger safe for concurrent use. This test // validates that the stored logging context does not get corrupted when // multiple clients concurrently log additional keyvals. // // This test must be run with go test -cpu 2 (or more) to achieve its goal. func TestWithConcurrent(t *testing.T) { // Create some buckets to count how many events each goroutine logs. const goroutines = 8 counts := [goroutines]int{} // This logger extracts a goroutine id from the last value field and // increments the referenced bucket. logger := log.LoggerFunc(func(kv ...interface{}) error { goroutine := kv[len(kv)-1].(int) counts[goroutine]++ return nil }) // With must be careful about handling slices that can grow without // copying the underlying array, so give it a challenge. l := log.With(logger, make([]interface{}, 0, 2)...) // Start logging concurrently. Each goroutine logs its id so the logger // can bucket the event counts. var wg sync.WaitGroup wg.Add(goroutines) const n = 10000 for i := 0; i < goroutines; i++ { go func(idx int) { defer wg.Done() for j := 0; j < n; j++ { l.Log("goroutineIdx", idx) } }(i) } wg.Wait() for bucket, have := range counts { if want := n; want != have { t.Errorf("bucket %d: want %d, have %d", bucket, want, have) // note Errorf } } } func BenchmarkDiscard(b *testing.B) { logger := log.NewNopLogger() b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { logger.Log("k", "v") } } func BenchmarkOneWith(b *testing.B) { logger := log.NewNopLogger() lc := log.With(logger, "k", "v") b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { lc.Log("k", "v") } } func BenchmarkTwoWith(b *testing.B) { logger := log.NewNopLogger() lc := log.With(logger, "k", "v") for i := 1; i < 2; i++ { lc = log.With(lc, "k", "v") } b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { lc.Log("k", "v") } } func BenchmarkTenWith(b *testing.B) { logger := log.NewNopLogger() lc := log.With(logger, "k", "v") for i := 1; i < 10; i++ { lc = log.With(lc, "k", "v") } b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { lc.Log("k", "v") } } golang-github-go-kit-kit-0.6.0/log/logfmt_logger.go000066400000000000000000000025411316471211400221620ustar00rootroot00000000000000package log import ( "bytes" "io" "sync" "github.com/go-logfmt/logfmt" ) type logfmtEncoder struct { *logfmt.Encoder buf bytes.Buffer } func (l *logfmtEncoder) Reset() { l.Encoder.Reset() l.buf.Reset() } var logfmtEncoderPool = sync.Pool{ New: func() interface{} { var enc logfmtEncoder enc.Encoder = logfmt.NewEncoder(&enc.buf) return &enc }, } type logfmtLogger struct { w io.Writer } // NewLogfmtLogger returns a logger that encodes keyvals to the Writer in // logfmt format. Each log event produces no more than one call to w.Write. // The passed Writer must be safe for concurrent use by multiple goroutines if // the returned Logger will be used concurrently. func NewLogfmtLogger(w io.Writer) Logger { return &logfmtLogger{w} } func (l logfmtLogger) Log(keyvals ...interface{}) error { enc := logfmtEncoderPool.Get().(*logfmtEncoder) enc.Reset() defer logfmtEncoderPool.Put(enc) if err := enc.EncodeKeyvals(keyvals...); err != nil { return err } // Add newline to the end of the buffer if err := enc.EndRecord(); err != nil { return err } // The Logger interface requires implementations to be safe for concurrent // use by multiple goroutines. For this implementation that means making // only one call to l.w.Write() for each call to Log. if _, err := l.w.Write(enc.buf.Bytes()); err != nil { return err } return nil } golang-github-go-kit-kit-0.6.0/log/logfmt_logger_test.go000066400000000000000000000026071316471211400232240ustar00rootroot00000000000000package log_test import ( "bytes" "errors" "io/ioutil" "testing" "github.com/go-kit/kit/log" "github.com/go-logfmt/logfmt" ) func TestLogfmtLogger(t *testing.T) { t.Parallel() buf := &bytes.Buffer{} logger := log.NewLogfmtLogger(buf) if err := logger.Log("hello", "world"); err != nil { t.Fatal(err) } if want, have := "hello=world\n", buf.String(); want != have { t.Errorf("want %#v, have %#v", want, have) } buf.Reset() if err := logger.Log("a", 1, "err", errors.New("error")); err != nil { t.Fatal(err) } if want, have := "a=1 err=error\n", buf.String(); want != have { t.Errorf("want %#v, have %#v", want, have) } buf.Reset() if err := logger.Log("std_map", map[int]int{1: 2}, "my_map", mymap{0: 0}); err != nil { t.Fatal(err) } if want, have := "std_map=\""+logfmt.ErrUnsupportedValueType.Error()+"\" my_map=special_behavior\n", buf.String(); want != have { t.Errorf("want %#v, have %#v", want, have) } } func BenchmarkLogfmtLoggerSimple(b *testing.B) { benchmarkRunner(b, log.NewLogfmtLogger(ioutil.Discard), baseMessage) } func BenchmarkLogfmtLoggerContextual(b *testing.B) { benchmarkRunner(b, log.NewLogfmtLogger(ioutil.Discard), withMessage) } func TestLogfmtLoggerConcurrency(t *testing.T) { t.Parallel() testConcurrency(t, log.NewLogfmtLogger(ioutil.Discard), 10000) } type mymap map[int]int func (m mymap) String() string { return "special_behavior" } golang-github-go-kit-kit-0.6.0/log/nop_logger.go000066400000000000000000000003161316471211400214640ustar00rootroot00000000000000package log type nopLogger struct{} // NewNopLogger returns a logger that doesn't do anything. func NewNopLogger() Logger { return nopLogger{} } func (nopLogger) Log(...interface{}) error { return nil } golang-github-go-kit-kit-0.6.0/log/nop_logger_test.go000066400000000000000000000007721316471211400225310ustar00rootroot00000000000000package log_test import ( "testing" "github.com/go-kit/kit/log" ) func TestNopLogger(t *testing.T) { t.Parallel() logger := log.NewNopLogger() if err := logger.Log("abc", 123); err != nil { t.Error(err) } if err := log.With(logger, "def", "ghi").Log(); err != nil { t.Error(err) } } func BenchmarkNopLoggerSimple(b *testing.B) { benchmarkRunner(b, log.NewNopLogger(), baseMessage) } func BenchmarkNopLoggerContextual(b *testing.B) { benchmarkRunner(b, log.NewNopLogger(), withMessage) } golang-github-go-kit-kit-0.6.0/log/stdlib.go000066400000000000000000000062571316471211400206240ustar00rootroot00000000000000package log import ( "io" "log" "regexp" "strings" ) // StdlibWriter implements io.Writer by invoking the stdlib log.Print. It's // designed to be passed to a Go kit logger as the writer, for cases where // it's necessary to redirect all Go kit log output to the stdlib logger. // // If you have any choice in the matter, you shouldn't use this. Prefer to // redirect the stdlib log to the Go kit logger via NewStdlibAdapter. type StdlibWriter struct{} // Write implements io.Writer. func (w StdlibWriter) Write(p []byte) (int, error) { log.Print(strings.TrimSpace(string(p))) return len(p), nil } // StdlibAdapter wraps a Logger and allows it to be passed to the stdlib // logger's SetOutput. It will extract date/timestamps, filenames, and // messages, and place them under relevant keys. type StdlibAdapter struct { Logger timestampKey string fileKey string messageKey string } // StdlibAdapterOption sets a parameter for the StdlibAdapter. type StdlibAdapterOption func(*StdlibAdapter) // TimestampKey sets the key for the timestamp field. By default, it's "ts". func TimestampKey(key string) StdlibAdapterOption { return func(a *StdlibAdapter) { a.timestampKey = key } } // FileKey sets the key for the file and line field. By default, it's "caller". func FileKey(key string) StdlibAdapterOption { return func(a *StdlibAdapter) { a.fileKey = key } } // MessageKey sets the key for the actual log message. By default, it's "msg". func MessageKey(key string) StdlibAdapterOption { return func(a *StdlibAdapter) { a.messageKey = key } } // NewStdlibAdapter returns a new StdlibAdapter wrapper around the passed // logger. It's designed to be passed to log.SetOutput. func NewStdlibAdapter(logger Logger, options ...StdlibAdapterOption) io.Writer { a := StdlibAdapter{ Logger: logger, timestampKey: "ts", fileKey: "caller", messageKey: "msg", } for _, option := range options { option(&a) } return a } func (a StdlibAdapter) Write(p []byte) (int, error) { result := subexps(p) keyvals := []interface{}{} var timestamp string if date, ok := result["date"]; ok && date != "" { timestamp = date } if time, ok := result["time"]; ok && time != "" { if timestamp != "" { timestamp += " " } timestamp += time } if timestamp != "" { keyvals = append(keyvals, a.timestampKey, timestamp) } if file, ok := result["file"]; ok && file != "" { keyvals = append(keyvals, a.fileKey, file) } if msg, ok := result["msg"]; ok { keyvals = append(keyvals, a.messageKey, msg) } if err := a.Logger.Log(keyvals...); err != nil { return 0, err } return len(p), nil } const ( logRegexpDate = `(?P[0-9]{4}/[0-9]{2}/[0-9]{2})?[ ]?` logRegexpTime = `(?PL9II 8H9|HHHH $:`H$HHH$HHHt$HHL$L9HD$0H|$@HT$ Ht$(HD$pHH$HD$HL$(H9HD$p@HD$@H$HD$pHD$D$HD$HD$P x 1bHL$8H$HL$)KHD$HD$XHL$xH $HT$8HT$KHD$pH$HD$XHD$?HD$pHHL$8HHD$PHT$0H9rH$H$H$HD$(H$Hl$`HhH$HL$xHL$HL$0HL$脓HD$PHD$@H$HD$D$HD$HD$PH$HL$xHL$HL$0HL$:HD$PH$HL$ HL$"JHD$H$HD$@HL$ H)HD$rHD$P(HD$HHH $&^HD$pH$HT$HHH$HH|$HHIHI1IHHLHH$H $]H|$H$H$HHHHH$5HH$H"H$H$H9|VH H$H$H$H$Hl$`HhHPH$H HD$諘 t H+H$HP HD$膘 _ eH %H;avvH Hl$Hl$1$HD$HHHH$%HD$HH|1&HD$HHHDH$%HD$HH|Hl$H F_qHD$1HHHwHL$eH %H;a>HPHl$HHl$HD$XHHHH H\$@H HHL$8HA(HD$ H$5-HD$HeHD$ H$-HD$HHL$8HA(A`fA`HA(H$,HD$HtHD$ HD$`Hl$HHPHD$@H$HD$8HD${$H1H$HD$H HD$D HD$HH`fHD$8HH(H $g,HD$HL$XH@HH!HT$8HBh1OHD$(H$HD$HL$(HHD$0H$ ,HD$HT$8HJ(HHD$0HB(HBhHL$(HH=rHD$@H$HT$\%HL$8vHqH$HD$) H H$HD$ HH$HD$ HH$HD$ ؞ a \eH %H;acH(Hl$ Hl$ H0H$HL$0HHT$HD$Hd HD$HH(H $*HD$HHD$0H$*HD$HL$HQ(HHD$0HA(A`PfQ`ϥ ubfu\D$8HHHHH$HL$"HD$H@(H ;/H $HD$H HD$Hl$ H(D$8Hs-HHHH $HL$HL$##  H;H$HD$!L E[eH %H;aH0Hl$(Hl$(H( H$11PD$@$HD$HD$H$i)HD$HL$ HL$@H@HH!HT$HHL$HD$HL$ H=@rH H$HD$8L$@Hs(HHT$ HXHT$H`Hl$(H0 . eH %H;aHHHl$@Hl$@HD$PL$XHHHT$8HXHL$0H`H\$(H5 H4$SHD$(HL$0SH $>(HD$HHD$HL$H $L$XL$L$XH@HH!HT$ H)HHL$HD$ HL$H=@wHk H$HD$8HL$HT$PHXHL$ H`Hl$@HH诀 h-eH %H;aH8Hl$0Hl$0H H$_1yHD$ H$M'HD$HHD$HL$ H $L$L$H\$H\$ H$'HD$HuHL$(HT$@HDŽ XHDŽ `L$A<s'HL$@Hs1D$HHT$(HXH@ H$Hl$0H8 a,eH %H;aHHl$xHl$xeH%HH0HH9Z$P- w=X1=w\$'H(Ht HHteHt H$D$'$.HD$HD$(H M H $HD$(H$$HH$Hl$xHĀËuHIHD$`HHL$PHXHT$HH$K%HD$HtSHD$HHD$(H$.%HD$HHL$PHT$`H XH `$H)H `HD$(?HD$`H$L$'L$HD$PHL$`HXH넉HL$@H HL$8H $HD$HD$0H FH $HD$0HQHHD$PH HTHT$pH$D$ts1HD$XH H $HD$XHtH$HD$oH)H$HD$8HD$Hr HD$HD$HHL$@HHhHD$PH HDHD$hHL$pH $HD$vHD$h\H$H HD$%?D$HD$@H$H HL$/HD$HtNH$HL$@HH$Hl$xHĀHH$HD$ 诖 8| 1| HH$HD$膖 H!H$HD$k HX7H$HD$!P (DeH %H;aHXHl$PHl$PeH%HL$`HH\$hHH)H{HH<H95۠ HH1HHw@t$H@0H(Ht HHtAH H$HD$`H$D$D$Hz H$Hl$PHXËu@HHT$0H\$HHHD$(H`HsMH $!HD$HL$(HT$HH XHHD$`H XH `H\$0HH `mH$@t$HL$`HT$8H&H$HT$HD$Hd ? u&H %H $HD$H\ HD$r HD$@HH H $ HD$HD$ H jH $豽HD$ HsPHH KHDH$HD$@HD$H,H$SH$H\$-Hl$PHXay H$6HD$HD$0ǝHD$0H$ HD$8H$Q,HH$HD$s x H}H$HD$Q HH$HD$6 %HD$HHT$HH9wHZH9s HRHHHH,$H,$HD$L$QʃHcH@w$HcHL$ HD$(HT$0HD$8@H,$Hx HH,$H,$HD$HPH@HL$HHH9sHHD$ H,$Hw eH %HD$H;A9HH$H$H$HH$HL$HD$(HL$HT$H\$ H$H$H$H$H$HHL$pHPHT$hHXH\$@H$Ht$`H$ILD$XHHD$PI9E1/LT$8MJHD$PHL$pHT$hH\$@Ht$`H$LD$XI92LL$8H$H$LL$D$<uH$H$HL$8HHL$7HD$H$LHHL$0H$H$H$H\$ƀƀH$HHL$H$H$HHL$²H$HHpHHHH8H $7H$H$HHL$H$H$H$HHH+HH5=H9HL$pH$HHL$/H$H$HL$pHL$D$H$H$HHL$H$H8H$6H$`HhHH0HH $HD$H$H $H`H$HD$ۇe uH$ƀdH$H$HT$pHL$hHHHL$`H$HT$XH$H\$PH$Ht$HHx@H|$@L@`LD$8LHPL$|H]H$HD$HD$ H$襌HH$HD$܍HD$hH$~HoH$HD$赍HD$`H$WHH$HD$莍HvH$HD$ uHD$XH$H_H$HD$NHD$PH$H(H$HD$'HD$HH$ɋHLH$HD$HH$HD$ HD$@H$艋HH$HD$HD$pH$bHH$HD$虌HD$8H$;H7H$HD$rH$H$!HH$HD$H3H$H\$ IHHHH$CHD$@ H$H$H$pHD$H$H$HpH$HD$!蜋HU9H$̉HH$HD$ s^HH$HD$w H?H$HD$"w HH$HD$ow H$D$HD$0fHH$HD$ H$H$蜊HH$HD$ ÊHD$0H$eHнH$HD$蜊臁H$HHD$pHH$HD$iHD$ H$ HH$HD$BHD$pH$HH$HD$HH$HD$Mv HH$HD$2v HAH$(HqH$0Hl$Hl$cHmH$(HCpH$0HCxHC8HD$pH HL$hHSHT$`L$0LD$XL$(LL$PL$PLT$HL[@L\$@Lc`Ld$8LkPL$HzH$HD$ HD$pH$‡HH$HD$HD$hH$蛇HH$HD$҈HD$`H$tHH$HD$諈HH$HD$ 蒈HD$XH$4H|H$HD$kHD$PH$ HEH$HD$DHD$HH$HiH$HD$HH$HD$ HD$@H$覆HH$HD$݇HD$pH$HH$HD$趇HD$8H$XHTH$HD$菇H$H$>HH$HD$eP~H$0H$H$(HD$H$PHD$H$HD$HH$HD$ _s H$HAHD$(HH$HYPH$@}HH$HD$ džHD$(H$iH)H$HD$蠆H$H$OHH$HD$ vH$H$%H;H$HD$LH$H$HH$HD$ "H$H$хHH$HD$|H$H@0HHH$HpH$Hl$Hl$_HmH$H${yH$HL$H$H$HD$H$HD$HL$FH+H$HD$$q HH$HD$q /1eH %H;avhH Hl$Hl$HD$0Ht%HHT$(H$HL$HD$JHl$H HH$HzCHD$XHD$HHD$0.eH %H;aeH Hl$Hl$HD$(H$AD$%u?HD$(HHu Hl$H HPH $HT$HHD$(HH@HD$(HH  U{ H(Hx H9ttHHHH)HHHrQHp8H)HHH9s0HPpHt Hl$H H$HL$D$Hl$H Hl$H Hl$H Hl$H Hl$H HTH$HD$o HH$HD$zo s-~eH %H;aH`Hl$XHl$XHHx H$诘1vHHtjH0x`fuHD$0Ht$8H$HD$?HD$0H@(H [H $HD$H˚ HD$HL$HՕH\$HHt$8HAH}%HD$HHHHH\$HHbHw H$ڙHH$1`H\$(H HL$@H$H\$HH$HL$(HL$H  HL$5HD$PHL$ HDH\$@HuHAH}$HD$ HHHH\HDHD$PHH$,Hl$XH`+XHHl$Hl$H?H$B*Hl$HeH %HD$H;AuHH$H$H$H$H1HHIHHH9}!LHMtK<L9HIHHLD$HHuGH|$PH$HHH9HHL:H:H$HL$D$H$H$HD$HHD$.HD$0HL$(HT$ H\$H\$@Ht$Ht$p1L$CL$MALL$hIyH)LL$`I)MII?L!LL$xIH\$@Ht$pLL$L9}]H|$hHL$XHD$`L$MPLT$8ML9~0HT$xH$L\$LT$[HD$8HL$XH9]IH$H$H$HĐHD$PH$H9sdHH$HTHH$H$H$HĐHDŽ$HDŽ$H$HĐQ P P HH$HD$j (ieH %H;avVH8Hl$0Hl$0HD$@H$HD$HHD$HD$HD$HD$ HL$(HD$hHL$pHl$0H8v(eH %H;avYH8Hl$0Hl$0HD$@H$HD$HHD$HD$HD$HD$ HL$(HD$xH$Hl$0H8(eH %H;av\H8Hl$0Hl$0HD$@H$HD$HHD$HD$HD$9HD$ HL$(H$H$Hl$0H8'eH %H;av\H8Hl$0Hl$0HD$@H$HD$HHD$HD$HD$HD$ HL$(H$H$Hl$0H8'eH %H;a H0Hl$(Hl$(HD$XHD$`HD$HHHL$8HH HL$ HD$XH$dHD$ r uPHL$ HHD$XH$=HD$HL$HHHHD$@HL$HHD$HD$ H$HL$ XHl$(H0H$HD$ HD$H$HD$D$WHL$VHD$XHD$`Hl$(H0%eH %H;avQHHl$Hl$HD$ H$uHD$HeH %HHIH9wH9D$0Hl$H1k%eH %H;aH8Hl$0Hl$0HD$@Ht_HL$HH 0wYH» HHT$PHL$XHD$`Ht$hH\$pHl$0H8H $HT$HL$HD$Ht$ H\$(HL$HL $^eH %H;aH@Hl$8Hl$8HD$HHHL$XH HH@H@H@Hʻ H\$(HL$ H9~EHD$0H$HL$PHL$HT$UHD$0HD$`HD$ HD$hHD$(HD$pHl$8H@HH $HL$HD$H\$HT$XHL$X#eH %H;awHPHl$HHl$H1HHHT$hH9}DH\$`4}HHL$0H$HT$HD$ HD$ HL$0HT$hH\$`H|$XHH WHl$Hl$NHmH  H\$XHL$0HD$8H\$@11D HH9}bLD$`E 0A} HH9rH|$(L$HT$Ht$\DL$Ht$ HD$8HL$0HT$hH\$@H|$(LD$`H\$pHL$xH$Hl$HHPH $ HD$H\$HL$HT$h?I 8J 1"leH %HD$H;AHH$H$D$<1H$HTHD$hH$HT$HmHD$xH$HH$HXX\$H$HT$HD$xHH0HP(H$HL$H$HHHHH?HH$H\$H\$xLC(ML ] M9ADCXL$MHLS`M_LL$PHL$`3H$H\$xHC`HHC`H$HL$`L$LL$PHS`HHC`IHHHH?HHIHDEHD$XHL$PHT$HH$CHt$H$Hl$Hl$?@HmHD$xt=HL$XH$HL$PH$HL$HH$$Hl$hHpHL$PHH$H5Hl$Hl$?HmH$H$H$H$Hl$hHpHL H\$xE1l@XH$H5!Hl$Hl$Z?HmH$H$H$H$H$Ƅ$Hl$hHpHH$H$H$7 eH %H;aHXHl$PHl$PHD$`HL$hH $Y[ HL$`HQ(HY0Ht$H|$Hy(Hq0HA(H$Ht$D$HD$`HH(H HT$hHPH9v L$pKHH0HP(HXH\$H$HL$D$!HD$(HL$ T$0H\$`HCH[ Hs@HK@SPHC(HK0H$HL$D$Q&HD$Htr Z HT$`HZ8uJHB8HB(HJ0HZH\$H$HL$D$HD$ @%D$(HL$`ATHl$PHXH$HD$HT$`륋OZ HL$`HQ8uHA8ATH$HD$ߟHL$`މT$H$HHHPHH$H9H$H>H|$XD$TH)H)HHH?H!HHD$`H$H\$hHD$XHD$p=H<H$HD$yGHcD$TH$EHH$HD$ RGHD$pH$EHyH$HD$+G>H$H$HT$`H|$hHL$XHH9L$(H$HT$H|$HD$XHD$HL$THL$ HD$8HL$0T$HH\$@gDŽ$H$HĠ$t : tfDŽ$H$HĠDŽ$H$HĠHH$HD$2 ~  p H$HHD$piH rH$HD$?H$H$(>HqH$HD$_?HD$HH$>HqH$HD$8?D$ eH %H;avFHHl$Hl$HJH$CLHD$H$%HIH$NHl$HeH %H;aHXHl$PHl$PHD$`HHH}HHHH IHH IHIHIHrH9HJH I , H4ӅHHH $HD$`HHuGIuc=Iu60It Hl$PHXI$HHD$SHHHH$HD$>HHHH$MH4$HD$qHD$`HHH$H\$HT$HL$Ht$ Z{HD$(HL$0HT$8HH+ uH{HHHHD$`HD$HHL$@H ZHH $HD$pHD$HHL$@.eH %H;aH0Hl$(Hl$(HD$8H GH $IHD$8HHGHGH}HGH$KD$@Hl$(H0HsH9H9>HH9* H|HHSH$H\$PH}dCHCH$HHD$HD$D$HD$ e8HCH$ECYH$HD$0H t$ HHt$@tCHHqCHrCH$IHHBCH$IGHRCH$HD$@HD$/MuH*HCH$HL$ikO ( !  eH %H;aHHl$Hl$H# HHBH$DBtHBH BHu#HZBH$aFHD$ Hl$HHH 4# H@H9}MH$# /Bt7$BHBHD$H AH $FHD$HD$ Hl$H11HD$ Hl$HreH %H;aTHPHl$HHl$HHAH AHT$XH9#HD$(HL$HH\$8HsHt$H;HHHzH?H>H|HH9LL MPL9H9H|$ D# LEuCLI# uHL $H\$@iHD$(HL$H\$8Ht$H|$ ]HT$XLL$0LD$@L$LD$iHD$(HL$HT$XH\$8Ht$H|$ LD$@LL$0wHl$HHP   eH %H;aHXHl$PHl$PH0@H 1@HT$`H9HD$0HL$HH\$HHsHt$L#LHHLBI9FLLMILRI9kL\M[M9HLBI90YLLMILbI9 6HT HRL9L9H9I9JNH9Ld$ D ! LEuFHH:! u JL$H\$MgHD$0HL$H\$HHt$Ld$ LD$@HT$8H|$(L$HT$gHD$0HL$HT$8H\$HHt$H|$(LD$@Ld$ tHl$PHXLM#LMLMLMMMMMd ] V O H A eH %H;av&HHl$Hl$H$HD$Hl$HfHD$HD$HD$HL$HHD$HD$eH %HD$H;A|HH$H$HOtH$HD$ RH  H$X?QCeH%H$HH0ƁH$H$H aH $HD$HD$nHD$(HL$ HT$H$H$HT$HL$HD$HD$ CHD$(HD$8H$H $H8HD$PH 81H$HKH\$HHSHD$PH9 HT$HH$HH$H$=HD$D$0twtH$ƀH$HHHHD$XHHD$X$ HD$HD$XHD$HD$HD$ /H$HHHHD$`HHL$`$HD$HL$`HL$HD$HD$ TD$0$H$HǀeH %HI0HHH H $[HD$H$H(HHHJH$HD$HD$HD$D$ HD$hHD$pHD$xH$HHT$hHD$pHD$8HD$x$ HD$HT$hHT$HD$HD$ ZD$0%<+G2H$HG H$HGf HgH$HD$HD$HD$m HL$ gH Y HV HH$H@0ƀtHD$H$L$L$4HH$HD$H1H\HL$@H$HJHH$H\$HL$HD$HL$ HT$@H HH$HHHHHHH|D$4$H H$<'NHDŽ$HDŽ$H$HH$HD$H$HD$H$H$H $H$H H$HL$`H H$/9JHl$8H@HH$HD$  HزH$HD$"  HH$HD$$  HH$HD$%e  ^eH %H;aHHl$xHl$xHH$6 eH %wH vHH utHQHBH$)8HH$HD$A[ fAHDŽ$HDŽ$HDŽ$Hl$xHĀHH$HD$\yHH{HHuKHHk,s u\HMH>H$%7HBH$HDŽ$HDŽ$HDŽ$Hl$xHĀHH$HD$+[딋c utHHH$6OH1H$HD$(HDŽ$HDŽ$HDŽ$Hl$xHĀH\H$HD$ZyIHWH+HWH* jYHEH+6WH*^iYL$`r HHH$5HVH$HD$HD$HD$HD$ KdHD$(HL$0HT$8H$HAHD$HT$iL$`f. H,HD$HD$ HL$(HT$0H1HtFHYH9#H 0HHL$H$H\$HT$HD$ HL$(HT$0HT$HHL$@HD$hH9H$HD$hH$HD$@H$HD$HH$Hl$xHĀHL$@H5TH4$HD$HL$HT$H\$ #cHD$(HL$0HT$8HYHL$@.\H,HH H,H$HD$bX>hH$HD$PH@  HHH$3HD$PH$HD$HD$pHL$PH $HD$pHHL$HIHH$H$HDŽ$Hl$xHĀH\H$HD$W^HH$eH%HD$?HH$H THL$HD$D$HD$ #H H$0O Z uqH H H$2H$HlHD$HD$iHD$HL$ HT$(H$H$H$Hl$xHĀHV H$HD$V|HD$XH$YHD$H m HHD$XH^ HK LH H$HL$9Vvo heH %H;aH Hl$Hl$H HuHD$(Hl$H H Hu  tHr H$y/H Hu#HV H$=1HD$(Hl$H H Hu  8 tH$* HD$HD$H q H $HD$ H H$0HD$HD$(Hl$H ^eH %H;avsHHl$Hl$HD$ HHǀHu Hl$HHL$Ho H$v.HD$H$(HQ H$80Hl$HteH %H;avsHHl$Hl$HD$ H$5HD$HHJ HuHD$ H9 H: Hl$HH) H$HD$HL$ HH9teH %H;aH Hl$Hl$H Ht[HD$H$HD$HH Hu H HD$H$hHD$HHD$HD$(Hl$H HD$(Hl$H [eH %HD$H;AfHH$H$H$HD$XL$L$4HT$ HT$hHH$HD$HtHHHHH4}BH$HD$H$QHD$H$sHD$HD$pHL$hH $kHD$pHD$p|H$HHL$pHQHH)HQHHYH$HH$sHD$8@v@t$3HAHD$@H $$ \$ D$3<11HD$`HL$pH $HT$8HT$d 1H$1HD$PHL$xHHT$pH$HD$8 HD$xHHHD$PHH$H9|H$HGHD$pH@HL$@H)H4hHL$`HtHD$4$H$HĈHL$pHQH\$XH$HT$HD$HD$HD$ ;HD$(HL$pH $HD$sgHD$pH$HD$WKHD$pH$HD$;HD$pHHHQHHHH$H9H\$HH $D$AnHD$pH$L$4HcHT$HD$pH$HL$HHL$HL$pH\$H1 $DH$HĈH=H$HD$   xeH %H;aH@Hl$8Hl$8eH%HL$HHHL$0H9Hud1H~HH~HHuHHL$`H9HSH$HT$PHT$HD$HL$D$ HD$pHl$8H@H $HD$hHD$HD$PHD$HT$XHT$HT$`HT$ "RHD$(HL$0^HD$hHH$HD$PHD$HL$XHL$HL$`HL$PHD$ HL$0  蹼eH %H;aH Hl$Hl$ H$HD$HH $aHD$Ht&HHT$HT$(L$0HHD$8Hl$H Hb H$'HD$HD$(D$0HH HD$8Hl$H OeH %H;avIHHl$Hl$D$t eH%H@0H$dHl$HH H$(蓻eH %H;anH8Hl$0Hl$0HH+eH %HI0HH9D$HL$@HH HHL$ H $HD$HHHD$ HD$@H$HD$HD$(H$HD$}HD$(H@H@D$uHD$@HD$HHl$0H8HH$'H$H( HD$ HD$HtHD$HH$+HD$HHHHT$XH9unHHH\$HH9uHD$ H$HD$HL$HT$@H\$H1HHH9}H9H9sBLL9tHD$ HD$ @D$`Hl$(H0H\$H`D$`Hl$(H0 IeH %H;avHH Hl$Hl$HD$(HH$HD$0HH(HD$ HD$HD$8Hl$H eH %H$XH;AgH(H$ H$ H-H$HD$H$8HL$LHD$HD$xHL$ HL$XHT$(HT$`H$0H$H$8H\$H$@H\$菛HD$H$HL$H$HT$`H\$XHt$xH$HHHHHT$`H\$XH$H$WHl$Hl$aHmH$wH$H$Hl$Hl$HmD$HD$WH$H$Hl$Hl$tHmHL$XHQH\$`H9H$HH< KuNHH$Hl$Hl$%Hm H$HH$PH$XH$ H(H$HT$pH\$hH,H$H|$H$HD$BD$WH$HT$pH\$hH+H$H$Ht$HL$H\$HT$ KHt$(HD$0H\$8HPD$WHL$XYteH %HqHH$pH)H=sHH$H$HDŽ$H$1HH$MHT$H$oH$H\$Hr H$ HHt$H$1H$)H$HL$pH$HH$HHl$Hl$YHmH$H$HHl$Hl$6HmH$H$H$Hl$Hl$HmnHD$`H$HL$XH$HT$PH$H\$HH$L$L$LD$hLD$LD$pLD$L$LD$HD$0HL$(HT$ H$HL$HD$H$HD$HD$ HL$(HT$0H$HL$HT$H$HD$HD$ HL$(HT$0H$HL$HT$H$HD$[H$Hp@H$HXHD$ HT$(HL$0H$HT$hH$LD$xL9AHJ H_HHH9H$H<$D$H$H$HL$hHL$H$HHHHH$HHHHH?H!HHt$hH9bH$H$H$HD$Ht$H$H$HH$HAH$HH$HD$H$H-H$H$HHL$H$H $HD$HD$HD$0HD$pHL$(HL$hHT$ H$H$H$HD$HL$HT$H$HL$HD$SHD$ HD$xHL$H$H$H$HT$hHT$HT$pHT$HD$2HD$ HL$0HT$(1H$H$HH<${HD$H$HD$H$?H|$H$HL$I@H$H$HHH$H= }.H$H$HH$kHD$H$^HH$H$H$HD$H$:HcH$JH$HHH $5H$ 1HH$HĐ 觩ReH %H;aH@Hl$8Hl$8HD$hHL$`H=HH9H)HHH?H!HHL$HH $HD$H\$.HD$HD$(HL$ H$HT$0H\$pHt$xH~pHH9wtH)IHH?H!HH $H\$LD$HD$HL$ HT$(H$H$HD$0H$H$Hl$8H@IHH9z s lHD$HD$HD$HL$HeH %H;azH(Hl$ Hl$ HD$8H$HD$HD$HD$8HL$0HHHH$HD$8H=H$H HD$gHD$HHD$HD$0HH $3HD$H$5HD$0H$HL$HL$HD$0H@HH $HD$HL$0HQHsKH\$8HHYHDHD$@Hl$ H(H$HD$0HHHT$8HHvH{ H^H$HD$ HeH$HD$ 讦ieH %H;avwH(Hl$ Hl$ PH $HD$HD$HH $HD$0H$HD$H$HD$Hk HD$HD$0HHuHl$ H(peH %H;av[H8Hl$0Hl$0HD$(D$@HcHD$($HD$HD$(HD$HD$HD$ 0Hl$0H8补eH %H;avhH8Hl$0Hl$0HD$(eH%H@0HcHD$($HD$HD$(HD$HD$HD$ Hl$0H8eH %H;aH@Hl$8Hl$8jH$HD$0HHL$(HH$HT$HHT$$HD$HD$HD$HD$ HD$(HL$0HH $$Hl$8H@ePeH %H;avlH8Hl$0Hl$0HD$(HHD$($HD$HD$(HD$HD$HD$ HHHHl$0H8{eH %H;avEH0Hl$(Hl$($HD$HD$HD$HD$ Hl$(H0weH %H;avEH0Hl$(Hl$($ HD$HD$HD$HD$ Hl$(H0eH %H;avEH0Hl$(Hl$($ HD$HD$HD$HD$ FHl$(H0跢eH %H;avHHl$Hl$eH%H@0HH$fHD$ u'ƀ Hǀ(Hǀ0Hl$HHeH$HD$$ heH %H;aH8Hl$0Hl$0eH%H@0HH$HD$ tH(HtHL$@H(H(Hl$0H8HD$($ HD$HD$HD$HD$ HD$(YDeH %H;aHHHl$@Hl$@eH%H@0HH$HD$ H(Huƀ Hl$@HHHD$8HD$(HD$0H(HL$(H0HL$0$ HD$HL$(HL$HD$HD$ HD$8HfH$HD$b [eH %H;avEH0Hl$(Hl$($+HD$HD$HD$HD$ Hl$(H0eH %H;avEH0Hl$(Hl$($,HD$HD$HD$HD$ &Hl$(H0藟eH %H;aH@Hl$8Hl$8HD$HHǀeH %HI0HHH MQH $t)HD$HL$PHHH H $HD$HD$HD$D$ HD$(HD$0HL$HHHL$(HD$0$ HD$HD$(HD$HD$HD$ !Hl$8H@蒞eH %H;aHpHl$hHl$heH%H@0HHD$`HH0HHL$(HHHH $ HD$HPH$HD$HL$`H9HHT$(H9uMHD$0HHD$0$&HD$HD$0HD$HD$HD$ Hl$hHpHHD$8HD$@HHD$8HHD$@$HD$HD$8HD$HD$HD$ HD$(H$HD$HD$HHD$PHD$XHL$`HHT$HHHL$PHXHsGH BHHD$X$)HD$HD$HHD$HD$HD$  膜eH %H;avEH0Hl$(Hl$($HD$HD$HD$HD$ Hl$(H0'eH %H;av`H0Hl$(Hl$(eH%HH0HH$HD$HD$HD$HD$ ;Hl$(H0講eH %H;av`H0Hl$(Hl$(eH%HH0HH$HD$HD$HD$HD$ Hl$(H0,eH %H;aH0Hl$(Hl$(D$8u:$HD$@HD$HD$HD$HD$ FHl$(H0$$HD$HD$HD$HD$ D$8胚^eH %H;aHHHl$@Hl$@eH%H@0HHL$PHHHHH9uNHD$(HHD$($'HD$XHD$HD$(HD$HD$HD$ UHl$@HHHHD$0HD$8HHD$0HHD$8$HD$XHD$HD$0HD$HD$HD$ deH %H;avEH0Hl$(Hl$($HD$HD$HD$HD$ Hl$(H0eH %H;aHHHl$@Hl$@HD$PHtH NH9}1eH %HI0HHHHHQ0HHHD$(HD$0HD$8HHT$(HHL$0HHD$8$HD$HD$(HD$HD$HD$ Hl$@HHeH %H;aH@Hl$8Hl$8ZH$HD$0HHL$(HH$HT$HHT$$HD$HD$HD$HD$ HD$(HL$0HH $Hl$8H@UPeH %H;av[H8Hl$0Hl$0HD$(H HD$($!HD$HD$(HD$HD$HD$ pHl$0H8eH %H;aH@Hl$8Hl$8H HuDH9HD$0$"HD$HD$0HD$HD$HD$ Hl$8H@HD$(H HD$($"HD$HD$(HD$HD$HD$ ?eH %H;aH Hl$Hl$HhH$H5HD$HD$H'HH$H=HD$HD$HHH$HEHD$HD$HH H$H HL$HD$HH H$H }HL$sHD$HH H$H HL$KHD$HHx H$H HL$#HD$HHP H$H uHL$HD$HH(H$HHD$HD$HwH H$H HL$HD$HHH$H mHL$HD$HoHH$HMHD$[HD$HgHH$H HL$3HD$HHH$HHD$ HD$HH8H$HEHD$HD$HHH$H]HD$HD$HgHH$HHD$HD$HHl$H (#eH %HD$H;AKHH$H$HD$`H|$hWHHl$Hl$RHmH$H@( HL$XHA(HmHD$XHHHHD$pHD$`HD$hHDŽ$HDŽ$HDŽ$HD$pHD$xHD$`H$0|HD$H$H$HD$H$H D$UH$HHL$@HHD$pH$芚HD$HD$PHL$HL$HH$HL$HD$HD$PHD$`HL$HHL$hHT$XH$iHD$H$HD$`H$HL$PHL$HL$HHL$D$HL$@HL$ HD$(HL$0H$H$H$HHD$pHD$8-HeH$HD$HD$8H$VH*H$HD$xH(H$HD$  踐eH %H$H;A HH$H$H$HH$HHHeH%H$H$H9uHr0HH9=腿$H$HH$HgH$HQpHEHYxHDŽ$XH$`WHHl$Hl$0HmH$hH$H@HHL$M1LI(MI(Mt MQItD$@@|$;L$0H$(H$L$hMuHH$hH$HH$H$hH$蟗HD$H$HL$H$ H $HD$WD$H$ H$XH$H$`H$WHl$Hl$Hm11H$(H$H$1L$0CH(HLGL$M9tItHH$0,L$M L$ML$hL\$xIOL$L$@L$A L$hM L$ MuM9v Ld$HL,$H$HD$Ld$HD$ H$HL$H$T$(T$ H$H$HĸHH$HH$H$H$T$;T$Ht$HL$H$HL$ HL$(H$H$H$ H$L$HL$L$HH$T$@5H$H$H$H H$HD$+H$H$H)H$H$ HHHHHHHHHHHHHHHH$@H$ H$H$HL$D$HT$HHT$HD$ 膘D$(H$H$\$<H$H$8\$DHH$H$@T T$H$ H$H$H\$苒HD$H$HL$ HL$pOH$H$HD$pHD$H H$HD$H6 H$HD$H$8H$H$HD$zHH$HD$aD$DHcH$HH$HD$8#H$H$@TT$H$ H$H$H\$=HL$ HT$H$H$@ttHcH=mHЉIiAEL$ QH$ H$H$HL$H$HT$H\$`H@@t${D$ tOH$H$H$\$:t$;H$0L$L$L$L$HD$`HD$`L$hL\$xML$ M,$M9vLT$PL$$H$HD$D$mHD$HuH$HSHD$`HL$x;H$@H$ H$H$HL$D$HT$PHT$H$HT$ CD$(H$@H$1 HHH|H~HcH=rH~HHD$`HL$xH$hHL$xHH$HHAH$H9|=H$\$:t$;H$0L$IIH$H$H$H$H$H+H$H xHL$HD$H$HH$H H\$xH$HDH$H$CI"L$AL$ L\$xL$H$XH$fHD$H$H$HD$H$H D$t:L$MH$H$H$\$:t$;H$0hHD$xH$H$HĸH*HDŽ$pH$PH$H$H$XH$H$ HL$H$HT$\$HD$ ~HD$(HL$0H$H$H$H$H$t$;H$xHuH$HHH$xH$xH$-HD$H$HL$H$H$HL$D$tH$H$H$HILMILMILMILMHH+LHH?LHH1H$HoHDŽ$H$HĸL$M@HY@HQ8H$H$H$H$H$H$H$H$HD$xHH$/HH$HD$ H$H$HH$HD$ H$H$+HH$HD$bH$H$HH$HD$8#H$HH$H@H$oH\ H$HD$H$H$HTH$HD$H$H$kH/H$HD$HD$xH$HH$HD${H$H$HH$HD$QHHruntime.H9u,Pgopau!P fniuPcu T$hT$,~D$pHl$@HHHD$8HL$0HD$PH$HD$XHD$qD$ui1u1HD$8H$HL$0HL$HHT$HD$ND$ uHD$8H$HD$0HD$\D$^HD$8H$HL$0HL$HHT$HD$ND$ bD$pHl$@HHGhHD$H~1HD$HHruntime.H9u@)Hl$8H@芲HmH$HD$eHH$HD$HD$H$HH$HD$Ż谲NHH$HD$蝻舲H$H\$HH+HH@GO?LIHH"H?H)HbG1RIHH\$HIHH5 ^eYeH %H;aqH`Hl$XHl$X蚔eH%HD$HHH0$T$$HH+H\$hH9HH$cHH HL$01HHH9hHHt$hH9tH|$HLG0ML9tHT$(H\$8HD$PH$D$uHD$PHL$0HT$(Ht$hHD$8H$%D$t"D$$}HD$PHL$0HT$(Ht$h^5HYH$HD$輹觰HD$8H$HD$8HH0HT$HHZ0H9u=H$HD$HD$HD$>HD$PHL$0HT$(Ht$hH$D$%tHD$8蒯HiH$HD$6HD$8H$VHEH$Hl$XH`HL$@@HdH$HD$Ǹ貯HD$@H$H$HD$HD$HD$@HD$[H\$hbrHD$HH !H9u D$H KH9uH (H9uH H9uH JH9uH HtH91HD$H(H H9u  tKH H9u D$H PH9uH %H9uH 2H9ƸeH %H;aJHxHl$pHl$pHXHHD$8H|$@WHHl$Hl$HmH$17HL$(HD$0H$HD$HD$8HD$HD$0HHL$(HH }HHuHD$8HD$8H$Hl$pHxH$1jHL$(HT$ HD$0ѬHH$HD$XHD$ H$HH$HD$1HD$0HHL$(HH }HHuHl$pHxN`eH %H;aH@Hl$8Hl$8HD$HHL$XH1HHD$HH\$PH9HT$H $HD$XHHHzH $OHHD$HD$0HL$HL$(ƫHD$0H$HD$(HD$NY4蟫HH$HD$&HD$XHHHusnHH$HD$HD$HH$藳HkH$HD$δ蹫HD$HHL$XHQ(HHD$`Hl$8H@H $gGHD$HD$(HL$HL$0HT$XHZH\$ ЪHD$0H$HD$(HD$XHH$HD$?HD$ H$qHH$HD$iHjH$HD$֪H*$^eH %H;avsH(Hl$ Hl$ v9H:pHD$HL$0H $GHH$HT$HHl$ H(eH%HH0HH9uHHp]teH %H;aHHHl$@Hl$@H0Hv|HoHL$`HHD$HD$XH$ GHD$HD$(HL$PHL$ HD$0HD$`HD$8HD$ H$FHH$HT$HHl$@HHeH%HH0HH9gH]obHl$@HH! \eH %H;aH Hl$Hl$HD$(H(L$H$HD$H$HD$HL$HT$(Rt.HrD$hHcH$.)HH$HD$` HD$ H$HEH$HD$/:H>HD$@HHL$0HHT$(WHH$HD$ު艣HD$0H${vHH$HD$譪XHD$(H$J襣耡HD$@HHbHD$pHl$PHX1HD$pHl$PHXHL$0HD$(螠HDH$HD$%ТD$hHcH$転HH$HD$ 蝢HD$0H$菨芢HIH$HD$lHD$(H$^蹢蔠H6H$HD$!ە HSH$HD$. SeH %H;av8H Hl$Hl$HD$(H$D$0D$MHD$HD$8Hl$H dSeH %H;aDHPHl$HHl$HHD$XH HH.HH9rHH9sHtyHHH~X\$`1HH9}DHD$eH$H$H$HHT$HrH$\$D\$eHD$ H$HH$HVHt$hH^HD$pH$H9H\$hH$D$DHcHH$st$H5wvH4$H$H|$jHD$HHHL$`H1H$H$HD$YH$H$H$HT$xH$6H4$HD$H$H$H$HD$cH$HqH$H\$HT$HL$Ht$ HD$(HL$0HT$8HVuH˩HHH$RH$HL$PH H $HD$H$HL$PH$HH$Hrj BeH %H$@H;AH@H$8H$8H$HH$(H$PH$0H'pH$H$XH\$H$(Ht$9D$ H$HH$H$PH$ HoH$H$XHT$H$H\$ ?HD$H$HH$PH9 PӃq@8^ \$/T$.H$3HD$H$HL$H$H$PH$HD$HL$H$H9tƄ$`H$8H@H$H$HT$HD$HL$ aD$ tH$HH$OHD$H$H$PH $1HD$H$H H D$.Hg <#<:<H$HH2H$PZ2f9H0Z0f9H$HD$H$HL$HL$HH$PH$fHD$H$HL$HL$81H\$XHSH$HL$8H\$HH9}ZH$HiHl$ H(_W /HD$H@HHHHHeH %H;aH(Hl$ Hl$ HBHD$HJHL$x{HYH$HD$}HD$H$蜃}H-H$HD$΄y}HD$H$k}{H&H$HD$$p A.LLD$H$H|$!HD$ HHL$H91HD$ HD$8HHT$HHH HHL$H$sHL$ueHD$HHHD$8HHT$@HH HHL$H$WsHL$u HD$@H:HD$@H$HL$HD$@HD$HH$HL$HD$@H$HL$HD$@HD$HH$HL$ɸILW&eH %H;aH Hl$Hl$HBHD$H$HD$H$HH$HD$H$*H/H$HD$HD$wHH$ǓHl$H %ceH %H;av)HHl$Hl$HBH@H$Hl$Hs%eH %H;avuH8Hl$0Hl$0HBHJHZHr HR(H@HIHL$H$H\$Ht$HT$ D$(t Hl$0H8H!H$HD$+g $rHD$HH~HHHH}HD$D$eH %H;avHH,$H,$@H,$H%eH %H;av.HHl$Hl$HD$H`H$͵Hl$H$eH %H;av(HHl$Hl$H7H$SHl$H$eH %H;av(HHl$Hl$HBHH$FHl$H#eH %H;aHHl$Hl$HBHD$H H  p$HדH$Hp Hl$H]H$HL$HsJΘ$HD$HH$QE$HnH$uH.J艖HD$HH $EsT"eH %H;aH8Hl$0Hl$0HD$HHH $mHD$H$dHD$HHHHHuD$PHl$0H8HD$(H $lHD$HD$ HL$(H $HD$lHD$ HPH$HD$HD$@HD$'lD$uD$PHl$0H8j"%eH %H;aYH8Hl$0Hl$0HBHD$HJHL$ H$HHT$襚HD$ HXHH`HL$(H $HD$p|HD$tCHiH$@ H$'HD$ H$/HD$HuH6H$HD$(H$HD$|HD$H$HHD$Hl$0H8Ht Hu4H`H$HD$ {H`H$HD${HH$HD$+b O HD$HHHD$eH %H;a%H8Hl$0Hl$0eH%H@0HJHL$ HRHT$(HHD$H91ۈ\$u@H $HT$cD$u Hl$0H8HD$H$HHD$賘H$HHL$虘HD$Hǀ kHuH HHL$ HT$(jH$HHD$vHD$H$&D$HD$HL$ HT$(eH %H;av.HHl$Hl$HBHJH$HL$ eHl$HeH %H;av=H Hl$Hl$HBHJHD$HD$(H$HL$rD$8Hl$H /eH %H;av2HHl$Hl$HBHD$蕕H$HL$HHl$HeH %H;avSH0Hl$(Hl$(HBHD$ H H $HD$H WHL$UHD$HL$ HHl$(H0ieH %H;aH@Hl$8Hl$8eH%H@0JL$HHD$(1XHT$ H\$0HH$H\$HH$HL$0HL$H HL$HD$ HPHD$(L$H@}t u HHuHl$8H@-eH %H;avUH0Hl$(Hl$(HBHD$ HJHZr R!H $H\$@t$T$HD$HL$ HHl$(H0eH %H;aHHHl$@Hl$@HBHD$8HJHL$(RT$$eH%H[0H\$0H$هHD$0H(HIH H H(HAH(HI HҠH H ȠH(H@ D$$tHډHHЉeu@HD$8H$HL$(HL$fD$HD$vHD$8H$Hl$@HHHjH$neH %H;av.HHl$Hl$HBHJH$HL$mHl$HeH %H;av_HHl$Hl$HBHL$ H9u)1u1D$(Hl$HH $趸D$H $SD$HL$ eH %H;avSH(Hl$ Hl$ HBHJHZHR H2HRHv"Ht$H$HL$H\$Hl$ H(A eH %H;ayH`Hl$XHl$XeH%HH0HZHrHzLB DJ(HR0ƁHKLSHI9#Ht$8H|$0LD$(DL$'HT$PHD$@HǀL eLLT$HHH4$脱HD$0H$HD$(HD$HD$HD$8HD$٩D$'umHD$@HH0ƁHHT$PH HǀHǀ euHǀHl$XH`HD$HH$HD$襪HD$8H$腳L$H\$腪Ht$8.@ jeH %H;av@H(Hl$ Hl$ HBHJHRH$HL$HD$HT$ۨHl$ H(eH %H;av@H(Hl$ Hl$ HBHJHRH$HL$HD$HT${Hl$ H(LeH %H;av%HHl$Hl$HBH$&Hl$HeH %H;av4HHl$Hl$HBHD$e7$HL$|Hl$HeH %H;av9H Hl$Hl$HBHD$HJH $-8D$HL$Hl$H ceH %H;av8H Hl$Hl$B$HHD$HD$3Hl$H eH %HD$H;AMHH$H$HBHD$XHJHL$@HH$߁HD$XHL$@HHIH\hHt`H|XIH?H?LHH9HH˘L˘HH|$pHt$hHT$PD aLV(L^(EL˘HF(LDhLL`LTXMYM9DIyH|`aK<ʅu K4.H<$Ht$?HD$XHL$@H H2;H$LT$LL$LD$L\$ uHD$(HL$0HT$8H\$PHt$XHTh!au)HDXHHHt$hIIHD$XHL$@GHD$`HL$HHL$pH $HD$藦HD$`HL$HH\$PHt$XL\$xL$LT$nHD$xH$HD$WHD$XHL$@HT$PHHt$hH|$pHH$H$HĈ; eH %H;aH0Hl$(Hl$(HBHD$ HcJH $)@HD$H$ HD$H$HtHD$D$,_HL$uHD$ HHl$(H0HD$ H$HL$h\eH %H;aHXHl$PHl$PHBHD$(HJHL$1HL҄HH\$8HT$0H4IH|XLD`LLhMI?I?MIM9MHM9hNTLT$@N\D%^EuiJDH|hI9/LL`Ht@5^Hz(u LR(XH<$LT$`HD$(HL$H\$8LT$@1L)LL$ Ht$L$HD$#HD$(HL$HT$0H\$8Ht$LL$ LT$@\HT}H$}HD$0 ^HP(H\$H5|HޘLޘu+Hx(HD$8HޘH}H$9Hl$PHXLD$HH$H|$|HD$HH$HD$8HD$d9 &9 9 eH %H;avKH Hl$Hl$HD$(H$QHD$Hu Hl$H HH$HD$ (S !eH %H;av7H Hl$Hl$HBHJHRH$HL$HT$VHl$H %eH %H;av1HHl$Hl$H%H$HD$jHl$H{eH %H;av(HH,$H,$HD$u H,$H 4eH %H;av3H Hl$Hl$HBHJH$HL$D$言Hl$H IeH %H;aH(Hl$ Hl$ BHD$J HL$[HH$HD$AeHD$H$cHH$HD$eHD$H$cHH$HD$d[H@H$HD$%Q ~9eH %H;av)HHl$Hl$HMH$HD$1P eH %H;aH0Hl$(Hl$(HBHHpHL$ HHT$H@HD$ZH H$HD$#dHD$ H$bHH$HD$cHD$H$bH\H$HD$cHD$H$wbHH$HD$cZHH$HD$ O 9 eH %H;a?H@Hl$8Hl$8HB HJHL$ HZH\$HRHT$H0Ht$(H@HD$0YHH$HD$cHD$ H$aHlH$HD$bHD$H$aHEH$HD$bHD$H$eaHJH$HD$bHD$(H$>aHH$HD$ubHD$0H$aHH$HD$Nb9YHhH$HD$N eH %H;a?H@Hl$8Hl$8HBHJHL$HP8HT$(HXpH\$ H0Ht$H@HD$0*XHZH$HD$aHD$H$S`H H$HD$aHD$(H$,`HH$HD$caHD$ H$`HH$HD$HD$ HL$H$XH$`D$(D$>D$)D$=H$`H$XH$H$D$>D$7D$=D$6D$6uuHT$@H趈Hl$(H0Ð覈Hl$(H0ސ蔈Hl$(H0TeH %H;aHpHl$hHl$hH$HuHD$xH$HD$HD$HHHuW}fH$Hu9HD$HH(H$wHD$HHHHP HXHpH{H9nHSHPH$H$HHHT5u+HDHD$HH(H$Hl$hHpH$HD$+HD$`Ht$XHeH$HL$H\$HT$H|$ kHD$(HL$0HT$8H\$`HS uHCHHHH-HD$PHL$@HL$XH $HD$HD$PHL$@H\$`HH$H$HHXu%HHHDŽ$HDŽ$cH$HL$7Hl$hHpfReH %H;aHHHl$@Hl$@HD$XHD$`HD$PH$HD$HD$(HHHHD$0HL$8HD$(H HPkH@/dHD$0HukHD$0Hu"HD$0HL$8HD$XHL$`Hl$@HHHD$PH@Hu%HD$PHPHH$HL$HD$0HL$8HD$(H(H$HD$(H@HD$ HHD$HD$H}HD$(HHH@HT$H9rHHDH HL$0HD$8HD$(H@ HL$H9vqHD$(HHHD$(H(H$HD$0HuHD$PH$MHD$HL$HL$0HD$8H$HD$#Yx w KPeH %H;aH`Hl$XHl$XHD$pHD$xHD$hH@HD$HD$hHHD$HbH$HD$ ;bHD$0HL$0HT$H9|%HL$ HL$0HAHL$HuHtHHH1HT$HL$HH $HL$HL$PH(H $HL$PHIHL$@HHL$(HL$(H}yHD$PHHH@HT$(H9rHH HDHL$pHD$xHD$PH@ HL$(H9vZHD$PHHHD$PH(H$Hl$XH`HD$PH(H$HL$0HL$8HHL$0v v v {N6eH %H;aHHHl$@Hl$@HD$Xq`H$HD$ HD$PH@HD$HD$PHHD$(HL$ HT$H9r,H$HD$ HD$UHD$HD$8HD$XHl$@HHHD$PH$.HD$HD$0HD$XHl$@HHM;eH %HD$H;AHH$H$HDŽ$_HɘH$HHD$$HcHD$wrM_H$HD$PH$H@HD$HH$HHD$`HL$PHT$HH9r;H$HD$PHD$+HD$HD$xH$賀H$HĠH$HHuH$MHD$HD$@HH$HD$@HD$HD$@HD$HD$ HL$HT$(H$H$H$H$HD$pH$H$HwjHL$HD$pH$ H$HL$@HHH$H$HT$PH9rHHH$H$HĠH]H NH?HYH9BHAH/aH$H4ʅu HH4$H\$H5=!H4$HT$HL$HD$H\$ @HD$(HL$0HT$8HʱuHHkHD$hHL$XH H $HD$~HD$hHL$X͐~H$HĠ'r r JeH %HD$H;AuHH$H$H H HH$H$H$HD$8H$HD$0H$HD$hHD$8HL$0H9|ZHD$hHHD$xHD$8HD$ HD$xHD$XHD$ H HuH9rH ‹HHD$(HD$XHL$(H@H9|_HD$XHH$HD$(HD$HD$HD$`H 2HPH@HD$PHD$`H@HD$HHD$PHL$HH9|pHD$PHD$HL$`HQHIH9rHHHTuHDHD$PHHD$PH$HD$@HD$`H@H@ aHPu%H@HD$(HD$@HHD$(H$HD$H$HD$HD$X u<HHD$XH@HD$hHHD$hHD$8HHD$8H$HD$jH $HD$VH:H$HD$HD$pH$HDŽ$HDŽ$HH  7uHH$HĸH ѭH $HD$n n FieH %H;av(HHl$Hl$H\H$#nHl$HFHHl$Hl$HD$(HD$ HHD$H$HD$(Hl$HeH %H;avIH0Hl$(Hl$(HD$HD$HD$HD$ H$ RHl$(H0FeH %H;avTHHl$Hl$HD$ HAD$ |"HD$ H H$MHl$HEeH %H;aH Hl$Hl$HD$(HAD$|tmJHk(H$HD$!HD$(HAD$t)HD$(HH$D$&Hl$H =tD)eH %H;aH Hl$Hl$HD$(H$HD$(HD$@D$ D$ uGHD$(L$ H D$u"HD$(HH$踐Hl$H CJeH %H;aH0Hl$(Hl$(HD$8@H@D$=@}H"H$HD$ FHD$HD$HcL$H9|/HD$8H H$D$菐HD$HD$ HHD$HD$8H$YHl$(H0C!eH %H;aH Hl$Hl$v<w Hl$H _<tl KD$>uHDŽ$HDŽ$HD$`H@ HL$hH$H$HT$H\$H $HD$HD$XHD$ HL$(H$H$HD$XHD$@H$H$HD$pHL$xHD$@H$HD$pHL$xH$H$H$HH$H$H$HD$HL$HD$HL$ HT$(H$H$H$HDŽ$HDŽ$H$H@ H$H$H$H$HT$H\$Ht$H $HD$ HD$HHD$(HL$0H$H$HD$HHD$PH$H$H$H$HD$PH$H$H$H$H$H$H[?eH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$HD$`HD$hH$H$H$HL$H$H$HD$HL$HD$ HD$(HD$0HD$8HD$PHD$@HL$HHD$`HL$hHD$PHD$XHD$`HL$hHD$pHL$xHD$XH$HD$pHL$xH$H$H$HĈ >eH %H$H;AdHhH$`H$`HDŽ$HDŽ$HDŽ$HDŽ$8HDŽ$@H$H$HH$HD$HL$D$(HL$ HT$H$8H$@D$?H$@H$8H$H$D$?D$<D$H$H$H$H$D$>D$=D$=uHDŽ$HDŽ$H$H@ H$H$H$HT$H\$H $HD$HD$hHD$ HL$(H$H$HD$hHD$pH$H$H$H$HD$pH$H$H$H$H$H$`HhH$HuHDŽ$HDŽ$H$H@ H$H$H$H$HT$H\$Ht$H $HD$ HD$`HD$(HL$0H$H$HD$`HD$HH$H$H$H$HD$HHHD$HH$H$H9vGH$HH$PH$XHDŽ$HDŽ$H$pH@ H$xH$HH$PH$XHT$H\$Ht$H $HD$ HD$XHD$(HL$0H$H$HD$XHD$@H$H$H$H$HD$@H!H$HD$PHL$@HH$H$Hu2H$H$H$H$H$`HhHD$HHL$@H9u HIH JH$H$H$HuxH$H ЛH9u)H$H$H$H$oH$H$H$HD$HHD$FD$u8hHH$HD$HD$HD$HL$ HT$(H$H$H$_ 7weH %H;a0H(Hl$ Hl$ <w Hl$ H(<tfa HH$HD$ ?HD$HL$H  HHoH$HD$ HD$HL$H [ <HLHH$HD$蹽HD$HL$HrH ٙHH$HD$vHD$HL$H/H Hc1H$HD$+3HD$HL$H%H sHH$HD$HD$HL$HH HH$HD$譼HD$HL$H<furH 1HH$HD$nHD$HL$H'uH s~Hl$ H(HH$HL$HH$HL$HH$HL$)HPH$HL$jHfH$HL$PoHH$HL$6H H $HD$H H $HD$X84eH %H;aHXHl$PHl$PHDŽ$Ƅ$HD$hHD$0HL$xH$H9|HDŽ$Ƅ$Hl$PHXHD$pHL$hHT$`H\$xH9vkH)HHH?H!HHD$8H)HL$@Ht$HH$HL$Ht$H$HD$9HD$ HD$(H$Ƅ$Hl$PHX0[ )3eH %H;aH Hl$Hl$HD$HHD$@HD$HvHt(HD$0HL$(HwHD$HHl$H Ht\HD$0HwRHD$(HL$0Hw4HL$0HT$(HwJHH HD$HHl$H HtHD$0HwHD$0HL$(HwxHL$0HT$(Hw^JHH HL$0HT$(Hw<JHH HL$0HT$(HwJHH HD$HHl$H PKFAHtHD$0HwHD$0HL$(HwHL$0HT$(HwJHH HL$(HT$0HwIHH HL$0HT$(HwJHH HL$0HT$(HwwJH H HL$(HT$0HwXIH(H HL$0HT$(Hw9JH0H HL$0HT$(HwJH8H HD$HHl$H   $W W W W W W W W HH$HHD$h 0eH %H$ H;AH`H$XH$XHDŽ$HDŽ$HDŽ$HDŽ$HDŽ$H$pHD$PHDŽ$H$Hu?H$pH$H H$pH$xH$hH$HD$HL$HD$H$D$ D$GH$HD$HD$GD$BD$BuH$pH$HL$HH9wOHD$PH$H$H$H$H$H$H$H$XH`HD$HH$xH$hH9vSH$H$H$ HD$HH$xH$pH$hH9v H)HHH?H!HH$hH)H$pH$xH$H$H$ H $HD$HT$HD$H$D$ D$FH$HD$`D$FD$BD$BuOHD$`HtH$ H$H$H$HL$HD$HD$H$D$ D$EH$HD$XD$ED$BD$BuH$H$HL$XHH9wiH$pH$HL$PH)HL$pH$H$H$H$H$H$H$H$XH`HD$XHHH$H$H$ HsH9v HKHHH?HHH$(H$0H$8H$(H$0H$8H$@H$HH$PHDŽ$H$HHD$xH$@H$H$HL$xH9|iH$D$DH$HD$hD$DD$Ct HD$hH$8H9vIH$0H$(H$0H$H$HtHw<.tH$(H$0H$H$HtkHw_HwPf=..tH$H$HH$H$H$HH$H$H$(H$0H$8HD$HL$HT$YHD$ HL$(H$H$H$H$H$HYH9THQH$H$H$HH\uH4u HdH4$HT$茻H5SH4$HD$HL$HT$H\$ HD$(HL$0HT$8H$H$h]T^H$HH$H$HH$)'KHc>9P Q Q Q Q (eH %HD$H;AHH$H$H YH$HD$HD$HD$HD$ t}HHYH ZHCH$H$H$HD$HH$HD$`H$HD$pHD$HHL$`H9|HD$pHHHH$H$HD$HHD$@H$H$HL$xH$HD$8H$HD$XHL$8H9|HD$8HL$xH$H9r<=tIHD$8HL$xH$H9vzH$H$HWH$H uHL$H$H$HL$HT$_D$(D$7D$6D$6u~HD$@H ՍH֍H9rHHDHru2HHD$pHHD$pHD$HHHD$HqH$HD$EHVH$H HL$H$H$HL$HT$pHD$ HD$hHL$@HyHD$8HD$PHHD$8Y]H$HH 7H $HD$豷twM M iM %eH %HD$H;AHH$H$HDŽ$HDŽ$Ƅ$H*qH$H_;HD$H$HD$PHt6HDŽ$HDŽ$Ƅ$YH$HĠHRqH$HBqHD$$H:HD$EOHUH$HHD$H$H$HL$HD$]HD$ HD$pD$(D$7HD$pHHD$HHD$8D$7D$6D$6uHHD$8H -H.H9rHHTHHD$xH$HD$@H$HD$hHL$@H9|HD$xH$HT$@H9r!<=tuHD$@HHD$`H$HT$xH9vH)HHH?H!HH$H$H$H$Ƅ$pWH$HĠHD$@HD$XHHD$@0HDŽ$HDŽ$Ƅ$!WH$HĠHDŽ$HDŽ$Ƅ$VH$HĠÐVH$HĠJ IJ BJ "eH %H;av8H8Hl$0Hl$0HD$@H$HD$HD$Hl$0H8T"eH %H;aRHxHl$pHl$pHDŽ$HDŽ$HD$`HD$hH$H$HD$HD$HD$HD$HHD$(HL$ HL$`HD$hHD$HHD$0HD$hHL$`H$H$H$Hu Hl$pHx$uyHD$0HD$@HHD$0HD$PHD$XH$H$HD$HD$0HD$NHD$ HL$(HD$PHL$XH$H$Hl$pHxHD$0HD$8HHD$0 HHl$Hl$HD$ H$H$HD$HtHD$ Hl$HHD$HHHD$ Hl$HeH %H;aH`Hl$XHl$XHD$pHD$xHD$hH|yHD$hHH$HD$HL$HL$HHD$PH$H#HD$HD$HD$HHL$PHD$HL$ HD$(HL$0HD$pHL$xHl$XH`HD$hH$:HD$HL$HD$8HL$@HD$pHL$xHl$XH`}eH %HD$H;AHH$H$HDŽ$HDŽ$HD$HHD$PHD$XHD$`HD$0H$H s}HL$0H$HHHHHHH)HS0H rT HHL$0HL$@HHL$0H$HL$8HHHH$sHD$0H$H0H rLHHD$HHD$0H v}HHHHHH?H!HDHHD$hHT$pHT$xH$HD$xHL$pHT$hHT$HL$HD$HD$ HL$(H$H$H$HĈE @E 9E -eH %HD$H;AjHH$H$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$HD$0H$HD$PHL$0H9|H$HL$0H$H9rtRHDŽ$HDŽ$HDŽ$Hz5H$HH$H$HİHD$0HD$HHHD$0PH$HD$@HHD$8HH$HD$8HD$HD$8HD$qHD$HL$(HT$ HD$xH$H$HD$xH$H$H$H$H$H$H$HD$hHL$pH$HD$`HL$pH9HD$pHD$`HD$`HD$XH$H$HD$hHD$HD$XHD$?MHD$xH$H$H$H$H$HDŽ$HDŽ$H$HİwB teH %HD$H;A}HH$H$HDŽ$HDŽ$HDŽ$HD$pHD$xHDŽ$HD$HHD$PH$H$H$HL$HD$HL$HT$ HD$pHL$xH$HD$(HL$0HD$HHL$PHD$pHL$xH$HD$XHL$`HT$hHD$HHL$PHD$8HL$@HD$8Hu6HDŽ$HD$8HL$@H$H$H$HĐHD$XHL$`Hw0H$HDŽ$HDŽ$H$HĐ@ faeH %HD$H;A HH$H$HDŽ$HDŽ$HDŽ$HD$PHD$PHD$`HD$XHD$hHD$pH$H$H$H$H$HD$HT$HL$HD$XHD$ 1HD$(HD$@HD$0HL$8HD$hHL$pHD$@HD$HHD$hHL$pHD$xH$HD$HH$HD$xH$H$H$H$HĐ#eH %H$XH;AH(H$ H$ HDŽ$0HDŽ$8HDŽ$@HDŽ$HHwH$HD$HD$̲HD$HL$ HT$(H$H$H$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$HIH$HD$HHD$D$H$H$H$HT$(HD$0HL$8HD$@HD$HHL$XHT$PH$H$H$HD$hHL$`H$H$H$H$H$H$H$H$H$H$H$H$H$HuJHDŽ$0HDŽ$8H.H$@HvH$HH$ H(H$HD$xHt`H$H$Hw`H@HD$pH}-H$H$Hw+HHPH@HL$HT$HD$H$WHD$ HL$(H$H$HwHD$@HD$HD$>D$?HD$HHD$xD$?$Hl$PHXJeH %H;aHXHl$PHl$PHD$xƄ$HD$hHL$`HT$pH $HD$HT$HD$HD$ HD$(HD$@D$0D$>HD$@HD$HD$>D$?HD$HHD$xD$?$Hl$PHXJeH %H;aHXHl$PHl$PHD$xƄ$HD$hHL$`HT$pH $HD$HT$HD$HD$ HD$(HD$@D$0D$>HD$@HD$HD$>D$?HD$HHD$xD$?$Hl$PHXJeH %H$H;AHH$xH$xHDŽ$HDŽ$HDŽ$HDŽ$HDŽ$H$H$H|HH$HD$~HD$HL$H$ H$(HDŽ$HDŽ$HDŽ$H$(H$ H$H$H$xHĀfDŽ$HDŽ$HDŽ$HDŽ$HDŽ$H$H$H $HD$HD$H$HD$ HL$H$H$H$H$H$H$H$H$H$Hu4HDŽ$HDŽ$HDŽ$H$xHĀH$H$H$H$H$H$H$H$Hw^H$H$H$HD$H$HD$H$HD$H$HD$ H$HD$(HD$0SHD$HH$HD$pHD$pHuHD$pH$H'H$H$HD$xrHD$HL$H$H$HDŽ$HDŽ$HDŽ$H$H$H$H$H$xHĀH$H$Hw%D$TH$H$H$H$HH$PH$XH$H$L$TH9|H$XL$TH9vH$PH$XH$PH$HHs|HHHH?HHH$HHAH$PH$XD$\H$PH$L$\H9|H$HH$PH$X\$\H9vH)HHH?H!HH$0H)H$8H$@H$H|SH4H$HD$+HD$HL$H$H$H$H$H$xHĀH$0H$8Hw>D$dH$0H$8HwHH@D$hD$d|UHH$HD$$耓HD$HL$H$H$H$H$H$xHĀH$PHD$xL$dL$h9wD$dD$hD$`H$HH$XHc\$dH9v>H9v2H)HHH?H!HH$`H)H$hH$pH$H$H$HYH9HQH$H$`H$hH$pH IH\HtHȋ5-WuCHD$`D$\D$XuD$\D$lL$X)ȃD$\PH$HT$蘜H5_}H4$HD$HL$HT$H\$ HD$(HL$0HT$8H$H$%H$xHĀ}p2 1 1 [2 T2 M2 1 1 8 CeH %H;aHPHl$HHl$HHD$pHD$xHD$`HD$0Hu"H"HD$pH`HD$xHl$HHPHD$8HD$@H$HD$(HD$HD$ HD$HL$HL$8HD$@HD$(HL$XHT$`Hw>HHD$ HL$XHT$`Hw"HAHD$8HL$@HD$pHL$xHl$HHP0 ' eH %H;aH`Hl$XHl$XHD$pHD$xHD$hHjrHD$hHjrHH aHHDHT$8HD$@HuHT$pHD$xHl$XH`HD$hH$HD$HL$HL$HHD$PH$HHD$HD$HD$HHL$PHD$HL$ ZHD$0HL$(HL$pHD$xHl$XH`/ eH %H;a)H8Hl$0Hl$0HD$HHD$PHD$@HD$ HvHtHD$HHD$PHl$0H8Ht$H*H HL$HHD$PHl$0H8HD$@HD$(H" H$HD$(HD$jHD$HL$HL$HHD$PHl$0H8Ht$HH HD$HHL$PHl$0H8H#t$HdH eHD$HHL$PHl$0H8_eH %H;aHXHl$PHl$PHDŽ$HDŽ$HDŽ$HD$@HD$HHD$`H$HD$xHL$pHT$hHT$HL$HD$M HD$ HD$8HD$0HL$(HL$@HD$HHD$8H$HD$HHL$@H$H$Hl$PHX eH %H;aHXHl$PHl$PHDŽ$HDŽ$HDŽ$HD$@HD$HHD$`H$HD$xHL$pHT$hHT$HL$HD$KHD$ HD$8HD$0HL$(HL$@HD$HHD$8H$HD$HHL$@H$H$Hl$PHXeH %H;aH`Hl$XHl$XHDŽ$HDŽ$HDŽ$H$\HD$hHD$HD$pHD$HD$xHD$HD$ HD$PHD$0HD$HHD$PHD$8HD$HHD$@HD$8H$HD$@Hu4HD$@H$!HD$HL$H$H$Hl$XH`eH %H;aHpHl$hHl$hHD$xHDŽ$HDŽ$HDŽ$H$*HD$HD$HD$HD$ HD$`HD$(HD$XHD$0HD$PHD$`HD$@HD$XHD$8HD$PHD$HHD$@HD$xHD$8H$HD$HHu4HD$HH$HD$HL$H$H$Hl$hHpeH %H;aJHxHl$pHl$pHDŽ$HDŽ$HD$HHD$XHD$`HD$hH$H$H $HD$EHD$HD$XHD$HL$ HD$`HL$hHD$XHD$HHD$`HL$hH$H$H$Hu Hl$pHxHD$HHD$PH$HD$PHD$$HD$HD$THD$0HD$@HD$8HD$8Hu4HD$8H$HD$HL$H$H$Hl$pHx^eH %H;aHPHl$HHl$HHD$`HD$hH$HD$XHD$HD$HD$HD$0HD$@HD$8HD$8Hu.HD$8H$HD$HL$HL$`HD$hHl$HHPOeH %H;avAH@Hl$8Hl$8H$HD$HHD$HD$HD$Hl$8H@;eH %H;aHXHl$PHl$PHD$pHD$xHD$hHD$HH$SHD$`HD$HD$HHD$HD$iHD$0HD$@HD$8HD$8Hu.HD$8H$HD$HL$HL$pHD$xHl$PHXyDeH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$HDŽ$H$HD$hHH$H$HwH$H$HD$`H$H$H$XH$HD$H$HD$HD$`HD$H$HD$ HD$(HD$0yHD$8HD$xHD$HHD$pHD$xHD$PHD$pHD$XHD$PH$HD$XHu:HD$XH$HD$HL$H$H$H$HĘHeIH$c% WeH %H;a^HHl$xHl$xHDŽ$HDŽ$HD$HHD$`HD$hHD$pH$H$H $HD$BHD$HD$`HD$ HL$HL$hHD$pHD$`HD$HHD$hHL$pH$H$H$Hu Hl$xHĀHD$HHD$XH$HD$PH$THD$XHD$HD$PHD$HD$C HD$0HD$@HD$8HD$8Hu7HD$8H$zHD$HL$H$H$Hl$xHĀJeH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$HD$XHD$`HD$pHD$xH$H$H$HL$HD$HD$`HD$HL$ HD$pHL$xHD$`HD$XHD$pHL$xH$H$H$HuH$HĈHD$XHD$hH$HD$hHD$H$HD$$HD$ HD$ HD$PHD$0HD$HHD$PHD$8HD$HHD$@HD$8H$HD$@Hu:HD$@H$HD$HL$H$H$H$HĈIeH %HD$H;AwHH$H$HDŽ$HDŽ$HDŽ$HDŽ$H$HD$hHH$H$HwH$H$HD$`H$H$HD$H$HD$HD$`HD$H$HD$ HD$(HD$0 HD$8HD$xHD$HHD$pHD$xHD$PHD$pHD$XHD$PH$HD$XHu:HD$XH$:HD$HL$H$H$H$HĐHDH$  geH %H;a=HxHl$pHl$pHDŽ$HDŽ$HDŽ$HD$hH$HD$XHH$H$HwHD$hH$HD$PH$H$HD$HD$hHD$HD$PHD$HD$ HD$HHD$0HD$`HD$HHD$8HD$`HD$@HD$8H$HD$@Hu4HD$@H$HD$HL$H$H$Hl$pHxH!CHD$h=" eH %H;aH`Hl$XHl$XHDŽ$HDŽ$HDŽ$H$HD$hHD$HD$pHD$HD$xHD$HD$ HD$PHD$0HD$HHD$PHD$8HD$HHD$@HD$8H$HD$@Hu4HD$@H$HD$HL$H$H$Hl$XH`eH %H;a^HHl$xHl$xHDŽ$HDŽ$HD$HHD$`HD$hHD$pH$H$H $HD$HD$HD$`HD$ HL$HL$hHD$pHD$`HD$HHD$hHL$pH$H$H$Hu Hl$xHĀHD$HHD$XH$HD$PH$RHD$XHD$HD$PHD$HD$HD$0HD$@HD$8HD$8Hu7HD$8H$:HD$HL$H$H$Hl$xHĀ eH %H;a=HxHl$pHl$pHDŽ$HDŽ$HDŽ$HD$hH$HD$XHH$H$HwHD$hH$HD$PH$H$HD$HD$hHD$HD$PHD$HD$ HD$HHD$0HD$`HD$HHD$8HD$`HD$@HD$8H$HD$@Hu4HD$@H$HD$HL$H$H$Hl$pHxHA?HD$h=B eH %H;aHxHl$pHl$pHDŽ$HDŽ$HDŽ$H$H$HD$H$HD$H$HD$H$HD$ H$HD$(H$HD$0HD$8HD$hHD$HHD$`HD$hHD$PHD$`HD$XHD$PH$HD$XHu4HD$XH$HD$HL$H$H$Hl$pHxeH %H;aHPHl$HHl$HHD$hHD$pH$IHD$XHD$HD$`HD$HD$HD$0HD$@HD$8HD$8Hu.HD$8H$HD$HL$HL$hHD$pHl$HHPNeH %H;a$H0Hl$(Hl$(;<w Hl$(H0;<t :H~H$HL$HT$H!XH "X ,=HWH$,HD$H<H)H$HD$HD$HD$HD$ <uHuC:Hl$(H0H [H $HD$UH lWH $HD$>`t;H|$Ht$HT$ E1E1E1HD$HsHD$(HD$0HD$8蘱HD$(HT$0HD$8ˬH|$Ht$HT$ LT$(LD$0LL$8HD$HsHD$@HD$HHD$P"HD$@HT$HHD$P H|$Ht$HT$ E1E1E1HD$HsHD$(HD$0HD$8HD$(HT$0HD$8eH %H;avwH0Hl$(Hl$(HY HujHD$@HD$HHD$8Hu;HD$8HH$HD$HL$HL$HD$ HL$@HD$HHl$(H0 pH|$8H9;uH#eH %H;aH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$HD$HD$8HD$0HH$HD$8HD$HD$VHD$HD$8HD$@Hl$ H(ceH %H;av{H8Hl$0Hl$0D$PHD$@HL$H f9tLHD$@HHD$(HD$HHHD$HD$(H$HD$ D$D$'D$PHl$0H8QleH %H;aH8Hl$0Hl$0HD$PHD$(HD$ jHD$(HL$ H9|AHD$(HD$HHD$@H$HD$HHD$KuHD$HD$HHD$(HHD$(HD$HHD$PHl$0H8ReH %H;aHhHl$`Hl$`Ƅ$HD$8HD$0jHD$8HL$0H9|HD$8HD$(HHD$pHH@HL$PHD$XHD$(HHD$xHHHHD$@HL$HHD$XH9uƄ$Hl$`HhHD$PHL$XH$HL$HD$@HL$HHD$HL$ D$ uHD$8HHD$8>Ƅ$Hl$`HhxHHl$Hl$D$0HD$(HD$HtD$0Hl$HHD$(HL$ HwD$<D$0Hl$H eH %H$H;A5HhH$`H$`HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$HD$8H$xHD$pHL$8H9|2HD$8H$xH$pH9r4HD$@H$H4~TH0~eH-to H$xHD$XHL$8HH9}H HD$8HHD$PHL$8H$xH$pH9v H9v H)HHH?H!H H$H$Ht Hw Hw Hw Hw  =-070t Hwp Hw` D f=00tK Hw; D <0tHD$8H$xH$pH9vH$H$HD$8HHD$HH$xH$pH9vH)HHH?H!HH$H$H$H$H$H$HDŽ$H$H$H$H$H$`Hh11H$xH$HL$8H H9}HD$8H H$HL$8H$xH$pH9vH9vH)HHH?H!H H$PH$XH tHwHwuHweHwUHwEHw5Hw%HwH H-07:00:0H9tHwD <0tHD$8H$xH$pH9vH$@H$HHD$8H H$H$xH$pH9vH)HHH?H!HH$0H$8H$HH$@H$H$HDŽ$H$8H$0H$H$H$`Hh//H$xH$HL$8HH9}HD$8HH$HL$8H$xH$pH9vH9vH)HHH?H!H H$ H$(HtRHwCHw3Hw#Hw =-070tHwD <0tH$xH$pHT$8H9vH$H$HD$8HH$pH$xH$pH9vH)HHH?H!HH$H$H$H$H$H$HDŽ$H$H$H$H$H$`Hh--H$xH$hHL$8HH9}HD$8HH$`H$xH$pH\$8H9vH9vH)HHH?H!HH$H$HtYHwJHw:Hw*Hw=-07:tHwHwDf=00tH$xH$pHT$8H9vH$H$HD$8HH$XH$pH$xH9vH)HHH?H!HH$H$H$H$H$H$HDŽ$H$H$H$H$H$`Hh++H$xH$PHL$8HH9}HD$8HH$HH$xH$pH\$8H9vH9vH)HHH?H!HH$H$HtTHwEHw5f=-0t$HwD<7tH$xH$pHT$8H9vH$H$HD$8HH$@H$xH$pH9vH)HHH?H!HH$H$H$H$H$H$HDŽ$H$H$H$H$H$`Hh**HD$8H$HHD$8G)))))))))))))))))))))))))))))H-07:00:0s)n)H-07:00:0h)^)Y)O)J)E)@)=)8)uH.tH$xH$HL$8HH9|H$xH$pHT$8HZH9rD <0tBH$xH$pHT$8HZH9r'D D$#HD$8HHD$0H$xH$HL$0H9|H$xH$pHT$0H9rx'L$#8tHD$0H$HHD$0H$xH$pH $HD$HD$0HD$_D$D$'uH-07:00:0rHD$( H$xH$pHT$8HZH9r&D <9tHD$(!HD$(H$HL$0HT$8HH)HH HD$(H$xH$pHT$8H9vH$H$H$xH$pHT$0H9vH)HHH?H!HH$`H$hH$H$H$H$HD$(H$H$hH$`H$H$H$`Hh%%cH$pH$xHT$8HZH9rD<9tg%~%H0tH$xH$HL$8HH9}H$xH$pHT$8HZH9rD <1sH$xH$pHT$8HZH9raD <6v@H$xH$pHT$8H9vH$pH$xHD$8HH$H$xH$pH9vH)HHH?H!HH$`H$hH$pH$xHT$8HZH9rDψD$&HrsH HH$H$xH$pH$H$H$H$H$hH$`H$H$H$`Hh%%%%H-07:00:0$$H-07:00:0H2~H1t"H$xH$HL$8HH9}H$xH$pHT$8HZH9ro$D <5tH$pHL$8H$xH9vH$PH$XHD$8HH$H$xH$pH9vH)HHH?H!HH$@H$HH$XH$PH$H$HDŽ$ H$HH$@H$H$H$`Hh}#x#H$pH$xHT$8H9vH$0H$8HD$8HH$H$xH$pH9vH)HHH?H!HH$ H$(H$0H$8H$H$HDŽ$H$ H$(H$H$H$`Hh""H2tH$xH$HL$8HH9}HD$8HH$HL$8H$xH$pH9vZH9vKH)HHH?H!H H$H$HtHwHwHwHw =2006tHD$8H$xH$pH9vH$H$HD$8HH$H$xH$pH9vH)HHH?H!HH$H$H$H$H$H$HDŽ$H$H$H$H$H$`Hh HD$8H$xH$pH9vH$H$HD$8HH$H$xH$pH9vH)HHH?H!HH$H$H$H$H$H$HDŽ$H$H$H$H$H$`HhH3tHD$8H$xH$pH9vH$pH$xHD$8HH$H$xH$pH9vH)HHH?H!HH$`H$hH$xH$pH$H$HDŽ$ H$hH$`H$H$H$`HhH4tHD$8H$pH$xH9vH$PH$XHD$8HH$H$xH$pH9vH)HHH?H!HH$@H$HH$XH$PH$H$HDŽ$ H$HH$@H$H$H$`HhHM~ H5tHD$8H$xH$pH9vH$0H$8HD$8HH$H$xH$pH9vH)HHH?H!HH$ H$(H$8H$0H$H$HDŽ$H$(H$ H$H$H$`HhHJtH$xH$HL$8HH9}ZHD$8HH$xHL$8H$xH$pH9v%H9vH)HHH?H!H H$H$HtHwHw f=JatHwD Hw.D   0 )          s   ^   I   4       s l  ^  P I B ; 4  &        ~ w  i  [     8  *    ~  p  b  TOeH %HD$H;AcHH$H$HDŽ$ HDŽ$(HDŽ$0H$HL$HH$H|H$H$H$HrH9HJH$-H$HHL$HHDŽ$HDŽ$HDŽ$HD$XHL$HH seHL$XHL$`HHL$XHL$HHHHHT$PHL$XH\$HH0HHH)Hr+ HL$PHL$HHD$XH$HHD$XHD$XHL$HH0HrHD$XHHHD$@HD$@H$H9|H$H$H$HYH9*HAH$ 0HD$@HD$xHHD$@H5AH4$HT$HL$HD$H\$ DOHT$(HL$0HD$8H$H$H$HD$XHvHHHHHH?H!HH$H$H$H$H$H$H$H$H$H$HHD$pH$H9w%H@H$H$H$H$HT$HL$HD$HD$pHD$ BNHD$0HL$8HT$(H$H$H$H$HL$pH9vH$H$HD$hH$H$HH$H$HD$HD$hHD$XH$H$H$H$H$H$H$ H$(H$0H$HT@MH>H$H\$HT$HL$Ht$ 3MH\$(HT$0HD$8H$H$:W ^ W {eH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$ H$HL$@HD$HDŽ$HD$H HL$HHqHL$HHL$XHHL$HHL$HHT$@HHHHHHH)HS0H rXT HL$@HL$PHHHHT$@H$H  HDŽ$ $uH$HH$HHH rHL$D<0tH$HD$pHH$H$Ht@H$H$H$H$H$H$ H$HH$H$H$HXH9HPH$.HD$H$H vH$H$HDŽ$ H$H$H$H$H$H$H$HHD$hH$H9w%H;H$H$H$H$HL$HD$HT$HD$hHD$ JHD$0HL$8HT$(H$H$H$H$HL$hH9vH$H$HD$`H$H$HH$H$HD$HD$`HD$H$H$H$H$H$H$H$H$H$ H$H^@WH5:H4$HL$HD$HT$H\$ HHL$(HD$0HT$8H$H$s   weH %HD$H;AHH$H$HDŽ$HDŽ$H$H$H$H$HL$HT$H}HD$HD$ 'HD$0HL$(H$H$H$H?H?HugH$HL$PD$G+H$H|>D$G-HL$PHHL$PHL$PHH6A_pHHH$HL$PHHH6A_pHHHHiʚ;H)H$H$HL$XH$HL$PHL$XHH6A_pHHHT$xHL$XHHH6A_pHHHHiʚ;H)H\$pHL$xHL$`HL$pHL$XHDŽ$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$HD$hH$HrH8H$H$H$H$HL$HD$HT$HD$hHD$ 9FHD$0HL$8HT$(H$H$H$HD$hH$H9vH$H$H$HH$H2HD$HD$^H$H$H$H$H$H$HYH9HAH$D$G HD$HHD$`HuH$H$H$H$HL$HD$HD$`HD$HD$ HD$8HL$0HT$(H$H$H$HD$H H$H$H$H$HL$HT$HD$XHD$HD$HHD$ 2HD$(HL$0HT$8H$H$H$HYH9THQH$.H$H$H$H$HL$HT$HD$PHD$HD$ HD$(HL$0HT$8H$H$H$H$H$H$H$H$H$H$H$HD$HL$HT$qHD$ HL$(HD$HL$ H$H$H$HD$HL$V~HD$(HL$0H$H$H$H$H$H$H$HH54H4$HD$HL$HT$H\$ BHD$(HL$0HT$8H$H$hH5f4H4$HT$HL$HD$H\$ BHT$(HL$0HD$8H$H$p,A :eH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$H$HD$`H HD$XHD$XH@|9H|$hWHl$Hl$HmHD$hH$HDŽ$HDŽ$@H$H$H$H$HL$HT$H$H$H$HT$HD$ HL$(H$H$HD$0HL$8HD$@HL$HHT$PH$H$H$H$H$H$H$HD$HL$HT$}HD$ HL$(H$H$H$HH/2H$HD$HD$XHD$?HD$HL$ HT$(H$H$H$eH %H$ H;AA%H`H$XH$XHDŽ$HDŽ$HDŽ$HDŽ$XHDŽ$`H$hH$pH$xH$HL$HT$7MHD$ HL$H$XH$`HD$(H$HD$0H$H$`H$XH$H$H$HD$xH$H$HD$XHDŽ$HDŽ$HDŽ$HDŽ$HD$pH$Hu#HDŽ$HHDŽ$PHDŽ$8HDŽ$@H$H$H $HD$RHD$HL$H$HH$PHD$ H$HD$(HL$0H$8H$@H$PH$HH$H$H$HD$hH$@H$8H$H$H$Hu"H$H$H$H$@H$HH$PH$HH$@H$PH9wd"H&/H$H$PH$HH$@H\$HT$HL$H$@HL$ I=HD$(HL$8HT$0H$@H$HH$PH$@H$PH9v)"H$HH$H$8H$H$@HH$H$HD$H$8HD$VH$PH$HH$@H$H$H$HL$hHtBH$H$H$H$H$H$H$XH`H$H$H$H$HL$XH| HL$hr H$H$D$^HD$H$HD$H$HD$ H$xH$HD$XH$H$H$xH$H$H|E HL$h r. H$H$KHD$H$pHD$H$hHD$H$`H$pH$H$hH$H$`HD$pL$hH$0H~MH~H~ HtH$HujH$H$H$H$hH$pH$xH$HH$H$xH9wH+H$H$hH$pH$xHL$HT$H\$H$HL$ :HD$(HL$0HT$8H$hH$pH$xH$H$xH9vH$pH$H$H$hH$HH$H$HD$H$HD$#H$hH$pH$xH$H$H$hXHL$xHHHHH?H)HT$PH|H$H$H$HrH92HZH$-HL$PHHL$PHL$PHHHHH?H)HT$H$H$H$H $HT$H\$HD$ HL$(HT$0H\$8H$H$H$HL$PHHHHHH?H)HkoH$H$H$H$H$H$HAH$H$H9wH H$H$H$H$HL$HT$H\$H$HL$ HD$(HL$0HT$8H$H$H$H$H$H9vH$H$H$HH$H3HD$HD$H$H$H$H$H$H$q 2 ަ צ Ц ɦ ¦ 軦 账 警 覦 ~HHl$Hl$D$8HD$(HD$HL$0H9~D$8Hl$HHD$(HL$ HT$0H9rD$< D$8Hl$H譥 HXHl$PHl$PHD$pHD$xHDŽ$HDŽ$HDŽ$HD$HD$hHD$HL$H9|HD$HL$hHT$`H9rD$HЀ whHD$hHL$`HT$H9vRH)HHH?H!HHD$0H\$8HD$xH$HDŽ$HDŽ$Hl$PHXHL$pH H9ZHXH YHD$ HL$(HD$pHD$xHDŽ$HD$(HL$ H$H$Hl$PHXHL$pH HDHHD$pH|ZHH HL$@HD$HHD$pHD$xHDŽ$HD$@HL$HH$H$Hl$PHXHD$HD$HHD$T  蔣 HHHl$@Hl$@HD$`WD$hHD$pHD$xHD$ED$hD$HD$XHD$ HL$H9|HD$HL$PHT$XH9rD$HЀ wMHD$XHL$HT$PH9vH)HHH?H!H HD$0H\$8HD$pH\$xHl$@HHL$uHD$HD$(HHD$KHL$`H H9D$HL$`H HDHHD$H|D$HD$`D$hD$ YYD$h&苢  eH %H$H;A9HH$H$HDŽ$HDŽ$HDŽ$ H$H$H$H$HDŽ$D$\H$Hup H$H$Hw D$]<-t6 <-D$\H$H$Hs] HHHH?HHH$H$H$Ht H$H$Hw <0t4HDŽ$HDŽ$HDŽ$ H$HH$HtH$Ht;HD$HD$H$H$HL$HD$ OHD$0HL$(H $HD$HD$HL$H$H$HDŽ$H$H$H$H$ H$HH$HuM HD$`HDŽ$D$pHDŽ$ HDŽ$(H$H$Hw <.t H$H$HDŽ$HDŽ$HDŽ$HDŽ$H$H$H $HD$bHD$H$HD$HL$ H$H$HD$0HL$(H$H$H$HD$`H$H$H$H$H$H$H$ H$(H$ HuH$HU9HD$HD$H$H$HD$HL$ MHD$(HL$0H$HL$HD$HL$H$H$HDŽ$H$H$H$H$ H$HH$H$H$H9D$YD$ZH$Hu(H$H$Hw <.tH$H$HsX HHHH?HHH$H$HT$xHDŽ$HDŽ$H$H$H$HL$OHD$H$D$$HD$ HL$(H$H$H$H$$D$pH$H$H$H$H$H$HL$xH9D$ZD$Yu#HDŽ$H$H$H$H9|H$H$H$H9rD$^<.tH$HtH$HOHD$HD$H$H$HD$HL$ KHD$(HL$0H$HL$ HD$HL$H$pH$xHDŽ$H$pH$xH$H$ H$HH$H$H$H9vH$H$H$H$H$H9vH)HHH?H!HH$H$HH$H HL$H$H$HL$HT$GHD$ H$D$(D$_H$HH$HD$hD$_D$[D$[uHL$`HT$hHu HHHtHHH1H9H$H4HD$HD$H$H$HD$HL$ 9IHD$(HL$0H$HL$1HD$HL$H$PH$XHDŽ$H$PH$XH$H$ H$HHD$`H$HL$hHHD$`H$HHD$`H$H$HT$hD$pWH*WH*^YH,HHD$`HD$`H|H$H3HD$HD$H$H$HD$HL$ HHD$(HL$0H$HL$HD$HL$H$@H$HHDŽ$H$@H$HH$H$ H$HH$H$HL$`HH$H$H|H$H2HD$HD$H$H$HD$HL$ 0GHD$(HL$0H$HL$(HD$HL$H$0H$8HDŽ$H$0H$8H$H$ H$HVH$H3#HD$HD$H$H$HD$HL$ H HD$(HD$0 H$H$HD$8HL$@+GHD$HHL$PH$HL$CHD$HL$H$`H$hHDŽ$H$`H$hH$H$ H$HÃ< vkH$H$HH$FD$ZuH$H0HD$HD$H$H$HD$HL$ \EHD$(HL$0H$HL$THD$HL$H$H$HDŽ$H$H$H$H$ H$HH$H$Hw< vH$H0HD$HD$H$H$HL$HD$ ~DHD$(HL$0H$HL$vHD$HL$H$H$HDŽ$H$H$H$H$ H$HD$\uMH$HH$H$H$HDŽ$HDŽ$ H$H<+tݔ f _  Q ړ ӓ ̓ 5 输 'leH %H;aH(Hl$ Hl$ HD$8HD$0H~EH$HD$HD$8Hl$ H((H$HD$HL$0HHD$HD$H|%HHD$HD$HD$8Hl$ H(zkUeH %H;avnH Hl$Hl$D$0HD$(H@ Hu+HD$(HH$hD$D$D$0Hl$H H H$HHD$蕣 jyeH %H;aTH8Hl$0Hl$0HD$PHD$@H$HD$HD$HD$HHD$(H]5H$H|$H|$ rWHl$Hl$HmHD$ HL$HHHD$ 3HP u~H HH HD$ HL$(H HP(HX0u:HH0HD$ HD$HD$HH$чHD$HD$PHl$0H8H$HL$oH$H*HD$XwH\4H$H|$)tieH %H;av]H Hl$Hl$HD$(HL$0H H9t$HL$2Hl$H H$HT$Hp{HD$& heH %HqHH$pH)H=}H H$H$HDŽ$8HDŽ$@HDŽ$HHDŽ$PHDŽ$XHDŽ$HDŽ$H$0H$(H $HD$HD$D$kHD$ HD$PHD$0HL$(H$H$HD$PHD$HH$H$H$xH$H$xHuZHDŽ$8HDŽ$@HDŽ$HH$H$xH$PH$XnH$H HD$HHD$$H>}HD$謑H|$x1HHDŽ$HDŽ$HDŽ$HD$@HD$xH$HDŽ$HDŽ$HDŽ$HDŽ$HD$HH$H$H$H$HD$HL$HT$_HD$ HD$pHD$(HL$0H$H$HD$pHD$@H$H$H$xH$HD$@HHD$xHL$@HvH$H$HDŽ$H$H$H$H$H$H$H$HHD$`H$H9w:H^ H$H$H$H$HL$HT$H\$HL$`HL$ HD$(HL$0HT$8H$H$H$HD$`H$H9vH$H$HD$XH$H$HH$H$HD$HD$XHD$蚖H$H$H$H$H$H$HD$@HtjH$H$H$H$8H$@H$HH$H$xH$PH$X2H$H H$xHuH$HD$hH=H$(H$0H$H$HDŽ$8HDŽ$@HDŽ$HH|H$H$HD$HD$HL$H$PH$XvH$H i"+IH$H 4 -cHeH %H;aHpHl$hHl$hHDŽ$HDŽ$HDŽ$HD$XHD$`H$HL$xH $HD$HD$D$]fHD$ HD$@HD$(HL$0HD$XHL$`HD$@HD$8HD$XHL$`HD$HHL$PHD$HHu0HDŽ$HD$HHL$PH$H$Hl$hHpHD$8H$HDŽ$HDŽ$Hl$hHpaeH %H;av&H Hl$Hl$HD$(H$e`Hl$H aeH %HD$H;AHH$H$HDŽ$HDŽ$HD$8H$H|kHD$8HD$xHDŽ$H$H$H$HD$HD$8HD$viHD$(HL$ HL$xH$HL$hHD$pHD$hHu*HD$hHL$pH$H$H$HİH$HD$HHHDŽ$HDŽ$H$H$H$H$H$HD$HL$HT$YHD$ HD$PHD$(HL$0H$H$HD$PHD$@H$H$HD$XHL$`HD$@H~HD$XHu*HD$XHL$`H$H$H$HİHoH$HD$ HD$HL$H$H$H$H$H$HİHD$@H$H$H$H9vdH)HHH?H!HH$H)H$H$^HDŽ$HDŽ$H$HİɆ ^D$HD$Hu:HD$H@H :H9uHD$HHD$D$HD$HH%?D$HD$HD$HH?H?Hu$HD$HHHH HHD$HD$H@HD$eH %H;avKH Hl$Hl$HD$0HD$(H$lHD$HD$H nHHD$0Hl$H ]eH %H;aH(Hl$ Hl$ HD$0HH?H?HuHD$0HHHHD$HD$8HD$HH9v9HL$0HT$0HH?HH HH HHl$ H(HD$0H$HHD$0H@HD$HL$0HT$8HHAHl$ H(\ eH %H;avzH(Hl$ Hl$ HD$0HH?H?HuNHD$0H$HD$HD$HL$0HAHD$0HHD$HL$0H%?HHl$ H([meH %H;aH0Hl$(Hl$(D$hHD$8HL$PH#H?H?HuHD$@HL$XH9D$hHl$(H0HD$8H$HD$HD$ HD$PH$HD$HD$HL$ H9L$hHl$(H0HL$ H9t;HD$8H$D$D$HD$PH$D$D$L$9ZeH %H;aH@Hl$8Hl$8D$xHD$HHL$`H#H?H?HuHD$PHL$hH9D$xHl$8H@HD$HH$HD$HD$0HD$`H$HD$HD$(HL$0H9|D$xHl$8H@HD$HH$HD$HD$ HD$`H$HD$HD$HL$ H9tHL$HAH$H$HL$8HT$0H9r0H$HD$PHl$ H(HL$HHwrH $HL$HH $HL$0HT$8H$Ht$HHHHHHHH)֍V0H9r,HL$HHL$HHHHT$Hh,o %o HD$HD$HD$HHl$Hl$WD$(HL$ HRZ/DHHH?H)H$HL$ HRZ/DHHHH?H)Hiʚ;H)H\$H $WH*WH*^XD$(Hl$HeH %H;aHHHl$@Hl$@HD$pHD$xHDŽ$HL$hHRZ/DHHH?H)HT$(HL$PH $L$L$HT$hHRZ/DHHHHH?H)Hiʚ;H)L$L$ʚ;}HD$(HD$8HHD$(D$D$6eĉD$HD$PH%HcL$H HD$PHD$PH$HL$(HL$PHD$PH?H?HuHD$XHD$hHD$ HL$hH|rHL$XH9?HD$PH$HD$PHL$XHT$`HD$pHL$xH$Hl$@HHHL$hHHL$XH9|HD$X몋D$|*HD$(HD$0HHD$(D$D$ʚ;D$DeH %HD$H;A HH$H$HDŽ$H$H$H#H?H?HuH$HD$PH$HD$HHL$PH)HL$`H|HD$PHT$HH9"HH$H$HĘHMHD$PHT$HH9|"HH$H$HĘH$H$HĘH$H$^HD$HD$pH$H$CHD$HD$hH$H$D$D$@H$H$D$D$DHL$pH+L$hT$@Hiʚ;)HcHHD$XH$H$H$H$HL$HT$HD$XHD$ HD$ HL$(HT$0HD$xH$H$HD$xH$H$HL$HT$H$H$H$HD$HL$ HT$(D$0D$?uHD$XH$H$HĘH$H$H$H$HL$HT$H$H$H$HD$HL$ HT$(ED$0D$>u$HH$H$HĘHH$H$HĘAeH %H;aH`Hl$XHl$XHDŽ$nH$HL$HT$HD$@HL$HHT$PHD$@HL$HH$HL$HT$HD$hHL$pHT$xHD$HL$ HT$(FHD$0HD$8H$Hl$XH`@PeH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$HDŽ$H$HJrE.HHHT$0H#HHHT$ HiҐHT$HL$0H$HT$ Hiұ:H)HL$0HL$0HHZHHHT$ H$HL$ HH)HT$ HL$H$HT$ HkdHHL$HL$0H$HT$ HiҬH)HL$0HL$0Hф"/fHHHH HL$ HL$HL$xHT$ H HL$HL$0HL$pHT$ HiҵH)HL$0HL$0H7q`gHHHHHL$ HL$hHT$ HH)HL$ HL$HL$`HT$ HHL$HL$0HL$XHT$ HimH)HL$0HAHL$H$HL$0H$$uH$H$H$9D$D$ubH$H;H$HL$PHH$H$H !B!HHHH?H)H$HJH rHu_DHcHD$(HD$8H$HL$(H9}dH$HD$HHH$HD$(HD$8H$HD$@HH$H$H+D$8HH$H$HĨH$H rhH ^HcHD$8H$H;t*HDŽ$HDŽ$H$HĨH$HĨd d =eH %H;aHHl$xHl$xHDŽ$HDŽ$HDŽ$#wH$HD$@D$D$HD$HD$8HD$@HD$ D$D$HD$8HD$(HD$ HD$0wHHD$ HD$ H!HutHD$`HD$hHD$pHcD$HD$`H HD$ HD$hH=HD$pHL$`HT$hH$H$H$Hl$xHĀHD$HHD$PHD$XHD$ HHcL$H HH HL$HHD$(HD$PHO=HD$XHL$HHT$PH$H$H$Hl$xHĀV;QH Hl$Hl$HD$8HD$@HD$HH$HD$HD$HcD$0H$HwHD$(HD$H<HD$H $HT$HL$8HT$@HD$HHl$H eH %H;av>H Hl$Hl$HD$@HD$(H$HD$HD$HD$@Hl$H n:eH %H;avfH(Hl$ Hl$ HD$HHD$0H$LHD$HD$HD$0H$D$D$HL$Hiʚ;HcHHD$HHl$ H(9eH %H;aSHpHl$hHl$hHDŽ$HDŽ$HDŽ$H$Hʚ;s H$HRZ/DHHH?H)HT$(HL$xHL$HHT$(HHL$xH$HL$@HT$(Hiʚ;H)H$H$H|H$HD$8Hʚ;H$HD$xHD$0HHD$xHD$xH$H$D$xHD$HL$HT$ HD$PHL$XHT$`HD$PHL$XH$H$H$Hl$hHpu8D$HL$HH?H>HHHH)HtuHL$H ףp= ףHHHHH?H)HkdH)Hu L$HT$H ףp= ףHHHHHH?H)HiҐH)HeH %H;aHHl$Hl$HD$(HD$ HuGHD$ H H9t2HPH$HMHD$HD$ HD$(Hl$HHHD$(Hl$H(7ceH %H;avUH Hl$Hl$HD$0HD$8HD$(H$#HD$HD$HH@HL$0HD$8Hl$H 6eH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$Ƅ$HDŽ$HDŽ$H$H$lHD$H$H@HD$HHtcHBH$HDŽ$HDŽ$Ƅ$HH$HH$H$HĈH$H@PHD$XHuH$HI@H$H9~H$H$HIHH9|zHHHH$H$HD$XH@H$HD$X@$H$H@@H$H$H@HH$H$HĈH$H@0HD$@HtH$H$HD$HD$8H$HQHIH9rHHHD$`HD$`HH@H$H$HD$`H@H$HD$`@$HH$H$H@0HD$0H9H$HH0H@(Hw!HH$H$HĈHH$H$H$HP0H@(HwHH9|H$HH8HP0H@(HD$hHT$pHL$xHH$HD$HD$pHD$(HD$(H+D$HyHD$(H+D$HH?H?HHHD$HD$HL$pHT$hH9rHHHD$ H$H9|H$HD$HD$(HD$HD$H$HHH@HT$hH\$Ht$pH9rHTH9rHH HL$PHLHH$H$HD$PH@H$HD$P@$HD$pHL$hHT$H9r.HHH$H$HĈ dY ]Y VY OY HY AY 1eH %H;aHPHl$HHl$HHD$`HD$XH$D$D$uHD$XH@0HD$@HpHD$XHL$XHPH@HY0HI(HwFIH9r6HDuHD$XHH0H@(Hw2@HHD$HD$H}WHD$XHHH@HT$H9rHDuHD$HD$8HHD$HD$HD$`Hl$HHPHD$0HD$XH@HD$(HD$0HL$(H9|RHD$0HD$ HL$XHQHIH9reHHDuHD$0HHD$0HT$`Hl$HHPHD$`Hl$HHPh,*HD$`Hl$HHP@W 9W 2W +W /HXHl$PHl$PD$hHD$`HH8HP0H@(HD$8HT$@HL$HHD$HD$@H$HD$8HD$0HD$H $H9|HD$0HPX @ HL$ T$(\$)D$*HL$ T$(\$)HL$T$\$D$D$tD$hHl$PHXHD$0HHD$0HD$HHD$jD$hHl$PHXeH %H;aHPHl$HHl$HHD$hHD$pH$HHD$HD$ HD$XHL$`HD$HL$ HoHD$(HD$0 HD$8HL$@HD$hHL$pHl$HHP-ZeH %H;aH8Hl$0Hl$0HD$PHD$XHD$`HD$@H@HD$HL$HH9|pHD$@H@H@ [yu;HHD$@@HD$PHD$XHD$`Hl$0H8H$HD$ʾHD$@HHHHT$HH9vHD$HT$ HL$(HD$@HHHH@H\$HH9vnHt$@H)HNH)HF xHH?H!Hu/HHD$HL$ HT$(HD$PHL$XHT$`Hl$0H8H4$HD$GT @T 9,deH %H;a HXHl$PHl$PD$hD$lHD$`H$HD$HD$ HL$HT$HT$8HL$@HD$HHL$0H|"HD$`@D$hD$lHl$PHXHD$@HL$8HwqHL$8HT$@HwWI HL$8HT$@Hw:I HL$@HT$8HwJ ȉD$,D$hD$lHl$PHXR +eH %H;aHPHl$HHl$HD$`D$aHD$XH$HD$HD$ HL$HT$HT$0HL$8HD$@HL$(H|HD$X@D$`D$aHl$HHPHD$8HL$0HwD$`D$aHl$HHPQ ?*:eH %H;abHhHl$`Hl$`HDŽ$HDŽ$HD$0HD$xHD$@HL$0H9|HD$xHL$0HT$pH9r t|HD$0HL$pH$H9vHL$HHD$PHT$XH$HD$HHL$PHT$XHD$HL$HT$XHD$ HL$(H$H$Hl$`HhHD$0HD$8HHD$0/H$HD$xHL$pH$HL$HD$HT$HD$(HL$ H$H$Hl$`HhP MP (eH %H$H;AHH$H$HDŽ$HDŽ$HDŽ$HDŽ$`HDŽ$hHDŽ$pƄ$xH$H$H$H$`H$hH$pƄ$xH$`H$HD$ HD$ HL$HT$H$xH$H$H$H$Hu\H܌H ͌H$H$HDŽ$H$H$H$H$H$HĈHwHwHwHw=TZifukHDŽ$`HDŽ$hHDŽ$pH$`H$HD$HD$ HL$HT$H$`H$hH$pH$Hu\HȋH ɋH$H$HDŽ$H$H$H$H$H$HĈH$hH$`HwuH$hH$`Hw<2uH$`H$hHwh<3u2H$0WHHl$Hl$/QHmHDŽ$H$H|H$`H$9D$D$dD$ D$OD$dD$PD$OD$GD$GuEH$L$PHr1HH0H$H$HH$jH8H )H$H$HDŽ$H$H$H$H$H$HĈH$HHHD$H$`H$HD$ HL$HT$H$H$H$HDŽ$@HDŽ$HHDŽ$PƄ$XH$H$H$H$@H$HH$PƄ$XH$HHD$H$`H$HD$ HL$HT$H$0H$8H$@H$PH@HHD$H$`H$HD$ HL$HT$H$H$H$HDŽ$ HDŽ$(HDŽ$0Ƅ$8H$H$H$H$ H$(H$0Ƅ$8H$XHD$H$`H$ HD$HL$ HT$H$H$H$H$@HHD$H$`H$H$8HD$H$`H$HD$ HL$HT$H$H$H$H$0HD$H$`H$aHD$ HL$HT$H$H$H$$xuZH=H .H$H$HDŽ$H$H$H$H$H$HĈH$PH$H$PHD$H2H$H$HD$証HD$ HL$(HT$H$H$ H$(HDŽ$H$ H$H$H$H9|cH$HD$xD$FD$TH$ H$D$D$`D$ D$ND$`D$TD$ND$FD$FuHD$xH$ H$Hc\$TH9r HH\D$HH$ H$kD$D$MD$ D$LD$MD$HD$LD$FD$FuH$ H$HT$x\$HH9r H\H$ H$D$D$KD$ D$JD$KD$HD$JD$FD$FufH$H$L$HH9}\HH لH$H$HDŽ$H$H$H$H$H$HĈH$H$H$\$HH9v H)HHH?H!HH$H)H$H$H$HT$Ht$HD$ HL$H$H$HT$xH$H$ H9r HHDH5ju"H H$HH$LH$HL$!HH H$H$HDŽ$H$H$H$H$H$HĈHAH 2H$H$HDŽ$H$H$H$H$H$HĈH$HH$H$HHD$HjH$H$HD$謸HD$(HL$HT$ H$HH$PH$XHDŽ$H$PH$H$H$H9|H$HD$pD$ED$XH$@H$D$D$\D$ D$ID$\D$XD$ID$ED$Eu"HD$pH$HH$PHc\$XH9rwHHH$ H$HL$pH$0H$8H9r9 H9}ZHH H$hH$pHDŽ$H$hH$pH$H$H$HĈHD$pH$0H$8H9r<HT$pH$HH$PH9rHDH$H$HL$pH9|HD$pH$H$H9rHT$pH$HH$PH9rHD H$H$HL$pH9|oHD$pH$H$H9rNHT$pH$HH$PH9r$HD H$HH$}xxsdpkHH H$xH$HDŽ$H$xH$H$H$H$HĈH$PH$HtHDŽ$ Ƅ$(fDŽ$)HH$ Ƅ$(H$HH$PH$XHYH9 HQH$PH$ $($)$*HH\@t @| HH$解HD$H$` Re|HHxWHHl$Hl$DHmH$`H$H$ H$(HPHX dHXHHH$`H$HH$PH$XHP0HX8dHX(HH(H$`H$RH$H$HD$hHDŽ$H$PH$H$H$H9|H$H$H$HH$PH9rHHHL$hH9~H$PH$H$HH9taH$H$HH$PH9rpH$HHHB@H$HHHHH$PH$H$HH9|H$HH$PH$HH9rH$HHHBHH$HPH@H$H$HH$PH9rrH\H9r]H$5bHxPHHڅu$HPPH$HH$HH<$HT$OH/*SHD$hH$HH$PH$HH9r%HH H9|fHqHDŽ$HDŽ$H$HĈH$HL$覧HH$HL$蓧H H $HD$٭H5bH4$HD$HL$HT$H\$ HD$(HL$0HT$8H$XH$Hxqjomki< < < < < < < < < < = < < < x< q< %eH %H$hH;A`HH$H$HDŽ$@HDŽ$HHDŽ$PH$(HD$XHH$(HD$PHHD$HH$ H$(H9vH)HHH?H!HH$H$HtHwHw}HwpHwc=.ziptHD$xHDŽ$HDŽ$H$ H$(H$HL$H$8H$0HL$HD$HD$ HD$xHD$0HL$(H$H$HD$xHD$`H$H$H$H$HD$`H$@H$H$H$HH$PH$HH$(HuSH$H$ H$(HD$HL$H̚HD$HD$ H$0H$8HD$(HL$0HD$8HL$@H$0H$8HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$H$0H$8H$HL$!HD$HL$HT$ H$H$H$HD$(HL$0H$H$H$H$H$H$H$H$H$H$H$HH$PH$HHuH$HHD$hHDŽ$HDŽ$H$H$H$H$HL$HT$UHD$HD$hHD$ HL$(H$H$HD$hHD$pH$H$H$H$HD$pH$@H$H$H$HH$PH$H 7 W8 P{HHl$Hl$HD$0HD$ H$H|HD$0Hl$HHD$ HL$HwoHL$ HT$HwXJHH HL$HT$ Hw9IHH HL$HT$ HwIHH HD$0Hl$H 7 HHl$Hl$HD$0HD$ H$H|HD$0Hl$HHD$ HL$Hw1HL$ HT$HwJHH HD$0Hl$Hz6 eH %H$H;AHH$H$HDŽ$HDŽ$HDŽ$HDŽ$0HDŽ$8H$H$H $HD$4HD$H$HD$ HL$H$0H$8H$H$H$0H$8H$H$H$HuH$H@ H$H $HD$HL$H$ H$(H$HHD$HD$H$H$HD$HL$ HݕHD$(HD$0H$(H$ HL$8HD$@LHD$PHL$HH $HD$dHD$HL$H$H$HDŽ$H$H$H$H$@H$HİH$HD$$H=#HD$#7OHDŽ$ HDŽ$HDŽ$H$ H$XHDŽ$`HDŽ$hH$H$H$hH$`H$XHT$HL$HD$HD$ xHD$0HL$(H$@H$HHuH$HHD$HD$H$H$HL$HD$ HD$(HL$0H$HL$ΒHD$HL$H$H$HDŽ$H$H$H$H$R?H$HİH$hH$`H$XH$HL$HD$HD$H$H=PKu H$hH$`H$XH sHHHH?H HH$HH$H$H$HL$H\$ HD$H$H$hH$`H$XH suHHHH?H HH$xHH$H$H$HL$H\$HD$HD$`H$`H$hH$XHsHHHH?HHH$`HH$hH$pH $HD$H\$gHD$HD$pHf H$HD$`HD$HD$`HD$蹤HD$(HL$ HT$H$XH$`H$hH$H$H$hH$`H$XHT$HL$HD$HD$pHD$ pHD$(HL$0H$`H$hHuH$HHD$HD$H$H$HL$HD$ HD$0HL$(H $HD$ȏHD$HL$H$H$HDŽ$H$H$H$H$L@>V/H$HİA# :# 3# ,# %# # # # # # " " " " " eH %HD$H;AHH$H$HDŽ$HDŽ$H"H$HD$HD$HL$H$H$D$ D$?H$H$HL$`HD$hD$?D$>D$>uHD$hHuHD$hHuXHD$XHDŽ$HDŽ$HD$`HL$hH$HL$HD$HD$XHD$HL$ H$H$HD$XHD$@H$H$HD$pHL$xHD$pHuWHbYEu"HHbH$HHbH$H]HD$׊HD$@ Eu<HH bHpH=bHl$Hl$'HmH$HH ~H $H FbHL$HD$NjHD$`HL$hHw]HL$`HT$hHwCI f=UTunHD$`HL$hHw@$HWHvH$HD$nyHD$HL$H }W '>HnWHH$HD$+yHD$HL$H JW =jH;WHz"H$HD$HD$HD$HD$ H$HpzH$HDŽ$HD$8H"H$H$HD$H$H$HL$HD$;HD$ HD$hHL$8HHzH$HDŽ$HD$8H!H$H$HD$H$H$HL$HD$o;HD$ HD$`HL$8HH&zH$HDŽ$HD$8H@!H$H$HD$H$H$HL$HD$;HD$ HD$XHL$8HHyH$HDŽ$HD$8H H$H$HD$H$H$HD$HL$:HD$ HD$PHL$8HHxH$HDŽ$HD$8@BHb H$H$HD$H$H$HD$HL$":HD$ HD$HHL$8HHwH$HDŽ$HD$8ʚ;HH$H$HD$H$H$HD$HL$9HD$ HD$@HL$8HH8wH$HDŽ$HXG HD$8H~H$H$HD$H$H$HD$HL$>9HD$ HD$xHL$8HHvH$HDŽ$H0FHD$8H H$H$HD$H$H$HD$HL$8HD$ HD$pHL$8HH$ :sHOHH$HD$ uHD$HL$H:S9H +SHmH$HD$tHD$HL$HR9H RH$HL$H$H$H$H$H$HD$HL$HHD$HD$ 4HD$(HL$0H 6 8u"H5{6H$HİH 5H $HD$~HRH$HL$k~8HRH$HL$Q~H }NH $HD$7~~H QH $HD$~H QH $HD$~*H oQH $HD$} eH %H;avwH0Hl$(Hl$(HY HujHD$@HD$HHD$8Hu;HD$8HH$yHD$HL$HL$HD$ HL$@HD$HHl$(H0 pH|$8H9;uH#eH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$sHD$HD$8HD$0HH$HD$8HD$HD$ SHD$HD$8HD$@Hl$ H(peH %H;aHPHl$HHl$HD$hHD$XHHHHD$8HL$@HD$`HHHHD$(HL$0HD$@H9tHD$8HL$@H$HL$HD$(HL$0HD$HL$ D$ uIHD$XH@HL$`HIH9u'HD$X@HL$`I8D$hHl$HHP eH %H;avQH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$ HD$HD$8HD$@Hl$ H({eH %H;avUH8Hl$0Hl$0D$PHD$@HD$(HD$HHD$HD$(H$HD$ D$D$'D$PHl$0H8eH %H;avwH0Hl$(Hl$(HY HujHD$@HD$HHD$8Hu;HD$8HH$)HD$HL$HL$HD$ HL$@HD$HHl$(H0 upH|$8H9;uH#eH %H;aH@Hl$8Hl$8HY Hu|HD$PHD$XHD$HHuMHD$HHHPH@H $HT$HD$;HD$ HL$HL$(HD$0HL$PHD$XHl$8H@& ZH|$HH9;vH#neH %H;avwH0Hl$(Hl$(HY HujHD$@HD$HHD$8Hu;HD$8HH$蹐HD$HL$HL$HD$ HL$@HD$HHl$(H0| pH|$8H9;uH#eH %H;aH8Hl$0Hl$0HY HusHD$HHD$PHD$@HuDHD$@HHHH$HL$HD$HL$HD$ HL$(HD$HHL$PHl$0H8 hcH|$@H9;uH#{eH %H;aH8Hl$0Hl$0HD$PHD$(HD$ HD$(HL$ H9|AHD$(HD$HHD$@H$HD$HHD$[nHD$HD$HHD$(HHD$(HD$HHD$PHl$0H8ReH %H;aHhHl$`Hl$`Ƅ$HD$8HD$0 HD$8HL$0H9|HD$8HD$(HHD$pHH@HL$PHD$XHD$(HHD$xHHHHD$@HL$HHD$XH9uƄ$Hl$`HhHD$PHL$XH$HL$HD$@HL$HHD$HL$D$ uHD$8HHD$8>Ƅ$Hl$`HheH %H;aH8Hl$0Hl$0HD$PHD$(HD$ HD$(HL$ H9|AHD$(HD$HHD$@H$HD$HHD$lHD$HD$HHD$(HHD$(HD$HHD$PHl$0H8ReH %H;aHhHl$`Hl$`Ƅ$HD$8HD$0HD$8HL$0H9|HD$8HD$(HHD$pHH@HL$PHD$XHD$(HHD$xHHHHD$@HL$HHD$XH9uƄ$Hl$`HhHD$PHL$XH$HL$HD$@HL$HHD$HL$D$ uHD$8HHD$8>Ƅ$Hl$`HhHD$HD$D$uHEH EHL$HD$HEH EHD$HL$HD$HD$H|HD$HD$ eH %H;aH0Hl$(Hl$(D$@HL$8H HL$rD$@Hl$(H0HHL$ Ht5HT$8HD$H L$uD$@Hl$(H0H"n H$HHD$ vAeH %H;a]HHHl$@Hl$@D$XHL$PH HL$rD$XHl$@HHHHHL$ HHL$8HH!HL$ HL$PHD$H\$ HL$uHD$HHu-HD$HD$0HHD$HD$PHH$f.HD$HHu4HD$HD$(HHHD$HD$PH H$.D$XHl$@HHHl H$H,HD$ eH %H;aH0Hl$(Hl$(D$@HL$8H HL$HtOHHL$ HT$8HD$H L$u HD$ H%HD$@Hl$(H0Hk H$H}HD$ D$@D$ D$@D$8rD$@D$ D$@Hl$(H0:eH %H;aHhHl$`Hl$`HDŽ$HDŽ$HD$pHL$xH$HL$HD$HL$HL$PHD$X$$D$D$,HD$PHL$XH$HL$D$,D$褔HD$HL$ HD$@HL$HHD$@HuH*H$q!HD$HD$0H@ H "HHD$0HL$pHT$xHPHXunHHHD$0HL$@HT$HHH HX(u3HP(HD$0HD$8H H$H$Hl$`HhH$HT$2(H$HL$"(H$H"HD$ (EHDŽ$HDŽ$Hl$`HhHD$ HD$(HD$HuHD$ HD$(HH HL$ HD$(HD$HD$ HD$HL$HD$HL$ eH %H;avWH8Hl$0Hl$0HD$XHD$@H$HD$PHL$HHL$HD$D$#HD$ HD$(HD$XHl$0H8%eH %H;avHHl$xHl$xHDŽ$H$HD$0H|HDŽ$Hl$xHĀH +H$HD$HD$@H2H$H|$H|$PWHHl$Hl$HmHD$PHL$0HHHD$P@(HD$P@)HD$PH$H$HH8 HX0JHP0HD$@HL$PHHD$@HD$8HH$H*HD$HD$$D$HD$(HL$ HL$hHD$pHu]HĤHD$HHD$8HH ~ H $HD$HD$HH HL$HD$yHD$8H$Hl$xHĀ$uIHD$0H$D$pHD$HL$HL$XHD$`Hu `HD$8H@HH$HL$$H$HT$v$H:H$H|$*6蒒meH %H;aHH,$H,$HD$HuwHD$H@H H9t\HD$ HH tHHD$HH@HtH,$HHD$HH@HtבReH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$D$:H$ r$rHDŽ$HDŽ$H$H$H $HD$%HD$(HL$ H$H$HL$hHD$pHD$pHL$hH $HD$D$D$;u D$:HD$@HD$xHDŽ$$$D$D$4 WrH|$8H9;uH#eH %H;avWH Hl$Hl$HY HuGD$0HD$(Hu(HD$($8D$D$D$0Hl$H 3 UWH|$(H9;uH#eH %H;aH Hl$Hl$HD$8HD$(H$HD$0HD$~HD$HD$0HD$(HH$HD$0HD$XHD$HD$0HD$(H H$HD$0HD$2HD$HD$0HD$(H0H$HD$0HD$ HD$HD$0HD$8Hl$H nV)eH %HD$H;AbHH$H$Ƅ$H$HHHH$H$H$HHHHD$xH$H$H9tH$H$H $HD$HD$xH$HD$HL$tuD$ uH$HHH@HL$hHD$pH$HHH@HL$XHD$`HL$pH9tYHD$hHL$pH$HL$HD$XHL$`HD$HL$tD$ uH$HH H@(HL$HHD$PH$HH H@(HL$8HD$@HL$PH9tHD$HHL$PH$HL$HD$8HL$@HD$HL$ntD$ uH$HH0H@8HL$(HD$0H$HH0H@8H$H$HD$(H9t@H $H$HD$HD$0HD$cD$$H$Hİc`IS|eH %H;aH Hl$Hl$HD$8HD$(H$HD$0HD$HD$HD$0HD$(HH$HD$0HD$HD$HD$0HD$(H H$HD$0HD$HD$HD$0HD$8Hl$H $SOeH %HD$H;AHH$H$Ƅ$H$HHHHD$xH$H$HH@HL$hHD$pH$H9tQH$HL$xH $HD$HD$hHL$pHD$HL$0rD$ u H$HHH@HL$XHD$`H$HHH@HL$HHD$PHL$`H9tHD$XHL$`H$HL$HD$HHL$PHD$HL$qD$ uH$HH H@(HL$8HD$@H$HH H@(HL$(HD$0HD$8H9t=H $HD$0HD$HD$@HD$D$$H$HĐli4QeH %H;avnH Hl$Hl$HD$8HD$(H$HD$0HD$bHD$HD$0HD$(HH$HD$0HD$D$D$!ĖHl$XH`GD$HL$H !#D$D$eH %H;avRHH,$H,$<w H,$Hؐ<tq ĐH,$HJG̋D$L$ D$\$L$T$1ЉD$T$ eH %H;avUH(Hl$ Hl$ HD$@HD$0H@H$HD$8HD$HD$-HD$HD$8HD$@Hl$ H(FeH %H;av]H8Hl$0Hl$0D$PHD$@H@HD$(HD$HH@HD$HD$(H$HD$eD$D$'D$PHl$0H8/FWD$L$f.wD$ fD$L$f.u {D$D$D$eH %H;avxH(Hl$ Hl$ WD$8HD$HD$0H};HHD$HD$H$D$D$D$8Hl$ H(HHD$4EoeH %H;avFH Hl$Hl$WD$(HH$D$D$D$(Hl$H DD$HD$D$D$WD$HD$D$D$HD$HD$HD$HD$WD$HD$D$D$eH %H;av_HH,$H,$<w H,$Hm<t-n Y?H@H,$HCH\$HHH!HH9$fHn [f/$ Y-*Y\]Y\Y UYX QYX MYX IYX MYX YYX ]YX qY }XY mXY ]XY MXYX%~/}/4HfHnYD$HH9u1HD$HH\$H0Hl$(Hl$(D$PHD$XHD$@HD$ H|D$PHD$XHl$(H0HD$@HL$8HwD$H D$HD$(HL$xH$H9r3$E D$D$#uHD$(H|HD$(H$HL$xHT$(H\$8H9vH9vH)HHH?H!HHL$XHD$`H $HD$D$D$$HD$HD$PD$$$HD$PH$HD$(H$HL$8H9u!DŽ$HDŽ$Hl$hHpHl$hHp,*3HD$(HD$@HHD$(_ _ _ k7HD$D$| HD$ËD$~ HD$ËD$=~ HD$ËD$(=v HD$ËD$=~ HD$ËD$=~ HD$HD$HHl$Hl$HD$8D$0D$v/HD$ HL$T$0HwPHD$8Hl$HÉvgHD$ HwHD$ HL$T$0HwHD$ HL$T$0?ʀHwQHD$8Hl$HÉwD$0HD$ HwHD$ HL$T$0 Hw\HD$ HL$T$0?ʀHw1QHD$ HL$T$0?ʀHwQHD$8Hl$HÉ(vU=vOHD$ HwHD$HL$ T$0HwHD$HL$ T$0 ?ʀHwePHD$ HL$T$0?ʀHwH$H$CHD$HD$(H$H HH@HH!H9tHD$XHHD$(HD$0HD$PHHD$0H$H$H\$0H+XHJHH@HH!HH9}H$HHH@HH!H#D$(HtH$H@HD$0i5 b5 H Hl$Hl$WD$@D$HHD$(H HH@HHu Hl$H HD$(H}WH*D$@D$8u @fD$@HD$0HtD$HHl$H HD$0HH$vHD$0HD$@D$HH HT$0HZH9r:PYD$@HD$0D$@ f.w Hl$H D$@ f.wD$@H HL$0H H9r YD$D$@D$HHl$H zHD$0HHrHD$@HH HT$0HH9rR ^$D$@D$HHl$H Hl$H HHHH WH*X=,3 %3 3 HHl$Hl$WD$8D$<HD$ H HH@HHu Hl$HHD$ H}WH*D$8D$0u fD$8HD$(HtD$<Hl$HHD$(HHvHD$(H D$8D$ H?H 0HT$(HZH9r6LYD$8HD$( D$8 X.w Hl$HD$8 ?.wD$8HHL$(HH9r YD$D$8D$<Hl$H|HD$(H H rID$8HfH WHT$(HH9rS ^D$D$8D$<Hl$HHl$HHHHH WH*XA0 0 0 eH %H$XH;AXH(H$ H$ W$@HDŽ$HHDŽ$PH$8H$0H $HD$D$$D$D$C$D$PD$CD$7D$7uAD$PZD$H$@HDŽ$HHDŽ$PH$ H( unH$8H$0H $HD$bHD$H$HD$H$D$ D$BD$!D$AD$"D$@H$HD$XH$HD$`D$BD$;D$AD$4D$@D$9D$9uD$4u3HDŽ$HDŽ$Ƅ$H$H$H$HD$XHD$HD$`HD$D$;D$D$4D$HHD$ GD$(D$8uH$H$HjHD$=HD$H$D$D$>H$HD$hD$>D$5HD$h$7D$$@D$5uiHCH$HD$ H$8H$0HL$HD$J HD$ H$H FH$HH$PH$ H(HDŽ$H$WHHl$Hl$0HmH$H$H$8H$0HL$HD$D$D$=uH$H$HHD$HD$HD$xD$D$D$!D$=D$"D$D$7D$=D$0D$H$H$HT$XH9rD$?HЀ vЈD$>D$>H$8s,HD$HHYH YH$H$HD$HHL$`H9s,HD$HHYH YH$H$HD$HHD$xH$HHD$HD$>HD$HHD$@HL$HH9r.HD$HHSYH DYH$H$HL$PH9wHD$HHD$XHD$pHHD$XHvD$>HvɈD$>HD$HHXH XH$H$HD$HH$HDŽ$HDŽ$H$HHtHHD$`H$Hu(HH1HHPHT$`H$HtMH$H$Hw,0tH$H$HH$H$HwSxt]H$H$H|#HWH WH$H$RHDŽ$HD$XH$H$Hw\SXtH$H$Hw0tHDŽ$HD$XHDŽ$ H$H$߇HD$HL$H$H$H$HHD$HD$ H$H$HL$HD$ HD$0HL$(H $HD$xHD$HL$H$H$    eH %H$xH;AHH$H$HDŽ$0HDŽ$8HDŽ$@H$(HtHDŽ$(@H$HD$pHtH H$HD$H$H$HL$HD$HD$ H$H H$H$HDŽ$0H$H$H$8H$@H$HH$H$H$H$D$?H$H$Hwz<+t{H$H$HsLHHHH?HHH$H$HD$@HDŽ$HDŽ$H$H$H $HD$H$ HD$H$(HD$HD$ HD$hHD$0HL$(H$H$HD$hHD$@H$H$H$8H$@H$8Hu|H$@H$8HbH9tHH H@(H$H$HGSH9uH$@H$8HH9tH$H@ ":H HH$8H$@HH9t8HL$xH$H$HQ9HYu$HAHDŽ$0H$HH$HD$PH$H'HD$9hH $H$HD$HDRHD$蒀D$uH$(HHHH@HH!HD$PT$?u"L$?uHL$@H9wH~H$HD$H$H$HD$HL$HD$ H$HD$PHHD$XH$H fH$H$HD$XH$0H$H$H$8H$@H$HHD$@HD$HL$?u?HHD$HHD$HH$0HDŽ$8HDŽ$@H$HHL$@H9sH}}H$HD$H$H$HD$HL$mHD$ H$HD$PHHD$`H$H TH$H$HD$`H$0H$H$H$8H$@H$H#H$H$Hw<-tKD$?H$H$HsHHHH?HHH$H$XH$H HD$H7 HD$I H $H HD$H7 HD$oI H $H HD$H7 HD$LI E  7  )eH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$HD$pHD$xH$H$H $HD$HD$ HD${HD$ HD$HHD$(HL$0HD$pHL$xHD$HHD$@HD$pHL$xHD$`HL$hHD$XHD$`HL$hHH9tHL$XD$?HD$XHD$PD$?D$>D$>uwHD$PH@ 4uGH rHHD$@H$HD$`HL$hH$H$H$HĈH$H}rHD$Hz11WvQeH %H$XH;A H(H$ H$ HDŽ$8HDŽ$@H$0H HH HL$8H$0H(H H$H$0H(HD HD$8H$0H(H| HD$8HD$XH$0H(H)HD$8HUu H$HD$8HD$HD$8HD$訂HD$(HL$ HT$H$@H$HH$PHD$0H$0H Ht-H@oH$8HDŽ$@H$ H(H$0H(H~jH$HH$@Hw 0HD$0HD$PHHD$0HD$0H$HH$@H9r .HD$0HD$HHHD$0HD$0HD$@H$0HL$0H(H)H$8H$PH$@H\$0H9vH9vH)HHH?H!HH$H)H$H$H$HL$Ht$- HD$H$0HL$@HHD$0HD$0H$(H$PHL$0H$HH$@H9vH)HHH?H!HH$H)H$H$H$0H H$ H$0H= vH$H$HDŽ$ H$H$H$H$H$H$H$H$H$H$H$H$H$H$H$H9H$H$H$H$H$H$H$HD$H$HD$H$H$H$(HHD$0H$PH$@HT$0H9vH$H$ H$(H$H$H$ H$(HD$HL$HT$豼HD$ HL$(H$8H$@H$ H(H$0H$0H(H H9|HDŽ$H$PHL$0H$HH$@H9vH)HHH?H!HH$H)H$H$H$0H(H$H$0H= v-H$H$HDŽ$ H$H$H$H$H$H$H$H$H$H$H$H$H$H$H$H9H$H$H$H$H$H$H$HD$H$HD$H$H$H$HHD$0HD$0H$@H$HH9r.HD$0H$HHD$0HD$0H$HD$0H$@H$HH$PH9vH)HHH?H!HH$H)H$H$H$0H(H$H$0H H$H$0H$H9v*H= vHHHHH?H!HH$xH)H$H$H$H$H$H$H$H$H$xH$H$H$H$H$H$HD$xH$H9cH$HD$xHD$xHD$pH$H$H$HD$HD$pHD$HD$xH$H$HHD$0sHDŽ$H$PH$HH$@H\$0H9v*H)HHH?H!HH$`H)H$hH$pH$0H H$H$0H= vH$HH$PHDŽ$X H$`H$hH$pH$pH$xH$H$HH$PH$XH$XH$`H$hH$xHD$hH$`H9$H$`HD$hHD$hHD$`H$pH$H$XHD$HD$`HD$HD$hH$H$HHD$0HD$0H$H$0H$0HT$0H(H+ H$HD$0H$@H$PH9vlH9vcH)HHH?H!HH$0H)H$8H$@H $HT$Ht$HD$H$H$HHD$0;    v    Z S GH(Hl$ Hl$ HD$HHD$HD$8HD$HD$HL$H9|/HD$H$HL$0HT$8H9r.0HD$HHD$HD$8HD$HD$HHl$ H( HHl$Hl$HD$H HHD$HL$H HQH rkD<0t'HD$H H$HL$HH HD$H HtHD$Hǀ(Hl$H eH %H;aH`Hl$XHl$XHD$@HD$HHD$PHD$HL$pHwyHL$pHHHHT$HL$pHL$8HT$HHH)HL$pHL$HT$pH0HrT @HL$HL$0HHL$HL$HL$p{HD$hHǀ HD$HD$(HHD$HD$H}sHD$HrdHL$hHT$hH D@H r= HD$hH HD$ HL$hHH HD$HD$HHD$64HD$hHL$hH H(HD$hH$Hl$XH`F ? CeH %HD$H;AHH$H$HD$HD$HD$HD$H$HH@HHt1H$HT$H H9}HD$Ht%H$Hǀ H$HĐHD$H$HH@HHt*HD$HHHD$HD$H$HHD$H$H(HD$pH$H\$HH)H(H$HH@HH!HHD$ H$HT$H H9|H$HT$H rHD$@HD$H$HH@HH!HD$0HD$HD$hHT$ H!HD$H$HT$H\$0H0H rHD$HD$`HHD$HD$HHHD$@HHD$HD$HD$XHHD$HD$HwHD$H$HH@HH!HD$(HD$HD$PHT$ H!HD$HD$H= |UH$HT$H\$(H0H rHD$HD$HHHD$HD$HHHD$WHD$(HwH$ƀ1H$HL$H H$H$AH$HĐH$HT$H rOHD$8HT$HHDPHD$HD$HD$xHHD$g  z s 7H(Hl$ Hl$ D$XH$HD$PHD$H $H9|HD$8HD$H $H9}D$XHl$ H(H$HL$0HT$8H9rHL$HH$H\$PH9rj 8uIHD$8H $HT$0H9r2 HL$PH$H\$HH9r 8D$XHl$ H(,*H$HD$HH$'D$XHl$ H(R K eH %HD$H;AAHH$H$H$H HH9rH@HHD$pH$H H$H$H= vH$H$HDŽ$ H$H mH^H9rxH@HLHDHL$HD$ H$H$H$H$HD$HL$D$(D$7u HT$pH$HHT$pH$H HT$PH$H HT$pHT$8HD$hHT$PH$HHT$PHT$PH}HT$hH$H$Ht$PH r{3H$HHH@HH!HHT$hHT$hHHHHT$XH\$hHHH)H\$@HT$8H$HHT$8HT$8H |RH$H\$8Ht$@H0H r@4HT$XHT$hHT$PH$HHT$PHT$@HuH$Ƃ1HL$hHwHL$hHHHHT$`HL$hHHH)HL$HHL$8H$HHL$8HL$8H |HtH$HD$`HH$HD$HD$XHHD$H$H?HtpH$HD$PHH$HD$HD$HHHD$H$H@H+D$H$H$H $HH$HL$HHHl$xHĀw7wHpHl$hHl$hHD$xHH HD$XHD$xHD$PHD$XHD$ HD$PHD$H$H HD$H$HD$@HD$HHD$HD$@HD$HL$ HHL$0HD$HL$HHD$(HL$xHT$ H\$HH\$0H HH HHD$0L$(HT$H\$HHH HH$HD$8HH$HD$xHHD$`HL$xH$H HHHD$xHL$xHIH$H H@HHHl$hHpeH %HD$H;A-HH$H$Ƅ$HD$H$uHDŽ$HD$HH$H$HH$H@H$$HH$H\H?H=H\HHD$0H$H|Ƅ$H$HĘHW}H$H\HH?H=H\HHH)HT$XH|H$HJHHrHH H9r?H$HH$HL$XHrH$HH HHH$H$HD$0HWrVH@H 2HH\HDHT$H\$D$H$H$HD$HHHD$HHD$pHHD$HHD$HHD$hHHD$HH$H$ HD$HD$ HD$HHD$`HL$ HH@HH!HD$HH$H@HHD$PHD$@H$H@HL$PH9~H$H$H\$PH+ZH+HC@HD$@HD$@HHHH@HH!HD$8H$HL$@HH@HH!HH#HT$(HD$8H+D$HH9|CHD$8HD$HH9|Ƅ$H$HĘƄ$H$HĘH$HHHHD$@@H$H$HD$XHrbH@H wHH\HDHT$H\$D$H$H$HD$HHD$xHHD$H?    6eH %H;axHXHl$PHl$PHD$hHD$pHL$`HIH.HHkHX`XHHH?H)HT$0H\H?H=H \HHL$ HD$`H@HL$ HWrH IHHLHH@HD$(H|HD$ HD$@HHD$ HHD$ HD$8HHD$ HD$ HWriH@H HH\HDHT$H\$D$HD$`H$HD$ HHHHD$HHD$hHD$ HD$pHl$PHX> 7 蠹keH %H;aH@Hl$8Hl$8HD$`HD$XH$(HD$HD$0HD$HD$(HD$0HD$`HD$(HD$ HD$ HWrH@H HH\HDHT$H\$D$HD$HH$HD$ HWrCH@H _HH\HDHT$H\$D$HD$PH$Hl$8H@"  脸eH %H$0H;AGHPH$HH$HƄ$pH$XHHtWH$`H@H$`H@ H$`H$XIH(Ƅ$pH$HHPH$hHH$XH$H$XH$fHD$H$ H$H$XHHHHL$XH$XHHH@HH!ȉD$@H$XH HT$XHHHH@HH!H)H$HD$PH$hHD$xHDŽ$HD$`HDŽ$HD$hH$H|MHT$h\$@H9wH$H$T$@T$ 7 H.; H$HZHD$) H; H$HZHD$  d_eH %H$H;AZ HpH$hH$hƄ$H$xH HtWH$H@H$H@ H$H$xIH(Ƅ$H$hHpH$xHIHt H$H$xH HH9tY H$H$xHIHRH9t. H$H$xIR8t H$H$H HH9t H$H$HIHRH9t H$H$IR8tHDŽ$PHDŽ$XHDŽ$`HDŽ$H$xH HL$PHL$PHwHL$PHHHHT$HHL$PH$HHT$HHHH)HL$PH$HT$PH0Hr( PH$H$@HH$HL$HHL$PfH$HHHD$xHDŽ$H$HL$xH9|uH$H$HHHrTH$HQH H$H$PD0H9r"H$H$8HH$HCH$HL$xHHH$HL$xHH H$H@HH$H$HPHHIHYH9rD<0t+H$H@H$0H$HHAH$H@HtGH$H@ H$H$xIH(Ƅ$H$hHpH$H$H$xH$H@HIH9H$xHH$(H$xH$xH$HKH+NHH@HH!HH$xH$HRHPH$H$H@HRH9+H$HH$ H$H$H$HKH+NHH@HH!HH$H$HRHPH$H$H$xHD$H$HD$;HD$H$H$HH$H$HHH$HH$H$HHH$HHHHL$`H$HHH@HH!ȉD$<0t/HD$@H@HD$@H@ D$pHl$0H8  eH %HD$H;AVHH$H$HDŽ$HDŽ$H$HH$HD$3HD$HD$PHZ. H$HD$HD$PHD$;HD$HL$ HT$(HD$pHL$xH$H$HL$HT$$D$$D$ H$HD$(H$HD$0uHD$8HL$@HT$HHD$XHL$`HT$hH$HD$XHL$`HT$hHD$HL$HT$xHD$ HL$(H$H$H$HĐ荟eH %H;aHpHl$hHl$hHDŽ$HDŽ$HDŽ$HD$xH$H$H$HL$HT$$D$$D$ H$HD$(H$HD$0NHD$8HL$@HT$HHD$PHL$XHT$`H$H$H$Hl$hHp虞eH %H$H;A HH$H$HDŽ$(HDŽ$0HDŽ$8HDŽ$HDŽ$H$ H$HL$ H$H t $Z$!YD$$H$HH$H$H$H$HHH HH@HH$H$H$H$HHBHH@HH!HHH@HH!HBH!H$H$HHH@HH!HH#$H$H$H$H$HJHH@HH!HH9t&HDŽ$HDŽ$H$HuH%H$HDŽ$H$H$H$H$H$H$H$HH$H$H9w/H) H$H$H$H$HT$HL$HD$H$HD$ 8HD$0HL$(HT$8H$H$H$H$H$H9v H$H$H$H$H$HH$H$HD$H$HD$H$H$H$H$H$H$H$(H$0H$8H$H9$u"H$H$HDŽ$GH|$H$HDŽ$%Ht H$H$HH$H$H$H$HIHH$$H$H$HDŽ$ HDŽ$ H$WHHl$Hl$PHmH$H$H$H$H$H$ H$H H$(H$H(H$0HD$ HD$0H$H$HHHHH@HH!H9wLH$HHD$ H$HD$0HD$@H|$HWHHl$Hl$蜮HmHD$@H$H$HD$ HHHD$fH$HL$0H+HAHD$H$H$ZH$D$HD$(H$HL$(H H9|cD$0H$HL$(H H9|9H$HL$(H rD$H$HL$(H rWD$D$0H$HL$(H H9|H$HL$(H rD$D$L$8uSD$D$L$8u2D$uuD$L$uu0H$H$HD$(HHD$HH$HL$u0H$H$HD$(HHD$۴H$HÄu0H$H$HD$(HHD$5H$HHD$(HD$8HHD$(oH$HT$(HH H9L$T$8D$u&H$HL$(HH H9~_H$HH$HL$H9tH$HHHD$ H$HHD$0. '  艀eH %HD$H;A[ HH$H$HDŽ$HDŽ$ HDŽ$($uH$H$H$HrH9HJH$-D$A0H$Hu]H$H$Hw L$AH$H$H$HqH9HYH$\$A H$HH$H$H$HYH91HAH$ .HD$PH$H$H$HHD$HD$HD$HHL$PH9|H$H$H\$PH9vH9vH)HHH?H!HH$H)H$H$H$H$H$HT$xH$H$H$HHD$hH$H9w!H H$H$H$HT$xHT$HL$HD$HD$hHD$ (HD$0HL$(HT$8HL$xH$H$HD$hH$H9vH$H$HD$`H$HL$xHH$H$HD$HD$`HD$DH$HL$xH$H$H$H$HD$HHD$PHL$PH$H9~H$H$H$HrH9*HJH$0HL$PHL$pHHL$PH H$H\$HT$HL$Ht$ H\$(HT$0HD$8H$H$H$H$H$HqH9 HYH$$ H$HHL$XH$HtHD$XHL$XH|D$A-HL$XHHL$XH$H$H$HrH9"HJH$L$A HL$XH |HD$X0D$GH$H$H$HZH9_HBH$D$G0DH$H$H$H$H$ H$(H$HİH5 H4$HL$HT$HD$H\$ 1HL$(HT$0HD$8H$H$]HL$XHd|HL$XHHHHH?H)ʍJ0L$FHL$XHHHHHH?H)H HH)ˍK0L$EH$H$H$HrH9&HBH$D$FL$ELH H$H\$HT$HL$Ht$ 5H\$(HT$0HD$8H$H$HL$XH ףp= ףHHHH?H)ʍJ0L$DHL$XHHHHH?H)iɚ k )ʍJ0L$CHL$XHHHHHH?H)H HH)ˍK0L$BH$H$H$HrH90HBH$D$D\$Ct$B\@tH H$HL$HT$H\$Ht$ HL$(HT$0HD$8H$H$H H$H\$HT$HL$Ht$ H\$(HT$0HD$8H$H$D$A+g?H+ H$HT$HL$H\$Ht$ nHT$(HL$0HD$8H$H$>H5 H4$HT$HL$HD$H\$ HT$(HL$0HD$8H$H$%H~ H$HT$HL$H\$Ht$ HT$(HL$0HD$8H$H$H1 H$H\$HT$HL$Ht$ tH\$(HT$0HD$8H$H$-: 蟞 weH %HD$H;AHH$H$HDŽ$HDŽ$ HDŽ$($ujH$H$H$HZH9HBH$-H$HVH$H$H$HD$HD$HD$HH$H$H9v H$H$H$H$H$H$H$H$H$H$HHD$hH$H9wHj H$H$H$H$HL$HT$HD$HD$hHD$ HD$8HL$0HT$(H$H$H$HD$hH$H9vH$H$HD$`H$H$HH$H$HD$HD$`HD$覦H$H$H$H$H$H$HD$HH$H9|H$H$H$HYH9*HQH$0HD$HHD$xHHD$HH5  H4$HD$HL$HT$H\$ NHD$(HL$0HT$8H$H$H$HH$H$H$HYH9oHQH$.HD$XHD$XH$H9|D$G0H$HD$XHD$PH}H$H9|H$H$H9rD$GH$H$H$HYH91HQH$T$GHD$XHD$pHHD$X@H5 H4$HD$HL$HT$H\$ HD$(HL$0HT$8H$H$bH$H$H$H$H$ H$(H$HĸH5 H4$HD$HL$HT$H\$ aHD$(HL$0HT$8H$H$MsH$H$H$HYH9HAH$ 0H5 H4$HT$HL$HD$H\$ HT$(HL$0HD$8H$H$H5C H4$HL$HT$HD$H\$ HL$(HT$0HD$8H$H$踘 ! qeH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$$uQH$H$H$HYH9HAH$ -HD$xHDŽ$HDŽ$H$H$H$H$HD$HL$H$HD$HD$ fD$(XHD$@HL$8HT$0HT$xH$H$H$H$H$H$H$H$HYH9HQH$pH$HD$XH$H H)H$H$H}lH$H$H$HYH9HQH$+HD$`HD$hHD$pH$H$H$H$HL$HT$H$HD$HD$ H$HD$(D$)HD$0HL$8HT$@HD$`HL$hHT$pH$H$H$H$H$H$H$H$H$H$HĘH5 H4$HD$HL$HT$H\$ D HD$(HL$0HT$8H$H$H5 H4$HD$HL$HT$H\$ HD$(HL$0HT$8H$H$H5l H4$HT$HL$HD$H\$ HT$(HL$0HD$8H$H$Qm HD$@H s"HD$pH$HHD$pHD$hH=rHL$pH[uHAr $uHD$pH$HHD$pHD$pHArƄ-$uH$HD$pHAvHHHHHH?H!HH$pH$xH$H$H$H$H$@H$HH$PH$xHH$H$PH9wH H$H$HH$@H$PHL$HD$HT$H$HD$ HD$0HL$(HT$8H$@H$HH$PH$H$PH9vH$HH$xH$H$H$@HH$H$pHD$H$HD$H$HH$@H$PH$H$H$H$HĐ$LH$HD$pHAvHHHHHH?H!HH$XH$`H$hH$H$hH$`H$XHT$HL$HD$GeH %H;avlH@Hl$8Hl$8HD$XHD$`HD$HHL$PH$HL$fD$"D$ HD$HL$ HD$(HL$0HD$XHL$`Hl$8H@>{eH %H;aHhHl$`Hl$`HDŽ$HDŽ$HDŽ$HD$pHL$xH$H$HL$HT$H$H$HD$HL$ fD$("D$*HD$0HL$8HT$@HD$HHL$PHT$XH$H$H$Hl$`Hh+=&eH %H;avlH@Hl$8Hl$8HD$XHD$`HD$HHL$PH$HL$fD$"D$HD$HL$ HD$(HL$0HD$XHL$`Hl$8H@<{eH %H;aHhHl$`Hl$`HDŽ$HDŽ$HDŽ$HD$pHL$xH$H$HL$HT$H$H$HD$HL$ fD$("D$*@HD$0HL$8HT$@HD$HHL$PHT$XH$H$H$Hl$`Hh;&eH %H;av`H0Hl$(Hl$(HD$@HD$HD$8$fD$'D$HD$HL$HD$HL$ HD$@HL$HHl$(H0<;eH %H;aHXHl$PHl$PHDŽ$HDŽ$HDŽ$HD$`HL$hHT$pH$HL$HT$D$xD$fD$'D$5HD$ HL$(HT$0HD$8HL$@HT$HH$H$H$Hl$PHXp:;eH %H;aHXHl$PHl$PHDŽ$HDŽ$HDŽ$HD$`HL$hHT$pH$HL$HT$D$xD$fD$'D$eHD$ HL$(HT$0HD$8HL$@HT$HH$H$H$Hl$PHX9;eH %H;aDHHHl$@Hl$@D$`HD$XHD$8HHD$PHL$XH$HL$D$D$$HD$HD$0D$$D$ HD$0HD$(HD$(HL$XHT$PH9vH)HHH?H!HHD$PH\$XHD$(H#D$ =tD$`Hl$@HHJD$ =tD$`Hl$@HHËD$ |:D$ uD$`Hl$@HHD$ `tD$ tD$`Hl$@HH;` 48H(Hl$ Hl$ HD$PHD$8HD$HD$HD$H$HD$H $H9|YH$H+D$HH?H?HHHD$HD$HL$8HT$0H9r8 BT$Hf9rHHD$H$HD$HD$PHl$ H(^ H(Hl$ Hl$ HD$PHD$8HD$HD$HD$H$HD$H $H9|VH$H+D$HH?H?HHHD$HD$HL$8HT$0H9r5 T$H9rHHD$H$HD$HD$PHl$ H(<^ eH %H$@H;AH@H$8H$8Ƅ$P$H=~z$H^vƄ$PH$8H@Ë$H_^v&$H=$PH$8H@Ƅ$PH$8H@Ë$H=r_$HfD$*HDH DHDH$ H$(H$0HDH zDHkDH$H$H$D$*fD$(H$(H$ H$0H$H$H$H$H$H$H$H$H$H$H$H$H$HL$HD$D$(fD$HD$ HD$HH$HD$pHL$HH9}Ƅ$PH$8H@D$(H$H$H\$HHH9r Yf9rH$H$HT$HHH9rPL$(f9r{H$H$H$H$HL$HT$D$(fD$HD$ HD$@H$HD$hHL$@H9}$PH$8H@HD$@H$H$H9r AT$(f9$HD$0HBH BHBH$H$H$H;BH ?H G?H8?H$HT$HL$D$.fD$#HD$ HD$0H ?HD$8HL$0H9|9D$.HL$0H>H>H9r Jf9D$XHl$@HHnW /eH %H;aH(Hl$ Hl$ 4y<w Hl$ H(y<tY  y8HH$HD$菶HD$HL$H . H{urH#HH$HD$PHD$HL$H {uH xHl$ H(HړH$HL$H H $HD$}.eH %H;aH Hl$Hl$HD$8HD$(H$HD$0HD$HD$HD$0HD$(HH$HD$0HD$ȶHD$HD$0HD$(H H$HD$0HD$袹HD$HD$0HD$8Hl$H .OeH %HD$H;AHH$H$Ƅ$H$HHHHD$xH$H$HH@HL$hHD$pH$H9tQH$HL$xH $HD$HD$hHL$pHD$HL$MD$ u H$HHH@HL$XHD$`H$HHH@HL$HHD$PHL$`H9tHD$XHL$`H$HL$HD$HHL$PHD$HL$LD$ uH$HH H@(HL$8HD$@H$HH H@(HL$(HD$0HD$8H9t=H $HD$0HD$HD$@HD$茿D$$H$HĐli,eH %H;avQH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$2 HD$HD$8HD$@Hl$ H(+eH %H;avUH8Hl$0Hl$0D$PHD$@HD$(HD$HHD$HD$(H$HD$2JD$D$'D$PHl$0H8'+eH %H;avQH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$)HD$HD$8HD$@Hl$ H(*eH %H;avUH8Hl$0Hl$0D$PHD$@HD$(HD$HHD$HD$(H$HD$ID$D$'D$PHl$0H8G*eH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$IHD$HD$8HD$0HH$HD$8HD$SHD$HD$8HD$@Hl$ H()peH %H;aHPHl$HHl$HD$hHD$XHHL$`H H9tHD$XHHH@HD$8HL$@HD$`HHH@HL$(HD$0HL$@H9tCHD$8HL$@H$HL$HD$(HL$0HD$HL$HD$ D$hHl$HHP(/eH %H;aH8Hl$0Hl$0HD$PHD$(HD$ HD$(HL$ H9|AHD$(HD$HHD$@H$HD$HHD$;HD$HD$HHD$(HHD$(HD$HHD$PHl$0H8'(RH Hl$Hl$D$8HD$HD$ HD$HL$H9|OHD$H$HHHD$(HHL$0 .uzD$8Hl$H HD$HHD$D$8Hl$H eH %H;aH8Hl$0Hl$0HD$PHD$(HD$ HD$(HL$ H9|AHD$(HD$HHD$@H$HD$HHD$˰HD$HD$HHD$(HHD$(HD$HHD$PHl$0H8&RH Hl$Hl$D$8HD$HD$HD$HL$H9|PHD$H$HHHD$(HHL$0 f.uzD$8Hl$H HD$HHD$D$8Hl$H eH %H;aH8Hl$0Hl$0HD$PHD$(HD$ =HD$(HL$ H9|EHD$(HD$H@HHD$@H$HD$HHD$wHD$HD$HHD$(HHD$(HD$HHD$PHl$0H8%NeH %H;a6HhHl$`Hl$`Ƅ$HD$8HD$0=HD$8HL$0H9|HD$8HD$(H @HHL$pH@HHT$xH HH9uƄ$Hl$`HhH@HHD$pHHH@HD$PHL$XHD$(H@HHD$xHHH@HD$@HL$HHD$XH9uHD$PHL$XH$HL$HD$HHL$@HL$HD$-DD$ uHD$8HHD$8 MƄ$Hl$`Hh"$eH %H;aH8Hl$0Hl$0HD$PHD$(HD$ WHD$(HL$ H9|EHD$(HD$H@HHD$@H$HD$HHD$wHD$HD$HHD$(HHD$(HD$HHD$PHl$0H8c#NH Hl$Hl$D$8HD$HD$WHD$HL$H9|HD$H$H @HHL$(H@HHT$0H HH9uD$8Hl$H H @HHL$(H@HHT$0HIHRH9uH @HHL$(H@HHD$0I@8uHD$HHD$BD$8Hl$H eH %H;aH8Hl$0Hl$0HD$PHD$(HD$ HD$(HL$ H9|EHD$(HD$H@HHD$@H$HD$HHD$HD$HD$HHD$(HHD$(HD$HHD$PHl$0H8!NH Hl$Hl$D$8HD$HD$HD$HL$H9|HD$H$H @HHL$(H@HHT$0H HH9uD$8Hl$H H @HHL$(H@HHT$0HIHRH9uH @HHL$(H@HHD$0I@8uHD$HHD$BD$8Hl$H eH %H;aH8Hl$0Hl$0D$HD$@=v#D$@H mD$HHl$0H8ËD$@$H0H 0H0HL$HT$HD$*D$ D$/D$HHl$0H8YeH %H;aHhHl$`Hl$`Ƅ$H$H$HT$xHT$HHL$PHD$XHD$(HD$PHD$ HD$HHD$@HD$(HL$ H9|gHD$@HHD$8HD$0H$D$pD$D$D$uƄ$Hl$`HhHD$@HHD$@HD$(HHD$(Ƅ$Hl$`HheH %H;aH(Hl$ Hl$ D$8D$0=v^D$0D$ ~7HvD$8Hl$ H(à tD$8Hl$ H(=t=tHP&H$D$0D$gD$D$D$8Hl$ H(6HPHl$HHl$HD$xHL$`HL$ H~HD$0HL$`HL$(HL$0HT$(H9|HL$0HL$HT$`H\$XH9rH IHKHT$@t$peH %H$H;AvHH$H$Y<wH$HĐoY<t9 [YH> H$HD$$HD$HD$HD$ H$0HH$xHDŽ$HH$H> H$H$0HD$H$H$xHL$HD$YHD$ H$H$[VHHdH$xHDŽ$H_H$H> H$H$0HD$H$H$xHL$HD$@YHD$ H$(H$ZHHٖH$xHDŽ$HH$Hs= H$H$0HD$H$H$xHL$HD$XHD$ H$H$YHHNH$xHDŽ$HmH$H< H$H$0HD$H$H$xHL$HD$&XHD$ H$H$iYvHHÕH$xHDŽ$HH$HY< H$H$0HD$H$H$xHL$HD$WHD$ H$(H$XօHHH$xHDŽ$HH$H; H$H$0HD$H$H$xHL$HD$ WHD$ H$H$OX6HHH$xHDŽ$HH$H?; H$H$0HD$H$H$xHL$HD$VHD$ HD$xH$WHH#H$xHDŽ$H H$H: H$H$0HD$H$H$xHL$HD$UHD$ H$(H$8WHHH$xHDŽ$HH$H(: H$H$0HD$H$H$xHL$HD$hUHD$ H$H$VYHH H$xHDŽ$H H$H9 H$H$0HD$H$H$xHL$HD$THD$ H$xH$VHHH$xHDŽ$HH$H9 H$H$0HD$H$H$xHL$HD$NTHD$ H$ H$UHHH$xHDŽ$HH$H8 H$H$0HD$H$H$xHL$HD$SHD$ H$H$UyHHjH$xHDŽ$H H$H7 H$H$0HD$H$H$xHL$HD$4SHD$ H$pH$wTـHHߐH$xHDŽ$H. H$Hg7 H$H$0HD$H$H$xHL$HD$RHD$ H$H$S9HHTH$xHDŽ$H H$H6 H$H$0HD$H$H$xHL$HD$RHD$ H$H$]SHH|H$xHDŽ$Ht H$HM6 H$H$0HD$H$H$xHL$HD$QHD$ H$hH$R~HH<H$xHDŽ$H H$H5 H$H$0HD$H$H$xHL$HD$QHD$ H$H$CRY~HHH$xHDŽ$H H$H35 H$H$0HD$H$H$xHL$HD$sPHD$ H$H$Q}HH&H$xHDŽ$H H$H4 H$H$0HD$H$H$xHL$HD$OHD$ H$`H$)Q}HHIH$xHDŽ$H( H$H4 H$H$0HD$H$H$xHL$HD$YOHD$ H$H$Py|HHH$xHDŽ$H H$H3 H$H$0HD$H$H$xHL$HD$NHD$ H$H$P{HHH$xHDŽ$HF H$H2 H$H$0HD$H$H$xHL$HD$?NHD$ H$H$O9{HHH$xHDŽ$H H$Hr2 H$H$0HD$H$H$xHL$HD$MHD$ H$H$NzHHoH$xHDŽ$H< H$H1 H$H$0HD$H$H$xHL$HD$%MHD$ H$H$hNyHHH$xHDŽ$HH$HX1 H$H$0HD$H$H$xHL$HD$LHD$ H$H$MYyHHYH$xHDŽ$HBH$H0 H$H$0HD$H$H$xHL$HD$ LHD$ H$H$NMxHHΉH$xHDŽ$HH$H>0 H$H$0HD$H$H$xHL$HD$~KHD$ H$H$LxHHH$xHDŽ$HhH$H/ H$H$0HD$H$H$xHL$HD$JHD$ H$xH$4LywHHH$xHDŽ$HH$H$/ H$H$0HD$H$H$xHL$HD$dJHD$ H$pH$KvHH+H$xHDŽ$HH$H. H$H$0HD$H$H$xHL$HD$IHD$ H$hH$K9vHHH$xHDŽ$HH$H . H$H$0HD$H$H$xHL$HD$JIHD$ H$`H$JuHHH$xHDŽ$HH$H}- H$H$0HD$H$H$xHL$HD$HHD$ H$XH$JtHH"H$xHDŽ$HH$H, H$H$0HD$H$H$xHL$HD$0HHD$ H$PH$sIYtHHH$xHDŽ$HbH$Hc, H$H$0HD$H$H$xHL$HD$GHD$ H$HH$HsHHvH$xHDŽ$HH$H+ H$H$0HD$H$H$xHL$HD$GHD$ H$@H$YHsHHH$xHDŽ$HXH$HI+ H$H$0HD$H$H$xHL$HD$FHD$ H$8H$GyrHH$0 GBrH]H* H$HD$HD$HD$HD$ H$0HH$8HDŽ$@HH$ Hc* H$H$0HD$H$@H$8HL$HD$EHD$ H$H$ FfqHHH$8HDŽ$@HH$ H) H$H$0HD$H$@H$8HL$HD$EHD$ H$H$ YFpHHCH$8HDŽ$@HH$ HI) H$H$0HD$H$@H$8HL$HD$DHD$ H$H$ E&pHHH$8HDŽ$@HH$ H( H$H$0HD$H$@H$8HL$HD$CHD$ H$H$ ?EoHHH$8HDŽ$@HH$ H/( H$H$0HD$H$@H$8HL$HD$oCHD$ H$H$ DnHHH$8HDŽ$@HyH$ H' H$H$0HD$H$@H$8HL$HD$BHD$ H$H$ %DFnHHH$8HDŽ$@HH$ H' H$H$0HD$H$@H$8HL$HD$UBHD$ H$H$ CmHHɂH$8HDŽ$@HoH$ H& H$H$0HD$H$@H$8HL$HD$AHD$ H$H$  CmHH]H$8HDŽ$@ HH$ H% H$H$0HD$H$@H$8HL$HD$;AHD$ H$H$ ~BflHHH$8HDŽ$@HeH$ Hn% H$H$0HD$H$@H$8HL$HD$@HD$ H$H$ AkHHUH$8HDŽ$@HH$ H$ H$H$0HD$H$@H$8HL$HD$!@HD$ H$H$ dA&kHHH$8HDŽ$@ H[H$ HT$ H$H$0HD$H$@H$8HL$HD$?HD$ H$H$ @jHHH$8HDŽ$@HH$ H# H$H$0HD$H$@H$8HL$HD$?HD$ H$H$ J@iHHH$8HDŽ$@HYH$ H:# H$H$0HD$H$@H$8HL$HD$z>HD$ H$H$ ?FiHH(H$8HDŽ$@HH$ H" H$H$0HD$H$@H$8HL$HD$=HD$ H$H$ 0?hHHH$8HDŽ$@HOH$ H " H$H$0HD$H$@H$8HL$HD$`=HD$ H$H$ >hHH}H$8HDŽ$@HH$ H! H$H$0HD$H$@H$8HL$HD$fgHH/H$8HDŽ$@HMH$ H! H$H$0HD$H$@H$8HL$HD$FHD$ H$hH$ $@HHQcH$8HDŽ$@ HxH$ Hq H$H$0HD$H$@H$8HL$HD$HD$ H$`H$ ?HH XH$8HDŽ$@HH$ H H$H$0HD$H$@H$8HL$HD$$HD$ H$XH$ g>HH;]H$8HDŽ$@HnH$ HW H$H$0HD$H$@H$8HL$HD$HD$ H$PH$ D>HH\H$8HDŽ$@HH$ H H$H$0HD$H$@H$8HL$HD$ HD$ H$HH$ M=HH&aH$8HDŽ$@ HlH$ H= H$H$0HD$H$8H$@HD$HL$}HD$ H$@H$ =HHeH$8HDŽ$@ HH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$8H$ 3d<HH4VH$8HDŽ$@HjH$ H# H$H$0HD$H$8H$@HD$HL$cHD$ H$0H$ ;HHTH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$(H$ $;HH|VH$8HDŽ$@HxH$ H H$H$0HD$H$8H$@HD$HL$IHD$ H$H$ :HH\H$8HDŽ$@HH$ H| H$H$0HD$H$8H$@HD$HL$HD$ H$H$ 9HH iH$8HDŽ$@ HnH$ H H$H$0HD$H$8H$@HD$HL$/HD$ H$H$ rD9HH_H$8HDŽ$@ HH$ Hb H$H$0HD$H$8H$@HD$HL$HD$ H$H$ 8HHrH$8HDŽ$@HdH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$H$ X8HH^H$8HDŽ$@ HH$ HH H$H$0HD$H$8H$@HD$HL$HD$ H$H$ d7HH`H$8HDŽ$@ HZH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$H$ >6HH!qH$8HDŽ$@HH$ H. H$H$0HD$H$8H$@HD$HL$nHD$ H$H$ $6HH]H$8HDŽ$@ HPH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$H$ $5HHQH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$THD$ H$H$ 4HHQH$8HDŽ$@HFH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$H$  D4HHSH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$:HD$ H$H$ }3HH`H$8HDŽ$@ HH$ Hm H$H$0HD$H$8H$@HD$HL$HD$ H$H$ 3HHWH$8HDŽ$@ HH$ H H$H$0HD$H$8H$@HD$HL$ HD$ H$H$ cd2HH\H$8HDŽ$@ HH$ HS H$H$0HD$H$8H$@HD$HL$ HD$ H$H$ 1HHlTH$8HDŽ$@H%H$ H H$H$0HD$H$8H$@HD$HL$ HD$ H$H$ I$1HHXH$8HDŽ$@ HH$ H9 H$H$0HD$H$8H$@HD$HL$y HD$ H$H$  0HH7fH$8HDŽ$@H;H$ H H$H$0HD$H$8H$@HD$HL$ HD$ H$H$ / /HH`NH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$_ HD$ H$H$  D/HHLH$8HDŽ$@HAH$ H H$H$0HD$H$8H$@HD$HL$ HD$ H$xH$  .HHTH$8HDŽ$@ HH$ H H$H$0HD$H$8H$@HD$HL$E HD$ H$hH$  .HHVH$8HDŽ$@ H?H$ Hx H$H$0HD$H$8H$@HD$HL$ HD$ H$`H$  d-HHMH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$+ HD$ H$XH$ n ,HHlMH$8HDŽ$@HEH$ H^ H$H$0HD$H$8H$@HD$HL$HD$ H$PH$  $,HHLH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$HH$ T +HHVH$8HDŽ$@ H;H$ HD H$H$0HD$H$8H$@HD$HL$HD$ H$@H$ *HHKH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$8H$ :D*HHqXH$8HDŽ$@ HQH$ H* H$H$0HD$H$8H$@HD$HL$jHD$ H$0H$ )HHOH$8HDŽ$@ HH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$(H$  )HHcWH$8HDŽ$@ HGH$ H H$H$0HD$H$8H$@HD$HL$PHD$ H$ H$ d(HHGH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$H$ 'HH'IH$8HDŽ$@H=H$ H H$H$0HD$H$8H$@HD$HL$6HD$ H$H$ y$'HHKH$8HDŽ$@HH$ Hi H$H$0HD$H$8H$@HD$HL$HD$ H$H$ &HH5FH$8HDŽ$@H3H$ H H$H$0HD$H$8H$@HD$HL$HD$ H$H$ _%HH JH$8HDŽ$@HH$ HO H$H$0HD$H$8H$@HD$HL$HD$ H$H$ D%HHIH$8HDŽ$@H)H$ H H$H$0HD$H$8H$@HD$HL$HD$ H$H$ E$HHBH$8HDŽ$@HH$ H5 H$H$0HD$H$8H$@HD$HL$uHD$ H$H$ $HH9BH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$H$ +d#HHzCH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$[HD$ H$H$ "HHBH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$H$ $"HHlBH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$AHD$ H$H$ !HH>H$8HDŽ$@HH$ Ht H$H$0HD$H$8H$@HD$HL$HD$ H$H$  HHCH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$'HD$ H$H$ jD HH0EH$8HDŽ$@H H$ HZ H$H$0HD$H$8H$@HD$HL$HD$ H$H$ HH BH$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$ HD$ H$H$ PHHDH$8HDŽ$@HH$ H@ H$H$0HD$H$8H$@HD$HL$HD$ H$H$ dHH:H$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$H$ 6HHJH$8HDŽ$@ HH$ H& H$H$0HD$H$8H$@HD$HL$fHD$ H$H$ $HH59H$8HDŽ$@HH$ H H$H$0HD$H$8H$@HD$HL$HD$ H$xH$ HH$0 MHH H$HD$"HD$HD$ѡHD$ H$pHTH$hHDŽ$pHZH$`H H$H$pHD$H$hH$pHD$HL$HD$ H$XH$`6qHH%KH$hHDŽ$p H5H$`H& H$H$pHD$H$hH$pHD$HL$fHD$ H$PH$`HH8H$hHDŽ$pHXH$`H H$H$pHD$H$hH$pHD$HL$HD$ H$HH$`1HH/DH$hHDŽ$p HӰH$`H H$H$pHD$H$hH$pHD$HL$LHD$ H$@H$`HHAH$hHDŽ$p H^H$`H H$H$pHD$H$hH$pHD$HL$HD$ H$8H$`HH>H$hHDŽ$pHH$`H H$H$pHD$H$hH$pHD$HL$2HD$ H$0H$`uQHH@H$hHDŽ$p HԯH$`He H$H$pHD$H$hH$pHD$HL$HD$ H$(H$`HH8H$hHDŽ$pHWH$`H H$H$pHD$H$hH$pHD$HL$HD$ H$ H$`[HH[H$hHDŽ$pHҮH$`HK H$H$pHD$H$hH$pHD$HL$HD$ H$H$`qHHw_H$hHDŽ$pHMH$`H H$H$pHD$H$hH$pHD$HL$HD$ H$H$`AHHECH$hHDŽ$p HȭH$`H1 H$H$pHD$H$hH$pHD$HL$qHD$ H$H$`1HHEH$hHDŽ$p HkH$`H H$H$pHD$H$hH$pHD$HL$HD$ H$H$`'HHPhH$hHDŽ$pH~H$`H H$H$pHD$H$hH$pHD$HL$WHD$ H$H$`HHgH$hHDŽ$pHH$`H H$H$pHD$H$hH$pHD$HL$HD$ H$H$` QHHNH$hHDŽ$pH̭H$`H H$H$pHD$H$hH$pHD$HL$=HD$ H$H$`HH1H$hHDŽ$p"HGH$`Hp H$H$pHD$H$hH$pHD$HL$HD$ H$H$`HH`H$hHDŽ$pH¬H$`H H$H$pHD$H$hH$pHD$HL$#HD$ H$H$`fqHHZPH$hHDŽ$pH=H$`HV H$H$pHD$H$hH$pHD$HL$HD$ H$H$`HHmGH$hHDŽ$pHH$`H H$H$pHD$H$hH$pHD$HL$ HD$ H$H$`L1HHIH$hHDŽ$pH3H$`H< H$H$pHD$H$hH$pHD$HL$|HD$ H$H$`HH,;H$hHDŽ$p HH$`H H$H$pHD$H$hH$pHD$HL$HD$ H$H$`2HHHH$hHDŽ$pH)H$`H" H$H$pHD$H$hH$pHD$HL$bHD$ H$H$`QHHGEH$hHDŽ$pHH$`H H$H$pHD$H$hH$pHD$HL$HD$ H$H$` HHjSH$hHDŽ$pH7H$`H H$H$pHD$H$hH$pHD$HL$HHD$ H$H$` HHqH$hHDŽ$pHH$`H{ H$H$pHD$H$hH$pHD$HL$HD$ H$H$`q HHCH$hHDŽ$pHH$`H H$H$pHD$H$hH$pHD$HL$.HD$ H$xH$`q HHa0H$hHDŽ$pHH$`Ha H$H$pHD$H$hH$pHD$HL$HD$ H$pH$`1 HH-KH$hHDŽ$pHH$`H H$H$pHD$H$hH$pHD$HL$HD$ H$hH$`W HH+H$hHDŽ$pHH$`HG H$H$pHD$H$hH$pHD$HL$HD$ H$XH$` HH9H$hHDŽ$p H٦H$`H H$H$pHD$H$hH$pHD$HL$HD$ H$PH$`=Q HHTH$hHDŽ$pHH$`H- H$H$pHD$H$hH$pHD$HL$mHD$ H$HH$`HH IH$hHDŽ$pHgH$`H H$H$pHD$H$hH$pHD$HL$HD$ H$@H$`#HHaKH$hHDŽ$pHH$`H H$H$pHD$H$hH$pHD$HL$SHD$ H$8H$`qHH6H$hHDŽ$p HmH$`H H$H$pHD$H$hH$pHD$HL$HD$ H$0H$` HH$p HH H$HD$HD$HD$辎HD$ H$(H$H$XHDŽ$`HϤH$ H H$H$(HD$H$XH$`HD$HL$HD$ H$H$ #HH$H$XHDŽ$`HJH$ H H$H$(HD$H$XH$`HD$HL$SHD$ H$H$ HH#H$XHDŽ$`HţH$ H H$H$(HD$H$XH$`HD$HL$HD$ H$H$  ~HHm#H$XHDŽ$`H@H$ H H$H$(HD$H$XH$`HD$HL$9HD$ H$H$ |HH"H$XHDŽ$`HH$ Hl H$H$(HD$H$XH$`HD$HL$HD$ H$H$ >HHY"H$XHDŽ$`H6H$ H H$H$(HD$H$XH$`HD$HL$HD$ H$H$ bHH$( EgH<H[ H$HD$HD$HD$HD$ H$H%H$HHDŽ$PHH$H H$H$HD$H$HH$PHD$HL$9HD$ H$H$|HH#H$HHDŽ$PHH$Hl H$H$HD$H$HH$PHD$HL$HD$ H$H$HH+H$HHDŽ$P HH$H H$H$HD$H$HH$PHD$HL$HD$ H$H$buRHH$ Iu"HLH$HĐH ,H $HD$(H$HL$(H$HL$( H$HL$(iH H $HD$(H$HL$n(VH$HL$[(H$HL$H(H$HL$5(vH$HL$"(H$HL$(6H [H $HD$'WH$HL$'#H$HL$'H$HL$'H$HL$'CH$HL$'H$HL$'H$HL$p'cH$HL$]'H$HL$J'#H$HL$7'H$HL$$'H$HL$'CH$HL$&H$HL$&H$HL$&cH$HL$&H$HL$&#H$HL$&H$HL$&H$HL$y&CH$HL$f&H$HL$S&H$HL$@&cH$HL$-&H$HL$&#H$HL$&H$HL$%H$HL$%CH$HL$%H$HL$%H$HL$%cH$HL$%H$HL$%#H$HL$o%H H $HD$U%H$HL$B%pH$HL$/%H$HL$%0H$HL$ %H$HL$$H$HL$$PH$HL$$H$HL$$H$HL$$pH$HL$$H$HL$$0H$HL$q$H$HL$^$H$HL$K$PH$HL$8$H$HL$%$H$HL$$pH$HL$#H$HL$#0H$HL$#H$HL$#H$HL$#PH$HL$#H$HL$#H$HL$z#pH$HL$g#H$HL$T#0H$HL$A#H$HL$.#H$HL$#PH$HL$#H$HL$"H$HL$"pH$HL$"H$HL$"0H$HL$"H$HL$"H$HL$"PH$HL$p"H$HL$]"H$HL$J"pH$HL$7"H$HL$$"0H$HL$"H$HL$!H$HL$!PH$HL$!H$HL$!H$HL$!pH$HL$!H$HL$!0H$HL$y!H$HL$f!H$HL$S!PH$HL$@!H$HL$-!H$HL$!pH$HL$!пH$HL$ 0H$HL$ 鐾H$HL$ H$HL$ PH$HL$ 鰼H$HL$ H$HL$ pH$HL$o кH$HL$\ 0H$HL$I 鐹H$HL$6 H$HL$# PH$HL$ 鰷H$HL$H$HL$pH$HL$еH$HL$0H$HL$鐴H$HL$H$HL$PH$HL$x鰲H$HL$eH$HL$RsH$HL$?ְH$HL$,9H$HL$霯H$HL$H$HL$bH$HL$ŭH$HL$(H$HL$鋬H$HL$H$HL$NH$HL$鮪H$HL$nH$HL$[nH$HL$HΨH$HL$5.H$HL$"鎧H$HL$H$HL$NH$HL$鮥H$HL$H$HL$nH$HL$ΣH$HL$.H$HL$鎢H$HL$wH$HL$dNH$HL$Q鮠H$HL$>H$HL$+nH$HL$ΞH$HL$.H$HL$鎝H$HL$H$HL$NH$HL$鮛H$HL$H$HL$nH$HL$ΙH$HL$m.H$HL$Z鎘H$HL$GH$HL$4NH$HL$!鮖H$HL$H$HL$nH$HL$ΔH$HL$.H$HL$鎓H$HL$H$HL$NH$HL$鮑H$HL$vH$HL$cnH$HL$PΏH$HL$=.H$HL$*鎎H ^H $HD$鯍H$HL${H$HL$یH$HL$;H$HL$雋H$HL$H$HL$[H$HL$黉H$HL$xH$HL$e{H$HL$RۇH$HL$?;H$HL$,集H$HL$H$HL$[H$HL$黄H$HL$H$HL${H$HL$ۂH$HL$;H$HL$雁H$HL$H$HL$n[H$HL$[H$HL$HH$HL$5{~H$HL$"}H$HL$;}H$HL$|H$HL${H$HL$[{H$HL$zH$HL$zH$HL$~yH$HL$xH$HL$w>xH$HL$dw蚆eveH %H$xH;AHH$H$HDŽ$8HDŽ$@HDŽ$HH$0 H$0H%HD$HHD$`H$ H$"HD$HD$XHL$`H HL$HHDŽ$HDŽ$HDŽ$H$ H$H$(H$HD$HH$H$ H$(H$0H$HL$HT$*HD$ HL$H$H$HH9t}HD$xH#H$H$HHD$PHDŽ$HD$xH$HD$HD$(H$HD$hH H$HD$H$HL$PHH$HL$hHXHHH$H$0H HHH$H$H$H$HX(HHpHx "HHHP H$HD$pHHHP H@(H$H$H$HD$pH@HD$(H$H$H $HD$H$H$H$HD$HL$HT$ HDŽ$HDŽ$HDŽ$HD$xH$HD$pH$H$0H`HH$H$H$H$8H$@H$HH$HH$H$H4$HL$H$H$H$HD$H$HL$4H $H HD$H;T HD$ H( H$H-)HD$# |eH %H$H;A( HH$H$HDŽ$H$H$H $HD$4!HD$HL$HT$ H$H$H$H$H$H$HL$HT$zHD$HD$`HuH$H$H$H$HL$HT$:HD$HD$XH  H$ HD$H$H@ SuH vHH$HcHD$H$H$H$H$HL$HT$HD$HD$PHD$@Ht!H0H$H$HĘHt!HH$H$HĘH$H$H$H$HL$HT$*HD$ HL$H$H$HIPH$HD$HL$H$H$HH9tHL$hHD$hH$8HD$HD$0HD$h@D$/tHD$0HtH$HHHH@H$H$ H$(H H$ HD$H$H QHH$H$ H$H$(HHHX MHXu(HPH$H$H$HĘH$HT$HD$hH$HD$HD$HHtH$HHHPHH$H$H$HF H$HD$H$H WQHH$H$H$H$HPHXdHXu(HHH$H$H$HĘH$HL$H$HD$xHD$hH$HD$HD$pH H$+HD$H$H %UHH$ HT$xHXHPH$HL$0HHH$ HT$hHXu]HPH$ aHT$pHX u(HP H$H$H$HĘH$HT$H$HT$H$HT$PHD$0HD$8HvHtH$HHHPHH$xH$H$H H$HD$H$H SHH$H$H$H$xHPHH QHPu(HXH$H$H$HĘH$H\$ HtH$HHHH@H$`H$hH$pH` H$HD$H$H aQHH$H$`H$pH$hHXHP~HXu(HHH$H$H$HĘH$HL$ HtH$HHPH@H$HH$PH$XH H$+HD$H$H OHH$H$XH$PH$HHPHH HPu(HXH$H$H$HĘH$H\$$ HtH$HHHPHH$0H$8H$@H H$XHD$H$H "NHH$H$@H$8H$0HPHH HPu(HXH$H$H$HĘH$H\$Q NH$HL$XHHH$H$H H $HD$ H$H HD$HJ HD$/ (yHD$HD$H@HHD$D$HD$H@D$eH %H;avHH(Hl$ Hl$ HD$@HD$0H$HD$8HD$bAHD$HD$HD$@Hl$ H(xD$HD$D$eH %H;avH0Hl$(Hl$(HD$@HD$8H$HD$CHD$HD$ HD$8H$HD$"HD$HD$HL$   HD$@Hl$(H0wheH %H;aHHHl$@Hl$@HD$XHD$PH$HD$HD$HD$8tHD$XHl$@HHHD$PH$HD$HD$ HHD$HD$PH$HD$HD$D$<H$HuD$HD$`H uHuH9rHH HDHL$hHD$pHl$PHXHD$`H$HD$HL$HD$@HL$HH$H HD$HD$HD$@HL$HHD$HL$ mAHD$(HL$0HD$hHL$pHl$PHX躑 #jeH %H;aHHHl$@Hl$@HD$XHD$`HD$hHD$P@HD$HD$PH$w2HD$HD$ HD$P@fD$HD$P@fD$HL$ T$H9v*HL$(HT$0HD$8HL$XHT$`HD$hHl$@HHF ?i*eH %H;av:H Hl$Hl$D$0HD$(H$}D$D$D$0Hl$H heH %H;avYH0Hl$(Hl$(HD$HHD$8H$D$@D$4HD$HD$ HD$HD$ HD$HD$HHl$(H0sheH %H;avFH(Hl$ Hl$ HD$@HD$0H$D$8D$HD$HD$HD$@Hl$ H(heH %H;avFH(Hl$ Hl$ HD$@HD$0H$D$8D$HD$HD$HD$@Hl$ H(geH %H;aH(Hl$ Hl$ HD$8HD$0@tHD$8Hl$ H(HD$0H$4HD$HD$HD$HvHvhHtHD$0HHHD$8Hl$ H(HtHD$0H@HD$8Hl$ H(HD$0H0HD$8Hl$ H(HtHD$0H8HD$8Hl$ H(HtHD$0HPHD$8Hl$ H(HvOHtHD$0HXHD$8Hl$ H(HtHD$0H8HD$8Hl$ H(CHtHD$0H8HD$8Hl$ H(HtHD$0HPHD$8Hl$ H(e%eH %H;aHHHl$@Hl$@HD$XHD$`HD$P@(D$HD$PH$HD$HD$H$HD$HL$HL$ HD$(HD$P@uDHD$(HL$ HsPHHHH?HHHD$0HT$8HD$XHT$`Hl$@HHHD$ HL$(HD$XHL$`Hl$@HH dHD$HD$HHD$eH %H;a%HhHl$`Hl$`HD$xHD$pHuHD$pH$IHD$HD$8HHwHD$pHHHD$xHl$`HhHD$pH$XHD$HL$HL$PHD$XH$HRHD$HD$%HD$XHL$PHL$HD$ :HD$(HL$0HD$@HL$HHS H$HD$@HD$ HD$HL$H$HL$8 H H$H HD$ scHD$HD$@HD$HD$HD$@HD$HD$HD$@HD$D$HD$@D$HD$HD$HD$eH %H$H;AHH$H$HDŽ$HDŽ$HDŽ$H$H$HDŽ$HDŽ$ H H$H$H x HL$HD$9HD$ HL$H$H$ D$(D$GH$ H$H$H$D$GD$CD$CuHDŽ$HDŽ$HDŽ$H$H$H H9tHHHPHH$H$H$H$H$H$H$HH$H$nHD$H$HuH$HD$HL$HT$H$@H$HH$PD$DH$PH$@H$HH$H$H$HD$`H$HD$XH$H$HD$`HL$XH9|1H$PX@ $$$$$$$$$$$H$H$$D$HD$H$H$RD$D$Fu*H$HH$HD$`HHD$`D$DHDŽ$(HDŽ$0HDŽ$8D$DuH$@H$HH$PH$(H$0H$8H$H$H$0H$(H$8H$pH$xH$HDŽ$HDŽ$H H$H$pHD$HD$HL$HL$HD$ HnH$H$H ۆ HL$HD$HD$(HL$0H$H$H$H$HDŽ$XHDŽ$`HDŽ$hH$H$Hg H9tHHQHIH$XH$`H$hH$H$H$H$HH$HHD$xH H$HD$HD$xHD$HD$HL$ HT$(H$(H$0H$8H$@H$HH$PH$H$H$HD$PH$HD$HH$H$HD$PHL$HH9|zH$PX@ $$$$$$$$$$$H$H$$D$HD$H$H$D$D$EuH$(H$0H$8HYH9iHQH$0$$$$H\t| H$HH$HD$PHHD$PH5ؔ H4$HD$HL$HT$H\$ HD$(HL$0HT$8H$8H$(SH$0HD$pH$0HD$hHL$pH$8H9vH9vH$0H$8 WUHDŽ$HDŽ$HDŽ$H$HH$HT$H\m HD$ ۂ H $HT$H9m HD$ ZeH %H;aH`Hl$XHl$XHD$pHD$hH$XHD$HD$0Ht,HD$hHD$8H$&HD$HD$(HD$pHl$XH`HD$h@tHD$pHl$XH`HD$hH$FHD$HL$HT$HT$@HL$HHD$PHL$ HL$pHl$XH`YeH %H$H;A HH$H$H$WHHl$Hl$HmH$H$;HD$H$HL$HtH$H$H$H$H$HD$0#H$H$Hl$Hl$ۇHmH$H$Hl$Hl$踇HmH$HH$H$HD$HL$HT$H$H$H$H$H|H$H$H9}xH$H$H$H9rMH \tD $$$$H$H$$D$HD$H$H$HD$HL$H$H$H$H$HD$hH$H$$D$ HD$H$H$H$HD$HL$HT$H$hH$pH$xH$H( H$HD$H$HHD$FHD$HL$(HT$ H$H$H$H$H$0H 8H$pH$xH$H$H$HYH9IHAH$H$xH$pHH H\ 5`HD H$H$HD$HL$HT$H$PH$XH$`H$8H$@H$HHDŽ$H$@H$H$8H$H$H$H9|5H$HH$H$H$(H H$`H$hH$H$H$HpH9HXH$H$hH$`HH4Ht=#u7H\H$HH$H$HH$H4$H\$H CH Z& H $HT$HD$H\$Ht$ HT$(HD$0HL$8H$H$H 0H$H$HD$HL$HT$H$ H$(H$0H$H% H$HD$H$HD$\HD$(HL$ HT$H$H$H$H$H$THD$HL$HT$H$H$H$H$H$H$HD$xH$HD$pH$H$HD$xHL$pH9|+H$HH$H$H$ H H$PH$XH$H$H$HrH9HZH$H$PH$XHHH\=ٞu1HtH$HH$HD$xHHD$x'H$Ht$VH H $ H $HD$HT$H\$Ht$ HD$(HT$0HL$8H$H$H 6H$H$ D$D$gH$H$H$H$HL$HT$H$H$H$HD$HL$ HT$(D$gD$0hHD$8HL$@H$@H$HH$@H$HH$H$H H$HD$H$8H$H$$D$DNH$8HT$HH$8H$HDŽ$HDŽ$HDŽ$H$@H$HHWH9tH$H$H$HD$hH$H$H$H$ H$(H$0H$H$8H$HH $HT$"+H$HD$H5! H4$HT$HL$HD$H\$ VHT$(HL$0HD$8H$H$sH$HGx HD$H{! HD$ jw Ha H$H6HD$\ OeH %H$H;AHH$H$H$WHHl$Hl$zHmƄ$XH$H$#HD$H$HL$HT$HtH$H$H$H$@WHHl$Hl$pzHmH$H$H$H$HL$HD$H$@H$Hl$Hl$}HmD$hD$vH$H$@Hl$Hl$[}HmD$vD$wH$H$Hl$Hl$/}HmD$w$XH$HH$H$H$ZHD$H$Hu1H$HD$HL$HT$H$H$H$HD$xH$HL$x@H9|HD$xH$H$H9rH \tD $$$$H$H$$D$QHD$H$H$D$D$uu H$H$HHD$HL$H$H$H$H9tH $HD$H$H$HL$HD$tlD$ uyH$H$HD$xHD$H$H$Hl$Hl$I{HmH$H$Hl$Hl$&{HmƄ$XH$HHD$xH$HHD$xHH$H5}Hl$Hl$zHmƄ$XH$HH$H5Hl$Hl$zHmƄ$XH$Hs |KeH %H;aH@Hl$8Hl$8HD$PHD$XHD$H@tHD$PHD$XHl$8H@HD$HH$RHD$HD$HuQD$HD$HH$HD$HD$ H$HD$HL$HL$(HD$0HL$PHD$XHl$8H@HD$PHD$XHl$8H@J eH %H;a'H`Hl$XHl$XHD$pHD$xHD$h@tHD$pHD$xHl$XH`HD$hH$2HD$HL$HL$8HD$@HD$0HHD$HD$H}HD$HL$8HT$@H9r}<.tQHD$HHD$ HL$@HT$8H9vLH)HHH?H!HHD$HH\$PHD$pH\$xHl$XH`HD$HD$(HHD$g?q p 1IeH %H;avvH(Hl$ Hl$ HD$8HD$0H$HD$HD$Hu#HD$0HD$H@8HD$8Hl$ H(HB H$HwHD$= HqeH %H;avxH(Hl$ Hl$ D$8HD$0H$@HD$HD$Hu)HD$0HD$@2fD$8Hl$ H(H H$HHD$諀 HoeH %HD$H;ARHH$H$HDŽ$HDŽ$H$H$xHD$HD$HD$ HvHtRH$HD$@H@0H$踂HD$HL$HD$`HL$hH$H$H$HĨHtRH$HD$8H@0H$^HD$HL$HL$PHD$XH$H$H$HĨHtXH$HD$0H@8H$HD$HL$H$H$H$H$H$HĨHtXH$HD$(H@0H$蝁HD$HL$H$H$H$H$H$HĨHtRH$HD$HH@0H$=HD$HL$HL$pHD$xH$H$H$HĨH- H$HHD$(~ EeH %HD$H;A"HH$H$HDŽ$H$WHHl$Hl$pHmH$H$HD$HD$xHH$H$H$H$HD$HD$H$Ht$H$Hl$Hl$wsHmH$H$H$H$Hl$Hl$DsHmH$HH H$HHD$| 1DeH %H$xH;A?HH$H$HDŽ$0H$8WHHl$Hl$EoHmH$H$HD$H$HH$H$H$H$H$(H$ HD$HT$HL$HD$ H$Ht$(H$Hl$Hl$rHmH$H$0H$8H$Hl$Hl$qHmH$HHm H$HHD$h{ BeH %H$H;AHxH$pH$pHDŽ$H$WHHl$Hl$mHmƄ$H$H$HD$H$H=H$H$HDŽ$H$WHHl$Hl$cmHmH$H$H$H$HD$HL$%HD$H$Ht$ H$Hl$Hl$fpHm$$H$H$H$H$Hl$Hl$$pHm$$H$H$H$H$Hl$Hl$oHm$$H$pHxHl H$HHD$gy @ eH %H$H;AHpH$hH$hHDŽ$H$WHHl$Hl$kHmƄ$H$xH$HD$H$H-H$xH$HDŽ$H$WHHl$Hl$ckHmH$H$H$HD$ HD$H$Ht$H$Hl$Hl$snHmD$x$H$H$H$H$Hl$Hl$4nHm$$H$H$H$H$Hl$Hl$mHm$$H$hHpH| H$H1HD$ww >eH %H;aH`Hl$XHl$XHD$xHDŽ$HD$hH$\HD$HD$ HHD$hHD$(H$HD$HL$HT$HL$@HD$HHT$PHT$pH9r8HH$zyHD$HL$HL$0HD$8HL$xH$Hl$XH`ze Hq H$H6HD$lv =eH %H;aH@Hl$8Hl$8HD$PHD$XHD$HH$_HD$HD$HuEHD$HHD$ H@0H$xHD$HL$HD$(HL$0HD$PHL$XHl$8H@H H$HHD$u =BeH %H;avvH(Hl$ Hl$ HD$8HD$0H$HD$HD$Hu#HD$0HD$H@@HD$8Hl$ H(H" H$HHD$u vHD$H$H$XHD$HL$H$H$H$H9tH $HD$H$H$HD$HL$QD$ uyH$H$HD$`HD$H$H$Hl$Hl$Y`HmH$ H$Hl$Hl$6`HmƄ$pH$HHD$hHHD$hH$H$HH$HyX 0eH %HD$H;AHH$H$HDŽ$H$WHHl$Hl$[HmH$H|H$H@@HD$ H$H9}bH$H$HP8H@@H9r5HIH HL$0HDH$UkHD$HL$HL$`HD$hH$H$HD$0HH$HD$HL$HL$PHD$XH$H$HD$0H$茶D$D$$(HD$0HH$D$D$uHD$0HH$bHD$HL$HL$@HD$HHuH$H$HD$0H$HD$HD$(H$H H$"HD$HD$8H$HHD$8H$HDŽ$HDŽ$H$HDŽ$HDŽ$ H$Hİ[HD$0HH$芹HD$HL$H$H$H$H$H$HtBH$H@0H$ZHD$HL$HD$pHL$xH$H$hU H_ H$HHD$Zf -eH %H$xH;AHH$H$HDŽ$0H$8WHHl$Hl$XHmH$H$hHD$HL$H$H$H$PH$XH$ H$H$(H$H$H$HDŽ$H$H$H$H$H$H$H9|H$HH$H$H$H$HD$xH$H~H$PH$XH$H$HH $HD$H$Ht7H$H@PH$H $HD$HL$H$H$HH $HD$H$HtH$H@PH$H $HD$HL$H$H$H$H$H$PH$XH$PH@XH$XHT$xHT$H $HD$H$0Ht$H$8Hl$Hl$YHmH$HH$H$HH$-XsH$H* eH %H$H;AWHH$H$HDŽ$H$WHHl$Hl$UHmƄ$xHD$xH$XH$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$H$H$PH$H$H$PH$HDŽ$HDŽ$HDŽ$HT H$HD$HD$HD$bHD$ H$H$H$H H$H$H$XHDŽ$`H$hH$H$H$H$H$H$H$hH$`H$XH$H$H$H$H$HDŽ$H$H$H$H$@H$HH$PHDŽ$H$HH$H$@H$HH$H$H9| H$HHHHHXH@H$H$H$H$H$H$pH$xH$H$H$pH$HR H$H$HL$H$HL$zSHD$u.H$HH H$HH$HH$HR H$H$HL$H$HL$$lHD$H$@HDŽ$H$H@@H$H$H$H9|C H$H$H$HQ@HI8H9rS H@HH$HH$蹯HD$HL$H$`H$hHDŽ$H$H$2D$D$u H$H@H$H$HD$H$Htn H$H$HD$HL$H$pH$xHH $HD$H$H$`H$H$hH$HL$HD$D$~uJH1Q H$H$HL$H$HL$NQHD$HHKH5H$H$H5&Hl$Hl$SHmƄ$xH$H$xuH$H$H$HD$HD$H$Ht$H$Hl$Hl$hSHmHDŽ$XHDŽ$`HDŽ$hHDŽ$(HDŽ$0HDŽ$8H$H$H$xH$H$H$ H$0H$(H$8H$H$H$H$HH$H$H9wH H$H$H$H$H\$HT$HL$H$HL$ 觿HD$(HL$8HT$0H$H$H$H$H$H9vH$H$H$H$0H$HH$H$HD$H$HHD$TH$H$H$H$XH$`H$hHYH9>HAH$`H$HƄ$xH$HH$H51 H4$HT$HL$HD$H\$ tHT$(HL$0HD$8H$hH$X$xuH$HuvH$H$žHD$H$HuH$H$HM H$H$HL$H$HL$MHD$HHEHLM H$H$HL$H$HL$yfHD$H$8HH$HuoHL H$H$HL$H$HL$ fHD$H$0HHL H$H$HL$H$HL$LHD$HHHvL H$H$HL$H$HL$eHD$H$(HHDŽ$HDŽ$HDŽ$H$xH$H$H$H$H$H$H$H$H$H$H$H$HH$H$H9wH H$H$H$H$HL$HT$H\$H$HL$ 讻HD$(HL$0HT$8H$H$H$H$H$H9vH$H$H$H$H$HH$H$HD$H$HHD$PH$H$H$H$H$H$HYH9HQH$H$HHDŽ$HDŽ$HDŽ$HDŽ$H$H$H$H$H$H$H$H$H$H$H$HYH9HQH$H$H$H$H$HHtH|5iH<LDuHH\L$ H$H<$HT$7H$ H$H$HD$H5 H4$HD$HL$HT$H\$ cHD$(HL$0HT$8H$H$H5ء H4$HD$HL$HT$H\$ HD$(HL$0HT$8H$H$"mRHH H$HD$HD$HD$HD$ H$Vo$xuH$H>D 7D C )eH %H$hH;AHH$H$HDŽ$8H$@WHHl$Hl$EGHmƄ$Ƅ$H$0HuHDŽ$H$ H@@H$H$H$H9|H$H$H$ HQ@HI8H9r7H@HH$HH$eHD$HL$H$H$H$0H9tH $HD$H$0H$(HL$HD$:D$ uH$ H$H$HD$HD$H$Ht$H$Hl$Hl$HIHmH$H$8H$@H$Hl$Hl$IHmƄ$H$HH$H$D$$u$Ƅ$H$HH$X$uHDŽ$@H$HWHHl$Hl$EHmHDŽ$HDŽ$HDŽ$H$H$H H$H$H$0H$(HH $eHXHPH$ H$H$HD$RHD$H$@Ht$H$HHl$Hl$GHmD$x$H$@H$H$H$HHl$Hl$fGHm$$H$H$8H$@H$Hl$Hl$$GHm$$H$HH$HT$שH$H1? eH %H;avqH@Hl$8Hl$8HD$XHD$`HD$HHD$HHL$PHD$HL$ HD$H$RHD$HL$HL$(HD$0HL$XHD$`Hl$8H@[veH %H$H;AHH$H$HDŽ$H$@,uGH$@,D$H$H$mHD$H$H$H$HH$H$HDŽ$pHDŽ$xH~H$H$H > HL$HD$臟HD$ HL$H$pH$xD$(D$GH$xH$pH$H$D$GD$ED$Eu;H$H$H; H9tH$H$HH$H$HD$HL$H$`H$hHD$`H$H HD$HD$H$`H$hHD$HL$ HD$0HL$(H$H$H$H$H$HL$&HD$ HL$HT$H$H$H$H$H$H$HD$XH$HD$PH$H$HD$XHL$PH9|>H$HH$H$H$H@0H$H9u%H$HH$HD$XHHD$XH$H$H$H$HDŽ$PHDŽ$XH,|H$H$H Y< HL$HD$H$H 9 HL$HD$ !HD$(HL$0H$PH$XH$ H$(H$ H$(HP9 H9tH$H$HHH g H$0H$8H$0H$0H$H H$tHD$H$H$_RHHHxHqHl$Hl$AHmH$H$H $HD$HD$HD$HD$ HD$(D$0àHD$8H$H$]D$D$LH$A(H$@,HD$FH$<D$FH$H$HDŽ$HDŽ$H$@$H$H$H$HD$HL$HT$D$ D$HH$AH$H$]HY0HA0H$H$H$H$HDŽ$@HDŽ$HH}yH$H$H 9 HL$HD$H$H 6 HL$HD$ rHD$(HL$0H$@H$HH$H$H$H$H6 H9tLH$H$HH$HD$肢Hf H$HD$HL$ãH$HT$H" HD$m H$HT$H" HD$m H $HT$H" HD$|m EH@Hl$8Hl$8D$hHD$`HL$XHT$PHT$ HL$(HD$0HD$HD$(HD$HD$ HD$HD$HL$H9|CHD$D$D$L$Hiɓ1L$HHD$HHD$HD$HHD$묋D$HD$hHl$8H@eH %H;aH0Hl$(Hl$(D$PHD$@HuHD$@HHL$HH $HD$HD$ HuiHD$HHL$@HdH9t*H$HD$8HD$D$D$D$PHl$(H0H $H#7 HD$HW HD$m HD H$HHD$?G H& H$H{HD$!G zeH %H;aH0Hl$(Hl$(D$PHD$@HuHD$@HL$HHcH9tZHL$ H $HD$8HD$ D$D$uD$PHl$(H0HD$ H$HD$8HD$tD$D$H$H6 HD$HB HD$l H/ H$HHD$*F eH %H;aH0Hl$(Hl$(D$PHD$@HuqHD$@HL$HHbH9t6HL$H $HD$8HD$޵HD$HD$ HD$PHl$(H0H$H55 HD$Hi HD$k HV H$H۴HD$QE 5D$HD$H@HuHD$H@H@HD$eH %H$H;A HH$H$Ƅ$H$H$HD$H$HuƄ$H$HH$H$H@@H$HtƄ$H$HH$H$vHD$H$Ht H$H$HD$@HD$8H$H@@H$HL$8H9|H$HL$@HP@H@8H9rHH$H$H$H$D$H$H$HD$H$H$HL$8HP@H@8H9rHH$HD$H$H$蝡HD$H$H$跓HD$HL$H$H$H$H$茓HD$HL$H$H$H$H9tH$H$H $HD$H$H$HL$HD$)D$ uPH$@D$H$H$8HD$H$@H$H$H$@D$H$H$HD$H$8H$@H9tH$H$跐D$D$/uhHD$@HD$xHHD$@H$H@@HD$pHL$@H9}Ƅ$H$HHD$8HD$hHHD$8fH$H$ߓHD$HL$H$xH$HtH$H@0H$đHD$HL$H$xH$H$H$wHD$HL$H$XH$`HtH$H@0H$\HD$HL$H$XH$`H$H$`H9uH$H$xH $HD$H$`H$XHL$HD$j'D$ ud)Ƅ$H$HH$H$蛟HD$H$HuyHD$HH$H$ HD$HL$HT$H$H$H$HD$0H$HL$0@H9|H$HL$HHP@H@8H9rHH$H$H$H$D$H$H$苝HD$H$HD$0H$H$H9rH \tD $$$$H$H$$D$HD$H$H$.HD$HL$H$H$H$H$HD$HL$H$H$H$H9tH$H$H $HD$H$H$HD$HL$%D$ ujH$H$$D$赜HD$H$0H$H$H$@D$H$H$tHD$H$(H$0H9tH$H$4D$D$.uhHD$HHD$`HHD$HH$H@@HD$XHL$HH9}Ƅ$H$HHD$0HD$PHHD$0UH$H$\HD$HL$H$hH$pHt%H$H@0H$AHD$HL$H$hH$pH$H$HD$HL$H$HH$PHtH$D$H$H$蟚HD$H$ H$蹌HD$HL$H$HH$PH$pH$PH9uH$hH$pH$HL$H$HH$PHD$HL$"D$ uD Ƅ$H$HƄ$H$H.* '* * * eH %H;aH`Hl$XHl$XD$xHD$hHL$pH9tD$xHl$XH`HD$hH$謷HD$HL$HD$HHL$PHuHD$pH$耷HD$HL$HD$8HL$@HuD$xHl$XH`HD$hH$蔞HD$HD$0HD$pH$|HD$HD$(HL$0H9uHD$hH$HD$pHD$D$uD$D$'D$xHl$XH`GeH %H;a*HxHl$pHl$pƄ$$u_H$H$H9tCH$H$H$HD$H$HD$D$$Hl$pHxH$HH$H $HD$HL$HL$`HD$hH$HH$H $HD$HL$HD$PHL$XHD$hH9uƄ$Hl$pHxHD$`HL$hH$HL$HD$PHL$XHD$HL$D$ uH$HH$H $HD$HD$8H$HH$H $HD$HD$0HL$8H9uUH$HH$H $HD$HD$HH$HH$H $HD$HD$@HD$HH$HD$@HD$D$2D$D$/$Hl$pHxeH %H$H;AHH$H$Ƅ$H$H$H9tƄ$H$HĠH$H$VHD$HD$@H$H$;HD$H$HL$@H9uƄ$H$HĠHD$@HHvƄ$H$HĠHD$@HtHD$@HtHD$@HD$pHv@HtH$H$HD$H$H$H$HD$H$H$H9tH$H$lHD$HL$H$H$H$H$AHD$HL$H$xH$H$H$H $HD$H$xH$HD$HL$$D$ D$(D$?$H$HĠHtH$H$qHD$H$HtH$H$xHD$HL$H$hH$pH$H$MHD$HL$H$XH$`H$pH$hH $HD$H$XH$`HD$HL$$D$ D$(D$>uƄ$H$HĠH$H$胲HD$H$H$H$eHD$H$H$H9tH$H$bHD$HL$H$HH$PH$H$7HD$HL$H$8H$@H$PH$HH $HD$H$@H$8HL$HD$$D$ D$(D$=$H$HĠHtH$H$ H$H$H$ I2P2f9uƄ$H$HĠH$ I0@0f9uHD$XH$ H$3HD$H$HL$XH9|H$ H$HD$XHD$ HD$HL$H$(H$0H$H$HD$XHD$ӺHD$HL$H$H$ H$(H$0H$HL$H$ H$HL$HD$$D$ D$(D$ HD$(HD$0HD$8HL$@H$H$$H$HL$"H@D$lH$(ȀAH H$H|$IN H$H$SD$D$mu;NaH$HT$HP HD$ _ H $HT$H- HD$ H$H$OHD$HL$H$xH$H$H HD$HD$,H$H$xHL$HD$ jHD$0HL$(H$hH$pHA H$H$hHD$HD$HL$H $HD$ HA H$Hg]HD$} ִD$HD$@ D$eH %HD$H;AHH$H$H$tH$HPHXHpHxLBI9HZHXH$HPHXH@HD$pH\$xH$H$D$LHT$xH\$pH9rnD$GH$H\$xHt$p$  T$LH9r1H$D$HH$H$HĐHD$hH|$`H0A H$Ht$HT$H\$LD$ sOHD$(HL$0HT$8H\$hHS%uHCHHHHD$XHL$PHL$`H $HD$DHD$XHL$PH\$hc ̲eH %H;aHxHl$pHl$pH$@u Hl$pHxH$@HD$PHvHtH$HD$XHD$ HD$XHL$ H@@H9|gHD$XH@0HL$ HHH$HL$HHD$XH@0HD$H$H$HD$HHD$HD$ HD$0HHD$ Hl$pHxHHHvTH$H$H9rH$H$D$H$H$D$HtmH$H$H9rH$H$D$aH$H$D$GH$H$D$1!HHHv!HtH$HD$`HD$@HD$`H@@HD$8HD$@HL$8H9|HD$@HD$HL$`HQ@HI8H9r~H@HHD$hH$%7HD$HD$(HD$hH@HD$H$H$H$HD$(HD$HHD$@HHD$@e4Ht?h ѯ HD$HD$HHD$eH %H;aH Hl$Hl$HD$@HD$(HHu[HD$(H$TLD$D$u<HD$8rHD$0HHD$@Hl$H HD$0HD$@Hl$H H; H$HWHD$ ?eH %H;aHXHl$PHl$PHD$xHDŽ$HD$`HD$ HD$@HD$HHD$@HD$0HD$ H$D$D$uHD$pmHD$hHD$(HD$prHD$ H$8HD$HD$8HD$ H$HD$8HD$HD$(HD$AHD$8HD$(HD$0 HT$(HXuXHPHD$0HL$ u(HHD$HHL$@HL$xH$Hl$PHXH$HL$1?H$HT$!?yHD$pr>HD$0HL$h7HXH u HHbH$HL$>HD$0 HPH\$hu HX)H$H\$>H_9 H$HdUHD$Z 賬eH %H;a_HxHl$pHl$pHDŽ$HDŽ$HDŽ$H$HD$8H$HD$0HuH$ IHD$HD$(HD$HD$0H$?D$D$uHD$HD$ H HD$HD$@HD$HHD$PHD$0HD$@HD$8H@HD$HHD$HD$PHL$@HT$HH$H$H$Hl$pHxHD$XHD$`HD$hHD$XHL$`H$H$HDŽ$Hl$pHx)eH %H;aHHl$xHl$xHDŽ$HDŽ$H$H@HtyH$HHHHD$HL$ H$HzV HD$HD$HvK HD$(HD$0 HD$8HL$@H$H$Hl$xHĀH$H@H$?HD$HL$HD$hHL$pH$HH@HL$HD$ H$HU HD$HD$H3 HD$(HD$0HD$hHL$pHD$8HL$@H6 HD$HHD$P0HD$XHL$`H$H$Hl$xHĀ脩_eH %H;aH`Hl$XHl$XHD$hHD$pH$蠊HD$HD$8HD$0HD$0H$cHD$HD$@Hu1H$詰HD$HL$HL$HHD$PHL$hHD$pHl$XH`HPL HD$hHD$pHl$XH`譨8eH %H;aHHHl$@Hl$@HD$PH$HD$HD$HL$XH9u{HD$H $HL$0HD$8HD$PH$uHD$HD$HD H$[2HD$HD$ HL$8HT$0HH uHH$HT$9 Hl$@HHHD$ HL$HHHD$ HD$(H H $HD$E 螧eH %HD$H;A`HH$H$H$HtoHD$H $H$H$HC H$d1HD$HD$HH$H$HH uHFH$HT$86H$H`H$sBH$HİHD$HH@HD$HHD$PH H $HD$ H$HL$HD$hHL$pH$H; HD$HD$ HD$hHL$pHD$HL$ H2n HD$(HD$0}HD$8HL$@HD$XHL$`H2 H$HD$XHD$\HD$HL$H$HL$t ]HD$H $H$H$H$H: HD$HD$ H$H$HD$HL$ HG HD$(HD$0,|HD$8HL$@HD$xH$H1 H$HD$xHD$HD$HL$H$HL$ ~eH %H;avBHHl$Hl$D$8HD$0H$HD$'HD$(D$8Hl$H誤eH %H;aH8Hl$0Hl$0HD$XHD$`HD$hHD$PH$HD$HD$@H$O\HD$HL$HD$ HL$(HH $HD$HD$Hu/HD$HHHHPHHD$XHT$`HL$hHl$0H8Hh0 H$H}LHD$c 輣eH %H;aH8Hl$0Hl$0HD$XHD$`HD$hHD$PH$HD$HD$@H$_[HD$HL$HD$ HL$(HH $HD$HD$Hu/HD$HHHHPHHD$XHT$`HL$hHl$0H8Hx/ H$HKHD$s ̢D$ HD$D$ eH %H$pH;AHH$H$HDŽ$HHDŽ$PHDŽ$XH$@HD$PH$(H$ ?HD$HD$`HtjH$(H$H@@HD$XHL$PH9H$HL$PHP@H@8H9rHH$H$H$H$D$H$H$8HD$H$H$(D$D$OuH$0H$HHuHH@H$HH$HHD$PH=rHD H$XH$H$H$@D$H$H$\8HD$H$PH$HH$(H$HH$(H$8HD$HD$xHu[HL$PPH9sH$H6HD$HL$HT$H$H$H$HD$PH9rH \tD L$h\$lt$pD$tH$(H$D$hD$7HD$H$H$P'D$D$NuH. H$)HD$H$H$(H$D$pD$v7H$HT$uBHH$H$XH$(H$D$lD$6HD$H$PpH $HT$0H$H34 HD$HD$ H$ H$HL$HD$ H2W HD$(HD$0WvHD$@HL$8H$H$H6+ H$H$HD$HD$HL$H $HD$  H* H$H]GHD$  H$He3 HD$HD$ H$ H$HL$HD$ H} HD$(HD$0!uHD$@HL$8H$H$Hh* H$H$HD$2HD$HL$H$HL$J H$H2 HD$HD$ H$ H$HL$HD$ HU HD$(HD$0tHD$@HL$8H$H$H) H$H$HD$HD$HL$H $HD$  H) H$HEHD$ ܜ7eH %H;a!HPHl$HHl$HHD$XHD$ H$|9HD$HD$HtNHD$`HD$(HD$pHD$@HL$(gHIuHHl$HHPH$HL$-HD$hrHD$ H$ND$D$u8HD$pHD$0 HT$`u HH$HT$-HD$pHD$8HL$`H u HH$HL$`-藛eH %H$xH;AHH$H$HY HH$HHHP H@(H$H$H$HDŽ$HDŽ$HDŽ$H$H@HD$(H% H$HD$H$H$H$HD$HL$HT$ HD$0H$HD$8H$HD$@H$H$HD$xH$HD$pH$H$HDŽ$HDŽ$HD$pH$HD$xHD$HD$H$HD$HD$hHD$ HD$`HD$0H$H$H$HD$hHD$XHD$`HD$HH$H$H$H$XGHD$HL$H$H$H' H9tH$H$H$H$H$HL$HT$H$HD$}HD$XHHwH$H$H$HHD$H$HD$HD$HD$XHHD$ $-H$HD$H$H$H$HD$H$HD$HD$HD$轘H$HH+D$HHwHD$HHHD$PH$HH+D$HHD$ H$H$H$HD$PHD$H$HD$HHD$HD$HHD$[,H$HHD$H$H$6H$H$H$H$H$H +& HL$HD$LCH$H$H$HH $HT$H HD$ 脗H$H9;H#eH %H;a@H@Hl$8Hl$8WD$`D$hHD$XH$bHD$HD$HD$Ht0HD$PHZD$`ZD$hHl$8H@Ht(HD$P@L$`D$hHl$8H@HD$XH$HD$HD$ H3 H$ HD$HD$(H@ guH P HH$HP HD$(HD$(HL$ HHHD$(HD$0H M H $HD$ eH %H$xH;AHH$H$HDŽ$(HDŽ$0HDŽ$8H$ H$HD$HD$(HD$@HtuHDŽ$HDŽ$H$H$:HD$HD$8HtH$HHHH$H$H$H$H $HD$_HD$HL$HT$ H$H$H$Hu^HT$`H$ H`H H$H$H$H$H$(H$0H$8H$HH$HH@H$H$H$Hu5HAH$H$H$H$H$Ht~H$HD$xH$ rWHHD$xHD$xHuH$HD$pH@0HD$hH$ H`H HD$0HD$XHD$hH$`0HD$HD$PHL$XH HL$0HDŽ$HDŽ$HDŽ$HD$hH$HD$xH$HD$0H$H$H$H$(H$0H$8H$HHDŽ$HDŽ$HDŽ$H$H$H$(H$0HDŽ$8H$HH$ H$HD$HD$HH. H$HD$H$H@ 7uH @ HH$H@ HD$#H$HL$HHHH$H$H  H $HD$v ϑeH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$H$H$HD$HD$(HutH$H$yHD$HD$ H- H$_HD$HD$xH@ uH C HH$HC HD$"H$HD$`H@@HD$PH$H9HD$`H$HP@H@8H9rH IHHT$pHDHD$XH$D-HD$HD$HH$HH HL$HD$pHH$D$D$uHD$pH$HD$HD$0H$HHD$hHDŽ$HDŽ$HDŽ$HD$XH$HD$hH$HD$H$H$H$H$H$H$H$HĨHD$pH$cD$D$uHD$HD$@H@HD$HD$HD$8H HD$HD$xHL$ HHHD$xH$H 1 H $HD$ | Hs H$H7HD$n ǎeH %H;a H@Hl$8Hl$8WD$`HD$XH$HD$HD$HD$H t!HD$PZD$`Hl$8H@HtHD$PD$`Hl$8H@HD$XH$[HD$HD$ H* H$AHD$HD$(H@ uH @ HH$H@ HD$HD$(HL$ HHHD$(HD$0H ͪ H $HD$/ 舍eH %H$hH;AHH$H$HDŽ$@HDŽ$HHDŽ$PH$0H$YHD$HD$`HD$@HtH$ H$H$8HP@H93H@0HD$xH$8HHHL$ H$(HHD$pHD$xH$u)HD$HD$XH$0HH HL$8HDŽ$HDŽ$HDŽ$HD$xH$HD$pH$HD$8H$H$H$H$@H$HH$PH$HHtTH$(H$H$8H@H9H$ H$H@0H$H$HH$H$HHD$H$H$H$8HD$H*HD$HD$hH$H$(HD$HD$PH$0H`H HɀHL$(HDŽ$HDŽ$HDŽ$H$H$HD$hH$HD$(H$H$H$H$@H$HH$PH$HHtH$(H$H$8HPH9HH$H$8HD$HD$()HD$H$H$0H`H HD$0HDŽ$HDŽ$HDŽ$HYH$H$H$HD$0H$H$H$H$@H$HH$PH$HH$0H$HD$HD$HH% H$HD$H$H@ BuH #< HH$H< HD$H$HL$HHHH$H$H  H $HD$ Hh H$H 2HD$c HJ H$H1HD$E H, H$H1HD$' 耈eH %H;aHHHl$@Hl$@HD$hHD$`H$xHD$HD$HD$XHD$(HD$HD$HvHtHD$(HHD$hHl$@HHHtHD$(HHD$hHl$@HHHD$`H$HD$HD$ H5$ H$HD$HD$0H@ uH 3 HH$H3 HD$oHtHD$(HHD$hHl$@HHHtHD$(HcHD$hHl$@HHHtHD$(HHD$hHl$@HH!HD$0HL$ HHHD$0HD$8H H $HD$X 豆H Hl$Hl$HD$@HD$8H$\HD$HD$HD$@Hl$H eH %H;a>HxHl$pHl$pHDŽ$H$H$HD$HD$ HD$@Hv Ht'H$HD$HH@@H$Hl$pHxHt\H$H$H$H$HL$HT$HD$HD$`H$A@HD$HD$8H$Hl$pHxH$H$0HD$HD$(Ho H$ HD$HD$hH@ uH b* HH$HO* HD$RHt\H$H$H$H$HL$HT$HD$HD$XH$ŤHD$HD$0H$Hl$pHxHt"H$H@H$Hl$pHxHt"H$H@H$Hl$pHxHD$hHL$(HHHD$hHD$PH ߚ H $HD$A }eH %HD$H;AHH$H$HDŽ$(HDŽ$0HDŽ$8H$H$HD$H$HD$xH@0HD$(H$H$H$ H$HL$HT$H: HD$HD$ HD$0 HD$8HL$@HT$HH$H$H$ HDŽ$H$ rH$H$H$H$H$H$HL$HT$HD$H$H$H$H$HD$H$HD$WHD$H$H$HuHD$xH@8HD$pH$H$ H H`HD$XHD$hHD$pH$HD$HD$`HL$hH HL$XHD$pH$D$D$WuHD$pH$HD$H$HD$pH$H$HD$H$HD$HDŽ$HDŽ$HDŽ$HD$pH$H$H$HD$XH H$H$H$H$(H$0H$8H$HHDŽ$HDŽ$HDŽ$HD$pH$H$HH$HD$XH$H$H$H$(H$0H$8H$HHDŽ$HDŽ$HDŽ$H$H$H$(H$0HDŽ$8H$HH$H$9y eH %H$pH;AHH$H$HDŽ$0HDŽ$8HDŽ$@H$(H$HD$H$HD$hH@0HD$xH$HD$HD$`H$(H`H HL$HH$H$ H$(H$HL$HT$HD$HD$pHD$8HD$pHuHD$pH$HD$HD$8H$H$HD$pHD$HD$H$H{ H$HD$8HD$HD$8HD$nHD$(HL$ HT$H$H$H$HD$@HD$@H$HD$XHL$@H9|H$H$6HD$H$HuiHD$xH$D$D$7u[HD$xH$!HD$H$HD$xH$H$HD$H$HD$, HDŽ$HDŽ$HDŽ$HD$xH$H$H$HD$HH H$H$HT$@H$H$H$H9rHRHDHH\DEu9H4H|H$H$軜HD$@HD$PHHD$@H$H$H$Ht$H$H$H$HD$HDŽ$HDŽ$HDŽ$HD$xH$H$HH$HD$HH$H$HT$@H$H$H$H9rHRHDHLDuH4H|L$H$H$Ht$&H$H$H$HD$H$H$HT$@H9vGH$H$H$H$0H$8H$@H$Heڜ c \ t0eH %H;aH0Hl$(Hl$(HD$PHD$8HuGHD$H rHD$PHl$(H0HD$8H$HD$HD$HD$PHl$(H0H H$sHD$HD$H@ uH 5 HH$Hz5 HD$HD$H@HD$HD$ H H $HD$b seH %H;avRH(Hl$ Hl$ HD$HHD$@H$HD$HD$0HD$H@@HD$HD$HHl$ H(JseH %H;a"HhHl$`Hl$`HDŽ$H$H$BHD$HD$ HD$(HvcHtCHD$pHL$xH$H$HL$HT$HD$HD$XH$Hl$`HhHtH$ r.Hi HD$@HD$@HT H$Hl$`HhHD$pHL$xH$H$HL$HT$HD$HD$8Hu#HHD$8HD$8H$Hl$`HhH$H$"HD$HD$0Ha H$HD$HD$HH@ uH E, H`H$H5, HD$GIHHHvHtHD$xHH$Hl$`HhHtcGHD$HHL$0HHHD$HHD$PH K H $HD$譩 qeH %H;aH@Hl$8Hl$8HD$XH$AHD$XH$HD$HD$HH$(HD$HL$HL$(HD$0HH$HD$HD$HuRHD$PHD$ HL$pHT$hH\$`HPHH NuHHl$8H@H$H\$H H$HHD$譨 peH %H;aH@Hl$8Hl$8HD$XH$AHD$XH$HD$HD$HH$'HD$HL$HL$(HD$0HH$HD$HD$HuRHD$PHD$ HL$pHT$hH\$`HPHH NuHHl$8H@H$H\$H H$HHD$譧 oeH %H;avxH Hl$Hl$HD$8H$EHD$8H$HD$HD$0HD$HL$HHT$@HH uHHl$H H$HT$;tnoeH %HD$H;A?HH$H$HDŽ$0HDŽ$8HDŽ$@HD$0HD$PHD$xH$H$!HD$HD$ HD$8HtH$H$HD$XH@@HD$0HD$XH@8HD$PH$HD$xH$ H|H$(H$ H9|H$(HL$0H9Hz H$aHD$H$H@H@ HH$HD$`H$(H+$ HHHD$`HL$0H+$ HHHD$0H+$ H>HD$PH@0H$HD$HD$@HD$xH$H$ HD$HD$@HD$F HD$H$HL$`<HH$H`H HD$(HD$PH$$ HD$H$HDŽ$HDŽ$HDŽ$H$H$H$H$HD$(H$H$H$H$0H$8H$@H$HH $HD$ .HD$`HL$xIu HH$HL$H$HD$'Ht;H$HD$PH$HD$pHHD$xHD$pH@HD$0UHtH$HD$hH$ H|\H$(H$ H9|@H$(H@H9&HT H$HD$H$HD$hHH$H$ HD$HD$ HD$H$HDŽ$HDŽ$H$H$H$(H+$ H$H$H$HAHHDŽ$HDŽ$HDŽ$H$H$H$H$H$H$H$H$H$0H$8H$@H$HH $HT$aH$H$=HD$HD$HH| H$#HD$H$H@ ƴuH  HH$H HD$_H$HL$HHHH$H$H H $HD$ H H$HHD$ H H$HHD$ɠ H H$HHD$諠 heH %H;aHHl$xHl$xHDŽ$HDŽ$H$H$HD$HD$HHD$PHt*H H$HDŽ$Hl$xHĀHt0H$HHHH$H$Hl$xHĀH$H$H$H$HL$HT$HD$ HL$HL$hHD$pHH$HD$HL$HD$XHL$`H$H HD$HD$HD$`HL$XHL$HD$ H HD$(HD$0>HD$@HL$8H$H$Hl$xHĀRf]eH %HD$H;AHH$H$HDŽ$HDŽ$H$HD$(HtYHn H$HD$HD$pH@ uH j HH$HW HD$Q s/H$H H$H$H$HĨH$H HD$ H$H$HD$HD$0HtH$HD$XH@@HD$8HL$ H9HD$XHL$ HP@H@8H9rHHT$`HDD$H$H$>HD$H$H H$H$H$HĨH$H$HD$HD$PHuHL$ PH9sH$#HD$HL$HT$H$H$H$HT$ H9rH\tL D$@\$Dt$HL$LH$H$D$DD$QHD$HD$xH H$H$H$HĨ7HD$pH@HD$pHD$hH H $HD$  H H$H HD$ۛ Ċ H H$H HD$趛 ceH %H;aHHHl$@Hl$@HD$hHD$`H$HD$HD$HD$XHD$(HD$HD$H vHtHD$(HHD$hHl$@HHHtHD$(HD$hHl$@HHH tHD$(HD$hHl$@HHHD$`H$dHD$HD$ H H$JHD$HD$0H@ uH  HH$H HD$mH tHD$(HD$hHl$@HHH tHD$(HHD$hHl$@HHH tHD$(HHD$hHl$@HH#HD$0HL$ HHHD$0HD$8H f~ H $HD$ș !aHD$ HD$HL$HHD$HD$ eH %H;aH`Hl$XHl$XHD$xHDŽ$HDŽ$HD$hHuwHD$pHL$hH $HD$0HD$pHL$hH $HD$³HD$HL$HT$ HD$@HL$HHT$PHD$@HL$HHD$xH$H$Hl$XH`HD$(HD$0HD$8HD$(HL$0HD$xH$HDŽ$Hl$XH`_eH %H;aHxHl$pHl$pHDŽ$HDŽ$HDŽ$H$HuH$HH$H $HD$HD$0H$HD$HD$(HD$ HD$0H$LD$D$uH$H$HcH9tH $HD$HD$8HD$XHD$`HD$hHD$0HD$XHD$8HD$`HD$ H HD$hHL$XHT$`H$H$H$Hl$pHxHD$@HD$HHD$PHD$0HD$@HD$HHD$ HD$PHL$@HT$HH$H$H$Hl$pHxH$HJ HD$H~/ HD$ Hk H$HHD$f ]eH %H;aFHXHl$PHl$PHD$pHD$xHDŽ$HD$`HuHD$hHL$`HH9tH$HD$HD$ HD$HD$`HHL$hH $HD$HD$0H$EHD$HD$(HD$8HD$@HD$HHD$(HD$8HD$ HD$@HD$HD$HHL$8HT$@HL$pHT$xH$Hl$PHXH $H݄ HD$H. HD$w H H$HsHD$ R\eH %H$pH;AHH$H$HDŽ$PHDŽ$XHDŽ$`H$( riH$8H$0H $HD$H$H$ H$(HD$HL$HT$ HD$(HL$0HT$8H$H$ H$(H$@H$H$HD$XD$D$nuH$(H%HD$pH$H$@H$HD$HD$xH$H HL$pHDŽ$HDŽ$HDŽ$H$@H$H$ H$HD$pH$H$H$H$PH$XH$`H$HH$@H$H$HD$MD$D$ouH$HHuH$H$ H$(H$HL$HT$D$HD$(HL$ H$H$H$@H$HD$H$HtH$HH$H$H$HHXHHHDŽ$HDŽ$HDŽ$H$@H$H$HH$HDŽ$H$H$H$PH$XHDŽ$`H$HH$HL$_H$@H$H$H$HL$HD$H$HHD$$H$@H$"HD$H$HNH$H$HD$HL$H$H$H$@H$]HD$HL$H$H$H$H$8H$0HL$HD$Hw HD$HD$ H$H$HL$(HD$0H! HD$8HD$@H$H$HL$HHD$P0HD$`HL$XH$H$H H$H$HD$ǸHD$HL$H $HD$ߏ 8WeH %H$H;AHxH$pH$pHDŽ$H$H$HD$H$H$HvHHHv\H$H$HD$HD$HHD$xHHH v!H+h H$H$pHxHHHv!Hg H$H$pHxHt!Hg H$H$pHxH$H$H$HD$D$VD$D$'uHHg H$H$pHxH$H$HD$H$Ht2H$H$ HD$HL$H$H$HtH$H$'HD$H$HtH$H$ HD$HL$H$H$HtH$H$ HD$HL$H$H$HH$HD$H$H$H$ HD$HL$H$H$HH $HD$H$H$H$H$HD$D$]UD$D$&uHe H$H$pHxH$H$H$HD$GD$D$%ufH$H$HD$H$HtHYe H$H$pHxHpe H$H$pHxHDŽ$H$pHxHC>9HHHvH$H$HD$HD$@HD$pHHH v!Hd H$H$pHxHHHv!Hd H$H$pHxHt!Hd H$H$pHxHHvH$H$YHD$HD$8HD$hHHHv!Hc H$H$pHxHHHv!Hc H$H$pHxHHv!Hc H$H$pHxHHHvVH$H$HD$HD$0HD$`HHv!Hc H$H$pHxjHt2H$H$5HD$H$HtH$H$< HD$HL$H$@H$HHH$HD$HL$H$0H$8HtH$H$HD$HL$H$ H$(HH $HD$H$HD$PHt!H>b H$H$pHxHt!Ha H$H$pHx3Ht/H$H$HD$HD$(HtH$H$HD$HL$H$H$HH$HD$HL$H$`H$hHtH$H$HD$HL$H$PH$XHH$HD$H$HD$XHt!Ha H$H$pHxHt!H` H$H$pHxNeH %H;aHpHl$hHl$hHDŽ$HDŽ$HDŽ$H$HH$H $HD$HD$ H$ HD$HD$(HD$ HHD$HvHtHD$(HD$8H$HD$ H$HD$HD$HD$PHD$XHD$`HD$ HD$PHD$(HD$XHD$xH D$H HD$`HL$PHT$XH$H$H$Hl$hHpHtHD$(HD$0H$fRKHtHD$(HD$HH$&HtHD$(HD$@H$HM6eH %H;aSH`Hl$XHl$XHDŽ$HDŽ$HDŽ$HD$xHH$H $HD$HD$ H$>HD$HD$(HD$ HHD$HtHD$(HD$8D$pZHD$ H$.HD$HD$HD$@HD$HHD$PHD$ HD$@HD$(HD$HHD$hH D$H HD$PHL$@HT$HH$H$H$Hl$XH`HtHD$(HD$0D$pSNKeH %H;apH`Hl$XHl$XHDŽ$HDŽ$HDŽ$H$HH$H $HD$HD$ H$HD$HD$(HD$ HHD$HtHD$(HD$8D$xL$pZZ@HD$ H$HD$HD$HD$@HD$HHD$PHD$ HD$@HD$(HD$HHD$hH D$H HD$PHL$@HT$HH$H$H$Hl$XH`Ht(HD$(HD$0D$xL$p@HCJseH %H;a#HhHl$`Hl$`HDŽ$HDŽ$HDŽ$H$H$H $HD$HD$HL$HT$ HD$HHL$PHT$XHD$HHL$PH$HL$HT$rHD$HL$ HT$(HD$0HL$8HT$@HD$0HL$8HT$@H$HL$HT$H$HL$xHL$HD$ HD$@H%H D$pHD$@HL$0HT$8H$H$H$Hl$`HhHeH %H;a0HhHl$`Hl$`HDŽ$HDŽ$HDŽ$H$H$H $HD$HD$HL$HT$ HD$HHL$PHT$XHD$HHL$PH$HL$HT$2HD$HL$ HT$(HD$0HL$8HT$@HD$0HL$8HT$@H$HL$HT$H$H$HT$xHT$HL$ HD$(HD$@H%H D$pHD$@HL$0HT$8H$H$H$Hl$`HhGeH %H;a0HhHl$`Hl$`HDŽ$HDŽ$HDŽ$H$H$H $HD$mHD$HL$HT$ HD$HHL$PHT$XHD$HHL$PH$HL$HT$HD$HL$ HT$(HD$0HL$8HT$@HD$0HL$8HT$@H$HL$HT$H$H$HT$xHT$HL$ HD$(~HD$@H%H D$pHD$@HL$0HT$8H$H$H$Hl$`Hh8FeH %H;aH`Hl$XHl$XHDŽ$HDŽ$HDŽ$HD$hHL$pHT$xH$HL$HT$YHD$HD$8HD$xH`H$HD$8HD$H$H$HL$HD$HD$ HL$(HT$0HD$@HL$HHT$PHD$@HL$HH$H$H$Hl$XH`:EeH %H;aH`Hl$XHl$XHDŽ$HDŽ$HDŽ$HD$hHL$pHT$xH$HL$HT$HD$HD$8HD$xH`H$HD$8HD$H$H$HL$HD$HD$ HL$(HT$0HD$@HL$HHT$PHD$@HL$HH$H$H$Hl$XH`:DeH %H;aH`Hl$XHl$XHDŽ$HDŽ$HDŽ$HD$hHL$pHT$xH$HL$HT$ D$D$8HD$xH`H$D$8H,HD$H$H$HL$HD$HD$ HL$(HT$0HD$@HL$HHT$PHD$@HL$HH$H$H$Hl$XH`2CeH %H;aH`Hl$XHl$XHDŽ$HDŽ$HDŽ$HD$hHL$pHT$xH$HL$HT$D$D$8HD$xH`H$D$8 f.wuH,HD$H$H$HL$HD$HD$ HL$(HT$0HD$@HL$HHT$PHD$@HL$HH$H$H$Hl$XH`\H,HH wAeH %H;aH`Hl$XHl$XHDŽ$HDŽ$HDŽ$HD$hHL$pHT$xH$HL$HT$HD$HD$8HD$xH`H$HD$8WH*D$H$H$HL$HD$0HD$ HL$(HT$0HD$@HL$HHT$PHD$@HL$HH$H$H$Hl$XH`@eH %H;aH`Hl$XHl$XHDŽ$HDŽ$HDŽ$HD$hHL$pHT$xH$HL$HT$yHD$HD$8HD$xH`H$HD$8H}yWH*D$H$H$HL$HD$HD$ HL$(HT$0HD$@HL$HHT$PHD$@HL$HH$H$H$Hl$XH`HHHH WH*Xs?eH %H;aH`Hl$XHl$XHDŽ$HDŽ$HDŽ$HD$hHL$pHT$xH$HL$HT$艰D$D$8HD$xH`H$D$8D$H$H$HL$HD$HD$ HL$(HT$0HD$@HL$HHT$PHD$@HL$HH$H$H$Hl$XH`>eH %H;aHpHl$hHl$hHDŽ$HDŽ$HDŽ$HD$xH$H$H$HL$HT$D$ L$L$@D$HH$H`H$D$HL$@L$D$H$H$HL$HD$ DHD$(HL$0HT$8HD$PHL$XHT$`HD$PHL$XH$H$H$Hl$hHp=eH %H;aHhHl$`Hl$`HDŽ$HDŽ$HDŽ$HD$pHL$xH$H$HL$HT$趴HD$HD$@H$HD$@HD$HD$HL$HL$HD$H$H`H$H$H$HL$HD$ HD$(HL$0HT$8HD$HHL$PHT$XHD$HHL$PH$H$H$Hl$`HhsHH$H$HDŽ$HDŽ$HDŽ$H$HH$H $HD$HD$PH$=HD$HD$8H$H$H$H$HL$HT$D$3HD$(HL$ HL$XHD$`H$HH$H $HD$HD$0HtHD$8HD$@HL$`HT$XH~HXHHH$H$HH$HD$HD$HHD$hHD$pHD$xHD$HHD$hHD$8HD$pH$H`H HD$xHL$hHT$pH$H$H$H$HĈH$HL$LH$H$HH9t,H $HD$`HL$XHL$HD$HD$8HD$RH$H2Z HD$Hf HD$̐ 1eH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$H$H$H$H$HL$HT$"D$D$GuH$H$H $HD$RHD$HL$HT$ HD$PHL$XHT$`HT$HH$H`H HT$`HD$PHL$XHT$`H$H$H$H$HĠH$H$H$H$HL$HT$wHD$HL$ HT$(H$H$H$H$H$H$HL$HT$H$H$HL$HD$ HD$(HL$0HT$8HD$hHL$pHT$xHD$hHL$pH$H$H$H$HĠ/eH %H;avfHHl$Hl$LuIHD$(HL$ H = o{uH2Hl$HH H $HD$6/eH %H;av,HHl$Hl$H H$H! HD$g .eH %H;avRHHl$Hl$HD$ HuHD$(Hu Hl$HH& H$H HD$!g z.eH %H;aH@Hl$8Hl$8HBHD$HBHJHRHT$ HL$(HD$0HD$HL$HHPHH9rHHD$HD$HL$PHH@H9rHD$HH@Ht$HH H9rsyHuUH HD$HL$PHT$ H\$(H9r0Hʋ5yuHHl$8H@H$HD$1H$HL$T ,eH %H;a@HHHl$@Hl$@HBHD$HBHJHRHT$(HL$0HD$8HD$HL$PHPHH9rHHHDHT$HD$ HD$HL$XHH@H9rHD$HH@Ht$PHH< HL H9rHHL3H3 sxucH<3HD$XHL$HT$ H\$(Ht$0H9r9HHT8xH4uH Hl$@HHH4$HL$нH$H|$辽S H+H0Hl$(Hl$(HBHD$HBHJHRHT$HL$HD$ HD$HL$8HPHH9rpHH$HD$HL$@HH@H9rNHD$HH@Ht$8H H9r.H H$HL$@HT$H\$H9rHHl$(H0R H0Hl$(Hl$(HBHD$HBHJHRHT$HL$HD$ HD$HL$8HPHH9rlD$HD$HL$@HH@H9rKHD$HH@Ht$8 H9r, D$HL$@HT$H\$H9r Hl$(H0Q H0Hl$(Hl$(HBHD$HBHJHRHT$HL$HD$ HD$HL$8HPHH9rrHfD$HD$HL$@HH@H9rOHD$HH@Ht$8 JH9r/f sD$HL$@HT$H\$H9rfJHl$(H0Q H0Hl$(Hl$(HBHD$HBHJHRHT$HL$HD$ HD$HL$8HH@H9ro D$HD$HHT$@H@H9rMHD$HH@Ht$8 H9r- 3D$HL$@HT$H\$H9r  Hl$(H0PP eH %H;aZHXHl$PHl$PHBHD$HHBHD$ HBHD$8HB HD$@HD$HHL$`H@H9sHD$HHL$hH@H9sHD$HHH$HD$`HD$HD$ HD$HD$HD$0HD$HHH$HD$hHD$HD$ HD$HD$HD$(HD$8H$HD$@HD$HD$0HD$菻HD$8H$HD$0HD$HD$(HD$mHD$8H$HD$(HD$HD$@HD$KHl$PHXH H$H HD$_ &eH %H;av|H@Hl$8Hl$8HBHJHL$(HD$0D$XHD$PHL$0H9tAHD$HHL$PH$HL$HD$(HL$0HD$HL$FD$ D$XHl$8H@&keH %HD$H;ADHH$H$BD$HHDŽ$HDŽ$HDŽ$HDŽ$HDŽ$D$HD$LHDŽ$HDŽ$D$LD$PHH$H4 HD$HD$PHD$HD$HL$ H$H$D$(D$GH$H$HL$xH$D$GD$FD$Fu$HDŽ$HDŽ$HDŽ$HD$xH$H| H9tHHQHIH$H$H$H$H$H$D$HD$TH$H$H$HYH925pH$LȅH<H$H$H$Hر H$HD$THD$HD$HL$H$H$H${ H$H$HD$nHD$HL$HD$HL$ HH$H$H$HD$HL$PH$HD$pH \yH$H$H$HHD$hH\$`HT$XL$H|$oHD$hHT$XH\$`HL$`H5K H4$HD$HL$HT$H\$ 袿HD$(HL$0HT$8HYHL$`VH$HT$H5 HD$f "eH %H;av\H(Hl$ Hl$ HBHD$HD$0HD$8HD$H$zHD$HD$H  HL$0HD$8Hl$ H("eH %H;aH8Hl$0Hl$0k<w Hl$0H8k<tL ks.  H H $H lHHD$. HD$HL$HL$ HD$(HcwH9t= muHI9kHl$0H8H /H $HD$qH $HI HD$H( HD$莀 !eH %HHl$Hl$HY HuH$HL$ HL$轅Hl$HH|$ H9;uH#eH %H;avwH0Hl$(Hl$(HY HujHD$@HD$HHD$8Hu;HD$8HH$HD$HL$HL$HD$ HL$@HD$HHl$(H0  pH|$8H9;uH#eH %H;avwH0Hl$(Hl$(HY HujHD$@HD$HHD$8Hu;HD$8HH$ HD$HL$HL$HD$ HL$@HD$HHl$(H0l  pH|$8H9;uH#eH %H;aH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$HD$HD$8HD$0HH$HD$8HD$HD$HD$HD$8HD$@Hl$ H(XcD$HD$HL$ 9t>HD$@HL$If9uHD$@HL$I9D$eH %H;avqH0Hl$(Hl$(HY HudHD$@HD$8Hu>HD$8HHPH@H $HT$HD$@HD$HD$ HD$@Hl$(H0 kvH|$8H9;uH#eH %H;avqH0Hl$(Hl$(HY HudHD$@HD$8Hu>HD$8HHPH@H $HT$HD$HD$HD$ HD$@Hl$(H02 vH|$8H9;uH#eH %H;avqH0Hl$(Hl$(HY HudHD$@HD$8Hu>HD$8HHPH@H $HT$HD$萨HD$HD$ HD$@Hl$(H0 +vH|$8H9;uH#eH %H;avqH0Hl$(Hl$(HY HudHD$@HD$8Hu>HD$8HHPH@H $HT$HD$HD$HD$ HD$@Hl$(H0 vH|$8H9;uH#eH %H;aH@Hl$8Hl$8HY Hu|HD$PHD$XHD$HHuMHD$HHHPH@H $HT$HD$HD$ HL$HL$(HD$0HL$PHD$XHl$8H@6 ZH|$HH9;vH#neH %H;aH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$HD$8HD$0HH$HD$8HD$ȣHD$HD$8HD$0H H$HD$8HD$袦HD$HD$8HD$0H0H$HD$8HD$HD$ CHD$HD$8HD$@Hl$ H( eH %HD$H;AlHH$H$Ƅ$H$HHHHD$xH$H$HHHHD$hHL$pH$H9tH$HL$xH $HD$HD$pHL$hHL$HD$9D$ uH$HHH@HL$XHD$`H$HHH@HD$HHL$PHD$`H9toHD$`HL$XH $HD$HD$HHL$PHD$HL$n9D$ u,H$HH(H@ HD$8HL$@H$HH H@(HL$(HD$0HD$8H9tH $HD$0HD$HD$@HD$iD$uH$H$H@0HI0H9tH$H$H@8HI8H9uaH$H$H@@HI@H9u7H$H@HH$HIHH9$H$HĐ>;3GreH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$肠HD$HD$8HD$0HH$HD$8HD$HD$#HD$HD$8HD$@Hl$ H(peH %H;aHPHl$HHl$HD$hHD$XHHHHD$8HL$@HD$`HHHHD$(HL$0HD$@H9tcHD$8HL$@H$HL$HD$(HL$0HD$HL$6D$ u(HD$XH@HL$`HIH9D$hHl$HHP0HD$HD$HD$HD$HD$HD$HD$ͰHD$HD$HD$馱HD$HD$HD$馱HD$HD$HD$ֲHD$HD$HD$ֲHD$HD$HD$ֲHD$HD$HD$HD$HD$HD$H|$WHHl$Hl$AHmHD$HD$H|$ WHHl$Hl$@HmD$pHD$HD$HD$HD$HD$HD$HD$HD$HD$HD$}HD$HD$HD$D$HD$HD$HD$HD$HD$HD$HD$H|$ WHHl$Hl$?HmHD$HD$HD$(H|$0WHHl$Hl$?HmHD$HD$HD$ H|$(WHHl$Hl$M?HmƄ$HD$HD$HD$H|$ WHHl$Hl$>HmƄ$HD$HD$HD$HD$ HD$HD$mHD$HD$HD$HD$=HD$HD$HD$HD$HD$HD$FHD$HD$HD$HD$HD$HD$6HD$HD$ HD$HD$D$ HD$HD$D$ HD$HD$D$ HD$HD$zD$HD$HD$*HD$HD$HD$HD$HD$HD$HD$魫HD$HD$HD$醬HD$HD$HD$醬HD$HD$HD$鶭HD$HD$HD$鶭HD$HD$HD$鶭HD$HD$HD$֭HD$HD$HD$H|$WHHl$Hl$;HmHD$HD$頶H|$ WHHl$Hl$;HmD$pHD$HD${HD$HD$HD$HD$HD$HD$HD$HD$]HD$HD$HD$D$HD$HD$HD$HD$HD$HD$mHD$H|$ WHHl$Hl$:HmHD$HD$HD$(H|$0WHHl$Hl$m:HmHD$HD$HD$ H|$(WHHl$Hl$-:HmƄ$HD$HD$HD$H|$ WHHl$Hl$9HmƄ$HD$HD$HD$HD$ HD$HD$MHD$HD$HD$HD$HD$HD$HD$HD$HD$HD$&HD$HD$HD$HD$HD$HD$HD$HD$ HD$HD$D$ HD$HD$D$ HD$HD$zD$ HD$HD$ZD$HD$HD$ HD$HD$HD$֤HD$HD$HD$HD$鍦HD$HD$HD$fHD$HD$HD$fHD$HD$HD$閨HD$HD$HD$閨HD$HD$HD$閨HD$HD$HD$鶨HD$HD$HD$ưH|$WHHl$Hl$6HmHD$HD$週H|$ WHHl$Hl$6HmD$pHD$HD$[HD$HD$HD$HD$mHD$HD$HD$HD$=HD$HD$HD$fD$HD$HD$HD$HD$HD$HD$MHD$HD$ HD$HD$MHD$HD$HD$HD$HD$HD$HD$HD$HD$HD$&HD$HD$HD$HD$HD$HD$HD$HD$ HD$HD$D$ HD$HD$D$ HD$HD$zD$ HD$HD$ZD$HD$HD$ eH %H;avQH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$4HD$HD$8HD$@Hl$ H(;eH %H;avUH8Hl$0Hl$0D$PHD$@HD$(HD$HHD$HD$(H$HD$4S'D$D$'D$PHl$0H8HD$HD$HD$HD$HD$HD$HD$魡HD$HD$HD$醢HD$HD$HD$醢HD$HD$HD$鶣HD$HD$HD$鶣HD$HD$HD$鶣HD$HD$HD$֣HD$HD$HD$H|$WHHl$Hl$1HmHD$HD$頬H|$ WHHl$Hl$1HmD$pHD$HD${HD$HD$HD$HD$鍺HD$HD$HD$HD$]HD$HD$HD$醼D$HD$HD$HD$HD$HD$HD$mHD$H|$ WHHl$Hl$0HmHD$HD$駿HD$(H|$0WHHl$Hl$m0HmHD$HD$HD$ H|$(WHHl$Hl$-0HmƄ$HD$HD$HD$H|$ WHHl$Hl$/HmƄ$HD$HD$HD$HD$ HD$HD$MHD$HD$HD$HD$HD$HD$HD$HD$HD$HD$&HD$HD$HD$HD$HD$HD$HD$HD$ HD$HD$D$ HD$HD$D$ HD$HD$zD$ HD$HD$ZD$HD$HD$ eH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$HD$8HD$0H8H$HD$8HD$HD$HD$HD$8HD$@Hl$ H(peH %H;aHHHl$@Hl$@D$`HD$PHD$8HD$XHD$0HD$8H$HD$0HD$HD$0%!D$uHD$P@0HL$XI0f9utHD$P@2HL$XI2f9uRHD$PH8HD$(HD$XH8HD$ HD$(H$HD$ HD$HD$ D$D$`Hl$@HH HD$HD$HD$6HD$HD$HD$HD$HD$HD$HD$ƛHD$HD$HD$ƛHD$HD$HD$HD$HD$HD$HD$HD$HD$HD$HD$HD$HD$HD$HD$&H|$WHHl$Hl$:+HmHD$HD$H|$ WHHl$Hl$ +HmD$pHD$HD$黯HD$HD$HD$HD$ͳHD$HD$HD$HD$靴HD$HD$HD$ƵD$HD$HD$:HD$HD$HD$HD$魶HD$H|$ WHHl$Hl$)HmHD$HD$HD$(H|$0WHHl$Hl$)HmHD$HD$HD$ H|$(WHHl$Hl$m)HmƄ$HD$HD$HD$H|$ WHHl$Hl$)HmƄ$HD$HD$ϼHD$HD$ HD$HD$鍾HD$HD$HD$HD$]HD$HD$HD$HD$HD$HD$fHD$HD$HD$HD$HD$HD$VHD$HD$ HD$HD$D$ HD$HD$D$ HD$HD$D$ HD$HD$D$HD$HD$JeH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$HD$8HD$0H8H$HD$8HD$HD$HD$HD$8HD$@Hl$ H(UpeH %H;aHHHl$@Hl$@D$`HD$PHD$8HD$XHD$0HD$8H$HD$0HD$HD$0eD$uHD$P@0HL$XI0f9utHD$P@2HL$XI2f9uRHD$PH8HD$(HD$XH8HD$ HD$(H$HD$ HD$HD$D$D$`Hl$@HHJHD$HD$HD$vHD$HD$HD$HD$-HD$HD$HD$HD$HD$HD$HD$HD$HD$6HD$HD$HD$6HD$HD$HD$6HD$HD$HD$VHD$HD$HD$fH|$WHHl$Hl$z$HmHD$HD$ H|$ WHHl$Hl$J$HmD$pHD$HD$HD$HD$HD$HD$ HD$HD$HD$HD$ݭHD$HD$HD$D$HD$HD$zHD$HD$HD$HD$HD$H|$ WHHl$Hl$-#HmHD$HD$'HD$(H|$0WHHl$Hl$"HmHD$HD$7HD$ H|$(WHHl$Hl$"HmƄ$HD$HD$_HD$H|$ WHHl$Hl$]"HmƄ$HD$HD$HD$HD$ HD$HD$ͷHD$HD$HD$HD$靸HD$HD$HD$6HD$HD$HD$馹HD$HD$HD$&HD$HD$HD$閺HD$HD$ HD$HD$-D$ HD$HD$ D$ HD$HD$D$ HD$HD$D$HD$HD$eH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$BHD$HD$8HD$0H8H$HD$8HD$HD$HD$HD$8HD$@Hl$ H(peH %H;aHHHl$@Hl$@D$`HD$PHD$8HD$XHD$0HD$8H$HD$0HD$HD$0D$uHD$P@0HL$XI0f9utHD$P@2HL$XI2f9uRHD$PH8HD$(HD$XH8HD$ HD$(H$HD$ HD$HD$D$D$`Hl$@HHHD$HD$HD$鶋HD$HD$HD$HD$mHD$HD$HD$FHD$HD$HD$FHD$HD$HD$vHD$HD$HD$vHD$HD$HD$vHD$HD$HD$閏HD$HD$HD$馗H|$WHHl$Hl$HmHD$HD$`H|$ WHHl$Hl$HmD$pHD$HD$;HD$HD$HD$HD$MHD$HD$HD$HD$HD$HD$HD$FD$HD$HD$麨HD$HD$HD$HD$-HD$H|$ WHHl$Hl$mHmHD$HD$gHD$(H|$0WHHl$Hl$-HmHD$HD$wHD$ H|$(WHHl$Hl$HmƄ$HD$HD$韭HD$H|$ WHHl$Hl$HmƄ$HD$HD$OHD$HD$ HD$HD$ HD$HD$HD$HD$ݱHD$HD$HD$vHD$HD$HD$HD$HD$HD$fHD$HD$HD$ֳHD$HD$ HD$HD$mD$ HD$HD$JD$ HD$HD$:D$ HD$HD$D$HD$HD$eH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$HD$8HD$0H8H$HD$8HD$HD$ CHD$HD$8HD$@Hl$ H(peH %H;aHHHl$@Hl$@D$`HD$PHD$8HD$XHD$0HD$8H$HD$0HD$HD$0 D$uHD$P@0HL$XI0f9utHD$P@2HL$XI2f9uRHD$PH8HD$(HD$XH8HD$ HD$(H$HD$ HD$HD$ Z D$D$`Hl$@HHHD$HD$HD$HD$HD$HD$HD$魆HD$HD$HD$醇HD$HD$HD$醇HD$HD$HD$鶈HD$HD$HD$鶈HD$HD$HD$鶈HD$HD$HD$ֈHD$HD$HD$H|$WHHl$Hl$HmHD$HD$頑H|$ WHHl$Hl$HmD$pHD$HD${HD$HD$HD$HD$鍟HD$HD$HD$HD$]HD$HD$HD$醡D$HD$HD$HD$HD$HD$HD$mHD$H|$ WHHl$Hl$HmHD$HD$駤HD$(H|$0WHHl$Hl$mHmHD$HD$鷥HD$ H|$(WHHl$Hl$-HmƄ$HD$HD$ߦHD$H|$ WHHl$Hl$HmƄ$HD$HD$鏨HD$HD$ HD$HD$MHD$HD$HD$HD$HD$HD$HD$鶫HD$HD$HD$&HD$HD$HD$馬HD$HD$HD$HD$HD$ HD$HD$魭D$ HD$HD$D$ HD$HD$zD$ HD$HD$ZD$HD$HD$ eH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$HD$8HD$0H8H$HD$8HD$HD$HD$HD$8HD$@Hl$ H(peH %H;aHHHl$@Hl$@D$`HD$PHD$8HD$XHD$0HD$8H$HD$0HD$HD$0%D$uHD$P@0HL$XI0f9utHD$P@2HL$XI2f9uRHD$PH8HD$(HD$XH8HD$ HD$(H$HD$ HD$HD$D$D$`Hl$@HH HD$HD$HD$6~HD$HD$HD$HD$HD$HD$HD$ƀHD$HD$HD$ƀHD$HD$HD$HD$HD$HD$HD$HD$HD$HD$HD$HD$HD$HD$HD$&H|$WHHl$Hl$:HmHD$HD$H|$ WHHl$Hl$ HmD$pHD$HD$黔HD$HD$HD$HD$͘HD$HD$HD$HD$静HD$HD$HD$ƚD$HD$HD$:HD$HD$HD$HD$魛HD$H|$ WHHl$Hl$HmHD$HD$HD$(H|$0WHHl$Hl$HmHD$HD$HD$ H|$(WHHl$Hl$mHmƄ$HD$HD$HD$H|$ WHHl$Hl$HmƄ$HD$HD$ϡHD$HD$ HD$HD$鍣HD$HD$HD$HD$]HD$HD$HD$HD$HD$HD$fHD$HD$HD$HD$HD$HD$VHD$HD$ HD$HD$D$ HD$HD$D$ HD$HD$D$ HD$HD$D$HD$HD$JeH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$HD$8HD$0H8H$HD$8HD$HD$@HD$HD$8HD$@Hl$ H(UpeH %H;aHHHl$@Hl$@D$`HD$PHD$8HD$XHD$0HD$8H$HD$0HD$HD$0eD$uHD$P@0HL$XI0f9utHD$P@2HL$XI2f9uRHD$PH8HD$(HD$XH8HD$ HD$(H$HD$ HD$HD$@D$D$`Hl$@HHJHD$HD$HD$vwHD$HD$HD$HD$-yHD$HD$HD$zHD$HD$HD$zHD$HD$HD$6{HD$HD$HD$6{HD$HD$HD$6{HD$HD$HD$V{HD$HD$HD$fH|$WHHl$Hl$z HmHD$HD$ H|$ WHHl$Hl$J HmD$pHD$HD$HD$HD$HD$HD$ HD$HD$HD$HD$ݒHD$HD$HD$D$HD$HD$zHD$HD$HD$HD$HD$H|$ WHHl$Hl$-HmHD$HD$'HD$(H|$0WHHl$Hl$HmHD$HD$7HD$ H|$(WHHl$Hl$HmƄ$HD$HD$_HD$H|$ WHHl$Hl$]HmƄ$HD$HD$HD$HD$ HD$HD$͜HD$HD$HD$HD$靝HD$HD$HD$6HD$HD$HD$馞HD$HD$HD$&HD$HD$HD$閟HD$HD$ HD$HD$-D$ HD$HD$ D$ HD$HD$D$ HD$HD$D$HD$HD$HD$HD$HD$VrHD$HD$HD$HD$ tHD$HD$HD$tHD$HD$HD$tHD$HD$HD$vHD$HD$HD$vHD$HD$HD$vHD$HD$HD$6vHD$HD$HD$HD$}HD$HD$HD$HD$MHD$HD$HD$vD$HD$HD$HD$HD$HD$HD$]HD$H|$ WHHl$Hl$HmHD$HD$闒HD$(H|$0WHHl$Hl$]HmHD$HD$駓HD$ H|$(WHHl$Hl$HmƄ$HD$HD$ϔHD$H|$ WHHl$Hl$HmƄ$HD$HD$HD$HD$ HD$HD$=HD$HD$HD$HD$ HD$HD$HD$香HD$HD$HD$HD$HD$HD$閚HD$HD$HD$HD$HD$ HD$HD$靛D$ HD$HD$zD$ HD$HD$jD$ HD$HD$JD$HD$HD$HD$HD$HD$mHD$HD$HD$HD$}oHD$HD$HD$VpHD$HD$HD$VpHD$HD$HD$qHD$HD$HD$qHD$HD$HD$qHD$HD$HD$qHD$HD$HD$yH|$WHHl$Hl$HmHD$HD$pzH|$ WHHl$Hl$HmD$pHD$HD$KHD$HD$HD$HD$]HD$HD$HD$HD$-HD$HD$HD$VD$HD$HD$ʊHD$HD$HD$HD$=HD$H|$ WHHl$Hl$}HmHD$HD$wHD$(H|$0WHHl$Hl$=HmHD$HD$野HD$ H|$(WHHl$Hl$HmƄ$HD$HD$鯏HD$H|$ WHHl$Hl$HmƄ$HD$HD$_HD$HD$ HD$HD$HD$HD$HD$HD$HD$HD$HD$醔HD$HD$HD$HD$HD$HD$vHD$HD$HD$HD$HD$ HD$HD$}D$ HD$HD$ZD$ HD$HD$JD$ HD$HD$*D$HD$HD$HD$HD$HD$hHD$HD$HD$HD$]jHD$HD$HD$6kHD$HD$HD$6kHD$HD$HD$flHD$HD$HD$flHD$HD$HD$flHD$HD$HD$lHD$HD$HD$tH|$WHHl$Hl$HmHD$HD$PuH|$ WHHl$Hl$zHmD$pHD$HD$+HD$HD$HD$HD$=HD$HD$HD$HD$ HD$HD$HD$6D$HD$HD$骅HD$HD$HD$HD$HD$H|$ WHHl$Hl$]HmHD$HD$WHD$(H|$0WHHl$Hl$HmHD$HD$gHD$ H|$(WHHl$Hl$HmƄ$HD$HD$鏊HD$H|$ WHHl$Hl$HmƄ$HD$HD$?HD$HD$ HD$HD$HD$HD$HD$HD$͎HD$HD$HD$fHD$HD$HD$֏HD$HD$HD$VHD$HD$HD$ƐHD$HD$ HD$HD$]D$ HD$HD$:D$ HD$HD$*D$ HD$HD$ D$HD$HD$麾HD$HD$HD$cHD$HD$HD$HD$=eHD$HD$HD$fHD$HD$HD$fHD$HD$HD$FgHD$HD$HD$FgHD$HD$HD$FgHD$HD$HD$fgHD$HD$HD$voH|$WHHl$Hl$HmHD$HD$0pH|$ WHHl$Hl$ZHmD$pHD$HD$ zHD$HD$HD$HD$~HD$HD$HD$HD$~HD$HD$HD$D$HD$HD$銀HD$HD$HD$HD$HD$H|$ WHHl$Hl$=HmHD$HD$7HD$(H|$0WHHl$Hl$HmHD$HD$GHD$ H|$(WHHl$Hl$HmƄ$HD$HD$oHD$H|$ WHHl$Hl$mHmƄ$HD$HD$HD$HD$ HD$HD$݈HD$HD$HD$HD$魉HD$HD$HD$FHD$HD$HD$鶊HD$HD$HD$6HD$HD$HD$馋HD$HD$ HD$HD$=D$ HD$HD$D$ HD$HD$ D$ HD$HD$D$HD$HD$隹eH %H;avQH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$ 9HD$HD$8HD$@Hl$ H(D$HD$HHL$H H9tHD$@HL$I9D$eH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$艫HD$HD$8HD$0HH$HD$8HD$MHD$HD$8HD$@Hl$ H(peH %H;aHPHl$HHl$HD$hHD$XHHL$`H H9tHD$XHHH@HD$8HL$@HD$`HHH@HL$(HD$0HL$@H9tCHD$8HL$@H$HL$HD$(HL$0HD$HL$D$ D$hHl$HHP$/eH %H;aH8Hl$0Hl$0HD$PHD$(HD$ HD$(HL$ H9|AHD$(HD$HHD$@H$HD$HHD$LHD$HD$HHD$(HHD$(HD$HHD$PHl$0H8gReH %H;aHhHl$`Hl$`Ƅ$HD$8HD$0HD$8HL$0H9|HD$8HD$(HHD$pHH@HL$PHD$XHD$(HHD$xHHHHD$@HL$HHD$XH9uƄ$Hl$`HhHD$PHL$XH$HL$HD$@HL$HHD$HL$PD$ uHD$8HHD$8>Ƅ$Hl$`HhHeH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$IHD$HD$8HD$0HH$HD$8HD$OHD$HD$8HD$@Hl$ H(peH %H;aHHHl$@Hl$@D$`HD$PHL$X 8tuHD$XHHH@HD$0HL$8HD$PHHH@HD$ HL$(HL$0H9t4H$HD$(HD$HD$8HD$RD$D$`Hl$@HHÉ@HD$H@H@ eH %H;avSHHl$Hl$HD$ HL$( uHHD$ H$Hl$HH$HL$0RieH %H$xH;AYHH$H$H$H~H$HH$HHAHQH H$H$H$HT$8H$HHD$@H$HD$XHL$@H9H$HD$PHH$H$HUM H$H$HD$H$HD$ZHD$(HL$ HT$H$H$H$H$H$H$H$H$H$H$HHAHQH H$H$H$H$HD$xH$H9H$HD$xHD$xHD$pH$H$H$HD$HD$pHD$ID$7 H$@uKD$70HD$8HL$@H$H$H9vH9vH)HHH?H!HH$H)H$H$HD$hH$HD$`HD$hHL$`H9|=HD$hHD$HL$7H$H$H9r HD$hHHD$hHD$@H$H$H9vsH$H$H$H$HHCHS? uH H$HH$HL$N[   eH %H;afH8Hl$0Hl$0HD$@@u?HD$@H@Ht=HD$@HH$HD$XHL$PHT$HHT$HL$HD$F0Hl$0H8HD$HHL$PHT$XH$HL$HT$*HD$HD$(HL$@HIH)HL$ HD$@@ uUHD$@HH$HD$HHL$PHT$XHD$HL$HT$/HD$@H$HD$ HD$cHl$0H8HD$@H$HD$ HD$?HD$@HH$HD$HHL$PHT$XHD$HL$HT$N/b}eH %H;a>H0Hl$(Hl$(HD$8@uHD$8H@Ht3HD$8HH$HD$HHL$@HL$HD$`0Hl$(H0HD$HHL$@H $HD$HD$HD$ HL$8HIH)HL$HD$8@ uKHD$8HH$HD$@HL$HHD$HL$/HD$8H$HD$HD$Hl$(H0HD$8H$HD$HD$HD$8HH$HD$@HL$HHD$HL$/eH %H;avmH Hl$Hl$D$0u/HD$(H$HWD HD$HD$UHl$H HD$(H$HaE HD$HD$&ozeH %H$hH;AHH$H$H$ H(H$HDŽ$DHDŽ$DHD$@H$ @ uH$ H@ HH$ H@ HD$@H HD$8H$HD$XHL$8H9HTF H$HD$8HD$HD$8HD$SHD$(HL$HT$ H$H$H$H$HD$HH$ @ u6H$(H=vH$($SD$D$7uHD$HHD$PHHD$HHD$HH$H$H9r'HD$HH$H$($/HD$H$H$H)HL$HHD$HH$H$H$H9vH)HHH?H!HH$H)H$H$H $HT$Ht$H$(D$LHD$HH$HHD$HH$HL$HH$H9r''HD$HH$HHD$HH$H$HT$HH9r H$(HsHD$HH$HHD$HHD$HH$H$H$(HH5_ H9r{HD$@H$HHD$@H$(H$HH$(gHD$HH$HHD$HH$(HrH$H$H\$HH5-_ H9rHD$@H$HHD$@HD$@HKHD$HHD$xHHD$HHD$HH$H$H9r0HD$@HD$pHHD$@HD$HHD$hHHD$HHD$HH$H$H9r7+HD$HHD$`HHD$HH$H$HT$HH9rUH$ @D$6H$ @H$H$HT$HH$H9vH)HHH?H!HH$H)H$H$H$ H$H$H$H$HL$HD$HT$3H$ L$6HH$H97\ V O H A : 3 ,   至"eH %H$PH;A H0H$(H$($Pu H$@HL$7uH$@HH$@H$8H(H$HDŽ$DHDŽ$DH$8IueH$8H$8HIHJ HHL$8H$H$HT$8H9HE@ H$HD$8HD$HD$8HD$MHD$ HL$(HT$H$H$H$HD$@H$8I uH$8HI HL$@HtH$@HtfH$8@D$6H$8@H$8H@HD$H$8H$=H$8L$6HH$(H0H$HL$PH$HHL$`H~Ht^H$@HsfHD$PH$HHD$PH$HL$PH$H$@HH0H9r H$@H$HH$@HD$PH$HHD$PH$@H$`H$XH9rH$H$Ht$PH9r~3HD$PHeH$H$HL$@HT$PH)H9HD$pHL$hH $HD$HD$HHD$tD$D$,HD$ HD$HPH$H$H$H$Hl$xHĀ ݧ8eH %H;avpH0Hl$(Hl$(HD$8H$HD$@HL$HHD$HL$HD$HL$ HD$@HL$HHD$8H$HD$@HL$HHD$HL$ Hl$(H0LweH %HD$H;A+HH$H$H$HD$PH$HuH$@ uH$H@ HL$PH9|H$H@ HD$PHD$PHHHD$HHH$R uH$R uHD$`HHL$HHD$HHD$xHL$PHDHD$HH$@u\H$H@HL$HH9:H$@ uH$HHAHQH H$H$H$H$@ uH$H$HwxAD$GH$H$H$HYH9HAH$D$G 0D D$AHD$XHD$XHL$PH9|H$@ uHD$XHH$H$H$HZH9XHBH$ H$@ u(H$H$Hwp@D$FH$H$H$HYH9HAH$D$F 0D H$Hu9HD$XH$H$H9rD$AD$AD$ED$AD$DH$H$T$EH9rD$CH$H$T$DH9rD$BH$H$H$HYH9:HAH$D$C\$B \ HD$XHD$hHHD$XH50 H4$HT$HL$HD$H\$ =?HT$(HL$0HD$8H$H$H$H$HT$XH9rD$AH50 H4$HT$HL$HD$H\$ >HT$(HL$0HD$8H$H$$:H520 H4$HL$HT$HD$H\$ u>HL$(HT$0HD$8H$H$dH$HH$H$H$HPHH HH$@uoH$H@HL$HH9SH$@ u;H$H@H+D$HHD$H$H$ H$HĠH$H\$3hH5/ H4$HT$HL$HD$H\$ H=HT$(HL$0HD$8H$H$H$H@H+D$HHD$H$H$ffH$I uHD$pHHD$HXH$@u6H$H@HD$H$H$H$HĠH$HD$P0     eH %H;aviHHHl$@Hl$@HD$PH$HD$`HL$XHL$HD$HD$HD$ HD$(HD$hHL$pHD$0HL$8BHl$@HHseH %H;avjHHHl$@Hl$@HD$PH$HD$HD$HD$XHL$`HT$hHD$HL$ HT$(HD$pHL$xHD$0HL$8Hl$@HHeH %HD$H;AHH$H$H$H$H$H$HL$HD$HD$HL$ H$H$H$R u/H$HL$dD$D$OuHD$PH$Hs& HD$HD$H$H$HL$HD$ HD& HD$(HD$0uHD$@HL$8HL$HD$H$H$~H$HH$H(HD$pHD$xHDŽ$DH$I uH$HD$HD$DH$H$HD$HL$ `HD$(HL$0HT$8H$H$H$H$H$H$H$H$HD$HL$HT$H$HH$HD$HD$DH$H$HD$HL$ ^HD$(HL$0HT$8H$H$H$H$H$H$H$H$HD$HL$HT$[Wu,7eH %HD$H;A'HH$H$H$D$,H$H=wD$,H$H(HD$8HD$@HD$HDHD$hHD$pHD$xDH$HD$HD$DD$,D$dHD$ HD$0HD$HHL$8HT$0H9vSHL$PHT$XHD$`H$H$HD$`HL$XHT$PHT$HL$HD$H$HĈ" ܚeH %HD$H;AHH$H$H$D$leH %H;aH8Hl$0Hl$0D$XD$,G~EtIHD$@H@H$D$HD$HD$PHD$D$XD$HD$ Hl$0H8ÃFt?HD$@H@H$D$HD$HD$PHD$D$fHD$ I밃GtBHD$@H@H$D$HD$HD$PHD$D$XD$HD$ gHD$@H$D$XD$Hf~bt둃vgtrvtBHD$@H@H$D$HD$HD$PHD$D$gHD$ ljKeH %H;auH@Hl$8Hl$8D$hD$$b~8HvHD$H@KD$#HD$HH$D$(*D$PD$0HD$`HH?H?HHHD$HD$HH$D$0D$D$hD$HD$H@KD$XD$(HD$`HH?H?HHHD$HD$HH$D$(D$D$hD$=HD$HH$H5 HD$HD$HD$HL$#HKHl$8H@ÃbtHD$HH$D$hD$΍HvvthneH %H;aH8Hl$0Hl$0D$XD$,q~XtKHD$@H@H$HD$PHL$HHL$HD$H HD$HD$ gHl$0H8Ãqt,HD$@H@H$HD$PHL$HHL$HD$*HD$@H$D$XD$맃st/HD$@H@H$HD$HHL$PHD$HL$qvtlHD$@@Pu/HD$@H@H$HD$HHL$PHD$HL$(HD$@H@H$HD$PHL$HHL$HD$腿уxtDHD$@H@H$HD$HHL$PHD$HL$H HD$HD$ f)eH %H$PH;A'H0H$(H$($XD$4q~XtgH$8H@H$H$PH$HH$@HT$HL$HD$H HD$ HD$(H$(H0Ãdt1H$8@PuH$8H$H$`H$hHD$HL$kH$@HuFH$8H$D${H$@H$HH$PH$H$H$HD$`H$HD$XH$H$HD$`HL$XH9|H$D$3HD$`HD$8D$3D$1HD$8HqH$8H$Hh HD$HD$}H$8H$D$1HD$D$H$HH$HD$`HHD$`KH$8H$D$}HH$8H$H HD$HD$H$(H0H$8H$D$[cH$@H$HH$PH$H$H$HD$PH$HD$HH$H$HD$PHL$HH9|H$D$2HD$PHD$@D$2D$0HD$@HH$8H$D$ H$8H@H$D$0HD$HD$ D$H HD$ HD$(ƯH$HH$HD$PHHD$P4H$8H$D$]%hqtwH$8H@H$HD$hH$H$HH$PH$@HT$HD$HL$;HD$(HL$ HL$HD$H$H$7H$HH$@H$PH$H$H$ HH$H$HD$aHD$HL$H $HD$9HD$HL$HT$ H$H$H$H$8H$H$H$H$HD$HL$HT$$XD$ HD$(VstzH$8H@H$H$H$H$PH$HH$@HT$HL$HD$J:HD$(HL$ HL$HD$H$H$UvtxtZH$8H@H$H$HH$@H$PHL$HD$HT$H^ HD$ HD$(Hh.`eH %H;agHpHl$hHl$hHD$0H$H$H$H$HL$HT$HD$HD$@HD$8HHHvH$H$H$H$HL$HT$HD$HD$0$D$,d~nXt6HD$xH$HD$0HD$D$$D$Hl$hHpÃbtÃdtHD$xH$$D$Ńp~Bot닃pt.HD$x@LD$HD$xH$HD$0HD$뚃vtHD$x@Pu,HD$xH$D$(H$H$H$H$HL$HT$HD$ HL$HL$XHD$`HH$HD$HL$HL$HHD$PHD$xH$HD$PHL$HHL$HD$HD$xH$H HD$HD$HD$0HtCHD$xH$H HD$HD$HD$xH$D$)%OHD$xH$HD$0HD$D$HD$0Ht-HD$xH@H$H HD$HD$ZHD$x@LD$HD$xH$HD$0HD$,҃xt°v= Pvb=.v)=tD$>H$H$HoH9tD$>L$?u9H$H$D$>D$$D$ H$pHxD$T=.tW$H$H$HH9tM$D$?u;H$H$$D$HD$@$D$XH$H$H$H$H$H$$D$tD$D$@uH$H$H $HD$HD$HL$HT$ H$@H$HH$PH$H$H$@H$HH$PHD$HL$HT$$D$ HD$(} e11\=~.8tHDŽ$(HDŽ$0HDŽ$8H$H$HgH9tHHHPHH$(H$0H$8\$?u_H$H$H$8H$0H$(HT$HL$HD$$D$ H HD$(HD$0OfD$T= Pt"HDŽ$HDŽ$HDŽ$ H$H$H H9tHHPH@H$H$H$ \$?uH$H$H$ H$HL$HT$D$D$CuQH$H$H$ H$HL$HT$D$D$BuH$H$H$ H$HL$HT$EHD$ HL$H$H$H$HJ טHZ HB H$H$$D$7D$D$AuH$pHxH$H$H$H$H$ HD$HL$HT$$D$ HD$(x _H$HD$]1111511H1;=%yvM=_B>ft<D$<H$H$HH9t D$°tWD$HH$H$H%H9t^D$HD$?u<H$H$D$HZD$HD$ $D$#<111W11~==Jv=Av[=mTtJW$$H$H$HNH9t A $$D$?uJH$H$$$D$L$HD$$D$ *D$T=AtD$PH$H$HH9tTD$PL$?u2H$H$HcD$PHD$D$$D$N111_=JtHD$xH$H$H?H9thHHD$xL$?u2H$H$HD$xHD$D$$D$?D$T='tD$=H$H$H|H9tD$=L$?u3H$H$HD$=HD$D$$D$D$T==Jt{D$LH$H$HyH9tOD$LL$?u1H$H$D$LHD$D$$D$?Z1111*h11=\vO=wt>HD$`H$H$HGH9t HHD$`L$?u2H$H$HD$`HD$D$$D$ND$T=\tHDŽ$HDŽ$H$H$HqH9tnHH@H$H$T$?u=H$H$H$H$HL$HD$$D$111114=΀tfD$DH$H$H:H9t{fD$DL$?u3H$H$HD$DHD$D$$D$9D$T=tfD$FH$H$HH9tfD$FL$?u2H$H$D$FHD$D$$D${D$T=qStHDŽ$H$H$HH9tXHH$L$?u5H$H$H$HD$D$$D$'J1111X11p$D$\Tt@H$H@H$H HD$HD$H$pHxÃvtH$H$$D$)H$H$HD$H$H$HD$H$HL$AeH %H$ H;AH`H$XH$XH$HH$pH$xH$H$HL$HT$D$D$uQH$pH$xH$H$HL$HT$tD$D$~u H$pH$xH$H$HL$HT$HD$HL$ H$H$H$hHBHZ HJ H$hH$$D$ D$D$}uH$XH`H$hH@ >HP H@ H$hH$pH$xH$HX8Hp(Hx0HH(HP0H$pH$xH$H$H$H$H$pH$xH$H$HL$HT$3HD$H$pH$HvH viHvgHtH$HtH$HD$HD$>uHD$HHL$PH9u@HD$PHHD$xHDŽ$HD$xH$Ƅ$H$HĠHD$@HHD$pHD$PHHD$hHD$pH$HD$hH$Ƅ$H$HĠqHD$PH$HHD$PuHDŽ$HDŽ$Ƅ$H$HĠOE eH %H;a,HHl$xHl$xHDŽ$HDŽ$Ƅ$H$HD$`H$H9~7H$H$H$H$Ƅ$Hl$xHĀH$H$H$H9r<[uH$ƀH$H$H$H9v7H)HHH?H!HHD$hH\$pH$H\$jHD$HD$XHD$HD$PD$ D$/HD$XHD$8HD$PHD$0D$/D$.D$.uHD$8H}HD$8H$H9|AH$HD$0HD$HHD$8H$HD$HH$Ƅ$Hl$xHĀH$ƀH$HD$0HD$@H$H$HD$@H$D$.$Hl$xHĀzC C leH %H;avzH Hl$Hl$HD$(H$H HD$HD$螐HD$(H$D$0D$HD$(H$H HD$HD$ aHl$H meH %H;avzH Hl$Hl$HD$(H$Hߢ HD$HD$HD$(H$D$0D$vHD$(H$Hk HD$HD$ Hl$H 2meH %H$HH;A-H8H$0H$0H$PH$HDŽ$D$OH$@ƀHD$pHD$pH$H9|uH$@ƀHD$pHD$hHD$pH$H9|<HD$pH$PH$HH9rf<%uHD$pH$HHD$pHD$pHL$hH9HD$hHL$pH$PH$HH9vH9vH)HHH?H!HH$H$H$@H$H$H$HL$HD$HD$pH$H9}AH$@uH$0H8H$`H$H$H9|H$@H@H$WH$@H$H HD$HD$ gH$hH$XH$`H$H9vH)HHH?HHH!HH$H)H$ H$(H$H$H$HDŽ$H$H$H$H$H$H$H9|H$HHHH$H$H$HD$xH$H$H$H$HD$xHmH$@H$H HD$HD$ H$HuH$H$H$HL$HD$HL$H$H$HH$HD$HL$H$H$H$@H$H$H$HL$HD$耋H$@H$D$=H$@H$H$H$HD$HL$D$vH$HH$H$HH$FH$@H$H HD$HD$݊H$@H$D$)^HD$pH$HHD$pH$@H@H$THD$pH$H9| HD$pH$PH$HH9r D$ND$P<#v < t+H$@@MHD$pH$hHHD$p<#tH$@@LD$N<v H$`H$H$H9|D$NeH %H;aH8Hl$0Hl$0HD$PHD$ HD$@HD$HD$ HL$H9|NHD$ HD$HHD$(HT$HH$HD$D$uHD$(HD$HD$(HHD$ HD$ HD$PHl$0H8yDeH %H;aHPHl$HHl$HHD$hHHD$0HD$0HL$pH9|HD$0HD$(HD$(HL$hH9HD$XH@(HL$(HT$`HL$HL$(HHL$H$D$D$'uDHD$`HL$XHI0HT$(HT$HT$(HHT$H$HD$(HD$@HHD$(nHD$0HD$8HHD$03Hl$HHPbeH %H;aOHHHl$@Hl$@HD$`HD$(HD$(HHHPHT$0H\$hH9} Hl$@HHHHT$hH9|HD$PH@(HT$XH\$pHLKHL$HL$pHL$0HHL$H$D$D$'uHD$0HD$8HHD$0HD$XHL$PHI(HT$pHT$(HT$HT$pHT$0HT$H$D$D$&uEHD$PH@0HL$XHT$pHT$(HT$HT$pHT$0HT$H $HD$0HD$(Hl$@HHieH %H;aMHhHl$`Hl$`H$HD$HHD$(H$H+$HD$@HHH?H?HDHHD$8HD$8H}LHD$pHL$xH$HL$HD$8HD$HD$@HD$HD$HHD$ HD$8HD$XHHD$8HD$@HHD$0HD$0H}|HD$pH@0HL$HHT$xHL$HL$HHL$0HL$H$HD$xHL$pH $HD$HD$(HD$HD$0HD$HD$HHD$ SHD$0HD$PHHD$0xHl$`Hh{eH %H;aJH0Hl$(Hl$(HD$8H@(HL$HHT$@HL$HL$PHL$H$D$D$'uHD$8H@0HL$HHT$@HL$HL$PHL$H$HD$@HL$8HI(HT$XHT$HT$HHT$H$D$D$&uHD$8H@0HL$XHT$@HL$HL$HHL$H$HD$@HL$8HI(HT$HHT$HT$PHT$H$D$D$%u6HD$8H@0HL$HHT$@HL$HL$PHL$H$Hl$(H0(eH %H$xH;AHH$H$HDŽ$0HDŽ$8H$ H$(HHD$HH$(H+$ H(H$(H+$ HH?H=HHHD$8H$H$H $HD$H$ HD$H$ HD$8HD$HD$8HH$ HD$ H$H$H $HD$HD$HHD$HD$HH+D$8HD$HD$HHD$8HD$ TH$H$H$HL$H$(HHD$H$(HH+D$8HD$H$(HHL$8HH)HD$ H$H$H$HL$H$ HD$HD$HHD$H$(HHD$ H$ HD$@H$ HH$H$(HHD$xH$HD$hHD$xHD$XHD$hHL$XH9|H$H@(HL$hH$HL$HL$@HL$H$D$D$7uHD$hH$HHD$hHD$hHD$`HD$`HL$XH9|ZH$H@(HL$@H$HL$HL$`HL$H$D$D$6uHD$`H$HHD$`HD$`HL$XH9|H$H@(HL$@H$HL$HL$XHHL$H$D$D$5uHD$XH$HHD$XHD$`HL$XH9}H$(H+D$XHD$/|D$/uHD$hHL$`H9|H$H$HI(HT$`HHT$HT$@HT$H$D$D$1uHD$`H$HHD$`HD$hHL$`H9|2H$H@(HL$hH$HL$HL$@HL$H$D$D$0uHD$hH$HHD$hHD$hHL$`H9}gH$H$H@0HT$@HT$HT$`HHT$H $HD$`HHD$pH$0HD$XH$8H$HH$H@0HL$hH$HL$HL$`HHL$H$HD$hH$HHD$hHD$`H$HHD$`E!,H$(H+D$XH$(H+$ HH?H>HHH9|HD$PH$H@(HL$@H$HL$H$(HHL$H$D$D$4u'H$H@(H$HT$`HHT$HT$@HT$H $D$D$3uH$H$HI(HT$HHT$HT$@HT$H$D$D$2uHD$PHD$/H$H$HI0HT$HHT$HT$`HHT$H$HD$`H$HHD$`HD$PH$HHD$PHD$`H$HHD$`HD$PH$HHD$P H$H@0HL$XH$HL$H$(HHL$H$HD$XH$HHD$XHD$PH$HHD$Px H$H@0HL$`H$HL$HL$XHHL$H$HD$`H$HHD$`HD$XH$HHD$XoxyeH %H;aHxHl$pHl$pH$H+$H H$HtBH$H$H $HD$H$HD$H$HD$kHl$pHxH$HD$`HH$H$H$H $HD$H$HD$H$HD$HD$ HD$XHD$(HD$PHD$XHD$8HD$PHD$@HD$8H+$H$H+L$@H9|XH$H$H $HD$H$HD$HD$8HD$H$HD$ HD$@H$H$H$H $HD$HD$@HD$H$HD$H$HD$ >HD$8H$H$H+$HH$HHD$HHD$HH$H9|H$H@(HL$HH$HL$HL$HHHL$H$D$D$7uMH$H@0HL$HH$HL$HL$HHHL$H$HD$HHD$hHHD$H[H$H$H$HL$H$HD$H$HD$Hl$pHx eH %H;av~H@Hl$8Hl$8HD$PHL$HHI H$HD$HD$(H$\HD$HD$0HD$HHL$PH$HL$HD$HD$(HD$HD$0HD$ }Hl$8H@>iH(Hl$ Hl$ HD$8HD$HD$0H$H$H&HD$HD$HHD$H$HD$HH$HD$HHD$8Hl$ H(eH %H;aHpHl$hHl$hH$HL$xH $HD$蔎HD$HL$HT$ HD$PHL$XHT$`H$HL$xH $HD$lHD$HD$8HD$PHL$XHT$`H$HL$HT$oHD$HD$(H$HD$HD$0HD$@HD$HH$HD$@HD$8HD$HHL$@H $HD$HD$HD$(HD$HD$0HD$ Hl$hHpHHl$Hl$HD$0HD$ H$HD$0Hl$HeH %H;aH@Hl$8Hl$8D$pHD$`HL$PHT$HH9rwHHLHHD$(HL$0HD$hHL$HHT$PH9rHHHHDHT$HD$HD$(HL$0H$HL$HD$ HD$pHl$8H@& :eH %H;aH(Hl$ Hl$ HD$HHL$8HT$0H9rHHLHHD$HL$HD$8HL$PHT$0H9rHD$HH\$0Ht$8HH< HL H9rHHLH 8ucH<HD$PHL$HT$H\$0Ht$8H9r9HHT8H4uH Hl$ H(H4$HL$:~H $H|$(~ ReH %H;avhH@Hl$8Hl$8HD$HHL$PHT$XHD$ HL$(HT$0HH$HD$ HD$PHD$HL$H$HL$Hl$8H@eH %H;avhH@Hl$8Hl$8HD$HHL$PHT$XHD$ HL$(HT$0HH$HD$ HD$;PHD$HL$H$HL$Hl$8H@DeH %H;aHHHl$@Hl$@HD$`HHD$(HD$(HL$hH9|HD$(HD$ HD$ HL$`H9HT$PHD$ H$HD$ HHD$HD$D$u6HT$XHD$ H$HD$ HHD$HHD$ HD$8HHD$ HD$(HD$0HHD$(LHl$@HHKeH %H;a+H@Hl$8Hl$8HD$XHD$ HD$ HHHXH\$(Ht$`H9} Hl$8H@HH\$`H9|HT$HHD$hHDHH$HD$hHD$(HHD$HD$D$uHD$(HD$0HHD$(HT$HHD$hHD$ H$HD$hHD$(HD$HD$D$u:HT$PHD$hHD$ H$HD$hHD$(HD$HHD$(HD$ Hl$8H@eH %H;a?HhHl$`Hl$`H$HD$HHD$(H$H+$HD$@HHH?H?HDHHD$8HD$8H}LHD$pHL$xH$HL$HD$8HD$HD$@HD$HD$HHD$ HD$8HD$XHHD$8HD$@HHD$0HD$0H}nHT$xHD$HH$HD$HHD$0HD$HHD$pHL$xH$HL$HD$(HD$HD$0HD$HD$HHD$ ~HD$0HD$PHHD$0Hl$`HheH %H;aH(Hl$ Hl$ HT$0HD$@H$HD$HHD$HD$D$uHT$8HD$@H$HD$HHD$HHT$0HD$PH$HD$@HD$HD$D$uvHT$8HD$PH$HD$@HD$HHT$0HD$@H$HD$HHD$HD$D$u+HT$8HD$@H$HD$HHD$HHl$ H(WseH %H$xH;ARHH$H$HDŽ$0HDŽ$8H$ H$(HHD$HH$(H+$ H(H$(H+$ HH?H=HHHD$8H$H$H$HL$H$ HD$H$ HD$8HD$HD$8HH$ HD$ H$H$H$HL$HD$HHD$HD$HH+D$8HD$HD$HHD$8HD$ H$H$H$HL$H$(HHD$H$(HH+D$8HD$H$(HHL$8HH)HD$ 6H$H$H$HL$H$ HD$HD$HHD$H$(HHD$ H$ HD$@H$ HH$H$(HHD$xH$HD$hHD$xHD$XHD$hHL$XH9|%H$HD$hH$HD$@HD$HD$D$7uHD$hH$HHD$hHD$hHD$`HD$`HL$XH9|H$HD$@H$HD$`HD$HD$D$6uHD$`H$HHD$`HD$`HL$XH9|MH$HD$@H$HD$XHHD$HD$D$5uHD$XH$HHD$XHD$`HL$XH9}H$(H+D$XHD$/|D$/uHD$hHL$`H9|pH$HD$`HH$HD$@HD$HD$D$1uHD$`H$HHD$`HD$hHL$`H9|H$HD$hH$HD$@HD$HD$D$0uHD$hH$HHD$hHD$hHL$`H9}YH$HD$@H$HD$`HHD$HHD$`HHD$pH$0HD$XH$8H$HH$HD$hH$HD$`HHD$HHD$hH$HHD$hHD$`H$HHD$`}=HH$(H+D$XH$(H+$ HH?H>HHH9|HD$PH$HD$@H$H$(HHD$HD$D$4uH$HD$`HH$HD$@HD$HD$D$3uH$HD$HH$HD$@HD$HD$D$2uHD$PHD$/eH$HD$HH$HD$`HHD$HHD$`H$HHD$`HD$PH$HHD$PHD$`H$HHD$`HD$PH$HHD$PHD$8H$H$H+$HH$HHD$HHD$HH$H9|tH$HD$HH$HD$HHHD$HD$D$7u?H$HD$HH$HD$HHHD$HHD$HHD$hHHD$HzH$H$H$HL$H$HD$H$HD$Hl$pHx)eH %H;avRHH,$H,$i%<w H,$HS%<t ?%3%H,$HeH %H;avqH0Hl$(Hl$(HY HudHD$@HD$8Hu>HD$8HHHPHH$HT$HL$HD$HD$ HD$@Hl$(H0r vH|$8H9;uH#eH %H;avH@Hl$8Hl$8HY HurD$`HD$HHuPHD$HHHHPHH$HT$HL$HD$PHD$HD$XHD$ 0D$(D$7D$`Hl$8H@Ķ ]hH|$HH9;uH#|eH %H;avmH0Hl$(Hl$(HY Hu`HD$8HuCHD$8HHHH@H$HL$HD$HD$@HD$HD$HHD$ UHl$(H0& zH|$8H9;uH#HD$HD$L$HD$HD$eH %H;aHXHl$PHl$PHD$xHDŽ$HD$@HD$HHD$hHL$pH$HL$D$D$/HD$HL$ HD$@HL$HD$/D$.HD$@HL$HHD$0HL$8HD$`L$.HD$0HL$8HD$xH$Hl$PHX-eH %H;avZH0Hl$(Hl$(HD$@HD$HHD$8$HD$HL$HD$HL$ HD$@HL$HHl$(H0"D$D$HD$HD$HL$HHD$HD$eH %H;aHpHl$hHl$hHDŽ$HDŽ$HD$XHD$`H$H$H$HL$HD$HD$@UHD$ HD$@HD$(HL$0HD$XHL$`HD$@HD$8HD$XHL$`HD$HHL$PHD$xHL$8HHD$HHL$PH$H$Hl$hHp eH %H;av[H0Hl$(Hl$(HD$@HD$HHD$8HH$lHD$HL$HD$HL$ HD$@HL$HHl$(H0qeH %H;aHpHl$hHl$hHDŽ$HDŽ$HD$XHD$`H$H$H$HL$HD$HD$@HD$ HD$@HD$(HL$0HD$XHL$`HD$@HD$8HD$XHL$`HD$HHL$PHD$xHL$8HHD$HHL$PH$H$Hl$hHpq eH %H;avdH8Hl$0Hl$0HD$HHD$PHD$@HH$HD$ iHD$HL$HD$ HL$(HD$HHL$PHl$0H8HD$HD$HL$HHD$HD$eH %H;aHpHl$hHl$hHDŽ$HDŽ$HD$XHD$`H$H$H$HL$HD$HD$@HD$ HD$@HD$(HL$0HD$XHL$`HD$@HD$8HD$XHL$`HD$HHL$PHD$xHL$8HHD$HHL$PH$H$Hl$hHp eH %H;avdH8Hl$0Hl$0HD$HHD$PHD$@HH$HD$ fHD$HL$HD$ HL$(HD$HHL$PHl$0H88eH %H;aHpHl$hHl$hHDŽ$HDŽ$HD$XHD$`H$H$H$HL$HD$HD$@HD$ HD$@HD$(HL$0HD$XHL$`HD$@HD$8HD$XHL$`HD$HHL$PHD$xHL$8HHD$HHL$PH$H$Hl$hHpA eH %H;avdH8Hl$0Hl$0HD$HHD$PHD$@HH$HD$ eHD$HL$HD$ HL$(HD$HHL$PHl$0H8eH %H;avaHHl$Hl$HD$8HD$0HL$(HT$ HH ouHHD$0HD$8Hl$HH$HT$c;eH %H;avrHHl$Hl$HD$8HD$@HD$ HL$(HT$0HPu#HHD$8HD$@Hl$HH$HL$qbuHD$HD$HD$HH@HL$HD$eH %H;aHhHl$`Hl$`HDŽ$HDŽ$HD$PHD$XHD$xH$H$HL$HD$@D$D$8HD$ HL$(HD$PHL$XD$8D$0HD$PHL$XHD$@HL$HHD$pD$0HD$@HL$HH$H$Hl$`HheH %H;avtHHHl$@Hl$@HD$XHD$`HD$P$D$gHD$HD$@%.HD$ HL$(HD$0HL$8HD$XHL$`Hl$@HHsHD$HD$HL$HHD$HD$eH %H;aH`Hl$XHl$XHDŽ$HDŽ$HD$HHD$PHD$pHL$xH$HL$SHD$HD$0HD$HL$ HD$HHL$PHD$0HD$(HD$HHL$PHD$8HL$@HD$hHL$(HHD$8HL$@H$H$Hl$XH`$eH %H;av[H0Hl$(Hl$(HD$@HD$HHD$8HH$^{HD$HL$HD$HL$ HD$@HL$HHl$(H0qeH %H$(H;AHXH$PH$PHDŽ$hHDŽ$pHDŽ$xH$`HuHHD$@HwYH$HD$@HD$HD$@HD$ hHD$ HL$HT$(H$H$H$HD$8H$`HD$pH$WHHl$Hl$HmHH$HD$pHD$H$HD$dH$HuH$HH$H$HD$hHL$8H$H$HpHH9rHHt H 5u2H HD$8HD$`HHD$8H$H$YH$HD$M]H$H$H$H $HD$HT$ H$HD$XHH$HD$XHD$HD$XHD$ofHD$HL$ HT$(H$H$H$H$H$H$H$H$H$HD$PH$HD$HH$HD$xHD$PHL$HH9|HD$xHH@H$H$HD$PHD$0H$H$H$H$HH$H$`HL$H$H$HL$HT$HD$0H$H$H\$ HH9rH5u*HHD$xHHD$xHD$PHHD$PH$H\$s[H$H$H$H$hH$pH$xH$PHX1w  WHD$HD$HD$H@PHuHD$HHPH@XHL$HD$Hc)H HL$HD$eH %H;aHHl$xHl$xH$H@(H$UHD$HL$HT$HT$`HL$hHD$pHT$HHL$PHD$XHD$(HD$PHD$ HD$HHD$@HD$(HL$ H9|DHD$@HHD$8HD$0H$H$HHD$@HHD$@HD$(HHD$(Hl$xHĀ eH %HD$H;AHH$H$Ƅ$H$HH(H@ H$H$HD$0HuVH@HD$0HD$0H$H$HL$耯HD$HL$HD$8HL$@HDŽ$HDŽ$HDŽ$HD$8HHL$@H $HD$HD$(HtHD$8H@PHL$@H $HD$HL$HL$xH$H $HD$iHD$HL$HT$ H$H$H$H$H$H$H$HL$HT$@HD$ HL$HL$hHD$pHD$XHD$`HD$pHL$hHh H$HL$HD$,HD$ HL$HL$XHD$`HI(H$HD$HL$HD$HHL$PH$H9tfH$H$H$HL$HD$HHL$PHD$HL$D$ uƄ$H$HH$H$H$H$HtƄ$H$HHtHw 0tƄ$H$HHtHwvHwlHwbHwXfalstJHw@AHD$XHHD$PH$HD$pHL$PH9|HD$PH$H$H9r#<`tmHD$XHHD$hHL$PH$H$H9v<H9v-H)HHH?H!HH$H$HD$XH$H$H9vH$H$HD$PHHD$`H$H$H9vH)HHH?H!HH$H$H$H$H$HL$HD$H$H$HL$HD$ H$H$HL$(HD$0FHD$@HL$8H$H$H$HHD$PH$HHD$P/HM H$HDŽ$H$HH(H@ H$H$Hu@D$LH$H$H) H$HL$HD$p&D$(D$Ku,HDŽ$HDŽ$H$HËD$L=!ߍv5D$L=M?/t H$H FH9tD$KuH4L H$HDŽ$D$L=tH$H +H9tD$Ku"HTI H$HDŽ$)D$L=!ߍtXH$H PH9t>D$Ku"HjM H$HDŽ$11d1&D$L=WvD$L=HtH$H H9t}D$KuD$L=WtVH$H H9t<D$Ku"HP H$HDŽ$111땋D$L=itH$H XH9txD$Ku"H I H$HDŽ$D$L=eH %H;aHPHl$HHl$HHDŽ$HH$HD$`HL$XHL$HD$HD$hHL$pHD$HL$ HD$xH$HD$(HL$0HD$8HD$@H$Hl$HHPs^eH %H;aHHHl$@Hl$@HD$pH$HD$XHD$7HD$HD$8HD$PH$HD$8H HL$HD$HD$`HL$hHD$HL$ HD$xH$HD$(HL$0nHl$@HH迱ZeH %H;aHHHl$@Hl$@HDŽ$H H$;HD$HD$8HD$PH$HD$8HD$HD$XHL$`HD$HL$HD$hHD$ HD$pHL$xHD$(HL$0HD$8H$Hl$@HHNeH %H;avrHHHl$@Hl$@HD$xHH$HD$XHL$PHL$HD$HD$`HD$HD$hHL$pHD$ HL$(HD$0HD$8HD$xHl$@HHjueH %H$H;AHH$H$H$H@(H$H $HD$HL$H$H$HC H$*:HD$HD$pH$H$HH WHHD$pH$H$HH HXHPHD$pH$H$HH _HX(HP(HD$pH$H$HH8 *HX0HP0HD$pHD$HH$H@(HD$HbH$H$H$HD$HL$?D$(D$GD$FD$FuHDŽ$HDŽ$H$H@HtH$H$H$@H$HHDŽ$HDŽ$H$HD$hH:H$H$@HD$HD$HL$H$H$HT$hH HZpHBHD$hH$HDŽ$HDŽ$H[ H$HD$H$H$H$HD$HL$HT$ /HD$(HL$0H$H$H$H$HD$HL$H$H$H$H$H$H$HDŽ$ HDŽ$(H$ HD$XHx9H$H$HD$BHD$HL$H$H$HT$XHHZuHJHD$X:H$HL$>>H$HD$.>H$H$H$0H$8HDŽ$HDŽ$HDŽ$HDŽ$H$HD$`H$HHD$H8H$Y HD$HL$H$H$HT$`HHZHJH48H$H$0HD$ HD$HL$H$H$HT$`HBcHZHJHD$`H$hHDŽ$pHDŽ$xHc H$HD$H$hH$pH$xHD$HL$HT$ &-HD$(HL$0H$H$hH$HL$y!086 d  V O ض A ʶ 3 , 赶 讶 觶 eH %H;aHpHl$hHl$hHDŽ$HDŽ$HD$x@HD$xH$H$H$HH8HX@ HX0;HP0HD$XHD$`HD$xH$'D$D$'HD$HL$HL$XHD$`D$'D$&HD$`HL$XHL$8HD$@D$&uHD$8HuHD$xH@HHD$(Ht&HD$8HL$@H$H$Hl$hHpHtH$Ht1HD$8HL$@HD$HHL$PHD$0Hu H@HD$0;9HDŽ$HDŽ$Hl$hHpH$HT$HD$0HL$PH$HL$ D$HD$@D$eH %H;aHPHl$HHl$HHPH QH:Hs`HHHH?HHHL$0HHD$8H\$@HH$HD$0HL$8HT$@HD$HL$HT$\Hl$HHPM FQeH %H;av:H Hl$Hl$D$(H7H$D$D$D$(Hl$H eH %H;avPHHl$Hl$H uH  HHl$HH$H HD$S茋eH %H;av!HH,$H,$HΌHH,$HKeH %H;anH0Hl$(Hl$(HD$PH& H$FH|$H|$ WHHl$Hl$UHmHD$ HL$@HT$8HH HXHPHD$ HL$HHHHHD$ HD$HH$HD$HD$H R HHD$HL$MHXuIHHHD$ 0HT$uHHD$HD$PHl$(H0H$HT$H$HL$H$HT$:Hb% H$H|$!躉ueH %HD$H;ABHH$H$HD$hHD$pHD$hHD$PHH HwHL$HH$HD$HL$HD$XHL$`HT$PHHZHJHD$PHD$xHDŽ$HDŽ$H+H \H $HD$HN( HD$HD$ HD$xH$H$HD$ HL$(HT$05H$HĘH$HL$"] QeH %H$H;A HpH$hH$hHBHD$`HDŽ$HDŽ$H$H$H$xHD$HWH$.HD$HL$H$H$ H$HHZHJH$H$0HDŽ$8HDŽ$@H H$HD$H$@H$8H$0HT$HL$HD$ Q HD$0HL$(H$H$HDŽ$HDŽ$HDŽ$HDŽ$H$xH$HD$HL$H$H$HD$ HL$H$H$H$H$H$H$H$H$H$H$H$HD$PHH$H$H$H$H$H$H$HL$HD$H HD$HD$ H$H$HL$(HD$0E]HD$8HL$@H$H$H$HD$XH~oH$H$H$H$H$H$H$HD$HL$Ht HD$HD$ E\HD$(HL$0H$H$H$H$H$H$H$H$H$HD$HL$H$H$HD$HL$ [HD$(HL$0H$H$H$xHH0H@8HL$HD$H$xH$qD$D$OuHD$`H$HD$HL$H$8H$@H$H$H$(H$0HDŽ$HHDŽ$PHDŽ$XHDŽ$`H$HHD$hHQH$H$(HD$HD$HL$H$H$HT$hHHZHJHD$hH HH UHPH ) HHHD$hH$HDŽ$HDŽ$H$8H$@H$HL$H$H$H$HD$HL$HT$ H$hHpH$H( HD$ghH$HL$T"H$xH@ H H9tWD$ND$MD$MuH$H$H$H$HDŽ$HDŽ$H$HD$xH$xH0HD$HH$[HD$HL$H$H$HT$xHHZHJHD$xH$HDŽ$ HDŽ$(Hb H$HD$ H$H$ H$(HD$HL$HT$ HD$(HL$0H$xH$H$H$H$HD$HL$H$xH$HD$HL$ XHD$(HL$0H$H${H$HL$zH$H$H$hH$pHDŽ$XHDŽ$`H$XHD$pH$xH0HD$H H$HD$HL$H$H$HT$pH#HZHJHD$pH$HDŽ$HDŽ$H H$HD$ H$H$H$HD$HL$HT$ HD$(HL$0H$HH$PH$H$hH$pHD$HL$H$HH$PHD$HL$ kVHD$(HL$0H$H$_H$HL$ 1H$H$H$H$H$H$H$HD$HL$HF HD$HD$ UHD$(HL$0H$H$H$HL$D}5eH %H;aAH(Hl$ Hl$ <w Hl$ H(<tV syFi[/NH4 H$HD$HD$HL$H  HH8H )HwHHIH$HL$HD$DHD$ yu!HuHl$ H(H mH $HD$H ^H $HD$l认 }eH %H;av*HHl$Hl$HBHD$H$!Hl$H2|eH %H;aH Hl$Hl$HD$8HD$(H$HD$0HD$HD$HD$0HD$(HH$HD$0HD$HD$HD$0HD$(H H$HD$0HD$HD$HD$0HD$(H0H$HD$0HD$HD$HD$0HD$8Hl$H {)eH %HD$H;AeHH$H$Ƅ$H$HHHH$H$H$HHHHD$xH$H$H9tH$H$H $HD$HD$xH$HD$HL$D$ uH$HHH@HL$hHD$pH$HHH@HL$XHD$`HL$pH9t\HD$hHL$pH$HL$HD$XHL$`HD$HL$肚D$ uH$HH H@(HL$HHD$PH$HH H@(HL$8HD$@HD$HH9tH $HD$@HD$HD$PHD$} D$uH$HH0H@8HL$(HD$0H$HH0H@8H$H$HL$0H9tRHD$(HL$0H$HL$H$H$HD$HL$耙D$ $H$HİQNFnyyeH %H;aH8Hl$0Hl$0HD$PHD$(HD$ HD$(HL$ H9|AHD$(HD$HHD$@H$HD$HHD$HD$HD$HHD$(HHD$(HD$HHD$PHl$0H8xReH %H;aH`Hl$XHl$XD$xHD$0HD$(HD$0HL$(H9|HD$0HD$ HHD$pHH@HL$HHD$PHD$ HHD$hHHHHD$8HL$@HL$HH9uD$xHl$XH`H$HD$@HD$HD$PHD$ D$uHD$0HHD$0PD$xHl$XH`weH %H;aH8Hl$0Hl$0HD$PHD$(HD$ HD$(HL$ H9|AHD$(HD$HHD$@H$HD$HHD$[HD$HD$HHD$(HHD$(HD$HHD$PHl$0H8vReH %H;aH`Hl$XHl$XD$xHD$0HD$(HD$0HL$(H9|HD$0HD$ HHD$pHH@HL$HHD$PHD$ HHD$hHHHHD$8HL$@HL$HH9uD$xHl$XH`H$HD$@HD$HD$PHD$D$uHD$0HHD$0PD$xHl$XH`uH(Hl$ Hl$ HD$8HD$@HD$HHD$0H@H$HL$0HQHYH H9v@H)HHH?H!HHL$H)H\$Ht$HL$8H\$@Ht$HHl$ H(J eH %H;aHXHl$PHl$PHD$hHD$pHD$`HuHD$`H@HD$0HL$`HQHYH H9vH)HHH?H!HHL$8H)H\$@Ht$HH$HD$8HL$@HT$HHD$HL$HT$MHD$ HL$(HD$hHL$pHl$PHXH HD$hHD$pHl$PHX> 7tHHl$Hl$HD$ HD$H@H$HL$HIH)HD$ Hl$HHD$HD$H@HD$H@HD$H@ H Hl$Hl$HD$8D$@HD$(H@H$HD$(H@HD$H $HL$0H9~EH$HD$0HD$HL$(HIH9v=HL$(HAH$HD$8D$@Hl$H HD$8D$@Hl$H  eH %H$H;AHhH$`H$`HDŽ$H$pH$aHD$HD$(Ht%H$pH@HuH$pH$tH$pH$H$xHD$HD$HD$8D$D$'HD$8HD$0D$'D$&D$&uHD$0H$H$`HhH$pHHuH$pH@H$HL$(H$xHH?H?HHH9~H$pHHHPHH$HH$PH$XH$pH@HD$xH$pHQHYH H9vH)HHH?H!HH$0H)H$8H$@H$PH$HH$XH$H$H$H$0H$8H$@H$H$H$H$HD$XH$H9H$HD$XHD$XHD$PH$H$H$HD$HD$PHD$H$pH@HD$(H$xHD$`H$pHIH9vH$pHAHD$(H$H$`Hh^H$pH@HD$pHH$xH$ HD$HL$HT$H$H$H$H$pH@HD$hH$pHQHHIH9vH)HHH?H!HH$H)H$ H$(H$H$H$H$H$H$H$H$ H$(H$H$H$H$HD$HH$H9H$HD$HHD$HHD$@H$H$H$HD$HD$@HD$0H$pH$H$H$HPHX0u HH$HL$yH$xH@~H$pH(H$xH@vH$H$HDŽ$@H$pHJHB@ u#HHDŽ$H$`HhH$HD$&Q J C < 5mPeH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$H$H@ H$HD$@H$H$HD$@HD$HD$HD$8D$D$'HD$8HD$(D$'D$&D$&uH$HHHPHH\$(H9v0H)HHH?H!HH$H)H$H$HD$xH$H$H$H$H$HD$`HL$hHT$pH$HD$PHL$hH9rHD$hHD$PHD$PHD$HHD$xH$HD$`HD$HD$HHD$\HD$PHD$XH$HDŽ$HDŽ$H$HİH$HD$0H$H$HD$0HD$HHD$HD$( keH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$H$H@ H$HD$@H$H$HD$@HD$HD$HD$8D$D$'HD$8HD$(D$'D$&D$&u H$HHHH@H\$(H9vH)HHH?H!HH$H)H$H$HD$pHL$xH$H$H$HD$`HL$hHD$xHD$PHL$hH9rHD$hHD$PHD$PHD$HHD$pH$HD$`HD$HD$HHD$?HD$PHD$XH$HDŽ$HDŽ$H$HĨH$HD$0H$H$HD$0HD$+HD$HD$( heH %H$H;AHxH$pH$pHDŽ$HDŽ$HDŽ$H$H@ H$H@HD$PH$HIH9}AH$H$\H$H@HD$HH$H@H$HL$HH)HL$@HD$@H=|H$HHHH@H$H$H$H$H@HD$@H=|H$H@H$HHH$HD$HL$HT$H$H$H$H$H@H$H$HQHYH H9v)H)HHH?H!HH$XH)H$`H$hH$H$H$H$H$H$ H$XH$`H$hH$H$H$H$HD$`H$H9QH$HD$`HD$`HD$XH$H$H$HD$HD$XHD$H$H@H$H$HIH)H$H$H$H9vH$@H$HH$PH$HCHSzH H$H@H$H@H$H$H@H$H$HQH H$H9vH9vH)HHH?H!HH$(H)H$0H$8HDŽ$HDŽ$H$H@ H$H$(H$0H$8HT$H\$Ht$H $HD$ H$HD$(HL$0H$H$H$HD$8H$H$H$H$H$H@HD$xHL$8HHD$pH$HIH9vH$HAH$HD$hHL$8HH$H$H UH9tH$H$H$HD$H3HD$D$u*HDŽ$HDŽ$H$pHxH$Hu0H$H$H$H$H$pHx0.H$HL$z    beH %H;aHPHl$HHl$HHD$`HD$hHD$p$Hr HD$ucHOH$HD$XHD$HD$XHD$HD$ HL$HT$(HL$0HD$8HT$@HL$`HD$hHT$p/Hl$HHPÐHl$HHPb+eH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$H$H@ H$H@HD$PH$HIH9|H$H$/HD$HD$8H$H@HD$HH$HQHHIH9vH)HHH?H!HH$H)H$H$HD$xHDŽ$H$H$H$HR H$H$HL$HD$Ht$H$HD$ HD$`HD$(HL$0HD$xH$HD$`HD$@HD$xH$HD$hHL$pHD$@HL$8H9H$H@HD$XH$HT$@HHAHD$@H$HD$hHu*HD$hHL$pH$H$H$HĨHD$@HL$8H9u.HrH sH$H$H$HĨH$H$H$HĨHH$H HD$ S L_GeH %H;aH@Hl$8Hl$8HD$XHD$`HD$HH@ HD$HH$HD$GHD$HD$0D$D$'HD$0HD$(D$'D$&D$&u@HD$HHHHT$PH\$(H9rBHD$XHD$`Hl$8H@HD$HH$HD$HD$HD$(ޅ G^eH %H;aHpHl$hHl$hHDŽ$HDŽ$HDŽ$$=|GHD$xH$$D$HDŽ$HDŽ$HDŽ$Hl$hHpHD$xH@ HD$xH$HD$HD$HD$@D$D$/HD$@HD$0D$/D$.D$.uHD$0HHD$8HL$xHQH H\$0H9vH9vH)HHH?H!HHL$PH)HD$XHt$`H $HD$Ht$$D$ &HD$ H$HD$0H$HD$HHL$xHIH9vWHL$xHAHDŽ$HDŽ$Hl$hHp/-HD$xH$HD$uHD$HD$0A : 3\eH %HD$H;AzHH$H$HDŽ$HDŽ$HDŽ$H$H@ H$H@HD$0H$HIH9}H$H$H$HD$(HtH$HĨHʾH HL$HHD$PHDŽ$HD$HHL$PH$H$H$HĨH$H@HD$ H$HQHYH H9vBH)HHH?H!HHL$XH)H\$`Ht$hH$H$H$H$H$H$HD$XHL$`HT$hHD$pHL$xH$H$HD$@HL$xH9HD$xHD$@HD$@HD$8H$H$HD$pHD$HD$8HD$؋HD$@H$H$H@HD$H$H$HHAH$H$H$H@ H$HĨ^萁 YdeH %HD$H;AHH$H$DŽ$HDŽ$HDŽ$HDŽ$H$H@ H$H@HD$PH$HIH9}jH$H$H@H AHD$hHL$pDŽ$HDŽ$HD$hHL$pH$H$H$HĘH$H$HPHHIH9rD$/uHD$xH$H$HİH$H$HH$HD$xH$HHD$xH$HL$xHQH?H=HLHH9H$H$H$H\$xH9vH)HHH?H!HH$`H)H$hH$pH $HD$Ht$H$H$H$HL$HD$ HT$(hrHD$0HD$`HD$`H}"HD$`HD$xH$H$HİHDŽ$H$HİHDŽ$H$HİH$H$H$H$HT$HL$D$D$\D$D$XD$\D$DD$XD$@D$HHDŽ$H$HL$pH9|UD$HiH$H$H$H9r ȉD$HH$H$HH$뗋D$HL$D9tHD$pH$H$H9vH$HH$PH$XH $HD$HT$H$H$H$HD$HL$ HT$(uD$0D$=uHDŽ$H$HİHD$pH$H$H$H$H9|D$HD$TiD$HD$HD$PH$H$H$H9r ȉD$HD$HD$LL$@H$H$H$H+t$pH9rO2)ȉD$HH$H$HH$D$HL$D9tH$H+D$pH$H$H$H$H9vH9vH)HHH?H!HH$0H)H$8H$@H$HL$Ht$H$H$H$HD$HL$ HT$(WsD$0D$D$D$L$D$D$D$L$D$HD$HD$8HHD$ՋD$ D$hD$D$lHl$@HHp HHl$Hl$HD$(HD$ H@HD$HL$ HIH9}HD$(Hl$HHD$ H@H$HL$ HIH)HD$(Hl$HHHl$Hl$HD$ HD$H@H$HD$ Hl$HeH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$H$H@HD$(H$HIH9}NHVH GHL$@HD$HHDŽ$HD$HHL$@H$H$H$HĠH$H@ H$H@HD$ H$HQHYH H9vH)HHH?H!HHL$hH)H\$pHt$xH$H$H$HD$PHL$XHT$`HD$hHL$pHT$xH$H$H$HD$XHD$8H$H9H$HD$8HD$8HD$0HD$PH$H$HD$HD$0HD$RxHD$8H$H$H@HD$H$H$HHAH$HĠ2n +FeH %HD$H;AyHH$H$DŽ$HDŽ$HDŽ$HDŽ$H$H@HD$HH$HIH9}kH$H@ HH HD$`HL$hDŽ$HDŽ$HD$`HL$hH$H$H$HĐH$H$HIHH H$H$HPHHIH9rRD$/(eH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$H$H$H $HD$o HD$HD$@H$H|H$HH$H$HD$H$HD$ HD$ HL$HT$(HL$xH$H$HD$HHD$HH$HH9|H$H$H$HL$D$D$4HD$HD$PD$4D$0HD$PHD$8HD$8H$H$H9v!HT$hHD$pHL$HH\$xH$H9rHHD H 5H H$HL$8H$H9vH)HHH?H!HH$H$D$0=tH$HL$xHT$HH9rXHHDZHu*H HHL$HHL$`HHL$HH$H HD$H H{ H$HT$H$HH$HHD$XH$H$H\$xH$H9rHHTH5uGH HD$xH$H$H$H$H$H$HĘH$HL$H$H9 %b b c b b :_HHHl$@Hl$@D$`D$dD$ HD$ HD$XHD$0HL$ H9|CD$ iHL$XHT$ H\$PH9r ȉD$ HD$ HD$(HHD$ D$D$HD$XHD$HD$HMHD$r>D$D$L$D$D$D$L$D$HD$HD$8HHD$ՋD$ D$`D$D$dHl$@HHRa HHHl$@Hl$@D$`D$dD$ HD$XHD$0HHD$ HD$ H}CD$ iHL$ HT$XH\$PH9r ȉD$ HD$ HD$(HHD$ D$D$HD$XHD$HD$HMHD$r>D$D$L$D$D$D$L$D$HD$HD$8HHD$ՋD$ D$`D$D$dHl$@HH3` eH %H;a7HhHl$`Hl$`HDŽ$H$HD$XHt7HD$xHL$pH $HD$HD$HD$PHH$Hl$`HhHD$(HD$pHL$xH$HL$H$H$HL$HD$HD$ HD$0HtHD$(H$Hl$`HhHD$(HD$HHHD$(H$HD$@HL$0HHD$8HL$xHT$pH9v$H)HHH?H!HHD$pH\$xBX_ Q7eH %H;avQH0Hl$(Hl$(D$PHD$@HL$8H $HD$D$HD$HD$HD$ HD$PHl$(H06eH %HD$H;A1HH$H$HDŽ$H$HD$HHt*H$H$H$H$HHtfH$H$HwD$H$H$H $HD$HD$H$H$H$HH$H$HL$HH9tH$H$H9t}H$H$H$HL$H$H$HL$HD$IUD$ uHDŽ$H$HHDŽ$H$HH$H$HL$HH9HDŽ$H$HH$H$H$HL$D$D$DD$D$@D$DD$,D$@D$(H$H$HL$HH)HD$PD$0H$H$HHD$`HD$`HL$PH9}ID$0iHL$`H$H$H9r ȉD$0HD$`HD$xHHD$`릋D$0L$,9tXH$HL$PH$H9vSH)HHH?H!HH$H$H$H9tH$H\$H$H$HL$HD$bSD$ uHD$PH$H$HHD$PHHD$XHD$XH}qD$0D$D$D$LD$D$HD$LD$4D$HD$0D$8HD$xHD$xHL$`H9|LD$8iH$H$xH\$xH9r ȉD$8HD$xH$HHD$x룋D$8L$49t]H$H$xHT$`H9vVH$(H$0H$H9tH $HT$H$H$HL$HD$1D$ uHDŽ$H$hHpHD$`HD$pH$H$HL$pH9|{D$8D$DiD$8D$8D$@H$H$xH\$pH9rv ȉD$8D$8D$H,$H eH %H;avnHXHl$PHl$PJAH$HL$HT$HD$8HL$@HT$HHu'H\$`H[ Ht$hHD$HL$HT$H4$Hl$PHX> yeH %H;avWHH,$H,$U<w H,$HU<t6 nU_*]UH,$H eH %H;aH8Hl$0Hl$0HD$@!u Hl$0H8HhbH$o HD$@H qbHXHD$@H DbH`@H$HL$HT$HD$HL$ HT$(HD$@HL$H\$ HH VHuHHD$@ƀ!LH$HT$臜 eH %H;aHxHl$pHl$pH$!u\H$HHD$PZH$HL$HT$HD$XHL$`HT$hH$HHHHL$HT$ HD$(HD$XHL$`HT$hH$HL$HT$HD$0HD$HH$HT$PHHH`H$H$HhHD$@H$H$H`H+XHHhH$HpHD$8H$H$H?`H+`HHpH$ƀ!Hl$pHx ]eH %H;aH8Hl$0Hl$0HD$@!uH_H$HD$@H _HXHD$@H _H`H$HL$HT$HD$HL$ HT$(HD$@HL$H\$ HH GTHuMHHD$@HǀHD$@HǀhHD$@HǀpHl$0H8H$HT$衙eH %H;aH Hl$Hl$HD$0HD$(HH~HD$0Hl$H HD$(HH$׿HD$HD$HL$(HHu!HtHHH1HD$0Hl$H / FeH %H;aHPHl$HHl$HHxRH$_HhRHD$$H HD$+1TL ǎH$HD$@HL$XHHAXHD$XHL$`HHD$XHǀPHD$XH$]HD$XH$HD$XHHD$XH$HHD$XH$uHD$XHL$`HHD$XHL$XHHHD$XH@XHD$8H$HD$0HL$XHT$8HHAXHD$XH@XHRHD$XH$H HD$HD$+HD$HD$ HD$(k9Hl$HHPY9Hl$HHPJ5HD$HD$HL$H9 HD$HD$HD$HD$HD$HD$HL$H9| HD$HD$HD$HD$H8Hl$0Hl$0HD$HH$HL$@H }9HL$@HHHHH?H)HT$@H $HL$(HH $HD$HD$HD$H $H9|,HD$HD$ HHHD$HD$HD$HHD$HD$HD$HHl$0H8eH %H;aH Hl$Hl$HD$0HD$(H$HD$HD$HL$(H9~HD$0Hl$H HL$(HHH9~HHT$0Hl$H HD$(H RH9~HRHD$0Hl$H HD$(H H9~HHD$0Hl$H HHHD$0Hl$H $eH %H$H;A)HH$xH$xƄ$H$HHD$pHuH$HHD$hHL$pHIHDHD$XHD$pHL$XH@H9HD$pHL$XHHHH$HD$$Hn HD$H$HH$HD$葺H$@AuHDŽ$(HDŽ$0HDŽ$8HDŽ$@H$(H$H$HHD$H.H$cHD$HL$H$H$H$H hMHZ HBH$HHD$HsH$acHD$HL$H$H$H$HJ MHZHBH$H$HDŽ$HDŽ$ H$HH8H@0H$HL$H HD$HD$H$ H$H$HL$ HT$(HD$0Ƅ$H$xHĀH$HD$MH$HD$H$@TD$TuHF H$HDŽ$H$@BuH H$HDŽ$H$@PuH$H@ HD$`H[H$H$5H$H$H$H$H$HWHHl$Hl$*HmH$HHD$xHH$H$HD$y`HD$HL$H$H$HT$xH JHZHBH$HHD$H?H$`HD$HL$H$H$HT$xHJ {JHZHBH$HHD$HpH$t`HD$HL$H$H$HT$xHJ JHZ(HB(HD$xH$HDŽ$HDŽ$H$HH8H@0H$HL$H HD$HD$ H$H$H$HD$ HL$(HT$00}Ƅ$H$xHĀH$HD$NH$HD$H$HD$bH$@QuMH$@QuƄ$H$xHĀvseH %H;a?HPHl$HHl$HHD$`HD$hHD$pHD$xHDŽ$HD$8HD$@HD$8HD$0HHD$8HD$0 8HHT$XHXHPHGH$HD$0HD$uHD$XHHu_HD$XHH$HD$XHD$HD$XH(HL$`H0H|$hHl$Hl$*HmHl$HHPHD$XH$#H$HT$3OieH %H;aH Hl$Hl$HD$0HD$8HD$@HD$HHD$PHD$(HD$$H HD$HD$(HH$HD$PHD$(H(HL$0H0H|$8Hl$Hl$)HmHl$H *eH %H;aHHl$xHl$xH$HD$$HY HD$$}H$HHD$0HD$ H$@A?H$HHL$0H9|HD$ H=ʚ;|#HD$ HD$(HD$0H$HD$HD$HHD$ H$H$HD$HD$HuHD$ HD$@HL$HuHtHHH1HD$ HL$ HHHHH?H)HT$ H$HL$(HkdHL$HL$HL$8H $HL$(HHL$HL$HL$ HL$ H $HL$HL$ H$H $HL$ HL$[HƧ HD$PH|$XH5 Hl$Hl$'HmH$HHD$PH$HHD$XH$HHD$`H$HhHD$hH$HpHD$pH$HL$PH(H0Ht$XHl$Hl$&Hm+Hl$xHĀ+Hl$xHĀ  eH %H;aH Hl$Hl$HD$PHD$(H~HD$PHl$H HD$0H$虯HD$HD$HL$(Hu!HtHHH1HD$PHl$H ] aeH %H;aH Hl$Hl$WD$PHD$8H~D$PHl$H HD$0H~HD$(H~HD$0H$D$D$HD$8HL$(WH*WH*Y ^^L$PHl$H :HH,$H,$HD$8HL$H~HD$8H,$HHD$(HL$Hu HtHHH1HD$8H,$H HH,$H,$HD$8HL$H~HD$8H,$HHD$0HL$Hu HtHHH1HD$8H,$H eH %H$0H;AyHPH$HH$HHDŽ$HDŽ$H$XH$H|$H$`Hl$Hl$#HmD$(D$@HDŽ$HDŽ$D$@Wf.uzD$@D$PHDŽ$HDŽ$H$H$HPrH$HD$PHD$UHD$HL$H$@H$HH$H@HZ@HJH$H$HDŽ$HDŽ$HL H$HD$ H$H$H$HT$HL$HD$ uHD$0HL$(H$H$H$XH$H|$H$`Hl$Hl$P"HmHD$(HD$8HD$HHDŽ$HDŽ$H$H$HxH$HD$HHD$SHD$HL$H$0H$8H$H >HZHBH$H$HDŽ$HDŽ$H[ H$HD$ H$H$H$HT$HL$HD$ utHD$0HL$(H$H$H$XH@HD$8Hd|)HD$8H |H$`H$HHD$HD$pH$XWH*WH*^D$hHDŽ$HDŽ$H$H$HoH$HD$hHD$ZRHD$HL$H$ H$(H$H==HZHJH$H$HDŽ$HDŽ$H H$HD$ H$H$H$HD$HL$HT$ rHD$(HL$0H$H$H$H$H$pH$xH$H$H$`H$hH$WHHl$Hl$HmH$HD$xHtH$H$XHD$QHD$HL$H$H$HT$xH;HZHJH^|H$H$pHD$(QHD$HL$H$H$HT$xHB;HZHJH|H$H$`HD$PHD$HL$H$H$HT$xHJ 1;HZ(HB(HD$xH$HDŽ$HDŽ$H H$HD$H$H$H$HD$HL$HT$ pHD$(HL$0H$PH$XH$H$H$HHPH$HD$,JH$HL$H$HL$lH$HL$H$`H$荦HD$HD$`H$XWH*WH*^D$XHDŽ$HDŽ$H$H$HkH$HD$XHD$NHD$HL$H$H$H$H9HZHJH$H$HDŽ$HDŽ$H H$HD$ H$H$H$HD$HL$HT$ BoHD$(HL$0H$H$BH$HL$~b*H$HD$y~H$HL$f~8beH %HD$H;AJHH$H$HDŽ$HDŽ$H$H$H|$H$Hl$Hl$5HmxHD$(HD$@H$H$H|$H$Hl$Hl$HmHD$(HD$8HDŽ$HDŽ$HDŽ$HDŽ$H$HD$HHqH$HD$@HD$lLHD$HL$HD$`HL$hHT$HHX7HZ HJHpH$HD$8HD$LHD$HL$HL$PHD$XHT$HHJ 7HZHBHD$HH$HDŽ$HDŽ$Hv H$HD$H$H$H$HD$HL$HT$ lHD$(HL$0HD$pHL$xH$H$H$HH$HD$|PH$HL${)eH %HD$H;AAHH$H$HDŽ$HDŽ$H$HuH$H$HD$hHL$pH$HD$8HDŽ$HDŽ$HDŽ$HDŽ$H$HD$@HuH$HD$hHD$JHD$HL$HD$HHL$PHT$@H$5HZHJHmH$HD$8HD$IHD$HL$HD$xH$HT$@HB4HZHJHD$@H$HDŽ$HDŽ$Hs H$HD$H$H$H$HD$HL$HT$ jHD$(HL$0HD$XHL$`H$H$H$HH$HL$yPH$HL$yH$H$H$H$H$HeH %H$H;AUHH$H$Ƅ$HHH@H$HtƄ$H$HĐHD$PH@NH 1NH"NH$pH$xH$HDŽ$H$xHD$xH$pH$H$HL$xH9|WH$HHD$pHD$HHL$PH92HD$PH$HH$H$HH$HGHHHHD$HL$H$H$H HD$HD$ t6HD$(H$H$HD$HD$PHD$HD$ HL$H$H$H$HH$pHD$H$H@H@ 1QHH$H$1HH$H$HHH$H$HDŽ$HDŽ$HDŽ$ H$H$H$H$XH$`H$hHD$hH$`HD$`H$XH$HD$hHL$`H9|pH$HHHH@H$@H$HH$PH$HH$@H$(H$0H$8H$HH$HD$H$0H$(HL$HD$r<D$0D$GD$FD$FuH$ H$H$HYH9UHAH$H$(H$8H$0H IHtH4H|D/EHH\H$(H$0H$HL$HD$PHD$SHD$ HL$H$H$H$H$HIHDHD$XH$HL$XH@H9?H$HL$XHHH$HH$HD$hHHD$h H$H$H4$HD$tH$H$H$HD$btH5H4$HT$HL$HD$H\$ ~HT$(HL$0HD$8H$ H$gHH H$lHD$H$ +.HHxWHHl$Hl$1 HmH$Hǀ -H2H k HH$H BH6HP0-HX8HH8HBH$APH$H$H$H H-HuHHeH$^kHD$H$H ȹHH$H$ H$H$HPHH ,HPHXH$H$,HHHAH$HHH$ b,H$HuUHH$H$H$HD$H$@A$H$HĐH$HT$qH$HL$qHH$H\$qH$HT$vqH$HL$cqH$Hi HD$IqH H $HD$wpH$HL$qH$HD$q;eH %H$@H;A H@H$8H$8HEH EHEH$(H$0H$8HD$xH$0HD$pH$(H$HD$xHL$pH9|V H$HHD$hHD$xHD$`HD$hHD$PH$6H$PHHH$HL$HD$PHD$HD$ HL$H$H$H$H$ HDŽ$HDŽ$HDŽ$HDŽ$H$H$H$HHHD$HbH$>HD$HL$H$H$H$H|)HZ HJHiH$H$HL$>HD$HL$H$H$H$HJ )HZ HBH$H$HDŽ$HDŽ$H$PHH8H@0H$HL$Hg HD$HD$H$H$H$HT$ HL$(H\$01\HD$`H H;VH$HD$ɅHD$H$H H$|fHD$H$ '( HHxWHHl$Hl$-HmH$H$'H8 HH$PH$HHH'H HH$PH$HP8H@0HA0U'HY8 HQ8H$PH$@PAPH$PH$ 'HH& HH$PH$HHH$H$PH$PH$H$PH$5HD$H$Ht$H$Hl$Hl$ HmH$P@AuH$H$H$H$HDŽ$HDŽ$ HDŽ$(HDŽ$0H$H$HzfH$H$HL$D;HD$HL$H$xH$H$H %HZ0HBH$PHHD$H LH$;HD$HL$H$hH$pH$HBB%HZHJH$H$HDŽ$HDŽ$H$PHH8H@0H$HL$H| HD$HD$H$H$H$HT$ H\$(HL$0VXH$HH$HD$xHHD$xH$HL$0j=H$HD$jH$H$H|$H$Hl$Hl$DHmHD$0HL$(H$H$HN9uH$H$H$H$H|$H$Hl$Hl$Hm%HD$0HL$(H$H$H$H$H$HD$HL$H_ HD$HD$ H$H$HL$(HT$0ծHD$8HL$@H$H$H$H$H$H$HDŽ$HDŽ$H$H$HjcH$H$HL$48HD$HL$H$XH$`H$H"HZHJH$H$pHDŽ$xHDŽ$H$PHH0H@8H $HD$H$pH$xH$HD$HL$HT$ P[H$PH@ H$HH$PH$? H$H$H$H$HDŽ$HDŽ$HDŽ$HDŽ$H$H$HbH$H$HL$6HD$HL$H$HH$PH$H5!HZ HJH$PHHD$HGH$.7HD$HL$H$8H$@H$HB HZHJH$H$XHDŽ$`HDŽ$hH$PHH0H@8H $HD$Hz HD$HD$H$XH$`H$hHL$ HT$(H\$0SH$HD$HD$XHL$PH9uH$H$H$H$HD$XH$HDŽ$HDŽ$HDŽ$HDŽ$H$H$H(`H$H$HL$4HD$HL$H$(H$0H$HUHZHJH XH$H$HL$4HD$HL$H$H$ H$HBHZHJH$H$@HDŽ$HHDŽ$PH3H 8H $HD$H HD$HD$&H$@H$HH$PHT$ H\$(Ht$0RH$HL$ dbH$HL$cH$HL$c`H$HL$cH$HL$cnH$P"uH$HD$cH$HT$ociH$HD$\cH$HL$IcH H $HD$itH$HD$cIH$HL$cH$8H@*eH %HD$H;AUHH$H$Ƅ$H$HTH`H$yHPHD$$Hu HD$H$HHHD$`HL$hD$<D$;H$HHuHD$pHD$xH$HHHD$PH$HD$HD$PH$H$H$HL$HD$.(HD$(HL$ HL$pHD$xD$0D$=D$1D$?HD$xHL$pHL$`HD$hD$=D$<D$?D$;D$u~HD$@H$BHD$@H(HL$H|$H0Hl$Hl$HmH$H$HD$@@A$H$HĈ^H$HD$=^"H$HL$*^H$HT$^vH$HT$^H$HD$]H$HT$]aH$HL$]H H $HD$dƄ$H$HĈ)H$HĈeH %H;aHxHl$pHl$pH$H(HL$hHǀ(HD$hH@HD$`H$H$H|$H$Hl$Hl$8HmHD$(HD$XHL$hHT$`HHAH$Ht/H$ƀ HD$hH@H$ uHD$hH@HD$HH$H$H|$H$Hl$Hl$Hm]HD$(HD$@HL$hHT$HHHAHD$hH@ HD$8H$H$H|$H$Hl$Hl$,HmoHD$(HD$0HL$hHT$8HHA Hl$pHxHD$hH@HD$PHL$hH$HHAeH %HD$H;AYHH$H$HD$@HD$HH$H@ HD$`HL$HH9|H$HH H@HT$HH9r< tHD$@HD$XHHD$@HD$@H }H$HH(H@HT$HH9vjH$H$H$HD$pHT$xH$HBHD$hH$H9w HLVH$H$HL$xHT$pHT$HL$HD$HD$hHD$ xdHD$0HL$(HT$8HL$pHD$xH$HD$hH$H9vHD$xHD$pH$HH$H HD$HD$HD$pHL$xH$H$H$H$H$HK HS( HSuHCH$HH$HD$'Y&9HD$HHD$PHHD$H8  *eH %HD$H;A8HH$H$H$Hu H$H$HL$`HD$hHL$XHuHAHD$XHD$pHD$xHD$pHD$PHD$XHL$hHD$pHL$xHD$PH$HDŽ$HDŽ$H&H H $HD$Hc HD$HD$ H$H$H$HD$ HL$(HT$0EH$RH$HĠ)eH %H$H;AY HH$H$HDŽ$HDŽ$HDŽ$H&H@Hu H&HHHH$HL$赏HD$HL$H$H$HDŽ$HDŽ$HDŽ$H$H$H $HD$Y(HD$H$HD$ HL$H$H$H$H$H$H$H$H$H$H$H $HD$DH$H$HDŽ$HDŽ$H$H$HPH$H,HD$%HD$HL$H$H$H$HHZW HJH$H$HDŽ$HDŽ$H$H $H $HD$HX HD$HD$ H$H$H$HT$ HD$(HL$0BH$HD$$Hg HD$ HD$pHD$XD$PH+H$H$WHHl$Hl$SHmHH$H$HD$H$HD$H$HuH$HHHPHH$hH$pH$xH$HHHH$H$H$xH$pH$hH$H$H$HH$H *HL$H$H$HT$HL$\HD$ HHHPHH$ H$(H$0HDŽ$H$HD$xH$HL$xH9|H$HD$hH$ H$(H9rHDHD$`HD$XH$HL$`HHD$XHD$hH$H$H9rHD$PwXHD$pH$HL$`HHD$pH$Hu%H$H$H$H$H$H$HD$`H$D$PD$THDŽ$HDŽ$H$WHHl$Hl$HmH$H$HLH$H$HL$!HD$HL$H$H$H$H HZ-HJHD$hH$ H$(H9rHHHD$HMH$ HD$HL$H$H$H$HB| HZHJHD$hH$ H$(H9rkHHDHD$HDLH$HD$HL$H$xH$H$HB  HZ(HJ(HD$hH$ H$(H9rHHDHD$HLH$HD$HL$H$hH$pH$HB0~ HZ8iHJ8HD$hH$ H$(H9r=HHD HD$HFKH$HD$HL$H$XH$`H$HB@ HZHHJHHtCH$H$HL$HD$HL$H$HH$PH$HBP HZX`HJXHJH$HL$THL$HD$HL$H$8H$@H$HB`D HZhHJhH$H$PHDŽ$XHDŽ$`H$H H $HD$Hu HD$HD$H$PH$XH$`HT$ H\$(Ht$0[HD$x hHH+H$HD$ZHD$H$H$HD$H$HD$$Hd HD$ztH$HL$HT$H$(H$0H$8Ƅ$H$(H$0H$8HD$HL$HT$ HD$xHD$(H$HD$0H$HD$8H$H$Hl$Hl$HmH$HD$p$hH HD$u%H$HА;H$pHxÐ%H$pHxH vH $HD$AaH$HD$AyԯeH %H$PH;AH0H$(H$(HDŽ$`HDŽ$HDŽ$HDŽ$H$HHugH$HH$@H $HD$ HD$HL$ HT$H$H$H$H$H$H$HD$xH$HD$pH$H$HD$xHL$pH9|H$HHHH$8H$@HD$xHD$PH$@H$8H$H$H $HD$zHD$HL$H$xH$H$H$Ht$PH9rAHHL3H 3=u0H3H$HH$HD$xHHD$xH $HD$?H$H$H$H$H$H$HD$hH$HD$`H$H$HD$hHL$`H9|H$HH@H$(H$0HD$hHD$XH$(H$0H$H$HDŽ$hHDŽ$pH$8H$H$H$HL$HA HD$HD$ H HD$(HL$0H$hH$pH$H$H$HuHD$XH$H$PH$XH$XH$`H$H$H$HH$PH$H$H$H$ H$HuH@H$H$WHl$Hl$hHmH$H$H0H$H$HL$ HD$HL$H$H$H$H}HZHJH7H$H$XHL$ HD$HL$H$H$H$HBHZHJH7H$H$HHL$] HD$HL$H$H$H$HB HZ(HJ(H$H$H$ HH0 HX8HP8H$H$HDŽ$HDŽ$H H H $HD$H HD$HD$6H$H$H$HT$ H\$(Ht$0)H$6H$HH$HD$hHHD$hFH$HT$j;2H$HL$W;H$HL$D;uH$HL$1;rH,H$3H|$H$>7WHHl$Hl$HmH$H$H$H$HPHH HH$ H$8HXHPHVH$HD$HD$HD$蒚HD$ H$H$eHY(u(HA(H$H$`H$(H0H$HD$9H$HT$9eH$H\$9&HH$H|$ @}k ԧeH %HD$H;A!HH$H$HDŽ$HDŽ$Ƅ$Ƅ$H$H$H$H$H$H H$LH$H HD$$H HD$w[H$HuEH$H@xH&H$H$H $HD$ HD$HL$H$H$H$HHHD$HL$H$H$H$H$HL$HD$ HD$0HL$(H$H$HH$KHHD$$Hػ HD$n3H$H$H$HL$H- HD$HD$a{HD$ HL$(HT$0H$H$H$H$H$H$HD$PH$HD$HH$HD$pHD$PHL$HH9|HD$pHH@H$H$HD$PHD$@H$H$HD$xH$H$H@HD$hHL$@H9}[H$HD$`H$H@HD$XHL$`H9D$>Ƅ$D$>$H$HH$H$HPHHIH\$@H9rHH HDH $HD$HD$xH$HD$HL$HD$ D$?D$=D$=u"HD$pHHD$pHD$PHHD$PƄ$Ƅ$H$HH$HtH$H 肣eH %H$xH;AHH$H$HDŽ$ HDŽ$(HDŽ$0H$H$H$HL$H"+ HD$HD$7HD$ HD$xHf/H$HD$HD$xHD$=HD$(HL$ HT$H$H$H$HD$PHD$XHD$HH$HD$pHL$HH9|H$HL$HH$H9rD$GH$H@(HD$HH$H$H$HL$HT$|HD$ HD$pD$(D$?HD$pHHD$PHD$@D$?D$=D$>u&H$H@(HD$HdH$H$H$HL$HT$1HD$ HD$`HL$@HHH$H$H$H$HD$@HD$HHDŽ$PHDŽ$XHDŽ$`HDŽ$hH$PHD$XH'H$H$HL$fHD$HL$H$H$HT$XHHZHJHA H$HL$HHL$HD$HL$H$H$HT$XHBsHZHJHD$XH$HDŽ$HDŽ$H\( H$HD$H$H$H$HL$HT$H\$ 6HD$(HL$0H$H$D$>H$HL$+^H$HL$o+D$=uH$H@(HD$H0H$H$H$HD$HL$HD$ HD$hHH$H$H$H$H$pHxH$HD$*%H$HL$*eH %H$XH;AH(H$ H$ HDŽ$@HDŽ$HHD$BH$H$HDŽ$HDŽ$H$8H$0H$H$HDŽ$H$H$H9|H$H$H$H$D$L=|GH$HH$D$LD$D$D$D$CuH$H$H$HYH9HAH$ _;H5;%H4$HT$HL$HD$H\$ ~3HT$(HL$0HD$8H$H$뢋D$D$`D$D$BuHD$HH$HcD$DHD$vHD$HL$H$H$H$H$H$H$H$H$H$HHD$hH$H9wHR$H$H$H$H$HL$HT$H\$HL$hHL$ x2HD$(HL$0HT$8H$H$H$HD$hH$H9vH$H$HD$`H$H$HH$H$HD$HD$`HD$H$H$H$H$H$H$eD$D$YHD$HL$H$H$HL$XHAHD$PH$H$HsH9v~HAHHH?HHH$H$H$H$H$H$H$H$H$HHD$xH$H9wH{"H$H$H$H$HL$HT$H\$HL$xHL$ 0HD$(HL$0HT$8H$H$H$HD$xH$H9v}H$H$HD$pH$H$HH$H$HD$HD$pHD$H$H$H$H$H$H$<cH$H$H $HD$H$HD$'`D$D$LHD$ H$H$H$H$H$HT$HL$HD$)lHD$(HL$ H$@H$HH$ H(  HHl$Hl$D$ D$= |kD$D$ ~9HvD$ Hl$Hà tD$ Hl$H=t=t=tʋD$= ~D$ Hl$HËD$$=/ ~2vD$ Hl$H=/ tp=_ t=0teH %H$ H;AH`H$XH$XHDŽ$xH$hH@HHL$HuMHL$xH9hH$H|$H$WHHl$Hl$cHmH$H$HDŽ$2HDŽ$2H$pHH$H$H$H$HT$HL$HD$uHD$ HD$XHD$XHH$HL$XH2vH$H$HDŽ$2H$HL$HD$2zHD$HD$pH$WHl$Hl$ѻHmD$UHD$`D$UuH$WHl$Hl$蕻HmHD$pH${H$Ht$xHl$Hl$ҾHmD$HD$WH$H$Hl$Hl$覾HmD$WD$UH$H$H$H$H$hHHhH@`H$H$H$H9tH$H$H$HL$H$H$HD$HL$D$ u(H$pHD$`HH$xH$XH`H$hH@HHD$H6H$H$H$HL$HT$D$(D$VD$TD$TuHD$`HD$hHHD$`BH$pHD$`H$xH$XH`hH$pH$xH$XH`H$pH$xH$XH` HH$H; HD$ ލ eH %H$H;AHH$H$HDŽ$HDŽ$H$H$HD$HD$HD$XHDŽ$HHDŽ$PHD$XH$nHD$HL$H$HH$PHD$ H$D$(D$WH$PH$HH$H$H$HD$`D$WD$VD$VuH$H$H $HD$H HD$HD$UHD$ HD$pH}HH$H$H$H9vH)HHH?H!HH$H$HH$eHD$H$H$D$ ,H$H$H$H$H$8H$@HD$`H$HDŽ$HDŽ$HDŽ$HDŽ$H$H$HH$H$8HD$HD$HL$H$H$ H$H CHZHBHH$H$HD$HD$HL$H$H$H$HJ HZHBH$H$pHDŽ$xHDŽ$H$H H $HD$H HD$HD$H$H$xH$pHT$ HL$(HD$0 H$H$H $HD$Hf HD$HD$_HD$0HL$(HT$ H$XH$`H$hHL$hHH$XH$`HYH9rHHDHtHAH$H$hH9vH$`H$XH$`H$hH$H$H$HDŽ$H$H$H$H$H$H$H9|H$HH@H$H$H$HD$xH$H$H$H$HD$xHH$H$H HD$HD$H$H$H$H$HD$HL$^H$HH$H$HH$H$H$D$ (H$H$HD$HL$H$(H$0H$H$H$H@H$HD$vH$HD$coH$H$H $HD$H HD$HD$PHD$ HD$pH}LHH$H$H$H9vcH)HHH?H!HH$H$H# H$HDŽ$HD$`ޮ g Ю ɮ †eH %H;aHhHl$`Hl$`HD$pH@pHD$PH$AHD$PHD$$H: HD$8HD$PHH8H@0H$HL$HD$xH$HD$HL$H$H$H$HT$ HL$(HD$0HD$pH$+AHD$pHD$$H HD$'HD$pHH(HPH@ H$HD$HL$DHD$HD$XHD$PHH0H@8H $HD$HD$XH HL$HD$EHD$pHD$pH@ *Hl$`HhÐHl$`HhÐ Hl$`HhFeH %HD$H;AHH$H$HDŽ$HDŽ$ HDŽ$(H$H$H$HD$PHH$H$H$H $HD$HT$D$ 4HD$ HD$@HtH$HD$@H$HH(HP H@HD$pHT$xH$H$H$H$HBHD$hH$H9w3HH$H$H$H$H\$HT$HL$HL$hHL$ HD$8HL$0HT$(H$H$H$H$HL$hH9vH$HD$xH$HH$H HD$HD$ܴH$H$H$H$HP HX(HX+HHHD$@H$H$H9vH$H$H$H$HHHP H@(H$H$H$H$H$H$H$HHD$`H$H9w{HH$H$H$H$HL$HT$H\$HL$`HL$ HD$(HL$0HT$8H$H$H$HD$`H$H9vH$H$HD$XH$H$HH$H$HD$HD$XHD$,H$H$H$H$HP HX(,HXufHHHD$@H$H$H$H9vH)HHH?H!HH$H)H$H$3H$HL$pHAH$HL$W2HD$HHHD$@[H$Hf _ X Q\eH %HD$H;AdHH$H$HDŽ$HDŽ$H$H$x8D$D$8HD$hHD$pHD$hHD$@HH$HD$8HD$HD$HL$HL$HHD$PHT$@H HZHBHD$@HD$xHDŽ$HDŽ$HQ H$HD$H$HL$xH$HL$HD$HT$ KHD$(HL$0HD$XHL$`H$H$H$HĘH$HD$V~zHD$HD$HD$HHHL$HD$eH %H;aH Hl$Hl$HD$(H@pHu{HD$(H@pH$HD$(H$g9HD$(HD$$Hݓ HD$cuHD$(@@ܱHl$H Ð̱Hl$H }FeH %H;aOH`Hl$XHl$XHD$hH@pHuHD$hH@pH$HD$hH$8HD$hHD$$H HD$蠧u.HD$h@Cu/HD$h@AHl$XH`ÐHl$XH`HD$hHHHD$HL$ H$H? HD$HD$Hs HD$(HD$0&THD$8HL$@HD$HHL$PH H$HD$HHD$HD$HL$H$HL$ I|eH %H;aH Hl$Hl$D$0HD$(H$ 6HD$(@AD$HD$(H$[6D$uD$0Hl$H H$HD$HL$(HIXHH{beH %HD$H;AHH$H$H$H$6H$HD$$H! HD$觥H$H$H$H$HL$HD$2HD$ HL$HL$PHD$XH$HHHP(H@ HL$xH$H$HL$`HD$hHT$pHL$XHHD$HHL$pH9wHaH$HD$`HL$hHT$pHD$HL$HT$HD$HHD$ HD$(HL$0HT$8HD$`HL$hHT$pHD$HHL$pH9vHD$hHD$XHD$@HD$`H$HH$HD$PHD$HD$@HD$辫H$HL$`HT$hH\$pHP HX(HXuHH豭H$HĘH$HL$S L膭H$HĘq jyeH %H;aHPHl$HHl$HHD$`HL$hH$HL$HD$pHL$xH$HD$HL$HT$ FHD$(HL$0HD$8HL$@HD$XH$HD$8HL$@HD$HL$0HD$XH$Hl$HHPxNeH %H;av|H Hl$Hl$D$0HD$(H$n2HD$(HD$$H, HD$躢u!HD$(@BD$0/Hl$H ÐHl$H xkeH %H$XH;AH(H$ H$ HDŽ$8HDŽ$@H9H$HD$HD$hHH@HD$hHL$HL$`H$HDŽ$HDŽ$H$0HH$H$H$H$HT$HL$HD$N[HD$ HD$PHD$PHHD$hHL$PHvHD$pHL$xHDŽ$H$HL$HD$aHD$HD$XH$WHl$Hl$'HmHD$XH$8bH$Ht$`Hl$Hl$dHmH$H$Hl$Hl$AHmH$H$H$8H$@H$ H( HH$H<# HD$蒮 ueH %H;aZHPHl$HHl$HH$HD$HL$HL$ HD$(HT$XHBhHZ`HJ`HD$XHD$$H HD$ǟH8H$HL$HT$HD$0HL$8HT$@HD$XHL$0H\$8HH HuUH H$HD$HL$XHHAXHT$`HD$XH$HHD$X@Q谨Hl$HHPH$HT$X릐萨Hl$HHPH$HL$8nteH %HD$H;AHH$H$Ƅ$H$HTHDŽ$HDŽ$H$HHHD$xH$HD$HD$xH$H$H$HL$HD$HD$(HL$ H$H$D$0D$WH$H$H$H$D$WD$VD$VuHH$HD$HD$HD$`HH$HD$HD$H$H3H$:HD$HD$p 8HHxWHHl$Hl$HmHD$pHL$`HHHD$pH$vHHHD$pH$H$H 8HHHH$HL$pHYpHApH$HL$pH@xHHAxH$HL$p@PAPH$HL$pHHHHD$pH$HDŽ$H$H$H$H[HQ0AHY8HA8H$@PuH$H@pHD$XHD$XH@pHuHD$XH@pHD$XHD$XH$,HDŽ$HDŽ$H$HD$hH$HHD$HH$HD$HL$H$H$HT$hHWHZHJHD$hH$HDŽ$HDŽ$HD$XHH8H@0H$HL$H  HD$HD$ H$H$H$HT$ HL$(HD$0qHD$XH$+H$HD$H$HD$$H HD$-9H$HH$HD$'H$@A$H$HH$HL$kH$HD$H$HD$mH$HD$H$HT$H$HL$_H$HL$mH }H $HD$Ƅ$H$Hqn eH %H;a.H0Hl$(Hl$(HD$HHH$HD$HD$HD$ H<H$CH|$H|$WHHl$Hl$aHmHD$HL$@ulHHD$ HT$ HXu;HPHD$HL$8HH(HD$H@HD$HD$HHl$(H0H$HT$ H$HL$HbH$H|$DTmeH %H;aH(Hl$ Hl$ HD$0HH$[HD$0HL$0H@HI(H9|H$HH$HD$dH$HD${H$@PuH$H$D$D$6uHD$hHL$`HL$pHD$xH$xWHHl$Hl$؉HmH$xHD$@HH$xH H$H$HHD$HH$bHD$HL$H$H$HT$@HBǩHZHJH<H$HD$pHD$ HD$HL$H$H$HT$@HJ nHZ(HB(HD$@H$HDŽ$ HDŽ$(H$H$HD$XHL$PHL$HD$H$H$ H$(HD$HL$ HT$(3H$HD$mH$HL$yHD$`HL$hH$H$H$HWHHl$Hl$ HmH$HHD$8HH$HHS H$PH$HHD$HH$薽HD$HL$H$H$HT$8HJ HZHBHpH$H$HD$:HD$HL$H$H$HT$8HJ HZ(HB(HD$8H$HDŽ$HDŽ$H$H$HD$PHL$XHD$HL$H$H$H$HD$HL$ HT$(d.H$HD$qH$HD$H$HZeH %H$H;A HH$H$W$h$x$HDŽ$XHDŽ$`HH$HH@H $HD$HB HD$HD$ HHD$0HL$(H$XH$`H$H$H$HuRH$H$H$H$ H$HuHAH$HDŽ$pHDŽ$xHDŽ$HDŽ$H$pH$HHD$HH$贺HD$HL$H$H$H$H HZaHBH$H$H$ HH ߤHXHPH$H$HDŽ$HDŽ$ HH !oH $HD$HY HD$HD$/H$ H$H$HT$ HL$(HD$0H$*H$H$H$H$XH$`H$hHDŽ$H$`HD$xH$XH$H$HL$xH9|H$HHHH@H$H$H$H$H$H$hH$pH$xHH$HHHH$HL$H$pH$hHL$HD$HD$ D$WD$RD$Ru HDŽ$HHDŽ$PH$HH$HwH$H$hHL$AHD$HL$H$H$H$H HZuHBH$H$HDŽ$HDŽ$H$HD$HD$H$HH$H$HH$@H$HD$vH$(H$ H$0H$@H$HH$PHD$pH$HHD$hH$@H$HD$pHL$hH9|H$HHHH@H$H$H$H$H$H$H$H$HضH$HH@H $HD$H$H$HD$HL$HD$ D$VD$TD$TuHDŽ$8HDŽ$@H$8H$HMH$H$HL$HD$HL$H$H$H$HzHZuyHJH$H$HDŽ$HDŽ$H$HD$HD$H$HH$HD$pHHD$pIH$HL$|H$8H$@H$HH$(H$0H$8HD$`H$0HD$XH$(H$HD$`HL$XH9|H$H$Hl$Hl$]HmH$H$Hl$Hl$:HmHH$HH@H $HD$H$H$HD$HL$HD$ D$UD$SD$SuHDŽ$(HDŽ$0H$(H$H6H$H$HL$HD$HL$H$H$H$HcHZuyHJH$H$HDŽ$HDŽ$H$HD$HD$|H$H0H$HD$`HHD$`VH$HL$|H$HH$HT$oH$HD$\UQeH %HD$H;AfHH$H$Ƅ$Ƅ$Ƅ$HBH 3H$H$H$H$HD$PH$HD$HH$H$HD$PHL$HH9|H$HHD$@HD$8H$H1HHHHD$HL$H$H$H HD$HD$ 谠HD$(HD$hH'HH$HD$hHD$HD$HD$`HH$HD$HD$H$HH$HD$nHD$H$H_H$!HD$HD$x ϛHHxWHHl$Hl$zHmHD$xH$H;HHD$xH$ZHHHD$xH HeHP0!Hp8HH8HfHL$xAPHD$xHL$`HPHHD$xHD$XHDŽ$HDŽ$HDŽ$HDŽ$H$HD$pH[<H$HL$pH$H$H$HqHYFHqHyHD$XH$HD$pHD$:$uqHD$XH$D$D$7$$u1$H$HH$HD$PHHD$PHL$XA@H4$H|$KTH4$HL$8HdH4$HL$HcEH$HL$H$HL$H U\H $HD$7tH$HLxeH %H$XH;AH(H$ H$ H_HHHIHHOH H@HuRHHHHH$HL$HD$HL$H$H$HD$`HDŽ$HDŽ$H$H$H$HL$腯HD$HD$`HD$ HL$H$H$HD$`HD$PH$H$H$H$H$Hu%H$H$H$PH$XH$HuHAH$HDŽ$HDŽ$H$H$H$H$XH$H$H$H$HDŽ$HDŽ$H>H oaH $HD$H HD$HD$ H$H$H$HT$ HL$(HD$0EH$ H(HD$PH$H$0HQH HI0H`H\$HD$H$HD$ HL$H$H$H$Hu3H$H$H$@H$HH$HuH@H$HDŽ$HDŽ$H$H$H$HH$H$H$H$H$HDŽ$HDŽ$HH _H $HD$H8 HD$HD$%H$H$H$HD$ HL$(HT$0HD$PH$]H$ H(HǪH@HuHHH@H $HD$1HD$HL$H$H$HDŽ$HDŽ$HDŽ$H$H$H$HL$իHD$H$HD$HL$ H$H$H$HD$XH$H$H$H$H$HuH$H$H$0H$8H$HuH@H$HDŽ$pHDŽ$xH$pHD$xH$H$8H$pH$xHD$xH$HDŽ$HDŽ$HH ]H $HD$H HD$HD$ H$H$H$HD$ HL$(HT$0H$ H(#HD$XH$H L]H $HD$8HD$HL$H$H$H$Hu$H$H$H$ H$(HD$pHuH@HD$pHDŽ$`HDŽ$hH$`HD$hHD$pH$(H$`H$hHD$hH$HDŽ$HDŽ$H*H [\H $HD$H) HD$HD$!H$H$H$HD$ HL$(HT$01HD$XH$ӷH$ H(HH@HuHHH}HHH$*)HH@HuHHH}HHH$V,H=H@Hu}HHtkHH 4[H $HD$HS HD$HD$_HD$ HD$(HD$0H$IH$ H(f?D&eH %H$@H;A]H@H$8H$8HWH@Hu*H$HHHHH@8H $HH@Hu 6H%H@Hu HHHHH$HL$ HD$HL$H$8H$@HD$hHDŽ$(HDŽ$0H$@H$8H $HD$~HD$HD$hHD$ HL$H$(H$0HD$hHD$XH$0H$(H$H$H$Hu H$H$H$H$H$Hu HAH$HDŽ$8HDŽ$@H$8H$H$H$H$8H$@H$H$HDŽ$HDŽ$H7H hXH $HD$H HD$HD$ H$H$H$HT$ HL$(HD$0>H$qHHD$XH$H$HHQH HI@HWH\$HD$H$HD$ HL$H$H$H$Hu_ H$H$H$H$H$Hu( HAH$HDŽ$HDŽ$ HDŽ$(HDŽ$0H$H$H,HD$HH$HD$HL$H$H$H$H HHZn HBH$H$H$HH HX# HPH$H$HDŽ$HDŽ$H!H RVH $HD$Hx HD$HD$H$H$H$HL$ HT$(HD$0(H$[HD$XH$軱HH@Hu_ HHH}B HuHH@H $HD$ HD$HL$H$(H$0HDŽ$HDŽ$HDŽ$ H$(H$0H$HL$2HD$H$HD$HL$ H$H$ H$HD$PH$H$ H$H$H$Hu]H$H$H$H$H$Hu&H@H$HDŽ$HDŽ$H$H$H$H$H$H$H$H$HDŽ$HDŽ$HH TH $HD$H7 HD$HD$ H$H$H$HD$ HL$(HT$0H$HD$PH$H$HHH@HIHH HT$HD$H$HwSH\$HT$ HD$(H$HD$0HL$8H$H$H$HuH$H$H$H$H$HurH@H$HDŽ$HDŽ$HDŽ$HDŽ$H$H$HiHD$HH$rHD$HL$H$xH$H$HՇHZHJH$H$H$HH HXmHPH$H$xHDŽ$HDŽ$HH QH $HD$H HD$HD$H$xH$H$HD$ HL$(HT$0赺H$HD$PH$HHH@HuHHH}HbHH@H $HD$HD$HL$H$H$HDŽ$HDŽ$HDŽ$H$H$H$HL$违HD$H$HD$HL$ H$H$H$HD$`H$H$H$H$ H$HuH$H$ H$hH$pH$HusH@H$HDŽ$HDŽ$H$H$H$H$pH$H$H$H$`HDŽ$hHDŽ$pHrH OH $HD$H HD$HD$ H$`H$hH$pHD$ HL$(HT$0yH$HD$`H$H$HHH@HIHH HT$HD$H$HOH\$HT$ HD$(H$HD$0HL$8H$H$ H$HuH$H$ H$XH$`HD$xHuH@HD$xHDŽ$HDŽ$HDŽ$HDŽ$H$HD$pHHD$H1H$HD$HL$H$HH$PHT$pHnHZHJHD$pHL$xH$`HH <HXHPHD$pH$HHDŽ$PHDŽ$XHPH MH $HD$H HD$HD$H$HH$PH$XHD$ HL$(HT$0WH$HD$`H$HYHupH$8H@H$HT$&H$HL$CpH$HT$H$HL$=H$HT$H$HD$HP(I5~eH %HD$H;AHH$H$HDŽ$HDŽ$HH@Ht2H$H$H$H$H$HH$HtH$H$HwQ$;D$D$?u0H$H$H$H$H$HH$H$HD$XHL$`H$WHHl$Hl$_HmH$HD$@HHD$HH$胕HD$HL$HL$xH$HT$@H HZXHBHD$@H HH HPH HHH.H$HD$XHD$HD$HL$HL$hHD$pHT$@HJ fHZ(HB(HD$@H$HDŽ$HDŽ$H H$HD$H$H$H$HD$HL$HT$ )HD$(HL$0HD$HHL$PH$H$H$HH$HD$gPH$H HD$MH$HD$:Z i2eH %H;aH Hl$Hl$HHH^HHH$HmH HD$+HD$ ~uHӓHl$H H H $HD$1beH %H;av?HHl$Hl$HtHHHiH$Hl$Hm1eH %H$H;AHH$H$HHHHH$HL$H3 HD$HD$HD$(HL$ HT$0H$PH$XH$`H$8H$@H$HHDŽ$H$@H$H$8H$H$H$H9|H$HHHH$H$ H$H$H$HL$EHD$HL$H$H$Ht.H$HH$H$HH$XHDŽ$HDŽ$H$H$H$HL$EHD$HD$hHD$ HL$H$H$HD$hHD$`H$H$H$H$H$HuJH$H$H$(H$0HDŽ$HDŽ$H$H$HH$H$(HL$YHD$HL$H$H$H$HzHZHJH$H$hHDŽ$pHDŽ$xH͎H DH $HD$H$ HD$HD$(H$hH$pH$xHT$ H\$(Ht$0ԭH$HD$PHkHL$PHH9rHH HHYH91HQHʔHT$`HHD$PH$HHD$PH5iH4$HD$HL$HT$H\$ HD$(HL$0HT$8Hv`yu HSH$HL$xH ;H $HD$H$HL$xH$HL$˾^HD$`H~HHuH$HĈHD$XH&HL$XHH9rH$mHD$H$HH HHYH97HQHkH$HHD$XH$HHD$XvH5H4$HD$HL$HT$H\$ GHD$(HL$0HT$8HwuHyH$HL$pH ӒH $HD$腽H$HL$p+GeH %H;av;HHl$Hl$HD$ HH$HV HD$Hl$HQ+eH %H;avmH Hl$Hl$HD$(HD$$H3A HD$qUu)HD$(H$HD$#^Hl$H Ð^Hl$H *zeH %HD$H;AHH$H$HBHD$PHDŽ$HDŽ$H$HD$hHڶH$HK H$HD$hH$HDŽ$HDŽ$HD$PHH8H@0H$HL$H־ HD$HD$ H$H$H$HT$ HL$(HD$0aHDŽ$HDŽ$H$HD$`HH$H H$HD$`H$HDŽ$HDŽ$HD$PHH0H@8H $HD$H HD$HD$ H$H$H$HL$ HT$(HD$0蚨HD$PHHu#HD$pHD$xHD$pHD$XHD$PHHD$H-H$HD$HL$H$H$HT$XHjtHZHJHD$XH$HDŽ$HDŽ$HD$PHH0H@8H $HD$H: HD$HD$H$H$H$HD$ HL$(HT$0脧H$HH$HL$tY'eH %H;av;HHl$Hl$HD$ HH$HW HD$Hl$HQ'eH %HD$H;AHH$H$HBHD$@HBHJHRHT$xH$H$HD$0H$HD$(HD$xHD$8HD$0HL$(H9|HD$8HHHPHHD$`HL$hHT$pHD$`HL$hHD$HHL$PHT$XH$H$HD$HHL$PHD$HL$HD$XHD$(UHD$8HHD$8HD$0HHD$0aH$HĘq%eH %H;avHH0Hl$(Hl$(HD$8H$5HD$HL$HL$HD$ H $HD$^Hl$(H0%eH %HD$H;AHH$H$HYH$衯HD$HD$p Qq9HHxWHHl$Hl$PHmHD$pHD$XH$HD$PHDŽ$HDŽ$HD$XH 9H $HD$HD$PH ;HL$HD$qHD$(HL$0H$H$HD$xH$H$H$HD$xHuhH$HL$xH$H$HL$hHu7HAHD$hHDŽ$HDŽ$H$HD$`HD$hH$H$H$HD$`H$HDŽ$HDŽ$H%H V:H $HD$H HD$HD$H$H$H$HD$ HL$(HT$0,H$_HD$pH$HD$HL$H$H$H$H$H$HD$H$HH WH $HD$"LeH %H$H;AX HH$H$H$HL$HT$H$HH$PH$XH$HH$PH$HL$HT$H$H$H$HD$HL$ HT$(iHD$0HD$@H$HD$HL$H$H$H$H$[H$  m> HDHDŽ$HDŽ$H$(H$H$HD$$H$H$HL$xH$HDŽ$HDŽ$H$H$aHD$HL$H$H$H$HL$xH $HD$9HD$HL$H$H$H$PH$HH $HD$HD$HL$HL$hHD$p$XuH$H$H $HD$jHD$HL$H$H$HD$pHL$hH $HD$jHD$HL$H$H$H$H9uH$Hu<H$HuVH$H$H$xH$H$H$H$hH$pH$WHHl$Hl$TKHmH$HD$PH<H$H$0HD$HD$HL$H$H$HT$PHlkHZHJHH$H$xHD$諀HD$HL$H$H$HT$PHBkHZHJHH$H$hHD$OHD$HL$H$H$HT$PHB jHZ(HJ(HD$PH$HDŽ$HDŽ$H H$HD$H$H$H$HD$HL$HT$ 7H$`H$HH$HH$HL$蹯TH$HL$覯H$HL$蓯vH$HuHuH$H$H$XH$`HDŽ$`HDŽ$hHDŽ$pHDŽ$xH$`HD$HHѩH$H$0HD$~HD$HL$H$H$HT$HHiHZHJHvH$H$XHD$@~HD$HL$H$H$HT$HHBhHZuxHJHD$HH$HDŽ$HDŽ$Hq H$HD$H$H$H$HD$HL$HT$ ,H$HL$׭H$HL$ǭH$HL$xH$H$HDŽ$HDŽ$HDŽ$HDŽ$H$HD$`H/H$H$HD$|HD$HL$H$HH$PHT$`H_gHZHJHԧH$H$HHD$|HD$HL$H$8H$@HT$`HJ gHZHBHD$`H$0HDŽ$8HDŽ$@H H$HD$H$0H$8H$@HD$HL$HT$ ƜHD$(HL$0H$H$/H$HD$eH$HL$H$H$H $HD$H$H$HD$HL$9D$ uH$H9uH$HuH$H$H$H$HD$hHL$pH$H$HDŽ$HDŽ$HDŽ$HDŽ$H$HD$XHܥH$H$HD$zHD$HL$H$(H$0HT$XH eHZHJHH$H$HD$KzHD$HL$H$H$ HT$XHBdHZHJHD$XH$HDŽ$ HDŽ$(Hd H$HD$H$H$ H$(HD$HL$HT$ sHD$(HL$0H$H$EH$HL$ƩeH$HL$賩H$H$H$HL$HD$hHL$pHD$HL$7D$ uH xH $HD$RH$H$H$HL$P heH %HD$H;AHH$H$LH$HD$XH$HIXHH;H$H$H HD$HD$&HD$HD$ HD$(eH$HHD$PH$HL$HT$H$H$H$H$HHHHL$HT$ HD$(H$H$H$H$HL$HT$YHD$0HD$HH$HT$PHHH$H$VHD$HL$H$H$H$IQuGH$HH$HHD$@HH$HH$cH$HH$H$HHHH$H$H$HD$hH$HD$`H$H$HD$hHL$`H9|WH$HHD$xHD$pHH$HD$7H$HH$HD$hHHD$hH$uH$H$#H$@CH$H@pHuhH$@TD$"H$H4Ӆu(H H$H$H$HĠH4$HL$gH$H$HH$H\$HT$HL$H|$ qHD$(HL$0HT$8H$HS!uHCHHHH8H$HL$xH$H $HD$!gH$HL$xH$H$<tH$H@0HD$hHtH$HH0H@(HwH$HQ0HI(Hw_I9tNH$HH0H@(Hw/H$@HQ0HI(Hw I 9tH$HH(H@0Hw$D$D$PH$HQ0HI(HwI9tH$HH(H@0Hw{A$D$D$LH$HQ(HI0HwJ 9tH$HH(H@0HwcD$TH$fD$ H$H$D$TD$D$D$GuHDŽ$H$HĠH$H$H@8HsH$H@0H$H$ fHH$<tGH$H@0HD$`Ht'H$HH(H@0Hw H$ HP0H@(Hw@9tH$HH0H@(Hw$D$D$HH$HQ0HI(HwI9t~H$HH0H@(Hwb@$D$D$\H$HQ0HI(Hw4 9tH$H$D$fD$ [Y\Z][\ZZXVKytRPW           eH %HD$H;AHH$H$Ƅ$H$H@HD$@H|Ƅ$H$HH$HQHIHXH9rHDHD$hH$HHH@HT$@HZH9reHDHD$`HL$h uƄ$H$HÄuHL$hIPf9u뺄HH0HP(H@8HT$pHL$xH$HD$hHH(HP8H@0H$H$H$HD$xHL$pH$H$H$H$H$HHD$XH$H9wQHTH$H$H$H$HT$HL$HD$HD$XHD$ 5H$H$H$H H$HD$HD$HL$HD$ e?HD$(HL$0HT$8HHHHH$HD$4&d_H$`H$hH$XH$H$H$HD$PH$H$H$XHDŽ$`H$hHDŽ$HDŽ$H$H$8H$H9~HDŽ$H$H$0H$H9|H$H$H$H9rPHHD$H$H$HD$H$H$HuFH$H$H$HD$D$D$IuH$H$SD$D$Hu$H$H$ HH$H$<tH$H$H@HHIPH9tH$HHH@HwDHH$NSD$D$GufH$HL$PH9t$H$HD$PH$H$*H$HL$PHH9tHD$PH$H$H9rHH$ H$hH$`H$XHYH9EHAH$`H$ Hʋ5uHCH$HD$1H5zH4$HT$HL$HD$H\$ ;HT$(HL$0HD$8H$hH$XwH$H$HD$PH$H$H$H9|H$HL$PH9D$EH$H$H$H9rHHD$H$H$D$ED$HD$H$0H$H$H$H9rHH ڋ5u*HH$H$(HH$&H $HD$B0 HD$PH$H$H$H9vH9vH)HHH?HHH!HH$H)H$H$H$H$H$H$H$HL$HT$HD$D$ HD$(H$H$H$D$HD$H$HHH@H$HDŽ$H$H`H$H$L@H0HxH$H$H$H$HSHK HSHCH$hH$`H$XHYH9CHAH$`H$H4ʅu HH4$H\$S.H5:H4$HT$HL$HD$H\$ 8HT$(HL$0HD$8H$hH$XyH$HD$-AH$H$H$H$L$H$Ht$-H$H$H$HD$-H$H$H$HnH$HD$HD$HL$HD$ 7HD$(HL$0HT$8HHHH H$`H$XH$hH$H$H$HD$PH$H$H$XHDŽ$`H$hHDŽ$H$H$H$H9~'H$H$H$H9|H$H$H$H9r HH$LD$D$Fu"H$H$HH$\H$HL$PH9tH$H$H$H9|H$H$H$H9rHH$H$XH$`H$hHYH9UHQH$`H$H4ȅuHH$HHD$P H4$H\$+H5H4$HD$HL$HT$H\$ d5HD$(HL$0HT$8H$hH$XgH$HL$PHH9tH$H$HT$PH9rHH$H$hH$`H$XHYH9EHAH$`H$H4ʅuHUH4$H\$%*H5 H4$HT$HL$HD$H\$ o4HT$(HL$0HD$8H$hH$XwHD$PHD$`HD$PHHD$pHD$pH$H9|fH$H$HT$`H9rEHЄH$H$H\$pH9rH ڄ 8r*HD$pHD$`HD$pH$HHD$piH$H$HT$`H9rHЄHL$pH$H$H9rH ʄ 8tH$H$HT$`H9r`HфH@0H$HD$pH$H$H9r-HH@0H$H$H9|H$H$HT$PH9rHH$HD$`H$H$H9rHT$PH$H$HH9ro H4ӅJHH$HL$`H$H$H9rH4ʅHHD$PHHD$xHD$xH$H9|HD$PH$H$H9rHH$HD$xH$H$H9roHHD$H$H$JHD$xH$H$H9rBHHD$H$H$]HD$xH$HHD$x3 HD$PH$H$H9rHH$KHD$PH$H$H9rHH$H$XH$`H$hHYH9CHQH$`IH$H4ȅu HH4$H\$%H5}H4$HD$HL$HT$H\$ (0HD$(HL$0HT$8H$hH$XyH4$HD$%H4$HD$n%]H$XH$hH$`H$H$H$HD$PH$H$H$XHDŽ$`H$hHDŽ$H$H$H$H$H9|H$H$H$H$H$HH9|kH$H$H$H9rGH<t0H$H$H$HZH9rHD<tH$HH$-H$H$H$H9rHH$H$XH$`H$hHYH9CHQH$`H$H4ȅu HbH4$H\$h#H5O{H4$HD$HL$HT$H\$ -HD$(HL$0HT$8H$hH$XykdH$XH$`H$hH$H$H$H$H$H$H$xHĀ胸 | u n g ` Y R K D = 覸 / ( !  胸  u  g   RHHl$Hl$HD$(HD$0HD$8fD$@HD$ <tHD$ H@H$HHD$ HHH@HwHHD$ HD$ <u,HD$(HD$0HD$8fD$@Hl$HHD$ HH(HP0H@8HL$(HT$0HD$8HD$ @fD$@Hl$H˶ eH %HD$H;A!HH$H$HDŽ$ H$<tH$H@HD$PHH$HHH@HwHH$H$H$H$HD$H$HD$@HD$H$H$HQHIHwBA=HH$<tH$H$H$HD$^H$H@HD$HHD$hHv{H$H$H@H@ HPu0H@H$H$ H$HH$HD$%Ht^H$H$H$HHH@Hw H@H$H$H$H$HD$bdH$HHHPH@HsHHHH?HHH$HAH$H$H$HHHPH@HL$HD$HT$H,vH$H$H$H$HT$ HL$(HD$0"H$H@HD$@HH$H$HIH9vH$HAheH $HD$H$<tH$HH8HP(H@0H$H9v}H)HHH?HHH!H H$H)H$H$H$HH8HP0H@(H$H$H$H$H$H$H$H$H$H$HD$`H$H9H$HD$`HD$`HD$XH$H$H$HD$HD$XHHD$}HD$`HD$xH$HI8H9v[H$HA0H$H@0HD$pHt1H$H$H$ H$HG:   藱 萱 艱 HHl$Hl$HD$0HD$(<tHD$0Hl$HHD$(<tzHD$(H@H$HLHD$(HHH@HwPHHD$tHD$0Hl$HHD$0Hl$HHD$(HD$0Hl$H襰 eH %HD$H;AHH$H$HDŽ$H$<tH$H@HD$PH $u H$HHH@HwoHHD$H$H$輯H$HHHPH@HsHHHH?HHHL$pHHD$xH$H$HHHPH@HT$HD$HL$HqH$H$HL$xHT$pHT$ HL$(HD$0HD$8HD$HH$HIH9v H$HAH$H@HD$@HD$XHtyH$H$H@H@ 8HPu.H@H$H$H$HĐH$HD$HtVH$HD$`H$HHH@HwHH$H$H$HD$`HD$ni|z($uXH$H$H$HD$貭H$H$D$芬HD$HD$hH$H$HĐ蟭  葭 eH %HD$H;AHH$H$HDŽ$H^PH$H|$H$3WHHl$Hl$HmH$H$HD$p$fHHD$pH@H$HDŽ$HDŽ$HL$pHA0HA8HY(HA(H$H$H$H$HD$hH$HL$hH9|1HD$hHD$`H$HL$hD$D=|HD$hHHD$hD$DD$@HD$pH@0HD$PHD$pH@8HD$HHL$PH9}H$H$H$HL$HD$F`HD$HL$ HT$(H$H$H$H\$pHK0HS8 HS(u'HC(HD$pH$H$HH$HD$MHD$pHH(HP0HX8Hp(HzH9HZHX0D$@H$H$HH$HL$HT$H\$H|$ KHD$(HL$0HT$8H$HS8uHC(HHH{HD$xHL$XH$H $HD$HD$xHL$XH$H$H$H $HD$HD$hHD$4OD$D$DHD$ HD$h H$HD$uHLH$H|$`6AeH %H$PH;A!H0H$(H$(HDŽ$PHDŽ$XHDŽ$`$HfuH$8H$@H$HL$虨HD$HL$H$H$HuH$`H@(H$H$`HHA(H$`H$D$腲HD$H$PH$`HI(HHXH$hH$pHsHHHH?HHH$hH$p]XHDŽ$HDŽ$HDŽ$xHDŽ$H$pH$hH $HD$ԤD$$HD$ HL$H$H$HD$0HL$(H$xH$$D$|H$H$H$hH$pH$H$xH$H$H$HuHD$@H$HD$XHL$PH$H$D$>D$=D$=u+H$Ht Hl$pHxH$H$Hw<,uH$H$H$Ht Hl$pHxH$H$Hw<}uH$H$HsHHHH?HHH$H$Ƅ$Hl$pHxH$H$HsMHQHHH?HH4H$H$Ht Hl$pHxHw<}tHDŽ$HD$`HD$hH$H$H$H$HD$HL$ HD$HD$HHD$ HL$(HD$`HL$hD$0D$?HD$HH$HD$`HL$hH$H$D$?D$=D$=u&H$H|HDŽ$8Hl$pHxHl$pHx跄 @ 9 袄 + 蔄  \eH %H$H;A HxH$pH$pHDŽ$HDŽ$HDŽ$HDŽ$H$H$H$H$H$H H$H$Hw A*HD$HD$XH|wH$H$H $HD$3HD$HL$H$H$Hu(HDŽ$HDŽ$H$pHxHH$*HD$H$H@ ͦH  HH$H$H$HH HXuwHPH$H$H qH$ H$(HDŽ$HDŽ$H$(H$ H$H$H$pHxH$HT$H$H HD$3HH$H$H$H9vH$H$H$H$HT$XHsH9vHBHHH?HHH$H$H$HT$FHD$HL$H$H$Hu(HDŽ$HDŽ$H$pHxH$H$H $HD$OD$D$9u-H$H@(H$H$HHA(H$H$D$>HD$H$H$HI(HHXH$H$H$HHh YHX`HP`HD$XHHD$xH$H$H9vSH)HHH?H!HH$`H$hH$H$HDŽ$HDŽ$H$pHxH$HT$ukHYH$HD$H$H@ H  HH$H$H$HH IHXuwHPH$H$H nH$H$HDŽ$HDŽ$H$H$H$H$H$pHxH$HT$|H$H HD$e3D$DH$H$HsHHHH?HHH$H$H$fD$:HD$PD$8H$Hu(HDŽ$PHDŽ$XHDŽ$@HDŽ$HH$H$H $HD$v~D$D$LHD$ HL$H$PH$XHD$0HL$(H$@H$HD$LD$DH$XH$PH$H$H$HH$@H$H$H$Hu(HDŽ$HDŽ$H$pHxËD$DD$H:~r)tHD$PH|D$8uD$:fD$:D$D:trH$H$D$AH$L$:fH$H$H$H$HDŽ$HDŽ$H$pHxH$HD$pH$HD$hHL$pH)HL$`H$H$H9v%H$0H$8HH$HD$H$H@" H e9 HH$H$0H$8HPHXuwHHH$H$H jH$H$HDŽ$HDŽ$H$H$H$H$H$pHxH$HL$H$H8 HD$3-t6HD$PH|~HD$PD$:fD$:D$8v:tFi~HUtD$:fD$< fD$:D$8뻃itD$:fD$BfD$:D$8몃mtD$:fD$@fD$:D$8pstD$:fD$>fD$:D$8K/L(Ey y y y y Ay Q%eH %H;aH`Hl$XHl$XD$xHD$pHtD$xHl$XH`HD$pHL$hHL$HHD$PHD$@HD$@HL$PH9|HD$@HD$8HD$@HL$HD$4=|NHD$@HHD$@D$4D$0_u.${D$D$/uD$xHl$XH`HD$HHL$PH$HL$HD$@HD$GD$D$4HD$ HD$@D$xHl$XH`oPHPHl$HHl$HHD$pHD$xHDŽ$Ƅ$HD$hHt Hl$HHPHD$hHL$`HwL<0rHD$hHL$`Hw+<9wHD$hHD$H}HD$hHL$`Hw<0tHD$hHL$`HwA<0sHD$hHL$`HwA<9v Hl$HHPHD$hHL$`HL$8HD$@HD$hHu]HD$hHL$`HwG<0s6HD$hHL$`Hw <9v:HD$hHL$`Hs7HHHH?HHHD$`HT$hzHD$hHL$`HL$xH$Ƅ$HD$@HD$HD$hHD$HL$H)HL$0HD$@H9vHL$@H$HD$@HD$(H $H9|dHD$pH=}HD$pHl$HHPHD$pHH $HT$8H\$@H9rK HDAHD$pH$HD$ HH$:33p,i%b%#=u u u (u !u u HHl$Hl$D$ HD$<ttHD$H@0H$HuDu*uD$ Hl$HHL$ HL$ HL$ H0Hl$(Hl$(D$HHD$8D$<v6<tSHD$8H@0HD$ Ht4HD$8HH0H@(Hw:L$@9D$HHl$(H0<tHD$HD$8H@0HD$HL$H9|HD$8HH0H@(HT$H9riL$@9~ZHD$8L$@HP(H@0H\$HsH9r5D9~D$HHl$(H0HD$HD$HHD$a_[D$HHl$(H0D$HHl$(H0<tD$@ D$HHl$(H0<tD$HHl$(H0r r eH %H;av~H(Hl$ Hl$ HD$8HD$@HD$0H$背HD$0H$D$D$uHD$8HD$@Hl$ H(HD$0H$D$EJieH %H$`H;A-H H$H$H$(D$J<v<tH$0HH0H@(HwkH$(HQ(HI0HwH 9t8H$0H$(@If9tH$H H$(H$(HH(H@8H$HDŽ$H$H$(HH(H@0HwD$PH$(@fD$H$H$H$H$HL$HT$D$PD$6QHD$ HL$(HT$0H$H$H$H$(HK0HS8 הHS(HC(H$(HH(HP0H@8H$H$H$H$0HH(H@0HwD$LH$0@fD$H$H$H$H$HL$HT$D$LD$MPHD$ HL$(HT$0HD$pHL$xH$H$(HK0HS8 HS(u HC(H$HD$H$HD$\W<tH$0<tH$(HH8HP(H@0HT$XHD$`HL$hH$0HH(H@0HwD$TH$0@fD$HD$hHL$`HT$XH$HL$HD$D$TD$(OHD$0HL$(HT$ H$H$H$H$(HK0HC8ɒHK(uHS(H $HT$dH$(HH8HP0H@(H$H$H$H$0HH0HP(H@8HT$HL$ HD$(H$H$H$H$HL$HD$WHD$@HL$0HT$8H$H$H$H$(HS0HC8HS(u HK(H$HL$<t@H$0H$D$ D$D$KuH$(<tl l l l CEeH %H;a(HpHl$hHl$hƄ$HD$xH@HD$H}HL$xHQHIHXH9rHL tuHL$xHQHIHXH9rTHDH$D$D$u/HD$xHHH@HT$HZH9r HDH$D$D$u]HD$xHHH@HT$HZH9rHDHD$XHD$xHHH@HT$HZH9rHDHD$@HL$X 8wHD$XHD$`HD$@HD$XHD$`HD$@HD$HHHL$8HT$xHZHRHt$@H9rqHLwu|HtHD$@H$HD$XHD$HD$xH$HD$XHD$jHD$HHD$ HL$xHIH9vHL$xHAƄ$Hl$hHpH $Ht$zwHD$H}xHD$xHHH@HT$HZH9rHDHD$PHD$xHHH@HT$HZH9rWHDHD$HH$Ht$.DƄ$Hl$hHpSmJbh h h h h i h h h h @eH %HD$H;AxHH$H$HDŽ$HDŽ$H$H$H$H$GD$D$uH$H@HD$8HHD$0H$HIH9vH$HAH$H$H$H@HD$ H|HH$!HD$HD$`H@ NjH HH$HL$`HP8H@0HQHYu9HAHD$`HD$PH VH$H$H$HĐH$HD$H$H HD$rH$HQHIHXH9rHDHD$HH$HHH@HT$ HZH9roHDHD$@HD$ HHD$(H$HIH9v6H$HAHD$@ZH$HHD$HD$pHL$xHD$HL$ZHD$ HHHPHXHH$H$H$H$H$HtH$HH$H$H$H$H$HD$HL$HT$H$H$H$H$HD$ HL$(HT$0H\$8HD$@HL$HHT$PH$H$H$H$H$HsyHHHH?HHHD$`HT$hH$H$H$H$H$H$HD$`HL$hH$H$H$HO O O t'?eH %H$`H;AH H$H$HDŽ$XHDŽ$`HDŽ$hHDŽ$pHDŽ$xHDŽ$HDŽ$H$8HD$`H|H$H H$8H$0HwE<[uH$0H$8Hw@<:uH$8H$0HsHHHH?HHH$H$H$HT$H{HD$HD$ HD$ HD$XHD$XH|H$H HD$XHD$xHHD$XHD$XHHD$pH$8H$0H9vGH$H$HD$XHHD$hH$8H$0H9v H)HHH?H!HH$H$H$H$H$H$H$H$H$0H$8H VH$HHD$H$H$HL$HD$NVHD$ HHHPHXHH$H$H$H$H$Ht;H1H$踮HD$H$H@ [pH MHH$H$H$HP!pHXHHH$H$H ;H$H$HDŽ$XHDŽ$`HDŽ$hHDŽ$pHDŽ$xH$H$H$H$H$H H$HL$,ZH$H_HD$H$(H$H$@H$HH$PHD$HL$HT$H$H$H$H$HD$ HL$(HT$0H\$8HD$@HL$HHT$PH$H$H$H$XH$`H$hH$0H$8H$pH$xHDŽ$HDŽ$H$H MJ FJ I 8"eH %H;a[HhHl$`Hl$`HDŽ$HDŽ$HDŽ$HD$pft8H$H|H$HL$xH$H $HT$HD$H$H$H$HT$HL$ HD$(55HD$@HL$8HT$0HT$xH$H$H$H$HT$xH$H$H$Hl$`HhH$HL$xH$H $HD$HT$H$H$H$HD$HL$ HT$(1HD$0HL$8HT$@HD$xH$H$OHD$pHHPH@@HD$HHD$PHL$XH$HD$HL$H$H$H$HD$HL$ HT$(2HD$0HL$8HT$@HD$HHL$PHT$XH\$pHKHHSP lHS@&HC@HD$pH@H$$HD$HL$HT$HD$HHL$PHT$XH$H|qHD$xH$H$H$HL$HT$HD$HHL$PHT$XHD$HL$ HT$(,3HD$0HL$8HT$@HD$xH$H$HD$xH$H$H$HL$HT$HD$HHL$PHT$XHD$HL$ HT$(/HD$0HL$8HT$@HD$xH$H$H$HD$臰eH %H;aH@Hl$8Hl$8HD$XHD$`HD$PHtHD$PHL$HHwHD$PHT$H HwB fAntHD$PHL$HHwjAHpHl$hHl$hHDŽ$HDŽ$HDŽ$$fu~HD$xH$H$H$HT$HL$$D$$D$HD$ HL$(HT$0HD$PHL$XHT$`H$H$H$Hl$hHpHD$xH$H$H$HL$HT$$D$$D$OHD$ HL$(HT$0HD$8HL$@HT$HH$H$H$Hl$hHpeH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$H$HD$PHD$XHD$XH~HD$PHL$XH9}HD$PH+D$XH$HD$PH+D$XHHH$H$H$H9raDD$LH$H$H$H9r2D$DD$LD$H$9~D$D$9~$L$D9|HD$PH+D$XHD$x$H$H$H9r $L$H9zHD$PH+D$XHHHL$pH$H$$H9r<tH$H$H$H$H$H$H$HİnHD$XHD$`HHD$X@H$H$H$HZH9Y$$4|H$H$H$H$H$H$H$HİHT$hH5yH4$HL$HT$HD$H\$ ԏHL$(HD$0HT$8HXHHT$hb   jeH %H;aHHl$xHl$xHDŽ$HDŽ$HDŽ$$A~$=C}H$H$H$H $HD$HT$$D$$D$3HD$ HL$0HT$(HD$`HT$hHL$pH$H$H$Hl$xHĀ$A|H$H$H$H$HL$HT$$D$$D$HD$ HL$(HT$0HD$HHL$PHT$XH$H$H$Hl$xHĀË$=Cg$A|rH$H$H$H$HL$HT$$D$D$@HD$ HL$(HT$0H$H$H$DŽ$A$=CH$H$H$H$HL$HT$D$D$D$nHD$ HL$(HT$0H$H$H$DŽ$C$D$@D$@$9~H$H$H$H$HL$HT$D$@D$D$@D$HD$ HL$(HT$0H$H$H$D$@$D$D$<D$D$0|D$D$D$|D$D$v2uuD$ËL$_L$Ѓ ؋L$eH %H;aH8Hl$0Hl$0HD$HHD$PHfH$ \HD$HD$ uwHHxWHHl$Hl$HmHD$H$HD$@HD$( HD$H$*\HD$HL$HD$ HL$(HD$HHL$PHl$0H8H H $HD$Mi&HHl$Hl$HD$(D$0HD$L$ HPHH9rH HH$H$<t6H$@D$ HL$HQH H9rHD$`H$XHD$HL$HL$hHD$pHD$@<D$.HD$hHL$pH$H$D$.$Hl$xHĀH H $HD$e YTHHl$Hl$D$(D$HD$ H@D$HL$ HQH H9rHHHD$HD$D$<v|<t:HD$@D$HL$ HHIH9rqHHHD$<tD$D$HL$I ȈD$D$D$(Hl$H<tD$(Hl$H<tj  eH %H;avHH(Hl$ Hl$ D$@HD$0H$D$8D$(HD$HD$HD$@Hl$ H(eH %H;aUHHl$xHl$xHDŽ$H$HHHP H@HD$`HL$hHT$pHL$XHtHD$hHL$`HwD$$9tHDŽ$Hl$xHĀH$Ifu}$͸D$D$D$L$9uB$L$9tHDŽ$Hl$xHĀD$$}D$D$HDŽ$Hl$xHĀHD$0HD$hHD$PHL$0H9|HD$0H~$HL$hHT$0H\$`H9r 9|HDŽ$Hl$xHĀË$HL$`HT$hH\$0HsH9r}L9~+HD$0HH?H?HHH$Hl$xHĀHD$0HD$HHHD$0"HD$(HD$hHD$@HH?H?HHHD$8HD$(HL$8H9|HD$8H+D$(HH?H?HHHD$(HD$ HL$hHT$`HHH9rHD$$9~^$HL$hHT$`H\$ HHsH9rdL9~HD$ H$Hl$xHĀHD$ HHD$(7HD$ HD$8HDŽ$Hl$xHĀ     ceH %H;aH8Hl$0Hl$0HD$HHD$PHH$MRHD$HD$ uwHHxWHHl$Hl$WHmHD$H$HD$@HD$xHD$H$jRHD$HL$HD$ HL$(HD$HHL$PHl$0H8H H $HD$_feH %HD$H;AHH$H$H$H$H$HL$hHD$pHT$xHD$8HD$pHD$0HD$hHD$@HD$8HL$0H9|fHD$@HH@HL$XHD$`HL$HHD$PH$H$HD$HHL$PHD$HL$[HD$@HHD$@HD$8HHD$8H$HĈ_eH %H$pH;AaHH$H$HD$XH$ H@HD$PHD$XHL$PH9|HD$XHD$8H$ HQH H9rHHHD$`HD$8H$[HD$HL$HL$xH$HD$HH|H$HD$@HvHHHHHH?H!H @NHH$H$H$H$H$H$HT$HD$ZH$ HL$8H@H9tH$HL$xH$H$H$H$H$HL$HD$HLHD$HD$ 輛HD$(HL$0HD$xH$H$H|$pH5r Hl$Hl$rHmHD$pH$HT$xHH <%HHD$pH$HDŽ$HDŽ$H$H$H$H$H$HD$HL$HT$lH$H$HD$`HD$qH$HD$hHn H n H$H$HD$hH$HDŽ$HDŽ$H$H$H$H$H$HD$HL$HT$HD$XHHD$XH$HT$TtH$H f zeH %H;av^H8Hl$0Hl$0HD$HHD$PD$@H$HD$ UHD$HL$HD$ HL$(HD$HHL$PHl$0H8NeH %H$0H;AHPH$HH$HH$`D$7<v<v3tH$`@$ HD$HL$H$8H$@H$`@$HD$HL$H$H$ H$H$H5q Hl$Hl$RHmH$H$@H$8HH 2 HXHPH$H$ H$HH8 HX0u~HP0H$H$PHDŽ$XHDŽ$`H$XH$H$`H$PH$XHL$HT$HD$&H$HHPH$HT$&RwH$HT$R0<tH$`@$nHD$HL$H$H$H$`@$?HD$HL$H$H$H$HH$H5o Hl$Hl$HmH$H$H$HH HXHPH$H$H$HH8 ] HX0uqHP0H$H$8HDŽ$@HDŽ$HH$XH$H$8H$HH$@HD$HT$HL$`H$HT$PH$HT$P@4<tH$`@$HD$HL$H$H$H$`@$HD$HL$H$H$H$H$H5fn Hl$Hl$HmH$H$H$HH HXHPH$H$H$HP8 HX0uqHH0H$H$ HDŽ$(HDŽ$0H$XH$H$(H$0H$ HT$HD$HL$H$HL$OH$HT$N@<tH$`@$KHD$HL$H$H$H$`@$HD$HL$H$H$H$H$H5m Hl$Hl$HmH$H$H$HH rHXHPH$H$H$HH8 :HX0uqHP0H$H$HDŽ$HDŽ$H$XH$H$H$H$HD$HT$HL$f=H$HT$sMH$HT$cM@<tH$H$Hf H f H$H$H$H$HDŽ$HDŽ$H$XH$H$H$H$HT$HL$HD$v6<vw<tH$H$Hpe H ae H$H$H$H$HDŽ$HDŽ$H$XH$H$H$H$HL$HD$HT$<t H$`@$hHD$HL$H$H$H$H$H5g Hl$Hl$HmH$H$H$HH HXuqHPH$H$HDŽ$HDŽ$H$XH$H$H$H$HD$HL$HT$H$HT$J<tH$`H@HuH$`HHHPH@ HL$HT$HD$HD$XH$轖HD$ HL$(H$HL${HD$HL$H$H$H$H$H5f Hl$Hl$HmH$H$H$HP[HX'HHH$H$HDŽ$HDŽ$H$XH$H$H$H$HD$HL$HT$H$`@fuH$H$H"b H #b H$H$H$H$xHDŽ$HDŽ$H$XH$H$xH$H$HD$HL$HT$H$`@$`HD$HL$H$xH$H$H$H5e Hl$Hl$HmH$H$xH$HPHXuqHHH$H$`HDŽ$hHDŽ$pH$XH$H$`H$hH$pHD$HL$HT$H$HL$GH$HL$GH$H$H\` H ]` H$H$H$H$HDŽ$HDŽ$H$XH$H$H$H$HD$HL$HT$!l<tH$`HHHPH@ HT$HL$HD$HD$8H$HD$ HL$(H$HL$wHD$HL$H$hH$pH$`@$0HD$HL$H$XH$`H$H$H5-d Hl$Hl$HmH$H$pH$hHH HXHPH$H$`H$XHH8 NHX0uqHP0H$H$HHDŽ$PHDŽ$XH$XH$H$HH$PH$XHD$HL$HT$zQH$HT$EH$HT$wE@< t H$`@$HD$HL$H$HH$PH$H$H5a Hl$Hl$dHmH$H$HH$PHP(HXuqHHH$H$0HDŽ$8HDŽ$@H$XH$H$0H$8H$@HD$HL$HT$T+H$HL$aD< tH$`@$HD$HL$H$(H$0H$hH|$xH5` Hl$Hl$THmHD$xH$(H$0HPHXunHHHD$xH$HDŽ$ HDŽ$(H$XH$H$H$ H$(HD$HL$HT$J!H$HL$WC英FeH %H$hH;A|HH$H$Ƅ$0H$ Hu&H$(HuH$ H$( 8uƄ$0H$HH$ D$+< v"Hv^H$ H@0HD$PH$(H@0HD$HHL$PH9uƄ$0H$HH$ HH8HP0H@(H$H$H$HD$pH$HD$hH$H$HD$pHL$hH9|H$D$4HD$pHD$@D$4D$0H$(HQ0HI(H\$@H9r 9uƄ$0H$HH$HH$HD$pHHD$p`Ƅ$0H$H< tJH$ H$(@%If9uƄ$0H$H< tWH$ H$(H@XHIXH9uƄ$0H$HH$ HH`H@hH$H$H$(HH`H@hH$H$H$H9uH$H$H $HD$H$H$HL$HD$D$ u{H$ HHH@Hw]HH$H$(HHH@Hw4HHD$H$H$_D$D$,uL1HvH$ H$(@ I f9uƄ$0H$HH$ HHH@Hw]HH$H$(HHH@Hw4HHD$H$H$D$D$.usw<t H$ H$(@ I f9uƄ$0H$HH$ H$(H@HHIHH9uH$ H$(H@PHIPH9uH$ HHH@Hw]HH$H$(HHH@Hw4HHD$H$H$qD$D$-u^-<v~H$ H@H$H$(H@HD$xH$H9uƄ$0H$HH$ HHHPH@H$H$H$HD$`H$HD$XH$H$HD$`HL$XH9|H$HH$HD$`HD$8H$H$H$(HHH@HT$8H9rHHD$H$H$D$D$/u*H$HH$HD$`HHD$`IƄ$0H$HH$ H$(H9$0H$H    { _eH %H$H;AHH$H$H$D$K<v{<v<v'<t:H$H$HVHD$HD$D>H$H<t*H$H$H2HD$HD$>H$H$>HD$HL$H$H$H$H$HAHD$HD$ H$H$HL$HD$ H0HD$(HD$0HD$@HL$8HL$HD$H$H$P= <t]H$@fu=H$H$H1HD$HD$=H$HH8HP0H@(H$H$H$HDŽ$H$H$H$H$XH$H$H9|]H$XD$lD$LH$H$D$LD$D$ H$XHH$XH$HH$H$@fu-H$H$H(/HD$HD$;<tH$H@0H$HH?H?HHHH)Hu+H$H$H\HD$HD$;9H$H$D$[ HH$H@0H$HtFH$H$H]MHD$HD$;H$H$D$]GH$HH(H@0HwtH$H@0H$H$HQ0HI(HXH9rD=t\H$H$D$^7GHD$xH$H@0H$HL$xHH9| H$HH0H@(HT$xH9rD$hH$HH0H@(HT$xHZH9rDȉD$dD$hD$TD$dD$\H$H$D$TD$D$T-D$  D$TL$\9u_H$H$D$-MFH$H$D$\D$D$\-D$ HD$xH$HHD$x| w HD$pH$H@0H$HL$pH9|HD$pHHH$H$HZ0HR(H9rDD$`H$HH(H@0HT$pH9rD$PD$`D$XH$H$D$PD$D$P-D$ D$PL$X9u_H$H$D$-EH$H$D$XD$D$X-D$ x HD$pH$HHD$p7 2 6 , <vm<t-H$H$H 1HD$HD$7i<t-H$H$HG/HD$HD$}76s<t-H$H$H/HD$HD$C7<t-H$H$H.HD$HD$7< v < v< t-H$H$H*HD$HD$6< tmH$@fu-H$H$H/HD$HD$67H$H$H6*HD$HD$S6L< t-H$H$H)HD$HD$6< t-H$H$H)HD$HD$5<vT< t'H$H@hHuH$H$H\*HD$HD$5H$HHhH@`HD$HL$H$H$a5H$H$D$>BH$HHH@HwXH<uUH$HHH@Hw'HHD$H$H$H$H$D$)AH$H$D$(lAa<vH$HHH@HwHH$0 wH$H$HZ(HD$HD$;4H$H$H$0HD$MH$H$H,'HD$HD$3H$D$J<v<tUH$H$D$*z@H$@f u H$H$D$?I@@<tH$H$D$+@<t H$H$D$??{<tMH$H$D${?H$H@HH$4HD$HL$H$pH$xH$H$H$xH$pHL$HD$2H$H$H@PHIHH9uH$H$D$,4?H$H@PH}~H$H@PH$X3HD$HL$H$`H$hH$H$H$`H$hHD$HL$2H$H$D$}>)}t@H@0H$HPH$H$H$0HD$6<tbH$HHHPH@H$H$H$HDŽ$H$H$H$H$PH$H$H9|H$PHH$HH$ <tH$H$H$HD$HD$0H$H$H$ HD$H$H$H#HD$HD$m0H$PHH$PH$HH$!H$H$H$ HD$O<t*H$HHHPH@H$H$H$HDŽ$H$H$H$H$@H$H$H9|H$@HH$8H$H$H$8H$(H$HgH$H$D$|;H$H$H$(HD$JH$@HH$@H$HH$;Xk d ] V O H 豙eH %H;aH8Hl$0Hl$0HD$HHD$PHH$#HD$HD$ MuwHHxWHHl$Hl$HmHD$H$HD$@HD$8HD$H$#HD$HL$HD$ HL$(HD$HHL$PHl$0H8H [H $HD$0趘eH %H;a*HhHl$`Hl$`D$x$wD$D$3uyHO:H$HD$D$xD$aD$D$2u:HD$pH$D$\9HD$pH$D$xD$9Hl$`HhD$|uD$xD$4 ~t1HD$pH$H HD$HD$,Hl$`Hhà t'HD$pH$H\ HD$HD$,ȃ t'HD$pH$H( HD$HD$U,D$x=|HD$pH$HHD$HD$,HcD$xH$HD$+HD$HL$HL$@HD$HHD$8Ht?HD$pH$D$08HD$pH$HD$@HL$HHD$HL$+HD$pH$HHD$HD$+HcD$xH$HD$*HD$HL$HL$PHD$XHD$pH$HD$XHL$PHL$HD$3+HD$pH$HfHD$HD$+R t*HD$pH$HHD$HD$*! t*HD$pH$HHD$HD$* t*HD$pH$HRHD$HD$}*"neH %H;a HhHl$`Hl$`HD$xHD$HD$p< tHD$pH@XHD$HD$pHHHPH@HD$HHT$PHL$XHD$(HD$PHD$ HD$HHD$@HD$(HL$ H9|[HD$@HHD$8HD$0H$9HD$HD$HL$H9|&HD$HD$@HHD$@HD$(HHD$(HD$HD$xHl$`Hh:=eH %H;aH`Hl$XHl$XHD$pHD$xHDŽ$HD$hH$HD$HD$8HHD$0HZ H$HD$0HD$HD$0HD$.HD$HL$ HT$(HD$@HL$HHT$PHD$hH$HD$@HL$HHT$PHD$HL$HT$CHD$@HL$HHT$PHD$pHL$xH$Hl$XH`3eH %H;aRHhHl$`Hl$`HD$p< t%HD$pHL$pH@XHT$xH$HqhHI`H9rHHtH5H HD$pHHHPH@HL$HHD$PHT$XHD$(HD$PHD$ HD$HHD$@HD$(HL$ H9|`HD$@HHD$8HD$0H$HD$xH$H$HD$HL$HT$HD$@HHD$@HD$(HHD$(Hl$`HhH$HL$#/,M 趑eH %H$H;A7HH$H$HDŽ$H$HuH$D$G<v{< tH$H$H$HHHPH@H$xH$H$HDŽ$H$H$H$xH$H$H$H9|H$HH$H$HD$HH$H$H$HD$H$H$H$H9tH$H9uvHZH$qH|$H$H$ Hl$Hl$ǾHmH$H@0H@8 HP(H@(H$H H$`HDŽ$hHDŽ$pH$HHH@HT$HH9v^H$HH$PH$XH$pH$hH$`H$H$H$H$PHH$H$H9wHxH$H$H$H$H\$HT$HL$H$HL$ *HD$0HL$(HT$8H$H$H$H$H$H9v^H$H$H$H$hH9v/H)HHH?HHH!H HL$H)HD$Ht$HwH$H$HH$XH$PHL$ H\$(HT$0.$H$H$H$H$0H$8H$@H$HSHCHSbHKH$H$H9u9H$HHHPHXHpH{H9jHSHP1H$H4مu8HH$HH$H$HH$H4$HT$H$XH$PHrvH$HL$H\$HT$H|$ (HD$(HL$0HT$8H$XHSuHCHHHH(H$HHL$xH$PH $HD$H$HHL$xH$XH$HL$|H$HD$/HVH$H|$Ht$DH$H$H$HĘÃ<vH$HHH@Hw HH$HD$H$H$D$FH$@fD$D$F$H$HD$H$HD$ HD$H$H$H$HĘH$H$H$HĘ<t H$H@HHt H$H@PHtH9UH$H|$H$kuKWHHl$Hl$̵HmH$H$H$H$HĘHTH$H|$'"H$HHH@Hwt HH$+HD$H$H$HIPHtH$H@HHtWH$@fD$$H$HD$HD$ HD$H$H$H$HĘH$H@HHtWH$@fD$$H$HD$HD$ HD$H$H$H$HĘHSH$ H|$H$x`WHHl$Hl$HmH$xH$xH$H H$HDŽ$ HDŽ$(H$HAHA(HYHAHD$PH$HL$PH@HHH9|H$HHHPHXHpHyH9VHYHXH$H4ʅu$HHD$PH$HHD$PwH4$H\$2H$XH$@H qH$HT$HL$H\$H|$ l#HD$(HL$0HT$8H$XHSuHCHHBH$8HL$xH$@H $HD$H$8HL$xH$XH$@fD$$H$HD$HD$H HD$H$H$HHHPHXHpHzH9ZHJHHVH$H4Ӆu(H H$H$H$HĘH4$HL$H$XH$0HoH$H\$HT$HL$H|$ "HD$(HL$0HT$8H$XHSuHCHHHH8H$(HL$pH$0H $HD$9H$(HL$pH$XH$HD$;HOH$H|$ZH$HIHHtpH$HIPHtH$H$HĘHDŽ$H$H@HHHqOH$H|$H$pWHHl$Hl$HmH$pH$pH$H H$HDŽ$HDŽ$H$HAHAHY*HAHD$`H$HL$`H@HH9|%H$HHHPHXHpHzH9VHJHHH$H Ӌ5u$HHD$`H$HHD$`zH $HD$!H$XH$ HlH$H\$HT$HL$H|$ [HD$(HL$0HT$8H$XHS uHCHHHHH$HT$+nH$HT$OH$HT$0H$HT$H$HT$H$HT$H$HT$H$HT$H$HT$vH OH $HD$yH$HT$fH$HT$SH$HT$@H$HT$-H$HT$kH$HT$L=SxeH %H;aH8Hl$0Hl$0HY HusHD$HHD$PHD$@HuDHD$@HHHH$HL$xHD$HL$HD$ HL$(HD$HHL$PHl$0H8. RcH|$@H9;uH#{eH %H;avnH Hl$Hl$HD$8HD$(H$HD$0HD$HD$HD$0HD$(HH$HD$0HD$HD$HD$0HD$8Hl$H QyeH %H;a"HpHl$hHl$hƄ$HD$xHHHHD$XHL$`H$HHHHD$HHL$PHD$`H9tHD$XHL$`H$HL$HD$HHL$PHD$HL$*qD$ uHD$xHHH@HL$8HD$@H$HHH@HL$(HD$0HL$@H9tFHD$8HL$@H$HL$HD$(HL$0HD$HL$pD$ $Hl$hHphPeH %H;avvH0Hl$(Hl$(HY HuiHD$@HD$HHD$8Hu:HD$8${HD$HL$HL$HD$ HL$@HD$HHl$(H0, &PqH|$8H9;uH#eH %H;avmH0Hl$(Hl$(HY Hu`D$PHD$8Hu>HD$8HH$HD$@HD$HD$HHD$rsD$D$'D$PHl$(H0+ OzH|$8H9;uH#eH %H;av_H Hl$Hl$HY HuOHD$0HD$(Hu,HD$(HH$"tHD$HD$HD$0Hl$H d+ NH|$(H9;uH#eH %H;av[H Hl$Hl$HY HuKHD$(Hu1HD$(HH$HD$0HD$HD$8HD$sHl$H * qNH|$(H9;uH#eH %H;aH8Hl$0Hl$0HD$PHD$(HD$ HD$(HL$ H9|AHD$(HD$HHD$@H$HD$HHD$kHD$HD$HHD$(HHD$(HD$HHD$PHl$0H8MReH %H;aHhHl$`Hl$`Ƅ$HD$8HD$0 HD$8HL$0H9|HD$8HD$(HHD$pHH@HL$PHD$XHD$(HHD$xHHHHD$@HL$HHD$XH9uƄ$Hl$`HhHD$PHL$XH$HL$HD$@HL$HHD$HL$lD$ uHD$8HHD$8>Ƅ$Hl$`HhLeH %H;aH(Hl$ Hl$ HD$8HD$0H$D$D$u?HL$0HIHL$Hu9HtHHH1HD$8Hl$ H(HD$8Hl$ H(bt KVeH %H;aH(Hl$ Hl$ HD$8HD$0H$D$D$uH}H$HD$HD$ rujHHxWHHl$Hl$vHmHD$ 8HT$0uHHD$HD$8Hl$ H(H$HT$H H $HD$H^HD$8Hl$ H(JHHl$Hl$D$ HD$H@H$H=D$ Hl$HeH %HD$H;A HH$H$H$H$HHH$H@8HD$XHtHCH$HD$HD$ H RHDH$H$H@8HL$xH9v H$HH0H$HL$$H$HĨHD$@H$H$H9~HD$@HuH$HH@(H$HH$H$HI8H$HHD$H$HD$H$HD$HD$PH|Ƅ$H$HĨH$H$HL$PHH$H$H@HD$xH H$HHH@H$HwHH$H@H@D$ H$H$H$HD$H$H$HL$HD$H$HD$((D$0D$=uƄ$H$HĨH$H$H@@H$HT$H $HD$HD$pHD$@H$HD$hHL$@HH$Ƅ$H$HĨ%Z Z Z Z HH$HlHD$k [2eH %H;aH Hl$Hl$HD$HHD$PHD$(HL$8HT$0H\$@HH }Hu8HHD$(HHD$H ZHL$HHD$PHl$H H$HT$b1FeH %H;aH Hl$Hl$HD$@HD$HHD$(HL$8HT$0H ?}Hu8HHD$(HHD$H ZHL$@HD$HHl$H H$HT$0ReH %H;aH Hl$Hl$HD$@HD$HHD$(HL$8HT$0H|HuXHHD$(ƀHD$(HǀHD$(HHD$H pYHL$@HD$HHl$H H$HL$02eH %H$HH;A H8H$0H$0HDŽ$PHH$HD$HD$P {HHxWHl$Hl$ZHmHD$PH$@n{HXJHHHD$PH$HE{HXHHHD$PHD$HH@H@HD$8H_H$HD$8HD$HD$8HD$2HD$HL$(HT$ H$H$H$HH$HD$HD$8HD$HD$HL$ HT$(H$H$H$H$WHHl$Hl$YHmH$H$H$H$H$H$H$H$H$H$H$ H$(HD$H yHx(H$Hl$Hl$\HmHH$HD$8HD$HD$8HD$HD$HL$ HT$(HD$pHL$xH$HH$HD$HD$8HD$HD$HL$ HT$(HD$XHL$`HT$hH$WHHl$Hl$XHmHD$pHL$xH$H$H$H$HD$XHL$`HT$hH$H$H$HD$H xHxX<H$Hl$Hl$[HmH$@H@ HD$0H|HD$0H$HH ތH9tH$@H$HD$HD$@HL$HHAHH$HD$0HD$HD$0HD$HHD$HL$ HT$(H$H$H$H\$HHH wHu(HHD$HH$PH$0H8H$HD$ER HH$H|$H$HD$wHH$H|$H$HD$PdH$HL$ݼH$HL$ʼH H $HD$h*HHHl$@Hl$@HD$PHHHHD$(HT$0HL$8HD$HD$0H$HD$(HD$ HD$H $H9|MHD$ HHD$HD$HHHT$XH9v`HPHD$ HHD$ HD$HHD$HD$PHHL$XH9vHD$PHHl$@HHQ Q eH %H;aHxHl$pHl$pHDŽ$HD$PH$HHD$0HH$HHHXH9rWHDHD$PHD$0HHD$HH$HH9vH$HHD$P uH$uHHD$PH$Hl$pHxH$HT$蘺HH$HD$HD$PH$HHD$@H$HHD$8HYH$HD$@HD$HD$8HD$HD$(HL$ HT$HT$XHL$`HD$hH\$PHKHC9tHKu HSH $HT$ֹP O (eH %H$PH;AH0H$(H$(Ƅ$XH$8H@TD$UH$ 0XH$(HXuHPHDŽ$(H$HT$蹝z*%H$HL$蔝rH$H$H$HD$HD$H$(D<t2<tH$@D$H$H$H$HD$H$HD$H$H$H$HL$ HD$(HT$0$ D$8H$(HD$@THD$HH$(<vNOH$HD$荜]VJ2 C2 <2 52 H,H$HHD$'C 2 2 2 k2 1 ] eH %H$hH;A HH$H$Ƅ$HH$ H@TD$"H$(H@ H$0H $D$D$'u H$ H$(HI0H$0HHD$H$D$D$&uH$8H$H$ HH@(H$H$HH$8H$0H$(HI@H$8HT$H$ыD$D$eH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$H$H@HD$@H$H@HD$8HL$@rrHrH$DxHD$HD$hHHrH$#xHD$HD$`HHsH$HD$HD$HD$(HL$ HT$H$H$H$HzH$HD$HD$览HD$(HL$ HT$HT$pHL$xH$D$7HD$7HD$H$HD$HD$pHD$ $H HD$xHD$HHDŽ$HDŽ$HDŽ$HDŽ$H$HD$XH1H$HD$X 8HX)HL$HHHHD$X t8HXH$HHHD$X K8HXHL$pHHHD$XHD$PHD$hHHL$@H9|HD$`HHL$8H9}HT$PHD$hH$H$HD$$D$HD$D$7D$7uHH HH$H$H$HH HH$H$H$OH$HHD$hHHL$@H9};HT$PHD$`H$H$HD$$D$HD$D$72H$HH@H\$`HH9rH$ HH@Ht$hH6H9r9|;HT$PHD$`H$H$HD$$D$HD$D$7HT$PHD$hH$H$HD$$D$HD$D$7mHD$`HHL$8H9|H$H$H$H$H$H$HD$pHL$xH$H$H$H$H$HH$HD$pHD$E{NH$H$HD$*{ H$HD$HHD${GH$H HuH$H^HD$! 8eH %HD$H;AHH$H$H$HHHPHHD$@HT$HHL$PHD$0HD$HHD$(HD$@HD$8HD$0HL$(H9|sHD$8HH$HpH$Hl$Hl$aHmHD$0HD$ H$HD$XH|$`H$Hl$Hl$*HmD$XD$<v<v&HD$8H(HD$8HD$0HHD$0F<vmH$HHHHT$ H9rHHD0HD8HL(3uHD(|H $HD$ ya<tT<v4H$HH@HT$ H9r.HHD0HD8HD(2HD(H$WHl$Hl$[HmHD$XH$H$Ht$`Hl$Hl$HmH$HH@HT$ H9rw2HH<u$H$Hl$Hl$JHmQHH$H|$H$HD$EyH$HD$w$H$H  {  t  eH %H$H;AHH$H$HDŽ$H$H@HD$hHHH$HD$hHD$HD$hHD$蛀HD$(HL$ HT$H$H$H$H]H$doHD$H$H$HIHHH$H$H@ HA H$H$H$H$HHHX 0HH$H$H$HHHH@H$H$H$HD$`H$HD$XH$H$HD$`HL$XH9|_H$HH$HpH$Hl$Hl$HmHD$`HD$@H$H$H$H$Hl$Hl$HmH$WHl$Hl$1HmH$H$H$H$Hl$Hl$HmH$HH@HT$@H9rxHH<?/uGH$Hl$Hl$HmH$H(H$HD$`HHD$`HH$H|$H$HD$uHD$PH$H@HD$HHD$PHL$HH9|^HD$PHD$8H$HHIH9rHD$7<vH$HL$8HH@H9r_HHD H$H$HL$8HPHH9r'HHTH$H$DHKHH9rHH4H$xHl$Hl$Hm$xtH$H$ HPHH9rHH4H$8Hl$Hl$YHm$8tHD$PHHD$P$8<tH$H$ HPHH9rHHDHD$xH$H$ HH@H9rHHD HD$pD$6$|HL$89tfD$6D$6uRHD$xH$ H$HL$x 9tH$HL$p Ë$HL$89t0D$6HD$xH$HD$pHD$xH$HD$p_$x<tBH$H$H$H$H$H$H$H$ HPHH9rHH4H$xHl$Hl$mHm$xt$x<tH$H$H$HH$HT$pe    | u n g ` HHl$Hl$HD$0HD$ H$HD$0Hl$HHH,$H,$D$8HD$(HL$HT$H9r0HL$HT$0H\$H9r 9D$8H,$H HHl$Hl$HD$0HL$ HT$H9rhD$HD$8HL$ HT$H9rIHL$ H\$Ht$0H9r,D$HL$8HT$H\$ H9r Hl$H- eH %H$pH;A"HH$H$HDŽ$ H$H@HD$pH=}H=H$ H$HH$H@HD$hH$XHD$H$H$H@HD$`H$/HD$HD$xHDŽ$H$H@HD$XH>H$HD$XHD$HD$XHD$wHD$(HL$ HT$H$H$H$H$WHl$Hl$HmH$H$HT$H$H$ (HPH$HHH$HL$x'HXGHHH$ 'HPH$HHH$H$H$H$HP(HH0 k'HP HX H$H$?'HX8jHH8H$H$H$H$JH$H@D$H$H$H$H@HD$PHTH$HD$PHD$HD$PHD$uHD$HL$ HT$(H$H$H$H$H$D$D$3HD$xH$H$H$D$D$4H$$H$H$H$HD$HL$H\$HD$ D$2u fHf:H$H$H M:H9uHD$HH$H@HD$@HD$HHL$@H9|HD$HHD$8H$H$H9ryH$HHRH4@HHD$HHL$@HL$PH $HD$[HD$HHL$@H\$XeH %H;aCH`Hl$XHl$XD$xHDŽ$HD$hH@HD$8HL$pH9|HD$hHHHHT$pH9rD$'H$%7HD$H$H$`HDŽ$hHDŽ$pH$H$0HQH @H9r]H@HTHHDH$HH$PH$XH$pH$hH$`H$0H$8H$@H$PHH$H$@H9wHX1H$H$8H$0H$@HL$HD$HT$H$HD$ GHD$8HL$(HT$0H$0H$8H$@H$H$@H9vH$8H$PH$H$hH$0HH$H$HHD$H$HHD$H$@H$0H$8H$H$H$H$0HsH$ H9rH4HTHDHuH H$0HHH$ H9rH RHDH$HH?H?HHHH$H7H$H$HD$H$HD$EHD$(HL$HT$ H$hH$pH$xH$HS0HC8HS(HK(HDŽ$H$H@0H$H$H$H9|PH$HD$pH$H$HY0HI(RH9rfH$HH$H$HL$;]H$HL$;* )$<v=H$H$0H$($ <H9rs.<v<t<tH$0H$($ H9roH$H@0H$xHH$@D$H$H$}H$H@H$pHtCH9H$]2HD$H$H$HDŽ$ HDŽ$(H$0HHI$ H9rH [HDHDHʋ5HHXH$1HD$H$H$IH$H$HDŽ$HDŽ$H$HA0HA8"HY(u HA(H$HD$8H$HD$8NH1,H$HD$HD$BHD$ HL$HT$(H$@H$HH$PH$H@H$hHtyH$@fuH$HHH@HwD$XH$HH$PH$@HXH97HHH$HL$X\$X \D$X$贓D$D$PD$PL$X9uH$HH$PH$@HXH97HHH$HL$P\$P \D$P$KD$D$PH5*H4$HT$HD$HL$H\$ AHT$(HD$0HL$8H$PH$@H$PH$HH$@H$PH$XH$`HUH$H$PHD$ HD$HL$H $HD$H$0HHHH$PH$@H$H$ H9rYH HtHTHȋ5HH$0HHH$ H9r H RHDH$`HH?H?HHHH$Hq1H$H$HD$H$HD$>?HD$(HL$HT$ H$8H$@H$HH$HS0HC8HS(HK(HDŽ$H$H@0H$H$H$H9|PH$HD$xH$H$HY(HI0RH9rH$HH$H$H$HL$4PH$H\$4sH51(H4$HT$HD$HL$H\$ >HT$(HD$0HL$8H$PH$@H$HHHP H@H$H$H$H$PH$HH$@H$H$H$H$HH$H$H9wHd'H$H$H$H$HL$HD$HT$H$HD$ >HD$0HL$8HT$(H$H$H$H$H$H9vU H$H$H$H$HH$HH$H$HD$H$HHD$H$H$H$H$@H$HH$P5WbR<tgH$0H$($ H9rt H$H@0H$XH>H$@D$H$H$賮H1H$*HD$H$H$XHDŽ$`HDŽ$hH$@fuH$HHH@Hw D$\H$XH$`H$hHYH9:HQH$`T$\\$\\D$\$xD$D$TD$TL$\9uH$XH$`H$hHYH97HQH$`T$T\$T\D$T$D$D$TH5$H4$HD$HL$HT$H\$ Q;HD$(HL$0HT$8H$hH$XH$XH$`H$hH$ H$(H$0HH$H$ HD$HD$HL$H$HL$˭H$0HH@H$XH$`H$h$ H9r HH\HtMH4HH$0HH@$ H9r HRHDH$PHH?H?HHHH$H5+H$H$HD$H$HD$9HD$HL$ HT$(H$H$H$H$HK0HS8 HS(HC(HDŽ$H$H@0H$H$H$H9|SH$H$H$H$HY(HI0RH9rH$HH$H$fH$HD$.MH4$HT$n.pH5!H4$HD$HL$HT$H\$ 8HD$(HL$0HT$8H$hH$XH$HHH@HwD$dH$HHH@HwD$`H$XH$`H$hHYH9$HQH$`T$d\$`\?H5!!H4$HD$HL$HT$H\$ 7HD$(HL$0HT$8H$hH$X'"< tH$0H$($ H9rH$H@0H$HHH$@D$H$H$CH|,H$C%HD$H$H$HDŽ$HDŽ$H$HDŽ$HDŽ$HåH$H$H9wHH$H$H$H$HD$HL$HT$H$HD$ }6HD$(HL$0HT$8H$H$H$H$H$H9v~H$HH$H$H$HH$HHD$H$HHD$H$H$H$H$H$H$H$0H3H[$ H9rHHLHT SHޅHH(JH$o#HD$H$H$IH$H$HDŽ$HDŽ$H$HA0HA8HY(u HA(GH$HD$b*H$HD$R*Nd< tH$0H$($ H9rH$H@0H$@HH$@D$H$H$BH{)H$B"HD$H$H$pHDŽ$xHDŽ$H$HDŽ$HDŽ$HH$H$H9wHH$H$H$H$HD$HL$HT$H$HD$ |3HD$(HL$0HT$8H$H$H$H$H$H9vhH$H0H$H$H$xHH$HHD$H$HHD$H$H$H$H$H$H$H$0H3H[$ H9rHHLHT RHޅuHH$0HH@$ H9rqHRHDH$8HH?H?HHHH$H:#H$H$HD$H$HD$1HD$HL$ HT$(H$H$H$H$HK0HS8 HS(HC(HDŽ$H$H@0H$H$H$H9|PH$H$H$H$HY(HI0RH9rOH$HH${H$HD$&]H$HD$&? 8 1 蚼 #  腼        ݻ ֻ ϻ 8  躻 賻 謻 襻 螻 藻  艻 肻 { t ݻ f _ X Q J C < 5 eH %H;avzHH,$H,$<w H,$H<t} [S0Vcq PzH,$HmHD$HD$HD$HD$}eH %H;aH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$xHD$HD$8HD$0HH$HD$8HD$HD$xHD$HD$8HD$@Hl$ H((cD$HD$HL$ 9tAHD$H@HL$HIH9uHD$H@HL$HIH9D$eH %H;aH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$wHD$HD$8HD$0HH$HD$8HD$HD$wHD$HD$8HD$@Hl$ H((cD$HD$HL$ 9tHD$H@HL$HIH9D$eH %H;aH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$HD$8HD$0HH$HD$8HD$HD$vHD$HD$8HD$0HH$HD$8HD$HD$vHD$HD$8HD$@Hl$ H("=eH %H;aHHHl$@Hl$@D$`HD$XHHHHD$0HL$8HD$PHH@HL$ HD$(HD$0H9tuH $HD$(HD$HD$8HD$"D$uIHD$P@HL$XI8u(HD$PH@HL$XHIH9D$`Hl$@HH3eH %H;avqH0Hl$(Hl$(HY HudHD$@HD$8Hu>HD$8HHHPHH$HT$HL$HD$HD$ HD$@Hl$(H0k 蛎vH|$8H9;uH#eH %H;avH@Hl$8Hl$8HY HurD$`HD$HHuPHD$HHHHPHH$HT$HL$HD$PHD$HD$XHD$ 耯D$(D$7D$`Hl$8H@Tj hH|$HH9;uH#|eH %H;avmH0Hl$(Hl$(HY Hu`HD$8HuCHD$8HHHH@H$HL$HD$HD$@HD$HD$HHD$ 5Hl$(H0i OzH|$8H9;uH#HH,$H,$fD$(HD$HwHHD$HL$Hw.HL$HT$HwI fD$(H,$HZ S HH,$H,$HD$HwMHD$HL$T$(Hw0HD$HL$T$(fHw PH,$H   HH,$H,$D$(HD$HwHD$HL$HwgHL$HT$HwPJ HL$HT$Hw3I HL$HT$HwJ ȉD$(H,$H= 6 HH,$H,$HD$HwHD$HL$T$(HwtHD$HL$T$(HwRQHD$HL$T$(Hw/QHD$HL$T$(Hw PH,$H蛲 蔲 荲 膲  HH,$H,$HD$(HD$HwHD$HL$HwHL$HT$HwJHH HL$HT$HwJHH HL$HT$HwJHH HL$HT$HwvJH H HL$HT$HwWJH(H HL$HT$Hw8IH0H HL$HT$HwIH8H HD$(H,$H  = 6 / HH,$H,$HD$Hw7HD$HL$HT$(HwHD$HL$HT$(HHwQHD$HL$HT$(HHwQHD$HL$HT$(HHwQHD$HL$HT$(H Hw{QHD$HL$HT$(H(HwVPHD$HL$HT$(H0Hw1QHD$HL$HT$(H8Hw PH,$H     ݯ ֯ ϯ ȯ HD$HD$H@$HD$HD$ HD$HD$H 9HD$HD$HH,$H,$fD$(HD$HwHHD$HL$Hw-AHL$HT$Hw  fD$(H,$H  HH,$H,$HD$HwMHD$HL$T$(fHw,HD$HL$T$(Hw PH,$H蓮 茮 腮 HH,$H,$D$(HD$HwHD$HL$HwfAHL$HT$HwNJ HL$HT$Hw1I HL$HT$Hw  ȉD$(H,$Hݭ ֭ HH,$H,$HD$HwHD$HL$T$(HwqHD$HL$T$(HwOQHD$HL$T$(Hw,QHD$HL$T$(Hw PH,$H; 4 - &  HH,$H,$HD$(HD$HwHD$HL$HwAHL$HT$HwJHH HL$HT$HwJHH HL$HT$HwJHH HL$HT$HwtJH H HL$HT$HwUJH(H HL$HT$Hw6IH0H HL$HT$Hw H8H HD$(H,$H  ݫ ֫ ϫ HH,$H,$HD$Hw7HD$HL$HT$(H8HwHD$HL$HT$(H0HwQHD$HL$HT$(H(HwQHD$HL$HT$(H HwQHD$HL$HT$(HHwwQHD$HL$HT$(HHwRPHD$HL$HT$(HHw-QHD$HL$HT$(Hw PH,$H蠪 虪 蒪 苪 脪 } v o h HD$HD$H1HD$HD$ HD$HD$H)HD$HD$eH %H;aH(Hl$ Hl$ <w Hl$ H(<tV rJ=n_HyH$HD$)% HD$HL$H  uHHl$ H(H H $HD$i袁-eH %H;avsH0Hl$(Hl$(HY HuffD$XHD$8HuBHD$8HD$PHL$HHT$@H$HL$HD$^D$fD$&fD$XHl$(H0p] tH|$8H9;uH#eH %H;avgH(Hl$ Hl$ HY HuWHD$0Hu=HD$0HD$HHL$8HT$@H $HT$HD$D$PfD$+Hl$ H(\ uH|$0H9;uH#eH %H;avqH0Hl$(Hl$(HY HudD$XHD$8Hu?HD$8HD$PHL$HHT$@H$HL$HD$ D$D$$D$XHl$(H0B\ vH|$8H9;uH#eH %H;aveH(Hl$ Hl$ HY HuUHD$0Hu;HD$0HD$HHL$8HT$@H $HT$HD$D$PD$Hl$ H([ GH|$0H9;uH#eH %H;avuH0Hl$(Hl$(HY HuhHD$XHD$8HuBHD$8HD$PHL$HHT$@H$HL$HD$LHD$HD$ HD$XHl$(H0[ ~rH|$8H9;uH#eH %H;avgH(Hl$ Hl$ HY HuWHD$0Hu=HD$0HD$HHL$8HT$@H $HT$HD$HD$PHD$Hl$ H(|Z ~H|$0H9;uH#eH %H;avoH(Hl$ Hl$ HY HubHD$8HD$@HD$0Hu3HD$0HD$H $HL$HD$HL$8HD$@Hl$ H(Y }}xH|$0H9;uH#eH %H;avoH(Hl$ Hl$ HY HubHD$8HD$@HD$0Hu3HD$0pHD$H $HL$HD$HL$8HD$@Hl$ H(DY |xH|$0H9;uH#eH %H;avsH0Hl$(Hl$(HY HuffD$XHD$8HuBHD$8HD$PHL$HHT$@H$HL$HD$.D$fD$&fD$XHl$(H0X 9|tH|$8H9;uH#eH %H;avgH(Hl$ Hl$ HY HuWHD$0Hu=HD$0HD$HHL$8HT$@H $HT$HD$D$PfD$Hl$ H( X {H|$0H9;uH#eH %H;avqH0Hl$(Hl$(HY HudD$XHD$8Hu?HD$8HD$PHL$HHT$@H$HL$HD$D$D$$D$XHl$(H0rW {vH|$8H9;uH#eH %H;aveH(Hl$ Hl$ HY HuUHD$0Hu;HD$0HD$HHL$8HT$@H $HT$HD$D$PD$Hl$ H(V wzH|$0H9;uH#eH %H;avuH0Hl$(Hl$(HY HuhHD$XHD$8HuBHD$8HD$PHL$HHT$@H$HL$HD$HD$HD$ HD$XHl$(H0>V yrH|$8H9;uH#eH %H;avgH(Hl$ Hl$ HY HuWHD$0Hu=HD$0HD$HHL$8HT$@H $HT$HD$HD$PHD$Hl$ H(U EyH|$0H9;uH#eH %H;avoH(Hl$ Hl$ HY HubHD$8HD$@HD$0Hu3HD$0HD$H $HL$HD$HL$8HD$@Hl$ H(U xxH|$0H9;uH#eH %H;avoH(Hl$ Hl$ HY HubHD$8HD$@HD$0Hu3HD$0@HD$H $HL$HD$HL$8HD$@Hl$ H(tT xxH|$0H9;uH#HHl$Hl$HD$ HD$(HD$H$H H9t!Hp%HD$ HD$(Hl$HH H9t!HvHD$ HD$( Hl$HH3HD$ HD$(Hl$HeH %H;av(HHl$Hl$H,H$s,Hl$HweH %H;aH(Hl$ Hl$ ,<w Hl$ H(<t qT3艃HH$HD$HD$HL$H o iH`HH$HD$ ;H2HqH$XHD$ ukHHH$HD$UHD$ u!HHl$ H(H H $HD$`H H $HD$IH H $HD$2EH nH $HD$NuIeH %H;a$HxHl$pHl$pHDŽ$HD$PH$H$HÉH9tHD$PL$7HD$PHD$@D$7D$6D$6uHD$@H@HD$8H$H9}HD$@H$Hl$pHxH$H~PHDŽ$H'H$H$HD$H$HD$tHD$ HL$HT$(HL$XHD$`HT$hHߧH$FH|$H|$HWHl$Hl$eHmHD$HHL$XHT$`H\$hHPHX HXu`HHHD$HH$H$HH0 }HX8uHP8HD$HH$Hl$pHxH$HT$H$HL$HH$H|$A J11'seH %H;avQH0Hl$(Hl$(HD$HHD$@HL$8H $HD$HD$iHD$HD$ HD$HHl$(H0reH %H$hH;AHH$H$HDŽ$(HDŽ$0H$ HHu1H$ HHHH$(H$0H$HH$ H@(Ht(HDŽ$(HDŽ$0H$HH$ H@(HD$PH$ HQHI H9vH$H$H$HDŽ$HDŽ$H$ HH8H@0H@ H$H$H$H\$HT$Ht$H $HD$ HD$HHD$0HL$(H$H$HD$HHD$8H$H$HL$xH$H$ HL$8H@(H9|HD$xHuHD$xHuTHD$8HCH$ HL$8H@(H9|H$ H@(H+D$8HD$@H$ HQHI H9vH$H$H$H$ H@(HD$pH$ HQHI H\$8H9vH9vH)HHH?H!HH$H)H$H$H$H$H$H$H$H$H$H$H$H$H$H$H$HD$`H$H9H$HD$`HD$`HD$XH$H$H$HD$HD$XHD$谠H$ H@(HD$hH$ HT$8H)HA(H$ HL$xH$H HXu5HPHD$xH$H$(H$0H$HH$HT$ 1lhVH$ H@(HDŽ$(HDŽ$0H$HHH HD$xH$C<Ε Ǖ m;HHl$Hl$HD$ HD$H@H$HL$HI(H)HD$ Hl$HHD$HD$H@(HD$eH %H$ H;AjH`H$XH$XHDŽ$HDŽ$HDŽ$H$xHD$`H$hH$HD$HD$XHL$`H9H$hHHHD$8H$hH$HD$HD$PHtSHDŽ$HDŽ$H$hHH8H@0H$H$xH@ H$pHt$H\$HT$H $HD$ HD$HHD$0HL$(H$H$HD$HHD$8H$hH$H$HHXHHH$H$HL$8HH$H$HL$8H$xH$pH9vH)HHH?H!HH$pH)H$xH$CH$HL$mH$hH@(H$H$hHQ HYHIH9v H)HHH?H!HH$@H)H$HH$PH$H$H$ H$xH$pH$H$H$H$H$H$H$H9H$H$H$HD$xH$H$H$HD$HD$xHD$ћH$HD$8H$hH@(H$H$hHT$8HHA(H$hH$7 wH$hHHu1H$hHH@H$H$H$XH`H$hH@(H$H$hHQHYHI H9v`H)HHH?H!HH$(H)H$0H$8H$H$H$H$pH$xH$H$H$H$H$HD$pH$H9H$HD$pHD$pHD$hH$H$H$HD$HD$hHD$(HD$pHD$@H$hH@(H$H$hHT$@HHA(H$H$HL$@HH$HDŽ$HDŽ$H$XH`K%ˏ ď 轏 gqeH %H$hH;A-HH$H$HDŽ$8HDŽ$@HDŽ$HHD$H$0HD$@H$ H$HD$HD$8HL$@H9H$ HHH$ H@(HD$0H$ HQ HYHIH9v^H)HHH?H!HH$H)H$H$H$H$H$H$0H$(H$H$H$HD$`H$H9H$HD$`HD$`HD$XH$H$H$HD$HD$XHD$՗HD$`HD$(H$ H@(H$H$ HT$(HHA(HD$H$HL$(HHD$H$0H$(HT$(H9v H)HHH?H!HH$(H$0H$ H$ H$ HHu>HD$H$8H$ HH@H$@H$HH$HH$ H@(HD$xH$ HQHYHI H9vQH)HHH?H!HH$H)H$H$H$H$H$H$(H$0H$H$H$HD$PH$H9H$HD$PHD$PHD$HH$H$H$HD$HD$HHD$֕HD$PHD$ H$ H@(HD$pH$ HT$ HHA(HD$HD$hHL$ HHD$HD$H$8HDŽ$@HDŽ$HH$HJ*x q j cceH %H$`H;ASH H$H$HDŽ$@HDŽ$HHDŽ$PH$(H$HD$HD$PHtHDŽ$HDŽ$H$(HH8H@0HTH$HD$HL$!D$(HL$ HT$H$H$D$?H$H$H$H$D$?D$>D$>uHDŽ$HDŽ$H$H@ H$8H$0H$HT$HL$H$HD$H$HD$(HL$ H$H$H$H$H$H$H$H$H$H$@H$H$H$HH$PH$H HD$HH$(H$HD$H$Ht*H$(H$HD$HL$H$H$Hu H$HH$PH$H HD$@HD$@Hd|H$(H@(H$H$(HQHYHI H9vH)HHH?H!HH$H)H$H$HDŽ$HDŽ$H$0H@ H$8H$H$H$HT$H\$Ht$H $HD$ HD$xHD$(HL$0H$H$HD$xHD$HH$H$H$HH$PHD$HHumHD$@Hdt.H H H$HH$PH$H H$(H@(HD$hH$(HT$HHHA(H$@HD$`HL$HHH$@H$HHuH$HH ZH9tH$HH$H$PHD$H8HD$D$u{H$(H$HD$HD$XHt?H$(H$HD$HL$H$HH$PH$H HDŽ$HHDŽ$PH$HHuHD$@HD$pHHD$@:e% ]eH %H;aH(Hl$ Hl$ <w Hl$ H(<t趇 ͦ%H#9H$HD$ HD$HL$H  CSHH9H$HD$ GHD$HL$H v HgH H$HD$HD$HL$H  HH!H$HD$HD$HL$Hz<H HC]H$HD$/~HD$HL$H7H ޾H]H$HD$0;HD$HL$HH HL.H$HD$HD$HL$HW%H HH%cH$HD$7HD$HL$HnH HeH$HD$;rHD$HL$Ha+urH VH,H$HD$ 3HD$HL$HBuH 7&Hl$ H(HH$HL$wHH$HL$`HH$HL$I)H%H$HL$/H+H$HL$oHH$HL$HǼH$HL$H ]H $HD$XH sH $HD$H IH $HD$YeH %HD$H;AtHH$H$HH$HD$HD$`HD$hHD$pHD$xH$HHHHHyH9bHYHHD$hH\$pHt$xH IH\HtHʋ5uHH$HĈH$HD$HD$XHt$PHH$HT$HL$H\$H|$ HD$(HL$0HT$8H\$XH|uHHH9HD$HHL$@HL$PH $HD$HD$HHL$@H\$X/XjeH %H;aHHl$Hl$HD$H8H$ HD$HǀHD$HǀHǀƀHD$ƀHD$HD$HǀHD$HD$HǀHD$H$Hl$HPW+eH %H;aH8Hl$0Hl$0HDŽ$HD$XH|LHD$`H|;HD$hH|*HD$@HL$PHT$HHƢHXHHHD$@HL$XHHHD$@HL$`HHHD$@HL$hHH HD$(HD$ HD$(HL$ H9|6HD$(HD$HL$@T$pHrT(HD$(HHD$(D$p< tJHD$xHD$HHD$xHD$@HL$xHH0HD$@H$HD$@H$Hl$0H8H$HL$ H} H?H$H$HD$: UNeH %HD$H;AbHH$H$HD$pHD$xH$HHHH@ H$H$H$HT$H\$Ht$H $HD$ HD$HHD$(HL$0HD$pHL$xHD$HHD$8HD$pHL$xHD$PHL$XH$HD$@HL$8H9uFHD$PHu HD$PHu.H$HĈH%H &HD$PHL$XHD$`HD$hHD$PHL$XHD$`HL$hHCH$HD$`HD$耳HD$HL$H$HL$訌 T|eH %H;aHXHl$PHl$PHD$pHD$0H$H9WHD$`H$HD$pHL$hHT$xHL$HD$HT$H$HD$(HD$pHD$ HL$(H)H$H$HL$hHT$xH9vEHL$8HD$@HT$HHD$`H$HD$8HL$@HT$HHD$HL$HT$Hl$PHXz ReH %H;aHPHl$HHl$HHL$XI( tHL$XHIHt Hl$HHPHL$XHT$XH\$hHYHCHJHuYHT$XHHtHHH1HKHHD$hHL$`H)HD$(HHL$XHT$XHIHDHJHuHtHHH1HD$ HL$XH $H aHaHaH\$HT$HL$Hl$HHPL$puHD$XH(HD$0HD$8HD$@HD$XH$HD$@HL$8HT$0HT$HL$HD$HD$hH+D$`HD$ IHl$HHPy HH$HHD$謉 uy PeH %H$H;AHH$H$HDŽ$H$H$H$HD$0HD$0H$H9|HH$HHHT$0H9r[H RHTHHDH$H$H$H$H@0D$'H$H$H$H$H$H$HD$@H$HD$8H$H$HD$@HL$8H9|H$HHP@H$H$$HD$@HD$(H$H$$H$H$$HD$(HeH$H@0rEH$H$H&_H _H_HT$HL$HD$dH$HtH$HH$HL$(H9|H$HHHT$(H9rHHD$H$H$H$HD$D$'D$qH$HH$HD$@HHD$@kD$'H$H@0sH$H8H$HD$HL$HT$H$hH$pH$xH$H$HH$H$xH$H$hH9vH9v H)HHH?H!HH$PH)H$XH$`H$H$H$XH$PH$`HL$HD$HT$H$H$H$HH$H$HH$HL$(H9|\H$HHHT$(H9rHHD$H$H$H$HD$D$)gbH$HHD$xHL$(H9|lH$HHHT$(H9rHHD$H$H$H$HD$D$H$H8H$HD$HL$HT$H$8H$@H$HH$H$HHD$pH$HH$8H$H9vH9vH)HHH?H!HH$ H)H$(H$0H$H$H$(H$0H$ HT$HD$HL$H$HD$hH$HH$hH$HHD$`HL$0HH9t8H$H8H$HD$HL$HT$H$H$H$H$H$HHHL$XH$H$H$H9vH9vH)HHH?H!HH$H)H$H$H$H$H$H$H$HD$HL$HT$3H$HD$PH$HHH$HD$0HD$HHHD$0IGH$H$H(YH )YH*YHD$HL$HT$H$HĠq q p p q p p HeH %HD$H;AHH$H$HDŽ$ H$H$ H$HHD$`H$HD$XHD$XH$H9|H$HHHT$XH9raH RHTH\HH$H$H$H$HD$`HKH9|H$H$H$ HD$H$HD$HD$XHD$HD$ H$ HD$XH$H$H@HD$HD$GHD$XH$H9|#H$HHHT$XH9rnH RHTH\HH$H$H$H$HD$`HKH9|H$HL$`H$H9rHIH H\HDH$H$$H$H$HH HL$PHD$HH9OHL$HH$H'D$GHD$XH$HHD$X$uD$GuH$H@0rHD$HH$HHHHHyH9HQHHD$HHH$H$H$ HD$H$HD$HD$XHD$HD$ H$ H$HH$HH$H$HH9vUH$HHD$XH$HD$XHD$xHHD$XH$H$HH$H\$HL$HT$H|$ HD$(HL$0HT$8H$HuHHHHH$HL$hH$H $HD$*H$HL$hH$C %H$H$H$ HD$H$HD$H$HD$HD$ HD$pH$ H$Hk jk ck \k CeH %H;av}HPHl$HHl$HHD$XH8H$HD$pHL$hHT$`HT$HL$HD$AHD$XHHD$@HD$hHD$8HL$XHT$@HHHl$HHP/CjeH %H;a[HHl$xHl$xH$HHD$@H$H8H$HD$HL$HT$HT$`HL$hHD$pH$HHD$8H$H8H$THD$HD$0HL$pHT$8H\$`H9vH9vH)HHH?H!HHL$HH)HD$PHt$XH $HD$Ht$HD$HD$(H$HT$@HHH$H8H$HD$HD$ H$HHl$xHĀi AHHl$Hl$D$ D$<&tHD$ƀ;Hl$H<teH %HD$H;AHH$H$H$H$`~HD$HL$HL$PHD$XHuHD$pHD$xHD$XHL$PHH9tHHHHD$pHL$xT$?HD$pHL$xHD$@HL$HD$?D$>D$>uiH$HL$@HT$HH HXuHPH$HĈH$HT$11HqH$HĈH$HHD$HD$H$H$HD$HL$ HD$(HL$0HD$`HL$hHH$HD$`HD$ΝHD$HL$H$HL$t ?<:eH %H;avVH0Hl$(Hl$(HD$@HD$HHD$8H$3HD$HL$HL$HD$ HL$@HD$HHl$(H0;eH %H;adH8Hl$0Hl$0HD$HHD$PHD$@HD$$HQHD$e HD$HHD$HHD$HD$ $HQHD$eHD$@HHHD$@uHD$@H$HD$@H$D$HD$@HHD$(HD$@H$HD$HD$HD$(HD$HD$HHD$PwnHl$0H8띐cnHl$0H8ÐSnHl$0H8D:eH %HD$H;AHH$H$HDŽ$(HDŽ$0HDŽ$8H$0HD$HeHD$HD$ $H%PHD$dHDŽ$(H$ H$H$H$H$H$HD$PH$HD$HH$HD$`HD$PHL$HH9|HD$`D$/HD$PHD$@D$/D$-H$tGD$.<&vHvH$(HL$@H$ H$H9vH9vH)HHH?H!HHT$hH)HL$pHt$xH$H$HD$xHL$pHT$hHT$HL$HD$H$H$HD$@HH$(H$H$D$-< D$HD$HD$0D$-< tH$H$D$-< tH$H$HD$HL$H$0H$8HukH$HD$-< tzH$H@0r`H$H$HGH GHFHT$HL$HD$HD$`HHD$`HD$PHHD$PHD$0HtD$-< tID<&tH$H@0rH$(HL$@H$H$ H9vH9vH)HHH?H!HH$H)H$H$H$H$H$H$H$HD$HL$HT$SH$H$HD$@H$(H$H$D$-D$;72<H$P@PuH$PH H=|^H$PH HtH$@HHH$PH H~!H$PH HD$xH$PH Hx H9vH$H$H$H$PH$H$H$H$HD$HL$HT$ HD$(HL$ H$H$H$PH HbH uIH H$PHǀ H$PH@XH$LH$@HHH$HD$覧H$PH HD$XH$PH Hx H9vH$H$H$H$PH@0H$D$H$H$H$HT$HL$HD$ 蝆H$PH$PHI0HHH aH uH H$HT$详H$PH H H$HDŽ$H$H$PH HD$PH$PH Hx H9vJH$H$H$H$PH@XH$H$H$H$HT$HL$HD$H$H$H$HT$ HL$(HD$07HD$8HL$@HT$HH$H$H$H$PH H _H CH H$PH HD$pH$PH$PH H HH)H9H$PH HD$hH$PHx H H9vH$(H$0H$8H$PH@0H$D$H$(H$0H$8HD$HL$HT$ H$PH$PHI0HHH ^H u0H H$PHǀ H$@HHH$HL$H$PH HD$`H$PHx H H9vH$H$H$ H$PH@0H$H$PH H H HL$HT$HD$H$H$D$ H$H$H$ HD$(HL$0HT$8sH$HD$H$@HHR89 19 *9 #9 9 @eH %H;aHhHl$`Hl$`HH$HD$HD$ HD$ HL$(HT$HT$HHD$PHL$XH\$pH H \Hx NHx HD$pHǀh HdH$HD$HD$@膫HD$HL$ HT$(HD$0HL$8HT$@H\$pH H \H H HD$pHǀ HD$pHǀ HD$pƀ HD$pHǀp HD$pǀ HD$pH@`HD$p [HP8uH HH8Hl$`HhH$HHD$ H$HD$DH $HT$ eH %H$H;AHH$H$H$H$H H+p H=|H$@PuH$H$H HH H$H$Hp H H9|pH$Hp H$`H$Hp HH$XH$H Hx H$`H9vH9vH)HHH?H!HH$hH)H$pH$xH $HD$Ht$ID$D$dH$ H$H$Hp H H9H$H$H H+p H$H=|8H$IPuH$H$Hp H H9<HtH$ uH$H$H Hx Hp HYH9rD$D$D$`H$H H H H HzH9HJH D$`H$ƀ H$H H$PH;H$H H H H$H$H$H$Hp HD$ H$H$H$H$H$HL$HD$HT$HD$0HL$(H$H$H$H ,WH ujH H$H HuH$HĈH$H$Hǀ H$HĈH$HD$iH$H$H>^H$H\$HT$HL$H|$ 衦HD$(HL$0HT$8H$H MVuH HHHHH$H$H$H $HD$ǛH$H$H$H$H$Hp H H9|H$Hp H$HH$Hp HH$@H$Hx H H$HH9vqH9veH)HHH?H!HH$PH)H$XH$`H $HD$Ht$D$D$\H$ H$H$ HThH$hH$DhHC`H$Hp H%H$H$H$HR`hH$hH$H$Hp Hh H$H HD$pH$H HD$hH$Hǀ H$Hǀ H$Hp HH$H| HDŽ$H$H$H@`H+h H$H9} H$H@(H=u{ H$H H$Hp H$H$H$H@`H+h HD$H$H$H$HD$HD$H$HD$ HD$(H$8HD$0H$0D$8D$CH$8H$H$0HD$xD$CD$BD$BuA H$H$H H$HL$xH H$H@(H=u H$H H} H$H@(H=uH$H HD$DH$H HȉD$D$D$~D$D$XH$H H H H HzH9HJH D$XH$H$H HI(H9~7HDŽ$H$H@(H=uH$H$Hp H H$H$Hp H$(H$HHp H$Hp H$H9|H$H$Hp H H9|H$Hp H$ H$Hp HH$H$H Hx H$ H9v5H9v&H)HHH?H!HH$8H)H$@H$HH $HD$Ht$D$D$PH$ H$H$ HDhH$pH$Hp H%H$H$H$phH$pH$H$Hp Hh H$Hp H$H$HHp !@ ; H$H@(H=tH$ƀ H$Hǀ H$H H$H=@t2H$H H H H$H$H$H$Hp HD$ H$H$H$H$H$HD$HT$HL$5HD$0HL$(H$H$H$H MH uaH H$H HuH$HĈH$H$Hǀ H$HD$ H$Hp HD$pHH$H$Hp H$H$H$H HHp H$H$Hp H H9|H$Hp H$H$Hp HH$H$H Hx H$H9vlH9v`H)HHH?H!HH$ H)H$(H$0H $HD$Ht$D$D$LH$ M50H$H$HzSH$H\$HT$HL$H|$ ݛHD$(HL$0HT$8H$H KuH HHHHH$H$H$H $HD$H$H$H$HD$pH$HD$hHȉD$輙D$D$TH$H H H H HyH9HYH D$T?H$H$HSRH$HT$HL$H\$H|$ 趚HD$(HL$0HT$8H$H bJuH HHwH$H$H$H $HD$H$H$H$H$H@(H=tHD$pH}{H$H HL$pH9~H$H@(H=uH$Hp HH$H$H@(H=uH$Hp H$H$Hx H H$H9rd$袗D$D$HH$H H H H HzH9HJH D$HH$H H$H=@t[H$H H H HD$HT$HL$H$H$H$HHD$ HD$0HL$(H$H$H$H HH H H$H HuH$HĈH$H$Hǀ H$Hp H$H$HHp H$H@(H=tH$ƀ H$HD$?H$H$HNH$H\$HT$HL$H|$ :HD$(HL$0HT$8H$H FuH HHHHH$xH$H$H $HD$`H$xH$H$9H$ uKH$H@(H=tHY0HA0H$(Ht<HH$HD$HD$HD$ HL$HT$(H$H$H$H$H H =Hx Hx H$ e=HP@uwH HH@H$ >=HPHu9H HHHHDŽ$0HDŽ$8H$HH$HJHD$訂H$H#HD$葂H$HL$聂GH$(HtHp~H$HD$HD$ŋHD$(HL$ HT$H$H$H$H$H H @<Hx Hx H$ <HP@uRH MHH@H$ ;HPHuH .HHHH$HHD$~H$HHD$gH $HT$WlH$(Ht@H$(H ~HH9rH$H@HH4Hl$Hl$>HmH|H$HD$HD$RHD$ HL$HT$(H$H$H$H$H H :Hx lHx H$ :HP@+H HH@H$ x:HPHH HHH8H$HD$@H$?:HYXHAXHAH$HD$HD$IHD$HL$ HT$(H$H$H$H$H H 9H uH H$HD$[H$HD$K[H$HHD$1H$HHD$H$HL$H$(HtHDŽ$(H$(H %HH9rH$H@HH4Hl$Hl$HmH$H$H$ 8HP@uRH HH@H$ 8HPHuH HHHJH$HHD$~H$HHD$~H$(HHv H$(HD$8HD$xHDŽ$HD$xHD$PHpH$HD$8HD$LHD$HL$HL$XHD$`HT$PH 7HZHBHD$PH$HDŽ$HDŽ$HH$HD$@H$H$H$HD$HL$HT$ nHD$(HL$0HD$hHL$pH$0H$8H$HH$HD$|PH$HD$|p i -eH %H;aHXHl$PHl$PHD$`H@0H$HD$pHL$hHL$HD$%HD$`@PHD$`Hǀ T6H Hǀ HD$`HHD$HHt HD$`Hǀ Hl$PHXHtGHD$`Hǀ HD$`HD$`Hǀ HD$`H@XH$HD$`H@`HD$@HD$8HD$@HL$8H9|7HD$@HD$HL$`H=rUDhHD$@HHD$@HD$0HD$(HD$0HL$(H9|:HD$0HD$ HL$`H=rDŽhHD$0HHD$0HD$`Hǀh HD$`Hǀp HD$`Hǀ HD$`Hǀ HD$`ƀ HD$`HD$`Hǀ HD$`Hǀ HD$`Hǀ HD$`ǀ HD$`Hǀ H$HD$y  7eH %H;aoH Hl$Hl$HD$0HD$8HD$(H Hu)HD$(H H HD$0HL$8Hl$H HD$(@PHD$(HPHHD$(H$HHD$(H Hu)HD$(H H HL$0HD$8Hl$H HD$(H@0H$HD$D$?HD$(H@0HHu/HD$(H@0HHHL$0HD$8Hl$H HD$(H@0H$"HD$(H@0HHHL$0HD$8Hl$H iteH %H;aHPHl$HHl$HHD$pHD$xHDŽ$H~H$QpH|$H|$02@1HHD$0H$HD$`HL$XHL$HD$HD$hHD$HD$(HL$ HL$8HD$@Hu*HD$pHD$8HL$@HD$xH$Hl$HHPHD$0HD$pHD$xHDŽ$Hl$HHPH~H$H|$\}L2eH %H;aHpHl$hHl$hHDŽ$HDŽ$HDŽ$HD$HHD$PHD$xHH@HI H$H$H$HT$H\$Ht$H$HD$ HD$8HD$(HL$0HD$HHL$PHD$8HD$@HD$HHL$PHD$XHL$`HD$@H$HD$XHL$`H$H$Hl$hHpeH %H;aHpHl$hHl$hHDŽ$HDŽ$HDŽ$HD$HHD$PHD$xH$H$H$H$HD$HL$HT$HD$ HD$8HD$(HL$0HD$HHL$PHD$8HD$@HD$HHL$PHD$XHL$`HD$@H$HD$XHL$`H$H$Hl$hHpeH %H;avXH0Hl$(Hl$(HD$@HD$HHD$8H$HD$HL$HL$HD$ HL$@HD$HHl$(H0eH %H;a^HPHl$HHl$HHD$@HD$XH@0HHHHH9tHL$@D$'HD$@HD$(D$'D$&D$&uHD$(HL$hHT$`H-HXHHHD$(HD$8HD$XH$HD$8H QHL$HD$HD$XHD$0HD$XH H H HL$HT$HD$HD$0H$荺Hl$HHPH$HL$slHD$XH$HD$`HL$hHD$HL$j11HHl$Hl$D$@D$8D$HD$(HD$HL$0HT$ Hc\$8Hct$H9vH9vH9vH)HHH?H!HHD$ H)Ht$(HL$0HD$(HL$ HwhHL$(HT$ HwQJ HL$ HT$(Hw4I HL$ HT$(HwI ȉD$@Hl$H    HHl$Hl$HD$@D$8D$HD$(HD$HL$0HT$ Hc\$8Hct$H9vGH9v;H9v/H)HHH?H!HHD$ H)Ht$(HL$0HD$(HL$ HwHL$(HT$ HwJHH HL$(HT$ HwJHH HL$ HT$(HwIHH HL$ HT$(HwwIH H HL$ HT$(HwXIH(H HL$ HT$(Hw9IH0H HL$ HT$(HwIH8H HD$@Hl$H   J D$D$i5D$eH %H;aHXHl$PHl$PHD$`HkH$HD$HD$yHD$ HL$HT$(HL$8HD$@HT$HH_H$gH|$H|$0)@1HHD$0ǀHD$0HL$8HT$@H\$HHHC)HuHHD$0HD$`Hl$PHXH$HL$nHH$H|$uqeH %H$H;Aq HH$H$HDŽ$HDŽ$HDŽ$H$=@ H$H$ H$H$H|H$$H$H$H$HǀH$H$H$H$HL$HD$H$H$H$HT$HL$ HD$(_ HD$@HL$8HT$0H$xH$H$H$H$H$H$HĘH$H$HD$TD$tD$XH$H$H$H $HD$HT$D$XD$D$ D$|$D$D$pD$P D$XD$lHDŽ$D$lD$XD$P$L$XȉD$lD$P$$ȉD$PD$lL$T9H$H$HcL$tH9|hH$H$H$Hc\$tH9vH)HHH?H!HH$HH)H$PH$XH$H$H$H$HL$HD$H$PH$HH$XHL$HD$ HT$(dHD$0HL$8HT$@H$H$H$H$$H$H$H$$ЉH$H$H$HH9vH$HH$HHHH$0H$8H$@H$H$H$H$H$ H$(H$8H$H$ H9H$ H$H$H$H$0H$H$HD$H$HD$ H$H$H$H$H$H$H$HĘeH$L$p?HD$$H$H$H$H $HT$HD$D$lD$pD$ D$hD$p%?$HDŽ$H$L$X$D$|$H$$$HTD$h$D$D$pH$L$X$+)щL$dD$hD$| D$|$9uH$H$HcT$tHc\$XH9vH9vH)HHH?H!HH$`H)H$hH$pH$H$H$H $HD$HT$H$pH$hH$`HT$HL$ HD$(HD$0HL$@HT$8H$H$H$D$X$D$XH$$+AD$LH$H$D$XD$D$LD$ H$H$H$HL$HD$HT$ D$(D$x$D$X+D$LȉD$oD$$H$H$H$HXH9SHPH$$D$X$L$xȉD$XD$XD$tD$XL$T9}WH$H$H$H$HL$HD$D$XȉD$HD$ H$$9D$D$\%?$HDŽ$H$D$Xȉ$H$$H$$$HTH$H$HH$H$$D$$H$%?HD$$$%?$HDŽ$H$D$X$H$$H$$$HTH$L$X$+)щL$`<H$HD$|$D$D$pD$X$D$XH$$9uH5c&H4$HL$HD$HT$H\$ nHL$(HD$0HT$8H$H$id ] V OjeH %H;aHHl$xHl$xHDŽ$HDŽ$HDŽ$H$H$H$HL$`HD$hHT$pHD$PHD$hHD$HHD$`HD$XHD$PHL$HH9|HD$XD$CD$B$lD$D$DH$H$H$HYH98HQH$T$DHD$XHHD$XHD$PHHD$PnH5$H4$HD$HL$HT$H\$ ,mHD$(HL$0HT$8H$H$H$H$H$H$H$H$Hl$xHĀTeH %H$`H;ApH H$H$DŽ$PHc$0HHD$H$@H$HL$H9H$@HD$$4}H$@H$8H$HHc$4H9vH)HHH?H!HH$H)H$H$HD$H$8H$HHc$0H9v)H9vH)HHH?H!HH$H)H$H$H$H$H9vH$HD$XH$HD$PHD$XHL$PH9|xHD$XHD$(H$H$H9rR H$H$H9r28u$PH$H HD$XHHD$XhcH$H$$PH$H E@H$(HH$$4ȉD$D$|DŽ$PH$H H$8HL$H$HHc$0H9vH9vuH)HHH?H!HH$H)H$H$H$(HHHHc\$H9vLH)HHH?H!HH$H)H$H$H$H$H$H$H9H$H$H$H9vH$H$HD$xH$H9vH$HD$HH$HD$@HD$HHL$@H9|xHD$HHD$H$H$H9rR H$H$H9r28u$PH$H HD$HHHD$HH$HD$pD$$0D$HcHL$H9tD$$PH$H Ë$0D$D$ H$HH$8H\$HcH9vIH9v=H)HHH?H!HH$H)H$H$H$HD$hH$HH$8H9vH$H$H$HD$8H$HD$0HD$8HL$0H9|{HD$8HD$ H$H$H9rX H$H$H9r;8uL$ȉ$PH$H HD$8HHD$8x>9;6H$0HxH$PH$0HxHpH$PHZH9rDtH$PH$HH$PH$0HH$XH$XHvH$0HHH$XHZH9rTDtH$XH$HH$XH$XHtH$0HHHwHDŽ$XH$0HH$H$0HpHxHHL$HT$HD$H$H$D$ #H$0HH$H$0HHHHL$HT$HD$H$H$D$ "H$ H(+    ܺ պ κ Ǻ 0eH %HD$H;ACHH$H$H$HHuH$HĈH$H$H$HL$hHT$pHD$xHD$XHD$pHD$PHD$hHD$`HD$XHL$PH9|iHD$`D$8D$=@rv$-D$D$fL$fD$ H$pH$H$`Hh 臭       V ߬ H Ѭ ʬ 3~H@Hl$8Hl$8HD$pH=sHD$hHD$PHL$HHT$XHL$ HD$(HT$0HD$HD$(HD$HD$ HD$HD$HL$H9|jHD$D$D$HL$hHT$`H9rBD$HL$hHT$`\$H9r!HD$HHD$HD$HHD$ Hl$8H@辫 ' HD$L$fHHD$L$fHHl$Hl$fD$D$f$D$f$D$$fD$D$Hl$HeH %H;aHXHl$PHl$PHD$hHH$HD$`HD$HD$`HD$HD$ HL$HT$(HL$8HD$@HT$HHH$d HD$HD$0 u|HHxWHHl$Hl$YHmHD$0HL$8HT$@H\$HHPHXuHHD$0HD$hHl$PHXH$HL$TH {H $HD$veH %H;aHHHl$@Hl$@HD$PH$HD$HD$ HHPH@HL$(HD$0HT$8fD$fD$D$f=r%fD$fD$D$f=rD$0fD$fD$D$f$D$D$6D$fD$D$D$fD$D$fD$HL$0HT$(\$t$H9rHf4fDD$fD$fD$:D$f=rD$fD$fD$ VD$f=rD$fD$fD$,D$fD$fD$HD$ HD$PHl$@HHE 讀9eH %H;aHXHl$PHl$PHD$`H$HD$HD$0HHHH@HT$8HL$@HD$HHD$(HD$@HD$ HD$(HL$ H9|yHD$(HD$f$D$D$fD$D$D$fD$fD$HD$@HL$8HT$\$H9r7HffDHD$(HHD$(vHD$0HD$`Hl$PHX HXHl$PHl$PHDŽ$HD$HD$xHL$pHT$hHT$8HL$@HD$HHD$ HD$@HD$HD$8HD$0HD$ HL$H9|HD$0D$HD$ HD$D$$uaHD$HD$(HL$`Hc$HYH Ht$H9rRHL1HHHD$HD$0HHD$0HD$ HHD$ gHD$H$Hl$PHX eH %H$H;A HxH$pH$pHDŽ$HDŽ$HDŽ$$v H$H$D$$D$$D$\H$HcH9v8 H$$L$f$$$H$H$Hct$$H9rHf2L2$L$$9D$$ȉ$H$WHl$Hl$^HmH$WHl$Hl$oHmD$0D$0$9~HDŽ$HDŽ$HDŽ$D$0$H$H$Hw A $H$H$HwA$H$H$Hw@H$H$HwHJ $HcD$0HrqH$HHHHH$@HcD$0HrlHHHcL$0HrND$0t:HcD$0HrHHDŽD$0D$XD$0}Hc$L$$HrHH$D$,HcD$,HrTHHH$ttMDŽD$,D$ 7 0 ) "    v HH$HHD$ QteH %HD$H;AKHH$H$fD$$H$H$H$H$H$H$HD$hH$HD$`H$H$HD$hHL$`H9|H$D$4HD$hHD$@D$4D$,D$$fD$&fD$$HD$@Ht'H$HH$HD$hHHD$h놋D$,tH$ H$HcL$,H)H$H$H$(H$ H9vH)HHHHH?H!HH$H)H$H$H$HxH$H$H$H$HT$HL$HD$UH$H$H$H$H$H$HD$XH$HD$PH$H$HD$XHL$PH9|H$@fL$HD$LL$HfL$8D$<D$$f$HD$@D$[ D$fD$*D$0D$*fD$0HD$@fD$2H$HHI\$0t$8H9rHf2fD2D$$fD$(fD$$H$HH$HD$XHHD$XH$ HD$xHcL$,H)HD$pH$(H9vH$ H$H v ߘ peH %H$8H;AHHH$@H$@H$PH@HuH$`H$HH$H$PHQ(HIH9vH$H$H$HD$`H$`H$XH$hH$H$H$ HDŽ$H$H$H$H$H$H$H9|4H$D$DH$HD$PD$DD$@ufDŽ$DŽ$HD$Pf$D$@$HL$`H$H$$H9rHf4 D HD$`H$HHD$`H$HH$H$HH$H$HL$`H$H9ryHfDH$PHHHHT$PH9r@HfDqH$`H$H$H$H9rHfDH$HL$`H9vH$HD$`H~H$H$H$H$H$HD$xH$HD$pH$H$HD$xHL$pH9|H$@fL$hD$lHD$xHD$XD$hL$lfD$HL$LH$PHH@T$HH9rHH$HD$XfD$fD$ H$HH$HD$xHHD$xQH$@HHH$PHH$H$H$H$HD$HL$HT$H$PH$H$H$H$HD$HL$HT$$pD$ /HD$(HL$0HT$8H$H$H$H$PH$H$H$H$HD$HL$HT$H$H$H$HD$ HL$(HT$0H$@HHHH$HD$HD$HD$(HL$HT$ H$(H$0H$8H$PHS HC(HSu HKH$HL$% W  ْ Ғ ˒ 4 -kXeH %H;avvH Hl$Hl$HD$(HL$0HT$8H\$@HPHX߶u0HHD$(HD$H H $HD$yHl$H H$HL$]jqHHl$Hl$HD$0HD$ H$HD$0Hl$HHH,$H,$D$8HD$(HL$HT$H9r;HHL$0HT$H\$H9rH f9D$8H,$H臑 HHl$Hl$HD$0HL$ HT$H9rH Df $D$HD$8HL$ HT$H9rhHL$H\$0Ht$ H<DH9rBHf<DHD$8 $T$H\$Ht$ H9rHf THl$H辐 eH %H;avvH Hl$Hl$HD$(HL$0HT$8H\$@HPHXߴu0HHD$(HD$H SH $HD$wHl$H H$HL$]hqHHl$Hl$HD$0HD$ H$HD$0Hl$HHH,$H,$D$8HD$(HL$HT$H9rHDHL$0HT$H\$H9rHL 9tSHD$(HL$HT$H9r;HHL$0HT$H\$H9rH f9D$8H,$H_]HD$(HL$HT$H9r:HDHL$0HT$H\$H9rHL 9D$8H,$H  ێ HHl$Hl$HD$0HL$ HT$H9rH Df $D$HD$8HL$ HT$H9rhHL$H\$0Ht$ H<DH9rBHf<DHD$8 $T$H\$Ht$ H9rHf THl$H eH %H;avOH Hl$Hl$fD$0D$(T$*J !f$5D$fD$fD$0Hl$H feH %H;avtH@Hl$8Hl$8HD$XHD$`H$H%HD$HD$HD$HHL$PHD$HL$ HD$8HHHPHH$HT$HL$HD$HD$ HD$@Hl$(H0> ;bvH|$8H9;uH#eH %H;avH@Hl$8Hl$8HY HurD$`HD$HHuPHD$HHHHPHH$HT$HL$HD$PHD$HD$XHD$ PD$(D$7D$`Hl$8H@= ahH|$HH9;uH#|eH %H;avmH0Hl$(Hl$(HY Hu`HD$8HuCHD$8HHHH@H$HL$HD$HD$@HD$HD$HHD$ Hl$(H0V= `zH|$8H9;uH#eH %H;avqH0Hl$(Hl$(HY HudHD$@HD$8Hu>HD$8HHHPHH$HT$HL$HD$HD$ HD$@Hl$(H0< K`vH|$8H9;uH#eH %H;avH@Hl$8Hl$8HY HurD$`HD$HHuPHD$HHHHPHH$HT$HL$HD$PHD$HD$XHD$ `D$(D$7D$`Hl$8H@< _hH|$HH9;uH#|eH %H;avmH0Hl$(Hl$(HY Hu`HD$8HuCHD$8HHHH@H$HL$HD$HD$@HD$HD$HHD$ Hl$(H0f; ^zH|$8H9;uH#eH %H;aH8Hl$0Hl$0HY HusHD$HHD$PHD$@HuDHD$@HHHH$HL$|HD$HL$HD$ HL$(HD$HHL$PHl$0H8: H^cH|$@H9;uH#{eH %H;aH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$5DHD$HD$8HD$0HH$HD$8HD$HD$DHD$HD$8HD$@Hl$ H(]cD$HD$HL$ f9tHD$@HL$I9D$eH %H;avRHH,$H,$<w H,$Hu<t= a%UH,$H\eH %H;aHHl$Hl$:$uKUuHmHۼHl$HHƼH$HcmHD$!$ 3HD$ HuH{H4mH}H bH $HD$H]H$HmHD$[ eH %H;aBHPHl$HHl$HDŽ$HD$`HD$@H ۻH9tLHۻD$X$HD$xHL$pH\$hH\$HL$HD$HЋD$ D$<$Hl$HHPH qH9thH٦H$H6lHD$HmD$X$HD$xHL$pH\$hH\$HL$HD$HЋD$ D$8$Hl$HHPD$X$HD$`HD$HD$hHL$pHT$xHD$HL$HT$ D$(D$4$Hl$HHPZD$+u#D$eH %H;aHHl$Hl$ߨuVרuG$ HD$ uH!Hl$HH H $HD$HSH$HHD$N YReH %HD$H;AHH$H$DŽ$u uH$HD$XH@}H$HD$PHHD$8H$HD$HHL$8H)HD$@HD$@H$H$H9vMHT$hHD$pHL$x$Љ$HD$pHL$hHT$xHL$HD$HT$/ D$ D$0Љ$HD$@H$H$H$H9vH)HHH?H!HH$H)H$H$H$HD$`Ht$$H$HĈ$$H HD$H$H$H$HD$HL$HT$ D$(D$4$H$HĈf  HH$HwHD$  fWeH %H;av[H Hl$Hl$HD$0HH$jHD$HD$D$($HD$HD$*HD$HD$0Hl$H VH0Hl$(Hl$(HD$HD$H=|HD$$HD$HD$H|?$t$$3D$8$HD$HD$ HHD$‹$D$$HD$@ $HT$Hr& HD$HD$HHD$YHl$(H0} H@Hl$8Hl$8D$pD$HЉD$HHD$hHL$`HT$XHT$ HL$(HD$0HD$HD$(HD$HD$ HD$HD$HL$H9|PHD$D$D$HL$PT$H1‹L$H1ȉD$HHD$HHD$HD$HHD$럋D$HЉD$pHl$8H@eH %H;a;HHHl$@Hl$@HD$XHH$&HD$HD$8HD$D$P$HD$ HD$ H=|HD$8HL$ HrD$HD$HD$H|fHD$8L$ɋL$1ȉD$HL$8HT$Hr2H HHT$ HrHD$HD$0HHD$/-HD$ HD$(HHD$ 6HD$8HD$XHl$@HHk{ d{ SeH %H;aHXHl$PHl$PDŽ$HD$xHD$HH}D$`ЉD$`HD$xHD$@HD$`D$4HL$xHT$pHw HT$xH\$pHwS HT$xH\$pHwS HT$xH\$pHw|S 1ȉD$`HD$hHL$xHT$pHwLHL$hRHT$xH\$pHw$HT$h[1HL$xH\$pHwHL$h[1HT$pH\$xHwH\$hHt$hH|$hLD$hAR T$`\$`ۋt$`@|$`@A11111D$`H$HL$xHT$pHsHHHH?HHHD$pHAHD$xH$D$`ЉD$`HD$xHD$8HtD$`$Hl$PHXHD$hHD$D$`$H$HL$xHT$pHT$HL$HD$ D$(D$0$Hl$PHXx Zx Sx PeH %H;avbH@Hl$8Hl$8D$hD$H$HHD$HD$XHL$PHT$`HL$HD$HT$ D$(D$4D$hHl$8H@:PeH %H;aHHl$Hl$g<w Hl$HP<tz < $ bHD$ uHүHl$HH H $HD$B{OFfnD$Ht$HL$ooVo^ of0fH@H@H@fofofofofDof:Df:Df:Df:DDoDofDon Dov0f:Df:Df:DfD:DffffAfAfAfAfAH@H@H@H@lfo#fof:Df:Dfffof:Df:Dfffof:Df:DffHr,Dofof:Df:DffAHHH}ftf:Dfsffo~fs fsff:Dffofoff:Dff:Dff:D$(eH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$H$HH wAH$HD$8HD$`HD$hHD$`HD$HHH$HD$8HD$HD$HL$HD$pHL$xHT$HHߘHZHJHD$HH$HDŽ$HDŽ$H!5H$HD$#H$H$H$HD$HL$HT$ HD$(HL$0HD$PHL$XHDŽ$HD$PHL$XH$H$H$HĠH$HL$:HNH$5HD$HD$@H$H$H$HL$HD$H$HD$KHD$@H$HDŽ$HDŽ$H$HĠKeH %HD$H;A2HH$H$H$H@xHD$HuH$H$H$HL$HD$qhHD$ H|$(WHHl$Hl$IvHmD$pH$H$HL$xH$H$H$HD$H$H$ u8HL$ HHxHt$(Hl$Hl$yHmH$HH H $HD$HD$ HD$M'!JeH %HD$H;AHH$H$HDŽ$HDŽ$H$HD$@H=MH2H$HD$#HD$HL$HD$hHL$pH$H$H$HH$HH$HDŽ$HDŽ$ H$HD$8H$H$H$H$HL$HD$HD$8fD$+H$HH$HDŽ$HDŽ$ HD$XHD$`H$HHXH@`HI H$H$H$HT$H\$Ht$H$HD$(HL$0HD$XHL$`HD$HHL$PHD$HHu*HD$HHL$PH$H$H$HHD$xHDŽ$H$HHXH@`HI H$H$H$HT$H\$Ht$H$HD$(HL$0HD$xH$HD$HHL$PHD$HHL$PH$H$H$HdGOeH %H$hH;A(HH$H$HDŽ$8HDŽ$@D$FH$0H$(H$H$HD$xHD$xH$H9|HD$xHD$pHD$xH$D$T=|HD$xHHD$xD$TD$HtUH4H$HD$%HD$HL$H$H$H$8H$@H$H=뢃D$F,H$H$H $HD$HD$xHD$D$D$THD$ HD$x<D$Fu%H$0HD$XHoH$HD$HD$XHD$HD$ HL$HT$(H$H$H$H$(H$0H$H$HD$hHD$hH$H9| HD$hHD$`HD$hH$D$P=|HD$hHHD$hD$PD$LD$GH$H$H$HYH9HQH$T$GcH5]H4$HD$HL$HT$H\$ HD$(HL$0HT$8H$H$H$H$H$HL$HD$hHD$D$D$PHD$ HD$h0HDŽ$HDŽ$H$ HHXH@`HI H$H$H$HT$H\$Ht$H$HD$(HL$0H$H$H$8H$@H$8HuH$HH$ ƀH$ HH$HDŽ$HDŽ$ HDŽ$HDŽ$H$ HHXH@`HI H$H$H$HT$H\$Ht$H$HD$(HL$0H$H$H$8H$@H$HHDŽ$HDŽ$H$ HHXH@`H $HD$H$(H$0HD$HL$HD$(HL$0H$H$H$8H$@BeH %H$XH;Ar H(H$ H$ HDŽ$PHDŽ$XHDŽ$`H$0HHuDHDŽ$PH$0HHH$XH$`H$ H(HD$HH$0@puH$0D$DH$@HD$XH$0T$DЉH$0$HHD$H$HH$8H$@HL$HT$HD$ D$(D$@H$0HDŽ$HDŽ$H$0H@xH$H$HH$@H$8HT$HL$HD$,\HD$ HD$PHD$(HL$0H$H$HD$PHD$HH$0H$H$HHuPHHD$HH$PH$0HHH$XH$`H$ H(H$HL$>H$0@pH$0H HHHH$0H@HuH$0D$?H$0H$0H@HHuqH$0D$>H$0H$0H@Hu*H$0D$=H$0H$HD$HD$HL$HT$ H$H$H$H$0HH(HP0H@8H $HT$HD$H$H$H$HD$HL$ HT$(%D$0D$eH %H$`H;AH H$H$HDŽ$8HDŽ$@HDŽ$HHDŽ$PHDŽ$XHD$XHDŽ$HDŽ$H$0H$(H $HD$裐HD$HD$XHD$ HL$H$H$HD$XHD$PH$H$HD$xH$HD$xHuWHDŽ$8HDŽ$@HDŽ$HHD$xH$H$PH$XaH$H HD$PHD$$H>HD$WhHD$HHDŽ$HDŽ$HDŽ$HDŽ$HD$PH$¾HD$HL$H$H$HD$HL$ H$H$H$H$HD$hHL$pH$H$H$H$H$HuiHD$PHD$`HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$HD$`H BH $HD$HD$HHHD$pHD$HL$ HT$(H$H$H$HD$0HL$8H$H$H$H$H$H$H$H$H$H$H$H$H$H$H$H$8H$@H$HH$H$H$PH$X9_H$H HD$hH@@HL$pH $HD$HD$@H=ʚ;| HD$He^H$H *eH %H;ajHpHl$hHl$hHD$xH$AkHD$HL$HL$HHD$PHu HD$XHD$`HD$HHL$PHwH$HD$HL$D$(HL$HT$ HL$XHT$`D$7HD$XHL$`HD$8HL$@D$7D$6D$6uHD$8H ɌH9tuHD$8H$HD$@HD$HHD$D$uDHD$xHL$8HT$@H uHXuHPHl$hHpH$HT$A Hl$hHpHD$HHL$PH$HL$a N)yeH %H;avuHH,$H,$r<w H,$Hkr<t-S WrjL5(rH,$H(reH %H$H;A HH$H$HDŽ$HDŽ$HDŽ$HDŽ$HH$HD$HD$lHD$(HL$ HT$H$H$H$HDŽ$HDŽ$HDŽ$H$H$H$HL$3HD$H$HD$ HL$H$H$H$H$H$H$H$H$H$HuNHDŽ$HDŽ$H$H$H$H$[H$HH$HD$$H,8HD$ZQH$H$H@sGH$HDŽ$@H$HDŽ$HDŽ$H$H$H$H$H$HT$HL$HD$HD$ 讀HD$0HL$8H$H$H$@H$HH$@HuNHDŽ$HDŽ$H$HH$@H$H$YH$HH$H$Hw<uNHDŽ$HDŽ$H;H ,H$H$fYH$HH$H$Hw AH$(H$0H$8HDŽ$HDŽ$H$H$H$(H$0H$8HD$HL$HT$H$HD$ 1tHD$0HL$8H$H$H$0H$8H$0HuNHDŽ$HDŽ$H$0H$8H$H$ZMH$HH$H$H$H9vH$H$H$ HDŽ$HDŽ$H$H$HoH$H$HD$zHD$HL$H$`H$hH$HdHZHJH$H$HDŽ$HDŽ$HH$HD$H$H$H$HD$HL$HT$ \HD$(HL$0H$pH$xH$H$HDŽ$HDŽ$KH$HH$HL$v)jH$H$H$HsHHHH?HHH$HH$H$H$PHRPH$XHD$HL$H\$H4$HD$ H$H$H$H$H$H sHHHH?H HH$HH$H$H$PHRPH$XHD$HL$H\$H4$HD$ H$HD$hHDŽ$HDŽ$H{H {H$H$2JH$H<tH$H$H$H(sGHHHH?H(HH$`HH$hH$pH$PHRPH$XHD$HL$H\$H4$HD$ H$HD$pH$H$H$H:sHHHH?H:HH$HHH$PH$XH$PHR@H$XHD$HL$H\$H4$D$ fD$FH$H$H@uLHDŽ$HDŽ$HsyH tyH$H$HH$HH$H$H$HH$HH$H$H$H$H${H$H@(H$H9uHD$hH$HD$`HD$hHL$`H9|iHD$hHD$8H$HQHIH9rAH H$H$H9r!HH9u.HD$hHHD$hH$Hu+H$H$D[H HH$HHD$HAH$HD$HHD$;H$ ZHT$HHH$HHD$HVAH$HD$HHD$SHD$H$H$Zu)HH$H$H$pHxH$HL$H$HT$ gH$HL$H$H@ H$H|4H{H$HD$HD$.HD$(HL$ HT$H$@H$HH$PH$HK HC(YHKHSH$HH H@HwH$H$HH(HP H@HsH$HHS HHK(4YHsHH?H8HȅHCH$HHD$H?H$HD$HHD$8H$ XHT$HHH$ XH$HX(sHP(H$H@8H$H$H$H$H9|.HdH$HD$HD$yHD$(HL$ HT$H$(H$0H$8H$HK8HC@WHK0HS0H$H$H$HQ@HI0H9vH$H$H$ H$HCHS WHS'HKH$H$H$HQ@HY8HI0H9vrH$H)H^8H)HV@"WH~0HH?HH!HȅHF0HD$XH$HD$PHD$XHL$PH9|]HD$XHD$@H$H$H9r7H$HZHRH H9rH HD$XHHD$XH$HHuH$HHD$H<H$HD$HHD$ROHD$H$H$V,HH$H@HuH$H@H$UHXubHHH$H$UHXu*HHH$H$H$pHxH$HL$(H$HL$H$H$>UHXuEHHH$H$UHXu HHkH$HL$賚H$HL$裚H$HL$蓚HW;H$HD$HD$HD$HD$ H$H$Tu HH $HD$(H<$HD$VH$HL$H $HT$GDH$HT$ڙH$HT$ǙCH4$HD$贙H $HT$衙A>b/ / / / F/ ?/ CeH %H;aDHxHl$pHl$pHHlH$H@lHu Hl$pHxH6H$HD$HD$HD$:HD$ HD$XH HD$`HD$h HHD$PH5H$HD$XHD$HD$hHL$`HL$HD$qQHD$ HD$HHL$PRVHHqHD$`HD$h HGHD$PHS5H$HD$XHD$HD$hHL$`HL$HD$PHD$ HD$@HL$PERHHHD$`HD$hHHD$PH4H$HD$XHD$HD$hHL$`HL$HD$PHD$ HD$8HL$PQFHHjHD$`HD$hH=HD$PHi4H$HD$XHD$HD$hHL$`HL$HD$PHD$ HD$0HL$P[QHHYHD$`HD$hHHD$PH3H$HD$XHD$HD$`HL$hHD$HL$OHD$ HD$(HL$PPu=HHD$X PuHi]H iH $HD$gH$HL$WH$HL$G6H$HL$4H$HL$!&H$HL$DeH %H;av(HHl$Hl$HhH$3Hl$HeH %H;aH0Hl$(Hl$(HD$H!$HCHD$.uOHl2H$HihHD$HD$@HL$8HL$HD$4HD$ HHD$H`7Hl$(H0ÐP7Hl$(H0ALHD$HD$HD$HH@HL$HD$eH %H$H;A|HhH$`H$`HDŽ$HDŽ$H$pH@HH$pH@(HumH$pHP(H$H$xH $HD$H$HD$HHD$ HL$HL$XHD$`H$H$H$`HhH$pHH$脧H$pH@Hu^HHD$HHtH$HD$HD$HHD$HD$(HL$ HT$H$H$H$H$pH@HD$PH$WHHl$Hl$,HmH.H$HD$PHD$H$HD$\H$Hu,H$HHPH@H$H$H$H$H$H$H$H$H$H$HYH9tHQH$H$H$H$H IH\HtHȋ5xLu HH$H$iH$HT$H5 sH4$HD$HL$HT$H\$ PHD$(HL$0HT$8H$H$HH$pHH$H$H$H$H$H$H$H~#H$H$HD$hdHD$HL$H$HL$H$H$H$H$H$H$H$pHH@HL$hHD$pHH$H$HD$cHD$HL$HD$(HL$0H$xH$H$HL$H$HD$HD$hHL$pHD$HL$ HD$8HL$@HD$xH$H$H$H$`Hh1HH$HEHD$ 7 d_HHl$Hl$HD$0HD$ H$HD$0Hl$HHH,$H,$HD$0HD$8HD$@HD$(HL$HT$H9r*H@HH\HDHT$0H\$8HD$@H,$HD% eH %H;a4H0Hl$(Hl$(HD$PHL$@HT$8H9rH@HLHHDH\$HL$HD$ HD$XHL$8HT$@H9rHT$PH\$8Ht$@H@HH@HTH\HHƅuH Hl$(H0H$HL$LH$H|$:# deH %H;aHHl$xHl$xƄ$H$H$H$H9rH@HLH\HHD$`HL$hH\$pH$H$H$H9rWH@HLHHDH\$HHD$PHL$XHD$hHL$`HT$pHL$0HD$8HT$@H$HD$PHD$H $H9|HD$8HD$H $H9|H$HL$HHT$PH9rHH $HT$0H\$8H9rrH H9uPH$HL$HHT$PH9r9HH $HT$0H\$8H9rH H9$Hl$xHĀXVH$HD$HH$-DBHD$PHD$(HD$8HD$ HL$(H9$Hl$xHĀ! ! ! JeH %H$H;AHH$H$HDŽ$HDŽ$H.H$&HD$H$x EHHxWHHl$Hl$)%HmH{H$҃HD$H$PH \HH$PH$xaEHXHHH$PH$H)H$HD$HD$HD$"HD$ H$HN)H$HD$HD$HD$HD$ H$HDŽ$pHDŽ$xHDŽ$H$H@ H$H $HD$HD$PHD$`HD$`HL$PH9|H$H@(HL$`H$HL$H$HD$ HL$HT$H$0H$8H$@H$H$HL$HD$HHHD$ HL$H$H$H,(H$H$HL$H$H$HT$HL$,)HD$ HHtH'H$H$HL$H$H$HT$HL$BHD$ H$HHL$`HH$H$xH$pHYH9HAH$xH$H$HH\ BH4 H H+'H$H$HL$H$H$HT$HL$+(HD$ HH$H&H$H$HL$H$H$HL$HT$AHD$ H$@H$HHHD$`H$HHD$`H4$HD$݇4H5H4$HT$HL$HD$H\$ $HT$(HL$0HD$8H$H$pH4H$HD$H$8H$pH$H$xHXHPA' HH$8H$_AHX HHH$8H$pH DH $HD$VH$HH$H$H$HL$HD$HD$HD$ D$( HD$0]HD$8H$H$hH$H$H$0H$8H$H@ H$H $HD$H$HDŽ$hHDŽ$pHDŽ$xHDŽ$H$hH$0HH$H$0HD$UHD$HL$H$H$H$0H ?HZ8HBHxH$H$HD$THD$HL$H$H$H$0HJ ?HZHBH$0H$HDŽ$HDŽ$H$hH I H $HD$HիHD$HD$H$H$H$HT$ HL$(HD$0rH$H$xH$pH$H$ H$(HDŽ$H$ H$H$H$(H$H$H9|vH$(HH@H$H$H$H$H$H$`H"H$H$HL$H$H$HL$HT$#HD$ HH$H$H$H$ H$(HDŽ$HHDŽ$PHDŽ$XHDŽ$`H$HH$ HXvH$H$HL$bRHD$HL$H$H$H$ HE=HZ%HJH}H$H$ HL$RHD$HL$H$H$H$ HB<HZHJH$ H$HDŽ$HDŽ$H$`H H $HD$H }HD$HD$H$H$H$HT$ H\$(Ht$0oH$H$XH$H@(HD$pH$H$He H$H$H\$H$H$H\$Ht$e!HD$ HHD$H$H$HD$pHD$HL$HT$ H$H$H$H$XH H $HD$H$H$H$HD$HT$H\$ D$( H$(HH$(H$HH$H$HL$ـBH$HL$ƀH$H$HD$HL$H$H$H$H$H$HĐH$HD$h/H$HD$UH$H$H$HL$HD$H$H$HD$ H$H$HL$HD$H zHD$ HD$(jH$HH$HD$ HD$IH$H$HD$H$H$HD$HL$HyHD$ HD$(PjH$H$HH$H$H$@HDŽ$HHDŽ$PHDŽ$XHDŽ$`HDŽ$hH$pH$xH$H$H$H$HDŽ$H$H$H$H$H$H$H9|$H$HH@H$H$H$H$HH$H$HL$H$H$HL$HT$H$@H$HHT$ HHw&HHDŽ$`H$H@(HD$pH$H$HRH$H$H\$H$H$H\$Ht$RHD$ HHD$H$H$HD$pHD$HL$HT$ H$H$H$H$H$H$HDŽ$H$H$H$H$H$H$H9|H$HHD$xHD$hH$H$HD$hHD$ nHD$HD$XHt.H$HH$H$HH$uH$XH$`H$hHYH9HQH$`HT$XHH5xH4$HD$HL$HT$H\$ 芆HD$(HL$0HT$8H$hH$XH$H$H$@H$HH$PHD$HL$HT$H$XH$`H$hHD$ HL$(HT$0HD$8gH$HH$H$HH$H$H$肉HDŽ$HDŽ$H$HĐH$HL${ H$HL$ {H$HL$zH H $HD$HD$HD$H$ H$H$H\$ HT$(HL$0^9H$HD$pcH$HD$pH$HD$pH$HD$pH$HD$pH $HD$H qHD$HD$>D$ D$WucHwHwHwHwHwHwHwHw~HHruntime.H9u+Hw[H wQH wGH w=QgoexuH w!H wQ fitu0 L PeH %H;aviH@Hl$8Hl$8HD$XHD$`HD$PHL$HH $HD$HD$HD$HL$ HD$(HL$0HD$XHL$`Hl$8H@3eH %H;av^HHHl$@Hl$@HD$PH$HD$HD$D$vHD$ HD$8HD$0HD$0HD$PHl$@HHeH %HqH.H$pH)H=0%.H@"H$8"H$8"HDŽ$`"HDŽ$h"HDŽ$HDŽ$HDŽ$H$HD$HD$D$HD$ H$D$(D$WH$HD$`D$WD$THD$`H2H$H@H$H$HL$H$HL$vHD$HL$(HT$ H$H$H$H$HT$HL$D$HD$ H$D$(D$UH$HD$`D$UD$TD$Tu?-HD$`H$H9v;-H$H$X"HtH$H"H$P"H$HL$H$H$H$HL$HD$HT$ HHD$(ΩHD$8HL$0H$8H$@H$`"H$h"H$8"H@"H$H$H$H$H$HDŽ$!HDŽ$!HDŽ$!HDŽ$!H$!H$ HöH$!H$ H$H$H$HHHX %HX+HPH0@H$H$HD$;HD$HL$H $HD$H$ HD$H$P"H$H"H $HD$WfHD$H$H$0H H $HD$HD$HD$HD$ D$( HD$0脦HD$8H$H$H$(H H$H"H$P"H$WHHl$Hl$HmHDŽ$H$H$H$H$H9|H$HD$pH$H$H9rh*HHHH$H$H$H$H HH$H$(H$H$HIHH$(H$ H$H$HIHH$ H$0H$H$HIHH$0H$HH$H$H$HD$H$H$H$HD$H$H|HH$H$!WHHl$Hl$HmH$!H$Hx\H$H$HD$7HD$HL$H$H$H$H "HZ(HBH\H$H$HD$d7HD$HL$H$H$H$HJ F"HZ(HBH[H$H$(HD$7HD$HL$H$xH$H$HJ !HZ('HB(H\[H$H$HD$6HD$HL$H$hH$pH$HJ0 !HZ88'HB8H=ZH$H$HD$G6HD$HL$H$XH$`H$HJ@ )!HZH&HBHH$H$pHDŽ$xHDŽ$H$P"H$H"H $HD$HHD$HD$(H$pH$H$xHD$ HT$(HL$0?THDŽ$H$H$H$H$H9|H$HD$hH$H$H9rR&HHHH$H$脽HD$H$H$H$FHD$H$H$!WHl$Hl$\HmH$!H$HDYH$H$HL$4HD$HL$H$HH$PH$HqHZHJHXH$H$HL$04HD$HL$H$8H$@H$HJ HZhHBH$HHD$HtXH$3HD$HL$H$(H$0H$HJ HZ(HB(H$HD$HXH$j3HD$HL$H$H$ H$HJ0 LHZ8|HB8H$H$XHDŽ$`HDŽ$hH$P"H$H"H $HD$H]{HD$HD$H$hH$`H$XH\$ HT$(HL$0bQH$H$1HD$HL$HT$H$H$H$H$H$H$HDŽ$H$H$H$H$H$H$H9|lH$HHD$xHD$XH$HDŽ$(HDŽ$0H$(H$H^H$H$HL$1HD$HL$H$H$H$HHZHJH$H$@HDŽ$HHDŽ$PH$P"H$H"H $HD$HYHD$HD$H$PH$HH$@H\$ HT$(HL$0OH$HH$H$HH$H$HL$sa9H$P"H$H"H $HD$HWHD$HD$HD$ HD$(HD$0OH$H$߸HD$HL$HT$H$H$H$H$P"H$H"H $HD$H$H$H$HT$HL$HD$ D$(~H$HH$SH$HD$v`yH$HD$c`H$HD$P`H$HL$=`H$81HH$8H$H$MH$P"H$H"H$HT$HHT$HD$HD$ HD$(HD$0MHDŽ$HDŽ$ H$H$H$HT$HQ[H$.HT$H\$H$H$H$HLFHVH$H$(HDŽ$0HDŽ$8H$P"H$H"H $HD$HkHD$HD$ H$8H$0H$(HT$ HL$(HD$0LHDŽ$HDŽ$H$H$H$HHD$H?ZH$-HD$HL$H$H$H$H yHZHBH$H$HDŽ$HDŽ$ H$H"H$P"H$HL$HyHD$HD$H$ H$H$HT$ HL$(HD$0KHDŽ$HDŽ$H$H$H$HHD$H-YH$,HD$HL$H$H$H$HgHZHJH$H$!HDŽ$!HDŽ$ !H$H"H$P"H$HL$HcHD$HD$ H$ !H$!H$!HT$ HL$(HD$0}JHDŽ$HDŽ$H$H$H$HHD$HXH$r+HD$HL$H$H$H$H UHZHBH$H$ HDŽ$!HDŽ$!H$H"H$P"H$HL$HmHD$HD$H$!H$!H$ HT$ HL$(HD$0kIHDŽ$HDŽ$H$H$H$H HD$H WH$`*HD$HL$H$H$H$HCHZHJH$H$ HDŽ$ HDŽ$ H$H"H$P"H$HL$HlHD$HD$H$ H$ H$ HT$ HL$(HD$0YHHDŽ$HDŽ$H$H$H$H(HD$HUH$N)HD$HL$H$H$H$H 1HZ\HBH$H$ HDŽ$ HDŽ$ H$P"H$H"H $HD$HyfHD$HD$ H$ H$ H$ HL$ HD$(HT$0GGHDŽ$HDŽ$H$H$H$H0HD$HTH$<(HD$HL$H$H$H$H HZ7HBH$H$ HDŽ$ HDŽ$ H$P"H$H"H $HD$HpHD$HD$H$ H$ H$ HD$ HL$(HT$05FHDŽ$HDŽ$H$H$H$H8HD$HSH$*'HD$HL$H$H$H$H HZHJH$H$ HDŽ$ HDŽ$ H$H"H$P"H$HL$H{iHD$HD$H$ H$ H$ HD$ HL$(HT$0#EHDŽ$HDŽ$H$H$H$H@HD$HRH$&HD$HL$H$xH$H$HHZHJH$H$ HDŽ$ HDŽ$ H$H"H$P"H$HL$HjHD$HD$H$ H$ H$ HD$ HL$(HT$0DHDŽ$HDŽ$H$H$H$HHHD$HQH$%HD$HL$H$hH$pH$HHZHJH$H$h HDŽ$p HDŽ$x H$H"H$P"H$HL$HlHD$HD$H$h H$p H$x HD$ HL$(HT$0BHDŽ$xHDŽ$H$xH$H$HPHD$HPH$#HD$HL$H$XH$`H$HHZHJH$H$P HDŽ$X HDŽ$` H$H"H$P"H$HL$HvHD$HD$H$P H$X H$` HD$ HL$(HT$0AHDŽ$hHDŽ$pH$hH$H$HXHD$HOH$"HD$HL$H$HH$PH$H HZ~HJH$H$8 HDŽ$@ HDŽ$H H$H"H$P"H$HL$HpHD$HD$H$8 H$@ H$H HD$ HL$(HT$0@HDŽ$h!HDŽ$p!HDŽ$x!HDŽ$!H$h!H$H$H`HD$HaNH$!HD$HL$H$8H$@H$H HZAHJH$HhHD$HMH$T!HD$HL$H$(H$0H$HB6 HZHJH$H$ HDŽ$( HDŽ$0 H$H"H$P"H$HL$HlHD$HD$H$ H$( H$0 HD$ HL$(HT$0L?HDŽ$H!HDŽ$P!HDŽ$X!HDŽ$`!H$H!H$H$HpHD$HLH$) HD$HL$H$H$ H$H HZHJH$HxHD$HnLH$HD$HL$H$H$H$HB HZHJH$H$ HDŽ$ HDŽ$ H$H"H$P"H$HL$H kHD$HD$H$ H$ H$ HD$ HL$(HT$0=HDŽ$(!HDŽ$0!HDŽ$8!HDŽ$@!H$(!H$H$HHD$HAKH$HD$HL$H$H$H$H{ HZ HJH$HHD$HJH$2HD$HL$H$H$H$HB HZ[ HJH$H$HDŽ$HDŽ$ H$H"H$P"H$HL$HKlHD$HD$H$H$H$ HD$ HL$(HT$0*HD$HL$H$H$H$`"H$h"H$8"H@"H$HL$B H$HL$ BH$HL$AH$HL$AH$HL$AH$HL$A]H$HL$A6H$HL$AH$HL$AH$HL$rAH$HL$_AH$HL$LA H$HL$9AH$HL$&AiH$HL$A,H$HL$AH$HL$@wH$HL$@RH$HL$@-H$HL$@H$HL$@H$HD$@H$HD${@H$HL$h@tH$HD$U@OH$HL$B@*H$HD$/@L$HT$@H$HD$ @/H$HD$?H$HD$?KH$HD$?H$HD$?gH$HT$?>i b  ĭeH %H;avYH@Hl$8Hl$8HD$HH$HD$HD$+HD$HD$0HD$(HD$(HD$HHl$8H@CeH %H;aHXHl$PHl$PHD$xHDŽ$HD$hHL$`H $HD$HD$pHD$HJHD$HD$ HHD$(HD$0HL$8HD$@HL$HHD$xH$Hl$PHX藬ReH %H;av4HHl$Hl$HD$ zH$HD$HD$ Hl$HHeH %H;aHhHl$`Hl$`HDŽ$HDŽ$H$H}FHD$xHL$pH $HD$HD$HL$HL$PHD$XH$H$Hl$`HhHD$pHL$xH$HL$H$HD$H~@HD$HD$ H}HD$(HD$0HL$8HD$@HL$HH$H$Hl$`Hh8eH %HD$H;AEHH$H$HDŽ$HDŽ$H8H$HD$HD$FHD$(HL$ HT$H$H$H$HD$@H$H$H$H$HL$HT$D$HD$ HD$8H$HD$`HL$8H9|HD$8H$H9vJH$HDŽ$HDŽ$H$H$HI H$H$H$HT$H\$Ht$H$HD$(HL$0H$H$HD$pHL$xHD$pHL$xH$H$H$HİH$HD$XH=};H$HD$PHHD$hH7H$HL$hHL$HL$hHL$ZDHD$HL$ HT$(H$H$H$HD$@HD$HHHD$@E ΨeH %HD$H;ARHH$H$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$H$H$HD$HD$HHD$HD$XD$ D$NHD$XHD$PD$ND$MHD$PH HD$`HH$HL$`HL$HL$`HL$CHD$(HL$ HT$H$H$H$H$H$HL$HD$HHHD$HD$hD$ D$OHD$hHD$PD$OD$MD$MuHD$PH$H9vH$H$H$H$H$H$HH$H$HD$ HD$HL$HD$(HL$0H$H$H$HL$H$HD$H$H$HD$HL$ XHD$8HL$@HD$pHL$xH$H$H$HĸWX QHHl$Hl$HD$0HD$ H$HD$0Hl$HeH %H;aH@Hl$8Hl$8HD$hHD$pHD$xHD$HHL$`HT$PH9rGHHH$HD$HL$HT$HD$ HL$(HT$0HD$hHL$pHT$xHl$8H@ kVeH %H;aHXHl$PHl$PHD$pHD$xH H$JH HD$$HӺHD$i:H Hu} ubHBtH$HD$HD$HD$HD$ 'HD$0HL$(HL$@HD$HHL$pHD$xwHl$PHX H$dhHD$hHL$`HL$HD$$HHD$mHD$pHD$xHl$PHXHH$HD$bMHD$HD$8 uH H w H $HD$y5Hl$PHX袣=eH %HD$H;AHH$H$H$H$H $HD$6HD$HD$PHD$XHD$`H$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$ nHD$HL$H$H$H$H$HD$ HL$HT$(H$H$H$D$0D$OH$H$H$H$H$H$H$H$H$H$H$H$D$OD$NHD$PH$H$H$H$HD$HL$HT$H$H$H$HD$ HL$(HT$09HD$8HL$@HD$hHL$pHuvHT$XHu^D$NuHHD$XHuQHD$PH$LAHH$H5BHD$MH$HHD$XHL$`HD$XH@ HL$`H $HD$HL$H$H$H$HYHD$HD$#H$H$HD$HL$ wHD$(HL$0HD$xH$H#-H$HD$xHD$HD$HL$H$HL$ aeH %H;aH Hl$Hl$HH$EHHD$$HյHD$ku\u=H$TdH}H$HD$;XHl$H ÐHl$H ÐHl$H 膟1eH %H;avYH@Hl$8Hl$8HD$HH$HD$HD${HD$HD$0HD$(HD$(HD$HHl$8H@eH %H;avYH@Hl$8Hl$8HD$HH$HD$HD$ˎHD$HD$0HD$(HD$(HD$HHl$8H@裞eH %H$H;A HH$H$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$H$HD$HD$SHD$H$D$ D$WH$HD$`D$WD$UHD$`H2H$H;H$H$HL$H$HL$8HD$(HL$ HT$H$H$H$H$HL$HD$讋HD$H$D$ D$VH$HD$`D$VD$UD$Uu HD$`H$H9v H$H$H$H$XH$`H$hHDŽ$HDŽ$HDŽ$HDŽ$H$H$H@zH$H$H$H$H$HHHX hHXHPH]H$H$XHD$gHD$HL$H $HD$H$HD$bH$H$H $HD$)HD$H$HDŽ$H$H$H H$H$H$HH$H$H $HD$HD$HD$HD$ D$( HD$0hHD$8H$H$H OH$H$H$H$H $HD$HjAHD$HD$HD$ HD$(HD$0eH$H$HDŽ$HDŽ$H$H$H/ H$H$HD$yHD$HL$H$HH$PH$H\HZHJH$H$HDŽ$HDŽ$H$H$H $HD$HDHD$HD$H$H$H$HT$ HL$(HD$0rHDŽ$H$H$H$H$H9|_H$HD$hH$H$H9rHiHH$HDŽ$pHDŽ$xHDŽ$HDŽ$H$pH$H$HHD$HH$HD$HL$H$8H$@H$HHZwHJH$HD$H'H$~HD$HL$H$(H$0H$HB`HZHJH$H$HDŽ$HDŽ$H$H$H$HL$H;&HD$HD$H$H$H$HL$ HT$(H\$0vH$HH$HD$HL$HT$H$@H$HH$PH$(H$0H$8HDŽ$H$0HD$xH$(H$H$HL$xH9|lH$HHD$pHD$XH$HDŽ$xHDŽ$H$xH$H$H$H$HL$HD$HL$H$H$ H$HHZHJH$H$HDŽ$HDŽ$H$H$H$HL$HHD$HD$H$H$H$HL$ HT$(H\$0H$HH$H$HH$H$HL$'9HDŽ$hHDŽ$pH$hH$H!"H$hH bAH$pH$H$HDŽ$HDŽ$H$H$H$HL$H$H$H$HD$HL$HT$ H$HH$HH$@}HD$HL$HT$H$H$H$ H$H$H$HL$H$H$H$ HD$HL$HT$ D$(H$HH$H$HL$&H$HL$%~H$Hu^H$H$WH$H$x!HD$HL$H$XH$`H$H$H$HĸH$HL$n%awH$HT$V%= ~ weH %H$H;AB HH$H$HDŽ$ HDŽ$(HDŽ$HDŽ$HDŽ$H$HD$HD$HD$H$D$ D$WH$HD$`D$WD$UHD$`H2H$H H$H$HL$H$HL$-HD$(HL$ HT$H$H$H$H$HL$HD$>HD$H$D$ D$VH$HD$`D$VD$UD$Uu HD$`H$H9v H$H$H$H$H$H$HDŽ$HDŽ$HDŽ$HDŽ$H$H$HoH$H$H$H$H$HHHX 8HX HPH-H$H$HD$7HD$HL$H $HD$H$HD$2H$H$H $HD$HD$H$HDŽ$H$H$ H dH$H$H$H2 H$H$H $HD$HD$HD$HD$ D$( HD$0]HD$8H$H$H H$H$H$H$H $HD$H(HD$HD$ HD$ HD$(HD$0_ZH$H$HDŽ$HDŽ$H$H$HH$H$HD$IHD$HL$H$hH$pH$H,HZHJH$H$@HDŽ$HHDŽ$PH$H$H $HD$H9HD$HD$H$PH$HH$@HT$ HL$(HD$0BH$vHD$H$HDŽ$HDŽ$H$H$HH$H$HD$#HD$HL$H$XH$`H$H HZHBH$H$(HDŽ$0HDŽ$8H$H$H $HD$H@HD$HD$H$(H$0H$8HD$ HL$(HT$0 HDŽ$H$H$H$H$H9|_H$HD$hH$H$H9rHiHH$HDŽ$HDŽ$HDŽ$HDŽ$H$H$H$HHD$H1H$HD$HL$H$HH$PH$HkHZwHJH$HD$HH$(HD$HL$H$8H$@H$HB HZHJH$H$HDŽ$HDŽ$ H$H$H$HL$HHD$HD$H$H$H$ HL$ HT$(H\$0 H$HH$sHD$HL$HT$H$H$H$H$pH$xH$HDŽ$H$xHD$xH$pH$H$HL$xH9|lH$HHD$pHD$XH$HDŽ$HDŽ$H$H$HH$H$HL$dHD$HL$H$(H$0H$HGHZHJH$H$HDŽ$HDŽ$H$H$H$HL$HfHD$HD$H$H$H$HL$ HT$(H\$0] H$HH$H$HH$H$HL$19HDŽ$HDŽ$H$H$HH$H 5H$H$H$HDŽ$HDŽ$H$H$H$HL$H$H$H$HD$HL$HT$ H$HH$HH$pHD$HL$HT$H$XH$`H$hH$H$H$HL$H$XH$`H$hHD$HL$HT$ D$(蹢H$HH$H$HL$H$HL$~H$Hu^H$H$KH$H$"HD$HL$H$xH$H$ H$(H$HH$HD$aH$HL$(>H$HT$l謮  eH %H;avHH,$H,$H,$H҆HD$HD$HL$HHD$eH %HD$H;AKHH$H$HDŽ$H$HHD$HH$H$H$HD$HL$襾HD$ HD$pD$(D$GHD$pHHD$PHD$HD$GD$FD$FuHD$HH$H$HĐH$HHD$HH$HHHHH{H9HKHH$H$HHLH 5buaHH$HHD$HH$H$H$HD$HL$HD$ HD$hHL$HHH $HD$HD$`H$HiH$HT$H\$HL$H|$ HD$(HL$0HT$8H\$`HuHHHHHD$xHL$XH$H $HD$HD$xHL$XH\$`HeH %H;aHPHl$HHl$HHD$XHHtHD$XHHD$8H=uHD$XHHD$@HD$XHHHHD$HT$HL$HD$@H$AHD$XHD$XHǀHl$HHPj%eH %H;a H@Hl$8Hl$8HD$HHH$LHD$HD$ HD$HH$HD$XHL$`HD$HL$MHD$HD$0HD$HHH$HD$HD$0HD$AHD$HH$HD$hHL$pHD$HL$HD$HD$(HD$HHH$HD$HD$(HD$eAHD$HHH$HD$PHD$HD$ HD$KLHl$8H@HD$0HH$HD$8HD$HD$HD$HHl$ H(~/eH %H;aH@Hl$8Hl$8HD$HHH$9HHD$HD$ HD$HHH$HD$HD$XHD$<HD$HHH$HD$HD$`HD$<HD$HHH$HD$HD$hHD$<HD$HHH$HD$HD$pHD$k<HD$HH$HD$xH$HD$HL$HD$HD$(HD$HHH$HD$HD$(HD$<HD$HH$H$H$HD$HL$HD$HD$0HD$HHH$HD$HD$0HD$<HD$HHH$HD$PHD$HD$ HD$GHl$8H@|*eH %H$H;A;HH$H$HDŽ$H$HHD$HH$H$HD$菨HD$HHD$hHL$HuH$H$HH$HO.H$vHD$H$H$HH$H$ HDŽ$(HDŽ$0H$HD$HD$%fHD$H$H$`WHl$Hl$;HmH$H$IgH$`H$Hl$Hl$rHmD$HD$WH$H$`Hl$Hl$FHmD$WD$UH$HtpH$H$HwTH$H$ Hw4H$H$RHH Hw H$H$[HH Hw H$H$@HH Hw H$H$RH H Hw H$H$@H(H Hwl H$H$[H0H HwD BH8H Hruntime.H9t H$H$Hw H$H$IH w H$H$[  H w H$H$v  H w S  сgoext{ H$H$H w^ H$H$R H w= K  fittHDŽ$H$HH$Ht H$HH$H$WHl$Hl$HmH$H$HDŽ$HDŽ$H$HHus H H$HAHD$hH$HHD$H H$H$HD$:HD$H$HL$hHH$HH$AHD$HD$XH$HH$HD$HD$hHD$46H$HH$HD$H$HD$6H$Hu@H$HHD$HH$H$H$HT$HL$讨HD$ HHD$xHtH$HHuHH$HHD$xH$HHD$HH$H$H$HT$HL$GHD$ H$HL$xHHDŽ$HDŽ$HDŽ$HDŽ$HDŽ$HD$xH$H$H$H$H$H$H$H$H$H$H$H$HYH9^HAH$HH ‹H$H H|H$Hl$Hl$覤HmH$H$HD$HD$xHD$H$HD$D$UuH$ WHl$Hl$辠HmH$H$`H$ H$Hl$Hl$HmD$HD$VH$H$ Hl$Hl$ɣHmD$VD$U:H$HH$HH$HH$HDŽ$PHDŽ$XHDŽ$`H$PH$HRH$PH$ *H$HXSHPH$H$HHH$H$H$HD$qHD$HD$pH$HH$HL$pH9|H$HHHT$pH9rHHH$H9vH$H$HHH\$pH9rgHHDH9rMH$HH$HD$HD$pHHD$v1H$HH$HD$HD$XHD$<H$H$H$H$8H$@H$HHDŽ$H$@H$H$8H$H$H$H9|HH$HH$HpH$Hl$Hl$2HmH$H$hH$pH$Hl$Hl$HmH$HH$n;HD$HD$`H$HH$HD$H$hHD$0H$H$H$pH$xHD$HL$HD$H$H$HH$HD$H$HD$~0H$H$H$pH$xHD$HL$SHD$H$H$HH$HD$H$HD$0H$H$H$H$HD$HL$HD$H$H$HH$HD$H$HD$/H$HH$HD$HD$`HD$4:H$H(H$H$HH$H$H$HD$hH$H$HH$HT$uHTzH$HL$H$HD$H5-zH4$HT$HL$HD$H\$ HT$(HL$0HD$8H$H$^1>H$H$Hw$H$H$ HwH$H$RHH HwH$H$[HH HwH$H$RHH HwH$H$@H H HwdH$H$[H(H Hw<H$H$RH0H HwCH8H Hruntime.H9uH$H$HwH$H$RH wH$H$[  H wH$H$v  H wlK  ʁgoexuH$H$H w:H$H$R H wK  fituQb`^\ZXVTRPNLJH1A?8642+)'%#!Hruntime.: 3 , leH %HD$H;AHH$H$HDŽ$HD$`H$H$H$HL$HD$uHD$HD$`HD$8/H$HL$HT$H$H$H$H[H$HD$HD$X ɷHHxWHHl$Hl$HmHD$XH$H$HtHUHHD$XHL$8HHHHD$XH$H$H$HHP HPHXHwH$HD$HD$PH HHH iHHD$PH$HDŽ$HDŽ$HL$XHǁHǁ_HHHH$HD$HD$HD$*\HD$ HD$HHDŽ$HDŽ$HD$0H8H$HD$HHD$H$H$HL$HD$[HD$ HD$xHL$0HHD$XHL$HHHHdH$HD$HD$HD$`[HD$ HD$pHL$X9HHHhH$HD$HD$HD$[HD$ HD$hHL$XݴHu@HHD$XHD$@HD$@H$/HD$@H$H$HH$HD$DH$HD$4PH$HL$!H$HD$H$HT$H$H\$5H$HL$H$HL$H WH $HD$KgIeH %H$hH;AHH$H$HDŽ$XHDŽ$`H$ I0uH$0H$HH$0H$H|pHH$HD$HD$HD$HD$ CHD$0HL$(H$H$H$XH$`H$HH$0H$H$0H$(HwUH H9wYH$0H$(Hw#HHrpHH$HD$HD$HD$HD$ sHD$(HL$0H$H$H$XH$`H$HH$@Hu.H$HHD$xH|fH$0H$(HwVHAHD$8H$0H$(Hw,HHD$pH$(H$8HsH9vHHHH?HHH$HH$H$H$0H$(HwHHD$hH$(H$0H$8H9vuH)HHH?HHH!HH$(H)H$0H$8HDŽ$H$@HuH$@H$HHwHH$H$@H$HH$PHsHHHH?HHH$@HAH$HH$PHD$8Ht?H$HD$`Ht H$H$HwNHHD$8HHyH$H IH $HD$HD$HD$XHD$HHD$HH$HD$XHD$HH$H$HDŽ$HDŽ$H$ H@H$H$H$H$HD$HL$HT$H$HD$ PHD$(H$H@0HD$PH$HT$8HHA0fyXSHDŽ$XHDŽ$`H$HH$0HL$@H|nHH$HD$HD$HD$HD$ HD$(HL$0H$H$H$XH$`H$HH$(H$0HwbH HupH H$HD$HD$HD$HD$ HD$0HL$(H$H$H$XH$`H$HH$0H$(HwHJHtgH$0H$(HwHJHuH$ ʚ;HHtHHH1HC8H$ A0H$0H$(H$8HsHCHHH?HHH$(HAH$0H$8 ][ }  o  a   ܇ Շ > 览  蹇 "`MeH %H$H;AhHxH$pH$pW$$HDŽ$HDŽ$"H$HL$HT$H$XH$`H$hH$H$XH$`HHHX `HX(HP(H$HHPH@H $HT$HD$$HD$H$H$HH$HD$ H$HD$8H$@0uH$H$HD$HHD$HD$HsHD$ HD$(-H$H$HD$HHD$HD$HHD$ HD$( H$HHHP H@(H$(H$0H$8H$HHPH@HL$HT$ HD$(H$(H$0H$8H$HL$HT$HD$0H$H$&HD$HD$xH$HH$HD$ HD$xHD$H$H$HD$ HHD$HD$HHD$ HD$( H$HH$H$H@8HD$H$H$HD$ GH$H$$H$H$HDŽ$HDŽ$HDŽ$HDŽ$HDŽ$H$H@HH$H$HuH$H$H$H@0HwHH$H$H$H$H@0HI8HHwYHCHDŽ$H$H@(HuHDŽ$HDŽ$HDŽ$ H$H$H:H$H$wHYH$HQH$H$CHqBHQH$H$HDŽ$H$HQ HYHIH$@H$HH$PHD$hH$HHL$`H$@H$HL$hHT$`H9|%H$H HL$XHL$hHL$HHL$XHL$PHT$HHtHL$pHHL$PH$H$HD$PHD$THD$HD$@Ht/H$HH$HL$hHHL$hH9MH$H$H$HYH9HAH$HD$@HH5QH4$HT$HL$HD$H\$ HT$(HL$0HD$8H$H$H$H$H$H$H$HT$HL$HD$H$H$H$HT$ HL$(HD$0H$HD$8H$H@H$H4$HT$H7H$H$HD$H7^H7H$HH$H$HHHHD$HT$HL$ H$H$HD$ H$HH$H$HHHHD$HL$HT$H$H$H$HH${ HDŽ$HDŽ$H$pHxH$HT$`O&  WseH %HD$H;AHH$H$HD$hHD$pHD$xHWH$HD$=(HD$HL$HT$ HL$hHD$pHT$xHL$PHD$XHT$`HD$@HD$HHD$@HD$8H+<HD$@HD$8H$HXuDHHHD$PHL$XHT$`H$HL$HT$HD$8HD$5H$HĈH$HL$PVeH %H$xH;AHH$H$HDŽ$@HDŽ$HHDŽ$PHDŽ$HDŽ$H$H$HI6H$H$ HPH$@HHH$H$H$H$HH$ H$H$H $HT$HD$D$ |HD$ HD$HH|EH$H$H$ H$@H$HH$PHDŽ$HDŽ$HDŽ$ H$HHD$H $H\$H$pH$xH$H $HD$H\$D$-d{HD$ HD$HH|H$pH$H9vH$H$H$HDŽ$HDŽ$ H$H$H$H$HD$HL$HT$,HD$ HL$(H$HL$HD$HD$@[HD$ H$HD$(HL$0H$H$ H$HD$@H$H$ H$H$H$HuHD$HHHD$xH$pH$xH$H9vH)HHH?H!HH$H)H$H$HDŽ$HDŽ$H$H$H$H$HD$HL$HT$+HD$ HL$(H$HL$HD$HD$@UZHD$ HD$pHD$(HL$0H$H$HD$pHD$PH$H$H$H$H$HuH$HH$HL$H\$H$(H$0H$8HL$hH|kH$(H$0Hw@HD$`HL$HH\$phIeH %H;avPHHl$Hl$HD$ H$HD$(HHHD$HD$ H$HD$0HD$Hl$HHeH %H;avLHHl$Hl$HD$ H$HD$(HHD$WHD$ H$HD$0HD$?Hl$HHeH %H$`H;AH H$H$H$@HD$@HH$(H@HD$8H$HH$@H$8H$H$H$HDŽ$H$H$H$H$H$H$H9|`H$HH$HD$H$(H$HD$HD$H$HH$H$HH$H$(H@HD$0H$(H$H$0HD$HD$0H+D$8HD$H$(H@HD$(H$(HH$HDŽ$HDŽ$H$(HH@HT$0H\$(H9vH9vH)HHH?H!HH$H)H$H$H$H$H$H$XH$`H$hH$H$H$H$@H$HH$PH$`H$H$HH9[H$HH$H$H$H$XH$H$@HD$H$HD$mwHD$(H+D$0HD$8H$H$(HHYHIH9vH)HHH?H!HH$H)H$H$H$(HH@HT$8H\$0H9v|H9vkH)HHH?H!HH$H)H$H$H$H$H$H$(H$0H$8H$H$H$H$H$H$ H$0HD$xH$H9H$HD$xHD$xHD$pH$(H$H$HD$HD$pHD$uH$(HHPH@H\$8H9vOH)HHH?H!HH$H)H$H$HD$(H+D$0H$H$(HHvH$H$HDŽ$H$H$H$H$H$H$H$H$H$H$H$H$H$HD$hH$H9QH$HD$hHD$hHD$`H$H$H$HD$HD$`HD$tH$H QH$8H$HH$@H$pH$xH$HD$XH$xHD$PH$pH$HD$XHL$PH9|dH$HHD$HHD$ H$(H$H$0HD$HD$ HD$H$HH$HD$XHHD$XH$H i i i AeH %H;avPH Hl$Hl$HD$8Ht Hl$H HD$(H$HD$0HD$HD$8HD$;Hl$H AeH %H;avDH(Hl$ Hl$ HD$@HD$HD$0H$HD$8HD$HD$HD$Hl$ H(@eH %H;avPH Hl$Hl$HD$8Ht Hl$H HD$(H$HD$0HD$HD$8HD$KHl$H L@eH %H$`H;AH H$H$H$@HD$@HH$(H@HD$8H$HH$@H$8H$H$H$HDŽ$H$H$H$H$H$H$H9|`H$HH$HD$H$(H$HD$HD$H$HH$H$HH$H$(H@HD$0H$(H$H$0HD$HD$0H+D$8HD$nH$(H@HD$(H$(HH$HDŽ$HDŽ$H$(HH@HT$0H\$(H9vH9vH)HHH?H!HH$H)H$H$H$H$H$H$XH$`H$hH$H$H$H$@H$HH$PH$`H$H$HH9[H$HH$H$H$H$XH$H$@HD$H$HD$-oHD$(H+D$0HD$8H$H$(HHYHIH9vH)HHH?H!HH$H)H$H$H$(HH@HT$8H\$0H9v|H9vkH)HHH?H!HH$H)H$H$H$H$H$H$(H$0H$8H$H$H$H$H$H$ H$0HD$xH$H9H$HD$xHD$xHD$pH$(H$H$HD$HD$pHD$mH$(HHPH@H\$8H9vOH)HHH?H!HH$H)H$H$HD$(H+D$0H$H$(HHvH$H$HDŽ$H$H$H$H$H$H$H$H$H$H$H$H$H$HD$hH$H9QH$HD$hHD$hHD$`H$H$H$HD$HD$`HD$NlH$H QH$8H$HH$@H$pH$xH$HD$XH$xHD$PH$pH$HD$XHL$PH9|dH$HHD$HHD$ H$(H$H$0HD$HD$ HD$H$HH$HD$XHHD$XH$H \a Ua Na G9eH %HD$H;AHH$H$H$HD$PH$H$H$HD$HD$PHD$|H$HHPH@HL$pHD$xH$HL$XHD$`HT$hH$HHD$HHL$hH9wHPH$HD$XHL$`HT$hHD$HL$HT$HD$HHD$ HD$(HL$0HT$8HD$XHL$`HT$hHD$HHL$hH9vHD$`H$HD$@HD$XHL$xHH$H$HD$HD$@HD$iH$HL$XHT$`H\$hHPHXuHH$HĐH$HL$JT~_ w72eH %H;aHxHl$pHl$pH$H$H$HL$XHD$`HT$hHD$(HD$`HD$ HD$XHD$0HD$(HL$ H9|vHD$0HH@HL$HHD$PHL$8HD$@H$H$H$HD$HD$8HL$@HD$HL$dHD$0HHD$0HD$(HHD$(yHl$pHxs6HHl$Hl$HD$(HD$ H@(HD$HL$ HHA(HD$ H@H$HD$(Hl$HeH %H$H;AHH$H$H$HD$(H$H@HD$ H$H$H$HD$HD$ H+D$(HD$!H$H@HD$H$HH$HDŽ$HDŽ$H$HHHHT$ H\$H9vH9v H)HHH?H!HH$H)H$H$H$H$H$H$8H$@H$HH$H$H$H$ H$(H$0H$@HD$`H$(H9[H$(HD$`HD$`HD$XH$8H$H$ HD$HD$XHD$eHD$H+D$ HD$(HD$0H$HHYHIH9vH)HHH?H!HHL$xH)H$H$H$HH@HT$(H\$ H9vH9vH)HHH?H!HH$H)H$H$HD$xH$H$H$H$H$H$H$H$H$H$H$H$HD$PH$H9H$HD$PHD$PHD$HH$H$H$HD$HD$HHD$udH$HHPH@H\$(H9vmH)HHH?H!HH$hH)H$pH$xHD$H+D$ HD$pH$HHvH$PH$XHDŽ$`H$hH$pH$xH$H$H$H$PH$XH$`H$H$H$H$HD$@H$H9uH$HD$@HD$@HD$8H$H$H$HD$HD$8HD$cH$H@(HD$hH$HHA(H$HĠ6X X X 0eH %H$xH;A) HH$H$HDŽ$@HDŽ$HH$H$H $HD$HD$H$8H$HD$ HyHD$HD$HHD$ HD$(迬H$8HH$HD$ H$8HD$@H$8H$HD$HHD$HD$ HHD$ HD$(LH$8H$HD$HDHD$HD$ H0HD$ HD$(H$8H$HD$H,HD$HD$ H HD$ HD$(īH$8H$HD$HHD$HD$ HHD$ HD$(耫H$H$XH5Hl$Hl$]HmH$XH$pHDŽ$xHDŽ$HDŽ$HDŽ$HDŽ$H$0H$(H$ H$H$H$HDŽ$H$H$H$H$PH$H$H9|H$PH$Hl$Hl$[HmH$H$Hl$Hl$[HmHDŽ$D$FHD$HHD$HH|H$H$HD$HL$HT$H$H$H$H$H$H$HD$xH$HD$pH$H$HHD$xHL$pH9|H$HHHD$hHD$`L$Fu_H$ 4HD$H$0Hu:H$J4HD$HL$H$`H$hH$HL$HHD$HD$ D$ D$Gu(H$HHH$HHD$xHHD$x*D$FH$8H$HD$`HD$HD$HD$PHtH$H$H$HYH9HAH$HD$PHbH57H4$HT$HL$HD$H\$ HT$(HL$0HD$8H$H$@DH$H$H5H$H$H$HD$H$8HD$HD$H$HD$ H$H$xH$pH$HwHH$xH$pH$HwHQH$H$HD$H$H$H$HD$H$H$H$H$HD$H$8HD$HD$H$HD$ H$H$xH$pH$HwHQH$xH$pH$HwHZHD$XH$xH$pHwH HH$xH$pHwyHBH$pH$xHwYH HuHtHHH1HD$XHDŽ$HDŽ$HDŽ$H$H$@Hg H$H$@HT$XHQH$@tH$8HqHYH$8H$H$H$xH$pHT$HL$HD$H$H$H$HD$ HL$(HT$0H$@HD$84H$PH H$PH$HH$.H4$H\$Qwu|z}D$FHD$HH$HHD$HiH$8H$HDŽ$@HDŽ$HH$HP 3O ,O %O O 'eH %H;a<H0Hl$(Hl$(HD$PHD$XHD$8HtHD$PHD$XHl$(H0HD$@HtHD$HH~HD$8HD$PHD$@HD$XHl$(H0HD$@HL$8WH*WH*^D$ fHD$HWH*^$D$D$  \^D$HD$8WH*YD$H,HD$PHD$@WH*YD$H,HD$XHl$(H0,&eH %H$xH;AHH$H$HBH$HDŽ$(HDŽ$0H$H$ٱH$H$H :H $HD$H­HD$HD$HD$ HD$(HD$0H$ H$H$H$H$H$HD$pH$HD$hH$H$HD$pHL$hH9|nH$HHD$`HD$PH$HD$xHD$PHD$XHDŽ$HDŽ$H$H$HH$HL$XHL$xHD$HL$H$H$H$H [pHZHBH$H$HDŽ$HDŽ$HD$xH 9H $HD$H~HD$HD$H$H$H$HT$ H\$(Ht$0uH$HH$HD$pHHD$pH$HD$OCH$H$9HD$HL$H$H$H$(H$0H$H"eH %H;aH0Hl$(Hl$(HBHD$ D$HHD$ HHHHT$8H9roH HHH$% HD$HD$HD$ HHHHT$@H9r7H HHH$ HD$HD$HL$H9D$HHl$(H0J !7HHl$Hl$HBH$D$(H$HHHHT$H9rEHiHDH $HHIH\$ H9r HiHLH9D$(Hl$HrI HHl$Hl$HBH$D$(H$HHHHT$H9rEHiHDH $HHIH\$ H9r HiHLH9D$(Hl$HH HHl$Hl$HBHD$HBH$D$(HD$HHHT$ H9r!HHDH $H9D$(Hl$HH eH %HD$H;AXHH$H$HBHD$HHBHD$8HD$HHHH(HHD$@H$WHHl$Hl$KHmHsH$HD$@HD$H$HD$n$H$HuH$HHHHD$pHL$xH$HHHHD$`HL$hHD$pHL$xHD$PHL$XHD$8H$HD$HD$`HL$hHD$HL$HD$PHL$XHD$ HL$(HD$0蘞H$H$'DH$HeH %H;aHHl$xHl$xHBHD$@HDŽ$HDŽ$HDŽ$HD$@HHHPHH$HL$HT$D$ EHD$ HD$(H|HD$@HHPH@HL$`HT$hHD$pHD$@H@H@ ju?HHD$pHL$`HT$hH$H$H$Hl$xHĀH$HD$HL$@HQH H9vlHL$HHD$PHT$XHD$(HHD$8HL$@HHYHIH9v/Ht$@H)H^H)HNiHH?H!HЅHHD$@H@HD$0HHD$@HH@Hw< tfHD$@HHPH@HsH\$@HHSHHC^iHH?HHȅuHsH$HD$HD$HHL$PHT$XH$H$H$Hl$xHĀH4$HD$訮D gD D D "MeH %H;av}HPHl$HHl$HHBHD$8HBHD$@HL$8HuOH$HD$HHD$HD$HD$ HD$(HD$8HD$0"Hl$HHPjeH %H;aRH(Hl$ Hl$ qe<w Hl$ H(Ze<tE FeH螼詤Խ/? vl(W2(HPH$HD$HD$HL$H  8gurHH H$HD$&@HD$HL$HfuH ldHl$ H(HH$HL$脬H sH $HD$meH %H;avvHPHl$HHl$HHBHD$@H$HD$XHD$HD$`HD$HD$hHD$HD$xHL$pHL$ HD$(H$H$HD$0HL$8Hl$HHPvqeH %H;aH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$HD$HD$8HD$0HH$HD$8HD$HD$HD$8HD$0HH$HD$8HD$HD$HD$8HD$@Hl$ H([FeH %H;aKHpHl$hHl$hƄ$HD$xHH$H H9tHD$xHHH@HD$XHL$`H$HHH@HD$HHL$PHD$`H9tHD$XHL$`H$HL$HD$HHL$PHD$HL$h8D$ uHD$xHHH@ HL$8HD$@H$HHH@ HL$(HD$0HL$@H9tFHD$8HL$@H$HL$HD$(HL$0HD$HL$7D$ $Hl$hHpfceH %H;avqH0Hl$(Hl$(HY HudHD$@HD$8Hu>HD$8HHHPHH$HT$HL$@qHD$HD$ HD$@Hl$(H0 [vH|$8H9;uH#eH %H;aHXHl$PHl$PHY HHD$pHD$xHDŽ$HD$`HuiHD$`HHHH@H$HL$HD$HD$hHD$pHD$ HL$(HT$0HD$8HL$@HT$HHD$pHL$xH$Hl$PHX s.H|$`H9;NH#FeH %H;avqH0Hl$(Hl$(HY HudHD$@HD$8Hu>HD$8HHHPHH$HT$HL$HD$HD$ HD$@Hl$(H02 vH|$8H9;uH#eH %H;aHXHl$PHl$PHY HHD$pHD$xHDŽ$HD$`HuiHD$`HHHH@H$HL$HD$HD$hHD$ HD$ HL$(HT$0HD$8HL$@HT$HHD$pHL$xH$Hl$PHXJ .H|$`H9;NH#FeH %H;avmH0Hl$(Hl$(HY Hu`HD$8HuCHD$8HHHH@H$HL$HD$HD$@HD$HD$HHD$ Hl$(H0 ?zH|$8H9;uH#eH %H;avH@Hl$8Hl$8HY HurD$`HD$HHuPHD$HHHHPHH$HT$HL$HD$PHD$HD$XHD$ `D$(D$7D$`Hl$8H@ hH|$HH9;uH#|eH %H;aH8Hl$0Hl$0HD$PHD$(HD$ HD$(HL$ H9|AHD$(HD$HHD$@H$HD$HHD$+HD$HD$HHD$(HHD$(HD$HHD$PHl$0H8ReH %H;aH`Hl$XHl$XD$xHD$0HD$(HD$0HL$(H9|HD$0HD$ HHD$pHH@HL$HHD$PHD$ HHD$hHHHHD$8HL$@HL$HH9uD$xHl$XH`H$HD$@HD$HD$PHD$赣D$uHD$0HHD$0PD$xHl$XH`eH %H;aH8Hl$0Hl$0HD$PHD$(HD$ HD$(HL$ H9|EHD$(HD$HHHD$@H$HD$HHD$'HD$HD$HHD$(HHD$(HD$HHD$PHl$0H8NeH %HD$H;AHH$H$Ƅ$HD$8HD$0HD$8HL$0H9|HD$8HD$(H HH$HHH$H HH9uƄ$H$HĈHHH$HHH@HD$pHL$xHD$(HHH$HHH@HL$`HD$hHL$xH9uHD$pHL$xH$HL$HD$`HL$hHD$HL$/D$ uHD$(HHH$HH H@HD$PHL$XHD$(HHH$HH H@HD$@HL$HHD$XH9uHD$PHL$XH$HL$HD$@HL$HHD$HL$.D$ uHD$8HHD$8`Ƅ$H$HĈeH %H;aH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$ HD$HD$8HD$0HH$HD$8HD$HD$HD$HD$8HD$@Hl$ H(8cD$HD$HL$ 9t_HD$HL$@I9u@HD$@HL$I8uHD$H@HL$HIH9D$eH %H;aHPHl$HHl$HD$xHDŽ$HDŽ$H[oHuHrHL$`H9u]HD$`HL$XH^r0Y H ?rHD$0HD$8HD$@HrH rH$HL$V8HD$HD$0HD$HL$ HD$8HL$@HD$0 XHnHD$8HL$@H$H$H$Hu Hl$HHPH^nH$HD$hHL$pHD$HL$ND$D$/D$xHDŽ$HDŽ$Hl$HHPH nH $HD$͝^H!qH$HL$賝HqH qH$HL$HD$XHL$`HD$HL$+D$ u9b[ eH %H;av`H8Hl$0Hl$0HD$PHD$XHD$HHL$@H $HD$eHD$HL$HD$ HL$(HD$PHL$XHl$0H8 eH %H;avHH,$H,$jH,$H eH %H;av`H8Hl$0Hl$0HD$PHD$XHD$HHL$@H $HD$,HD$HL$HD$ HL$(HD$PHL$XHl$0H8l eH %H;aHPHl$HHl$HHDŽ$HDŽ$HD$`HL$XH $HD$HD$HD$0H$HD$hHL$pHD$HL$HD$xHD$HD$ HL$(HD$8HL$@H$H$Hl$HHP FHD$HD$HnH nHD$HL$eH %H;av\HH,$H,$R<w H,$HR<t]3 RuRH,$H eH %H;a HhHl$`Hl$`HY HƄ$HDŽ$HDŽ$HD$pHuHD$@HD$HHD$pH$HL$xH $HD$H$H$HL$HD$D$ D$>HD$(HL$0HD$@HL$HD$>D$?HD$@HL$HHD$PHL$XD$?$HD$PHL$XH$H$Hl$`Hh6 H|$pH9;H#eH %H;aH8Hl$0Hl$0HY HuvHD$XHD$`HD$@HuGHD$@HD$PHL$HH $HD$HD$HL$HD$ HL$(HD$XHL$`Hl$0H8| `H|$@H9;uH#xeH %H;av=HH,$H,$HY Hu/HD$HuHD$H,$H H|$H9;uH#eH %H;aH8Hl$0Hl$0HY HuvHD$XHD$`HD$@HuGHD$@HD$PHL$HH $HD$9HD$HL$HD$ HL$(HD$XHL$`Hl$0H8L `H|$@H9;uH#xeH %H;aHPHl$HHl$HHY HHDŽ$HDŽ$HD$XHunHD$XHD$hHL$`H $HD$HD$pHL$xHD$HL$H$HD$ HD$(HL$0HD$8HL$@H$H$Hl$HHP[ /H|$XH9;OH#GeH %H;avoH(Hl$ Hl$ HY HubHD$8HD$@HD$0Hu3HD$0HD$H $HL$HD$HL$8HD$@Hl$ H( MxH|$0H9;uH#eH %H;aH@Hl$8Hl$8HD$XH$HL$HT$HD$ HL$(HT$0HMH$HD$HD$HL$PHT$HHOHXuoHHHD$HL$ HT$(H\$0HHHP OHP u+HX HD$H@(ʚ;HD$HD$XHl$8H@H$H\$H$HL$)eH %H;aH8Hl$0Hl$0HD$@HHHPH@ H $HT$HD$9HD$HD$(HL$@HI(HHD$ HD$ H|@HD$ HD$@HHHH@ HT$ WH*D$H $Hl$0H8hCHD$HL$HH(eH %H;avRHH,$H,$wK<w H,$HaK<t-, MKAKH,$HeH %H;avwH(Hl$ Hl$ HD$@HD$0H$HD$8HD$HD$HD$8HD$0HH$HD$8HD$HD$ HD$HD$8HD$@Hl$ H(EpeH %H;aHHHl$@Hl$@D$`HD$XHHHHD$0HL$8HD$PHHHHD$ HL$(HL$0H9tH$HD$(HD$HD$8HD$D$uHD$PHL$XH@HIH9tnHD$PHL$XH@HIH9uLHD$PHL$XH@ HI H9u(HD$PH@(HL$XHI(H9D$`Hl$@HHʉbeH %H;avRHH,$H,$FI<w H,$H0I<t) IIH,$HeH %HD$H;AHH$H$HDŽ$HDŽ$HDŽ$H$HD$HHH?H?HHHH)HuPH$H$H$HYH9HQH$HHDHJHHH$H$H$HT$PHL$XHD$`H$HHD$@HL$`H9w>HH$HD$PHL$XHT$`HD$HL$HT$HD$@HD$ lHD$(HL$0HT$8HD$PHL$XHT$`HD$@HL$`H9vHD$XHL$PHT$`H$H9vH)HHH?HHH!HHL$H)HD$Ht$H@H$H$H$H$HD$ HL$(HT$0ГHD$PHL$XHT$`HD$hHL$pHT$xH$H$H$H$HĈnlH$H|HD$܎[H5H4$HD$HL$HT$H\$ #HD$(HL$0HT$8H$H$$ eH %H;avRHH,$H,$E<w H,$HE<t& EOEH,$HJeH %H;aH Hl$Hl$HD$(H2H$FH|$H|$Gu.WHl$Hl$i'HmHD$HD$(Hl$H H1H$H|$͓aeH %H;aHxHl$pHl$pHDŽ$HDŽ$H$HH HPH@(H$HL$HD$H$H$H$HD$HL$ HT$(wHD$0HL$8HT$@HD$XHL$`HT$hH1H$)H|$H|$HFWHl$Hl$H&HmHD$HHL$XHT$`H\$hHP HX(FHXugHHH$HL$H@0A0H$HL$HH@8HA8HD$HHD$PH H$H$Hl$pHxH$HL$ԋH0H$H|$CNeH %H;a\H8Hl$0Hl$0HD$@H$HD$@HD$$HuHD$#HD$@H@8HD$(HL$@HHA8HD$@@0D$ HD$@HL$@H0HA8H}WH*HD$@^\@0HD$@@0D$HD$@L$HH@8H}.WH*HD$@^X@0,Hl$0H8HHHH WH*XHHHH WH*X[{,Hl$0H8leH %H;aH Hl$Hl$WD$0HD$(H$&HD$(HD$$H HD$r"u$HD$(@0D$0+Hl$H Ð+Hl$H `eH %H;avpHH,$H,$@<w H,$H@<t! @o%PK@H,$HHZHBHpH$HD$XHD$SHD$HL$H$H$H$HJ >HZHBH$H$HDŽ$HDŽ$H$H$HZHD$HD$H$H$H$HT$HL$ HD$(xH$HH$HD$襃`H$HD$蒃AeH %HD$H;AHH$H$LH$HD$pHD$xH H $HD$9HD$HD$hH$R HD$hH$HD$ʚ;HD$hH$ mD$8HD$pH$D$D$P]D$0D$PD$@D$0\D$@$赪D$D$HL$8f.wD$0D$`D$@D$XHDŽ$HDŽ$HDŽ$HDŽ$H$H$HinH$HD$`HD$6QHD$HL$H$H$H$H <HZHBHnH$HD$XHD$PHD$HL$H$H$H$HJ ;HZHBH$H$HDŽ$HDŽ$H$H$HHD$HD$H$H$H$HT$HL$ HD$(uH$HH$HD$΀`H$HD$軀*eH %H;avfHH,$H,$8<w H,$H8<t 7OJu@7H,$HfeH %H;av]HHl$Hl$HPS2:uHH.SHl$HHSH$HHD$eH %H;aHxHl$pHl$pHH$H9HD$HqH rHsHD$HL$HT$ H H HHD$(HL$0HT$8H H H HD$@HL$HHT$PHD$XHD$hHD$hH$HD$HD$`H$yHl$pHxeH %H;avkHH,$H,$26<w H,$H6<t 6菍Z%P&5H,$Hq|BCFMNRT_bcdefghimnprstuvwxioos.FDoFdHiInLoOSOpPCTobpbscsdpfdfnfpfsg0gpgshihzidinisixlolrmpmundnsokonopotpbpcpdpppsq0q1r1r2r8r9rdrergrtrwscspsst1t2txwdwgwrwtzwfmtAddArgCapDayDevErrGenGetGidInoIntKeyLenLogMaxMinNewNumOldOutPutR16R32RunSecSetSubSysTagUTCUidVar_g__p_absaddalgallaltargarravgbadbssbufcapcascatcgocntcurdirdstendeoferrexpextfinfmtfungcwgetifninckeylenlfslnslocloglvsmOSmaxmemmtxmulnegnopnowobjoffoldoutpadpfdpinpopposptrputr10r11r12r13r14r15ranrawraxrbprbxrcxrdirdxretriprsirsprunsecseqsetsigsizsp1sp2sp3spcsrcstkstrsubsystabtagtfntlstmptypvalwidflagsortsynctime*intAddrArgsBaseBitsBoolCallCodeCol0Col1CopyDataDateDoneElemExprFailFileFindFlagFromFuncGrowHourInitInstKindLessLineLoadLockLogfMmapModeNArgNameNanoNextNsecPathPermRdevReadRecvRuneSeekSendSizeSkipSortStatStopSub0SwapSyncTypeUintUnitUnixWithYearZoneacctaddranonargpargsbasebiasbig4bitpbitsboolbptrbufpbusybytecallcellcodecondctxtcurgdatadatedepsdictdonedropdstpdumpebsselemexprfailfdmufilefilefillfindfintflagfreefreqftabfullgoidgoodgopcgrowhashheadhmaphtabidleinfoinitinstinwbitabitypjobskeyskindlastlazyleftlinelinklistloadlocklocsmantmaskmhdrminvmmapmodemoffmonomoremtypnamenbitnbufncgonestnewgnextnicenobjnodenotenretnsecnstkoldppad0parkpclnpcsppluspoolprecprevprogptabpushrcvrreadrecvregsrootrun1runNrunerunqsbrkseeksemasendsghisignsizeskipsortsrcpstarstatstepsynctEndtagstailtesttexttinyuservarpwaitwallwhenwordzerozone@e  @0g p   0P 0P{p`h  pj |@l @0  0Gp7:@=04@?s  v    @    n ;P@pP@`0 `pppt_ @b  c  d   @ p p ` A]`e p?0 Pf  p @0 `zg   Pi  |k @/  F6:<p3p> r u 0 0   p 0  m P;0PPpp0` 0p@@@`  Ps _ a b c  P `` 0@ ` @ ``A P`\`bufiobytes*bool*int8*uintAfterAlignAllocBytesChdirChmodChownClockCloseCountDeltaEntryEqualErrorExtraFatalFieldFlagsFloatFlushFreesFstatFsyncGCSysHoursIndexInt64IsDirIsNilLine0Line1LocalMatchMonthMutexNFlagNlinkNumGCNumInParsePreadRLockRangeResetRoundRune0ShiftSkipfSliceSplitStackStartStmtsStoreSysfdUsageValueVisitWidthWrite_Func__pad_func_typeafteralignallocarrayatEOTblockbuildbytepbytescachechaincheckchmodchunkclassclearclosecodescountcycledatapdeltadensedirtydyingedataemptyentryequalerroretextevictextrafailffaultfflagfirstflagsflushfmt_cfmt_qfmt_sfreesfunc_funcsgcbssgfreehash0heap0heap1heap2identincgoindexint64interinuseisDSTisstdisutclargelevellimitlineslocallocksmatchmaxpcmidleminpcminusmutexnbitsndonenextpnfreengsysnpagenprocnumgcnwaitparampatchpcbufpidleplusVpreadptrToquestqueuerLockrNextrecvqrecvxresetreuserightrlockrsemarunesschedsendqsendxseqGCsharpshiftsiglrsigpcsigspslicespacespansspiness_spstackstartstatestorestuffsweeptMarktableteststflagtimertreaptrunctypesudatausagevaddrvalidvaluewLockwbuf1wbuf2widthwritewsemaerrorsregexp*[]int*error*int16*int32*int64*uint8AcceptAssignBeforeBlocksBySizeCanSetCyclesDeleteErrorfExpandFailedFatalfFchdirFchmodFchownFormatHasAESHasAVXHeaderHelperIntVarIsZeroLastGCLookupLspareMaxCapMethodMinuteMunmapNextGCNumCapNumOutOffsetOutputParsedPrefixPwriteQspareReadAtRemoveSearchSecondSetCapSetIntSetLenSlice3Stack0StrideStringUint16Uint32Uint64UnlockWritev_defer_panicactiveactualaddSecallocsappendarglenargmapattachbeforebitmapbucketchattyclosedcommonconcatcutoffcyclesdecrefdeletedigestdivMuldivmodefenceencodeetypesexpandextLenfactorfailedfflagsfieldsfileIDfilterfmt_bxfmt_qcfmt_sxformalformatframesfreghifreglofuncIDfuturegc_sysgcdatagflockhasSubhelpgcinListincrefinhashinsertint64sintbufiovecsisFileisFreelabelslaunchlayoutlengthlinenolocabslockedlookupmaxLenmcachemcountmergedmethodmissesmunmapmustBenbytesnchunkneedednelemsnewvalngfreenmidlenoCopynoscannotifynpagesnpidlenumCapoffsetoldvalopaqueoutputpallocparentparkedparsedpbLinepcfileperiodprefixprocidpwriteqcountreaderrefillopxremoverepeatreportresultreviserflagsrunnerrwlocksetLocsetRansharedsharpVshift2si_pidsi_uidsignalsparsestatusstringtagLenthreadtickettokenstryGettstarttv_secuint64uniqueunlockunusedvaluesvarintwantedwidthswindowwrite0writeNwritercontextreflectruntimestrconvsyscalltestingunicode**uint8*[0]int*[1]int*[2]int*[6]int*[8]int*[9]int*[]bool*[]int8*[]uint*fmt.pp*func()*string*uint16*uint32*uint64AddDateBlksizeBoolVarCanAddrChanDirCommentComplexConvertDebugGCDirAttrFailNowFindAllFloat64HasAVX2HasBMI1HasBMI2HasERMSHasSSE2HasSSE3HeapSysISOWeekIsValidLongestLookupsMallocsMapKeysMinutesModTimeNsPerOpObservePauseNsPkgPathPointerRLockerRUnlockRawReadReadMsgReaddirRoundUpSecondsSetBoolSetUintSkipNowSkippedSyscallTimeoutTryRecvTrySendUintVarVolAttrWeekdayWriteAtWriteToYearDayabortedaddLineadvancealignmealldonealllinkallnextalloc_mamendedargSizebadVerbbalancebarrierblockedboolOptbucketsbufLockby_sizecallerscentralcgoCtxtclosingcodegencompilecontextcreatedcurrentdebuggcdeflatedequeuedestroydirinfodisposedoBenchdoMatchdoPrintenabledendCharenqueueentriesexpbitsfiletabflushedfmt0x64fmtBoolfmt_sbxforwardfreeStkfrexp10funcoffgctracegetSlowgoidgengrowinggsignalhdrsizehelpersif_versignoredinCountincacheinlTreeint_repisEmptykeysizelibcallliterallockedglockedmlongestmachinemapBitsmatchedmethodsmodTimemorebufmsgh_idnameLennameOffnameoffnextAllnext_gcnlookupnmallocnpcdatansPerOponepasspaddingpauseNSpbLabelpinSlowpkgPathpkgpathpointerpreemptprepareprivateptrdatapushcntputFastracectxreaddirreadersreadingreclaimreleaserunlockrunnextrunningsa_masksetMonoset_ripset_rspsi_addrsi_bandsi_codesigaddrsigcodesigmaskskipNopskippedsortkeyspanKeyss_sizestartedstartpcstringssysStatsyscalltakeAlltextOfftimeEndtimerOntopbitstophashtv_nsectv_usectypeOfftypemapuint64sunixSecvisitedwaitingwrapErrwrapped **uint32*[8]bool*[]int16*[]int32*[]int64*[]uint8*cpu.x86*float32*float64*fmt.fmt*os.File*os.file*poll.FD*uintptrBufferedCapNamesCountersDeadlineDefValueDurationEnableGCFileAttrFileLineForkattrFunctionGoStringHasSSE41HasSSE42HasSSSE3HeapIdleInt64VarIsStreamLocationMSpanSysMapIndexMemBytesMultiplyNumFieldOtherSysParallelPauseEndRawWriteReadByteReadFromReadRuneSetBytesSetFloatShutdownSimplifyStackSysTruncateUnixNanoVisitAllWriteMsgaddExtraaddNonGoallspansassignTobaseMaskbaseaddrbitCountbusyListbytedatacacheEndcapNamescgocheckchar_repcollapsecontainscontinpccoprimesdataqsizdecoratedivShiftdoPrintfdurationelemsizeelemtypeenablegcencSpeedendCycleeofErrorerroringexamplesfastrandfinishedfmtBytesfmtFlagsfmtFloatfreeListfreeSpanfullHeadfullNamefullTailfuncInfofuncNamefuncTypegenerategfreecnthashHeadhashPrevheapGoalheap_sysinitSpaninlIndexint64OptisMarkedit_valuelastFreqlastReadlastpolllibcallglocForPCmachportmantbitsmapSpansmatchLenmatchcapmaxprocsmbPerSecmcentralmig_versminwidthmstartfnnbgsweepncgocallneedzeronetBytesnewStacknextFreenextHashnonblocknonemptynoptrbssnumExtraobjIndexoutCountoverflowpadbytesparseIntparseOnepause_nspbSamplepointerspollablepositionprefetchprevRunepreviousprintArgpriorityreadLockregexpROresetAllrunqheadrunqsizerunqtailrwunlocksa_flagssa_trampscanWorkscavengeseqStartsetRunesset_usecshutdownsi_errnosi_signosi_valuesigcode0sigcode1sleepingspecialsspineCapspineLenspinningss_flagsstackTabstktopspstopnotestopwaitstwprocssubNamessudogbufsweeperssweepgensysAlloctabwidthtagCounttargetpcthrowingticksEndtmpClasstracebuftraceseqtruncatetryAlloctryStoreuncommonwaitReadwaitlinkwaitlockwaitnotewaitsemawaittailwasPanicwritebuf *[0]int32 *[0]uint8 *[1]int64 *[1]uint8 *[29]int8 *[2]int32 *[2]int64 *[2]uint8 *[37]uint *[3]int64 *[3]uint8 *[44]int8 *[4]int32 *[4]int64 *[4]uint8 *[5]int32 *[5]int64 *[5]uint8 *[6]int32 *[8]int32 *[8]int64 *[8]uint8 *[9]uint8 *[]*uint8 *[]string *[]uint16 *[]uint32 *[]uint64 *chan int *sync.Map Anonymous Atimespec Available CallSlice Ctimespec FindIndex FreeBytes Ftruncate GobDecode GobEncode HasPOPCNT HeapAlloc HeapInuse Interface IsRegular MCacheSys MatchRune MemAllocs MemString Mtimespec Normalize NumMethod NumSubexp Pad_cgo_0 Precision PutUint16 PutUint32 PutUint64 ReadBytes RoundDown SetOutput SetString StartCond StopTimer StringVar Temporary Uint64Var Unordered WaitWrite WriteByte WriteRune allocBits alternate arena_end argNumber backtrack badArgNum benchFunc benchTime bestSpeed bitCounts bitLength blockSize bootstrap busylarge cacheSpan cacheZone caughtsig chainHead dataCount deferlock deferpool divShift2 doExecute doPrintln dotdotdot endEscape enoptrbss fillStore findMatch fixedSize floatBits float_rep fmtString fmt_float framePool frameSkip freeindex freelarge freqcache gcbssmask gcwaiting goidcache hasPrefix hashMatch heap_idle heap_live heap_scan insertNew instQueue isPointer itablinks largefree lastTicks libcallpc libcallsp localSize lockOwner lostExtra mallocing matchFunc maxmcount msgh_bits msgh_size mspan_sys nBSSRoots netAllocs nevacuate newRegexp nextIndex nextwaitm nfuncdata noptrdata noverflow npagesKey numBlocks numSubexp other_sys overflow0 overflow1 padString pad_cgo_0 panicking pause_end pbMapping pclntable pkghashes prefixEnd previousN printlock profilehz profiling ptrToThis readSlice readerSem recovered reordered reserved1 reserved2 retOffset schedlink schedtick schedwhen setMarked si_status sizeclass softfloat spanalloc spanclass spineLock stackLock stacksize startAddr startSema startTime storeHuff stringMap stringOpt stringSeq stripMono sudoglock sweepdone syncFlush syscallpc syscallsp tMarkTerm timeStart totaltime traceback traceskip typelinks uint64Opt valuesize waitWrite waitsince walkTreap wbufSpans windowEnd writeBits writeCode writeLock writerSem hash/crc32 *[0]string *[10]uint8 *[13]int32 *[14]uint8 *[16]int32 *[16]uint8 *[17]int32 *[19]int32 *[1]string *[1]uint32 *[1]uint64 *[20]uint8 *[22]uint8 *[24]uint8 *[2]string *[2]uint32 *[2]uint64 *[32]int32 *[32]uint8 *[3]string *[3]uint64 *[40]uint8 *[4]string *[5]string *[64]uint8 *[65]uint8 *[67]uint8 *[68]uint8 *[6]string *[7]string *[7]uint64 *[80]uint8 *[8]*uint8 *[8]string *[8]uint32 *[8]uint64 *[9]string *[][]int32 *[][]uint8 *[]float32 *[]float64 *[]uintptr *chan bool *complex64 *flag.Flag *fmt.State *io.Reader *io.Writer *runtime.g *runtime.m *runtime.p *struct {} *sync.Once *sync.Pool *syntax.Op *testing.B *testing.M *testing.T *time.Time *time.data *time.zone *unicode.d AllocBytes CommonAttr Comparable FieldAlign FindString Float64Var HasOSXSAVE Implements ImportPath InUseBytes IsBoolFlag IsVariadic MSpanInuse Nanosecond RawControl ReadDirent ReadString ReplaceAll ResetTimer SetComplex SetPointer StackInuse StartTimer TotalAlloc UnreadByte UnreadRune UnsafeAddr addCPUData addMapping allMatches allocCache allocCount allocLarge arena_used assistTime benchmarks bgMarkDone blockStart bucketsize bulkHasher cacheStart cachealloc catchPanic cgoCallers checkValid checkempty clearflags compressor countAlloc endMessage enoptrdata fieldAlign fieldalign fillWindow fixsigcode fmtComplex fmtInteger fmtPointer freeManual free_bytes gc_trigger gcdatamask gcmarkBits gcscandone gfreeStack goodArgNum hashOffset havePeriod heap_alloc heap_inuse importPath inputBytes insertBack invalidptr isExported isParallel largealloc local_scan lookupName mcache_sys missLocked missingArg modulename nDataRoots nSpanRoots needextram newLiteral nlargefree nmspinning npreleased nsmallfree numWaiting offsetAnon offsetFreq oldbuckets pagesInUse pagesSwept parseClass pauseStart pcExpander pluginpath preemptoff prefixRune printValue raceErrors raceignore readUnlock readerPass readerWait releaseAll removeNode removeSpan replaceAll rotateLeft runtimeCtx schedtrace selectdone sigContext signalLock sleepUntil stackcache stacks_sys startBytes startCycle storedSize sudogcache sweepSpans sysmonnote sysmontick sysmonwait tSweepTerm throwsplit ticksStart tinyallocs tinyoffset traceSweep traceSwept tracelastp treapalloc trimOutput tryGetFast userForced visitQueue waitreason widPresent workbufhdr writeBlock writeBytes writeLines sync/atomic **flag.Flag **runtime.g **runtime.m **runtime.p **sync.Pool **testing.T *[0]uintptr *[100]uint8 *[11]string *[128]uint8 *[129]uint8 *[12]string *[16]uint16 *[16]uint32 *[19]uint32 *[1][]int32 *[1]uintptr *[20]uint64 *[248]uint8 *[249]uint8 *[256]uint8 *[27]string *[29]uint32 *[2]uintptr *[32]uint32 *[3]uintptr *[44]uint32 *[4]uintptr *[512]uint8 *[67]uint16 *[67]uint64 *[6]uintptr *[800]uint8 *[82]uint16 *[8][]uint8 *[8]uintptr *[][]uint32 *complex128 *flag.Value *fmt.buffer *func() int *os.dirInfo *regexp.job *sync.Mutex *sync.entry *time.Month *time.Timer AllocsPerOp BuckHashSys DurationVar FieldByName FreeObjects HeapObjects LabelValues LatinOffset LoadOrStore MCacheInuse MarshalJSON MarshalText MatchReader MatchString Nanoseconds NumForcedGC OverflowInt RunParallel SetDeadline SetMapIndex StackRecord SubexpNames WriteString acquiretime allocManual alloc_bytes appendGroup arena_alloc arena_start assistQueue bgMarkReady bitmapCount bytesMarked checkBucket clearMarked codegenFreq createstack dirtyLocked dynamicSize ensureSwept fillDeflate findfunctab fmt_boolean fmt_integer fmt_unicode gccheckmark gcscanvalid hasOverflow heap_marked indexTokens indirectkey initDeflate inputReader inputString isLargeSpan it_interval literalFreq lookupMaybe maxParallel maybeConcat mspan_inuse nStackRoots newSigstack newoverflow next_sample nlargealloc noldbuckets npausesweep numforcedgc overflowBuf parallelism parseEscape parseRepeat pbValueType precPresent preemptible preemptscan prefixBytes prepareRead readMapping readerCount reclaimList releasetime rotateRight runtimehash safePointFn scheddetail set_sigaddr set_sigcode setoverflow shouldVisit speciallock stackguard0 stackguard1 startAllocs startBucket startEscape storeLocked stringIndex subexpNames syscalltick syscallwhen textsectmap total_alloc uncacheSpan unknownType unusedsince updateWidth waittraceev waitunlockf wakeupExtra wholeRegexp writeString writeTokens writeUnlock wroteHeader A` internal/cpu unicode/utf8 **sync.entry *[1024]uint8 *[106]string *[11]float32 *[128]uint16 *[139]uint16 *[23]float64 *[256]uint32 *[256]uint64 *[257]uint32 *[32]uintptr *[33]float64 *[33]uintptr *[378]uint32 *[4096]uint8 *[462]uint16 *[50]uintptr *[5140]uint8 *[64]uintptr *[67]uintptr *[8][]uint32 *[][16]int32 *[][]uintptr *[]struct {} *[]time.zone *chan string *crc32.Table *flate.hcode *flate.token *func() bool *gzip.Header *gzip.Writer *io.WriterTo *os.FileInfo *os.FileMode *os.fileStat *runtime.hex *runtime.mOS *sync.noCopy *syntax.Inst *syntax.Prog *syntax.frag *sys.Uintreg AllocObjects AppendFormat AssignableTo CanInterface ExpandString FieldByIndex FindAllIndex FindSubmatch FixedDecimal HasPCLMULQDQ HeapReleased InUseObjects MatchRunePos MethodByName OverflowUint PauseTotalNs Readdirnames ReportAllocs RuntimeError atomicstatus bgScanCredit buckhash_sys defaultUsage deferpoolbuf dequeueSudoG enlistWorker gcAssistTime gcpacertrace gfreeNoStack goidcacheend heap_objects idleMarkTime last_gc_unix linktimehash markDoneSema markrootDone markrootJobs markrootNext mcache_inuse mig_encoding missingBytes modulehashes morePointers nextCharFreq nextOverflow nextPairFreq nmidlelocked onePassRunes overflowTime paniconfault preparePanic prepareWrite processBench readdirnames reflexivekey rescheduling sameSizeGrow setArenaUsed shutdownSema stacks_inuse startMessage sweepWaiters sysexitticks takeOverflow triggerRatio tryBacktrack waitCanceled waitParallel writePadding (0 8(@0H8P@XH`PhXp`xhpxȬЬجȰаذ (0 8(@0H8P@XH`PhXp`xhpxȭЭحȱбر (0 8(@0H8P@XH`PhXp`xhpxȮЮخȲвز (0 8(@0H8P@XH`PhXp`xhpxȯЯدȳгسp 0@P`p   0 @ P ` p     0 @ P ` p    0 @ P ` p     0 @ P ` p    0 @ P ` p     0 @ P ` p    0 @ P ` p     0 @ P ` p    0 @ P ` p     0 @ P ` p  0@P`p 0@P`p 0@P`p 0@P`p 0@P`p 0@P`p pdppppphpp p0plptp pxp~pppppppppppppppppppppppppppppp^pdpppppppppppp pp(ppp p@p`p$ptpzpp(pppppp*pppp,p0ppppp4ppp6p.p8p4p@pp<p^ppdpjp@ppApppppBpCppDpppHpppLpppNppPp p@p5 p 5 pp p pTp`plpXp pZpp` dh 0lt x~^d ( @`$tz(*,046.84@<^dj@ABCDHLNP @5  5   T`lX Z` compress/gzip internal/poll regexp/syntax runtime/pprof *[128]uintptr *[253]uintptr *[64488]uint8 *[65528]uint8 *[8][]uintptr *[8]struct {} *[]*flag.Flag *[]*runtime.g *[]*runtime.p *[]*sync.Pool *[]*testing.T *[]regexp.job *atomic.Value *bufio.Writer *bytes.Buffer *bytes.Reader *bytes.readOp *flag.FlagSet *flate.Writer *flate.byFreq *fmt.Stringer *fmt.fmtFlags *func() int64 *func(func()) *interface {} *os.LinkError *os.PathError *poll.fdMutex *pprof.memMap *reflect.Kind *reflect.Type *reflect.flag *reflect.name *regexp.entry *regexp.input *regexp.queue *runtime.Func *runtime.bmap *runtime.hmap *runtime.itab *runtime.name *runtime.note *sync.RWMutex *syntax.Error *syntax.Flags *time.Weekday AssignDecimal Birthtimespec ConvertibleTo FindAllString GCCPUFraction InterfaceData LiteralPrefix MarshalBinary OverflowFloat PrintDefaults SetsockoptInt UnmarshalJSON UnmarshalText ZeroReadIsEOF __sigaction_u bitmap_mapped byteAvailable cgoCallersUse checknonempty errorHandling firstZoneUsed flushToParent footerWritten gcAssistBytes handleMethods headerWritten heap_released incrnoverflow indirectvalue isCheckmarked isSpanInTreap leadingRegexp leadingString local_nlookup markStartTime missingMethod msgh_reserved needkeyupdate newInputBytes nextFreeIndex oldbucketmask safePointNote safePointWait stackExpander startParallel startingtrace terminateCell waittraceskipcompress/flatetext/tabwriter**runtime.bmap**runtime.hmap**runtime.itab*[0]*sync.Pool*[1000]uintptr*[16][16]int32*[32768]uint32*[8]*flag.Flag*[]*sync.entry*[]crc32.Table*[]flate.hcode*[]flate.token*[]syntax.Inst*atomic.noCopy*flag.boolFlag*flag.intValue*fmt.Formatter*func() string*func(float64)*io.ReaderFrom*io.RuneReader*metrics.Timer*poll.pollDesc*pprof.Profile*pprof.newFunc*pprof.profMap*reflect.Value*reflect.rtype*reflect.tflag*regexp.Regexp*regexp.thread*runtime.Frame*runtime._func*runtime._type*runtime.eface*runtime.gobuf*runtime.hchan*runtime.hiter*runtime.iface*runtime.mheap*runtime.mlink*runtime.mspan*runtime.mutex*runtime.slice*runtime.stack*runtime.sudog*runtime.tflag*runtime.timer*runtime.waitq*sort.lessSwap*sync.readOnly*syntax.InstOp*syntax.Regexp*syntax.parser*syntax.ranges*syscall.Errno*syscall.Iovec*testing.Cover*time.Duration*time.LocationReplaceAllFuncRoundedIntegerSetParallelismSetsockoptByteStopCPUProfileWriteProfileToallocfreetracearena_reservedassertedStringcanCheckPrefixcanWriteRecordconcreteStringcreateOverflowfreeSpanLockedgcBgMarkWorkergcrescanstacksgcstoptheworldincrefAndClosemanualFreeListmaxBitStateLenmaxInsertIndexmustBeExportednewInputReadernewInputStringoffsetEncodingparseClassCharparsePerlFlagspause_total_nsprefixCompleteprocresizetimerunSafePointFnsetCheckmarkedsysblocktracedtraceBufHeadertraceReclaimedtryLoadOrStorewriteBlockHuffencoding/binary**pprof.Profile**reflect.rtype**regexp.thread**runtime._type**runtime.hchan**runtime.mspan**runtime.sudog**runtime.timer**syntax.Regexp*[131072]uint32*[8]*sync.entry*[]interface {}*[]pprof.memMap*[]reflect.Type*[]regexp.entry*chan struct {}*flag.boolValue*flag.uintValue*fmt.GoStringer*func() []uint8*func() uintptr*func(chan int)*func(int) bool*func(int, int)*lv.LabelValues*map[string]int*pprof.labelMap*pprof.protobuf*reflect.Method*reflect.method*regexp.machine*runtime.Frames*runtime._defer*runtime._panic*runtime.bucket*runtime.dbgVar*runtime.gcBits*runtime.gcMode*runtime.gcWork*runtime.gclink*runtime.lfnode*runtime.mTreap*runtime.mcache*runtime.mstats*runtime.regs64*runtime.schedt*runtime.sigset*runtime.stackt*runtime.tmpBuf*sort.Interface*sync.poolLocal*syntax.EmptyOp*syscall.Stat_t*tabwriter.cell*testing.common*time.zoneTrans*unsafe.PointerCoveredPackagesFieldByNameFuncFindAllSubmatchFindReaderIndexFindStringIndexMatchEmptyWidthObserveDurationOverflowComplexSetReadDeadlineShortestDecimalStartCPUProfileUnmarshalBinaryaddLostAtomic64allocSpanLockedcodegenEncodingexportedMethodsfastSkipHashinggc_cpu_fractiongenerateCodegeninitialHeapLiveinterfaceStringliteralEncodinglocal_largefreelookupFirstZonemarkBitsForBasemsgh_local_portpagesSweptBasisparseNamedClassparseRightParenpersistentAllocshowAllocResultswapVerticalBarunexpungeLocked**regexp.machine**runtime._defer**runtime._panic*[129]*runtime.g*[1]interface {}*[2]interface {}*[3]interface {}*[4]interface {}*[5]interface {}*[7]interface {}*[8]interface {}*[]*runtime.bmap*[]*runtime.itab*[]pprof.newFunc*[]reflect.Value*[]runtime.Frame*[]syscall.Iovec*flag.int64Value*flate.byLiteral*flate.levelInfo*func(int) error*io.stringWriter*map[uintptr]int*os.SyscallError*pprof.msgOffset*reflect.ChanDir*reflect.imethod*reflect.mapType*reflect.nameOff*reflect.ptrType*reflect.textOff*reflect.typeAlg*reflect.typeOff*regexp.bitState*regexp.regexpRO*runtime.functab*runtime.funcval*runtime.imethod*runtime.keventt*runtime.lfstack*runtime.libcall*runtime.machndr*runtime.maptype*runtime.nameOff*runtime.profBuf*runtime.ptrtype*runtime.rwmutex*runtime.sigTabT*runtime.sigctxt*runtime.siginfo*runtime.special*runtime.textOff*runtime.timeval*runtime.typeAlg*runtime.typeOff*runtime.workbuf*strconv.decimal*sync.notifyList*syntax.compiler*syscall.mmapper*testing.matcher*unicode.Range16*unicode.Range32ReplaceAllStringSetWriteDeadlineSetsockoptIPMreqSetsockoptLingerWriteHeapProfilecompressionLevelgcMarkWorkerModegcshrinkstackoffhelperDrainBlocklast_gc_nanotimelocal_nlargefreelocal_nsmallfreelocal_tinyallocsmarkBitsForIndexmarkWorkerLabelsmsgh_remote_portmustBeAssignablenFlushCacheRootsparseVerticalBarpreviousDurationrefillAllocCachetryExpungeLockedtryGrowByReslicewriteFixedHeaderwriteStoredBlock A`**[]*runtime.bmap**runtime.funcval**runtime.maptype**runtime.ptrtype**runtime.special*<-chan time.Time*[1025]*runtime.p*[8]pprof.newFunc*[]*pprof.Profile*[]*reflect.rtype*[]*regexp.thread*[]*runtime._type*[]*runtime.mspan*[]*runtime.sudog*[]*runtime.timer*[]*syntax.Regexp*[]reflect.method*[]runtime.dbgVar*[]runtime.gcBits*[]sync.poolLocal*[]tabwriter.cell*[]time.zoneTrans*[]unsafe.Pointer*binary.ByteOrder*binary.bigEndian*context.emptyCtx*flag.stringValue*flag.uint64Value*flate.compressor*flate.dictWriter*flate.tableEntry*func() time.Time*func(*flag.Flag)*func(*runtime.g)*func(*runtime.p)*func(*testing.B)*func(*testing.T)*func(error) bool*func(int32) bool*map[string]int64*reflect.chanType*reflect.funcType*regexp.runeSlice*runtime.MemStats*runtime.chantype*runtime.divMagic*runtime.finblock*runtime.fixalloc*runtime.funcInfo*runtime.functype*runtime.guintptr*runtime.heapBits*runtime.mapextra*runtime.markBits*runtime.mcentral*runtime.muintptr*runtime.parkInfo*runtime.pollDesc*runtime.puintptr*runtime.semaRoot*runtime.stackmap*runtime.stkframe*runtime.stringer*runtime.textsect*runtime.timespec*runtime.traceBuf*sort.StringSlice*strconv.NumError*strconv.extFloat*syntax.ErrorCode*syntax.charGroup*syntax.patchList*syscall.Timespec*syscall.attrList*tabwriter.Writer*testing.indenter*testing.testDeps*unicode.foldPair*utf8.acceptRangeAllocedBytesPerOpFindSubmatchIndexReplaceAllLiteralallocBitsForIndexassistWorkPerBytededicatedMarkTimeincrementOverflowinitCheckmarkSpanparseUnicodeClasspoolLocalInternalsweepPagesPerBytewriteBlockDynamicwriteStoredHeader**runtime.mapextra*[0]tabwriter.cell*[1]*syntax.Regexp*[1]unsafe.Pointer*[4]*reflect.rtype*[8]*pprof.Profile*[8]*reflect.rtype*[8]*runtime._type*[8]unsafe.Pointer*[]*regexp.machine*[]*runtime._defer*[]*runtime.bucket*[]flate.levelInfo*[]reflect.imethod*[]runtime.functab*[]runtime.imethod*[]runtime.keventt*[]runtime.sigTabT*[]runtime.typeAlg*[]runtime.typeOff*[]unicode.Range16*[]unicode.Range32*atomic.ifaceWords*flag.float64Value*flate.deflateFast*flate.literalNode*func(string) bool*interface { M() }*map[string]uint64*metrics.Histogram*poll.TimeoutError*pprof.keysByCount*reflect.StructTag*reflect.arrayType*reflect.bitVector*reflect.fieldScan*reflect.layoutKey*reflect.sliceType*regexp.inputBytes*runtime._typePair*runtime.bitvector*runtime.finalizer*runtime.gcTrigger*runtime.gclinkptr*runtime.itimerval*runtime.mSpanList*runtime.memRecord*runtime.pollCache*runtime.profIndex*runtime.ptabEntry*runtime.spanClass*runtime.sweepdata*runtime.treapNode*strconv.floatInfo*strconv.leftCheat*tabwriter.osError*testdeps.TestDeps*time.runtimeTimer*unicode.CaseRangeFindAllStringIndexFindStringSubmatchSetsockoptIPv6MreqassistBytesPerWorkcanWriteTwoRecordsclearCheckmarkSpanfractionalMarkTimesetMarkedNonAtomicsweepHeapLiveBasiswriteDynamicHeader**runtime.treapNode*[0]unicode.Range16*[14]runtime.dbgVar*[16]*reflect.rtype*[1]unicode.Range16*[1]unicode.Range32*[2]runtime.keventt*[2]unicode.Range16*[2]unicode.Range32*[32]*reflect.rtype*[3]unicode.Range16*[3]unicode.Range32*[4]unicode.Range16*[4]unicode.Range32*[5]*runtime._defer*[5]unicode.Range16*[5]unicode.Range32*[64]*reflect.rtype*[6]unicode.Range16*[6]unicode.Range32*[7]unicode.Range16*[7]unicode.Range32*[8]runtime.typeOff*[8]unicode.Range16*[8]unicode.Range32*[9]unicode.Range16*[]*[]*runtime.bmap*[][]*runtime._type*[][]tabwriter.cell*[]flate.tableEntry*[]runtime.divMagic*[]runtime.guintptr*[]runtime.textsect*[]strconv.extFloat*[]syntax.charGroup*[]unicode.foldPair*[]utf8.acceptRange*errors.errorString*flag.ErrorHandling*flag.durationValue*func() (int, bool)*func() os.FileMode*func(string) error*map.hdr[string]int*map[*uint8][]uint8*pprof.countProfile*pprof.profMapEntry*pprof.stackProfile*reflect.ValueError*reflect.layoutType*reflect.structType*regexp.inputReader*regexp.inputString*regexp.onePassInst*regexp.onePassProg*runtime.adjustinfo*runtime.bucketType*runtime.cgoCallers*runtime.cpuProfile*runtime.gcSweepBuf*runtime.mSpanState*runtime.machheader*runtime.moduledata*runtime.modulehash*runtime.pcExpander*runtime.plainError*runtime.profAtomic*runtime.randomEnum*runtime.sigactiont*runtime.sysmontick*runtime.traceAlloc*runtime.traceFrame*runtime.traceStack*runtime.workbufhdr*testing.CoverBlock*time.fileSizeError*unicode.RangeTableAssignComputeBoundsSetsockoptInet4AddrremoveLeadingRegexpremoveLeadingStringspecialprofileallocruntime/internal/sys**pprof.profMapEntry**regexp.onePassProg**runtime.moduledata**unicode.RangeTable*[1009]*runtime.itab*[10]unicode.Range16*[11]unicode.Range16*[128]*reflect.rtype*[128]*runtime.sudog*[12]unicode.Range16*[134]*runtime.mspan*[13]unicode.Range16*[13]unicode.Range32*[14]runtime.typeAlg*[14]unicode.Range16*[15]unicode.Range16*[15]unicode.Range32*[16]flate.levelInfo*[16]unicode.Range16*[16]unicode.Range32*[17]unicode.Range32*[18]unicode.Range16*[20]unicode.Range16*[21]unicode.Range16*[22]unicode.Range16*[22]unicode.Range32*[23]unicode.Range16*[25]unicode.Range16*[28]unicode.Range16*[2]*[]*runtime.bmap*[31]unicode.Range16*[31]unicode.Range32*[32]*runtime._defer*[32]runtime.sigTabT*[32]unicode.Range16*[33]unicode.Range16*[33]unicode.Range32*[35]unicode.Range32*[36]unicode.Range32*[37]unicode.Range16*[40]unicode.Range16*[40]unicode.Range32*[43]unicode.Range16*[44]unicode.Range16*[47]unicode.Range32*[48]unicode.Range32*[58]unicode.Range32*[5]utf8.acceptRange*[62]unicode.Range32*[63]unicode.Range16*[64]runtime.keventt*[64]unicode.Range32*[66]unicode.Range16*[66]unicode.Range32*[70]unicode.Range16*[72]unicode.Range32*[77]unicode.Range32*[8][]*runtime._type*[8]strconv.extFloat*[8]syntax.charGroup*[93]unicode.Range16*[96]unicode.Range16*[][]*runtime._defer*[]flate.literalNode*[]reflect.fieldScan*[]runtime._typePair*[]runtime.finalizer*[]runtime.mSpanList*[]runtime.ptabEntry*[]strconv.leftCheat*[]unicode.CaseRange*binary.littleEndian*crc32.slicing8Table*flate.InternalError*func() interface {}*func() reflect.Kind*func() reflect.Type*func(int) []uintptr*func(int, int) bool*map.hdr[uintptr]int*map[string][]uint32*reflect.StructField*reflect.methodValue*reflect.sliceHeader*reflect.structField*regexp.queueOnePass*runtime.StackRecord*runtime.blockRecord*runtime.errorString*runtime.gcBitsArena*runtime.gobitvector*runtime.inlinedCall*runtime.randomOrder*runtime.structfield*runtime.traceBufPtr*runtime.usigactiont*testing.testContextFindAllSubmatchIndexReplaceAllStringFuncfindRunnableGCWorkerparsePerlClassEscapertype reflect:"map"rtype reflect:"ptr"*[0]reflect.fieldScan*[101]unicode.Range16*[102]unicode.Range16*[103]unicode.Range16*[109]unicode.Range16*[112]unicode.Range16*[117]unicode.Range16*[121]unicode.Range16*[127]unicode.Range16*[140]unicode.Range32*[146]unicode.Range16*[173]unicode.Range16*[176]unicode.Range16*[179]unicode.Range32*[1]reflect.fieldScan*[280]unicode.Range16*[357]unicode.Range16*[4]runtime.mSpanList*[5][]*runtime._defer*[67]runtime.divMagic*[87]strconv.extFloat*[88]unicode.foldPair*[8]runtime._typePair*[]pprof.profMapEntry*[]regexp.onePassInst*[]runtime.gcSweepBuf*[]runtime.modulehash*[]testing.CoverBlock*flate.huffmanEncoder*func(*os.file) error*func(*runtime.gobuf)*func([]uint8) uint16*func([]uint8) uint32*func([]uint8) uint64*map.hdr[string]int64*map[string]struct {}*pprof.profileBuilder*pprof.runtimeProfile*reflect.stringHeader*reflect.uncommonType*runtime.forcegcstate*runtime.gcDrainFlags*runtime.gsignalStack*runtime.pcvalueCache*runtime.stringStruct*runtime.uncommontype*strconv.decimalSlice*testing.InternalTest*testing.benchContextFindAllStringSubmatchassignEncodingAndSizertypereflect:"chan"rtypereflect:"func"specialfinalizeralloc*[256]runtime.guintptr*[26]runtime.mSpanList*[2]runtime.gcSweepBuf*[61]strconv.leftCheat*[65520]runtime.gcBits*[]*pprof.profMapEntry*[]*reflect.structType*[]*runtime.moduledata*[]*unicode.RangeTable*[][32]*runtime._defer*[]reflect.structField*[]runtime.StackRecord*[]runtime.inlinedCall*func() *reflect.rtype*func([]uint8, uint16)*func([]uint8, uint32)*func([]uint8, uint64)*func(io.Writer) error*map.bucket[string]int*map.hdr[string]string*map.hdr[string]uint64*map[string]*flag.Flag*reflect.interfaceType*runtime.gcTriggerKind*runtime.interfacetype*runtime.stackExpander*runtime.stackfreelist*runtime.traceStackPtraddCountsAndClearFlagsrtypereflect:"array"rtypereflect:"slice"*[100000]unsafe.Pointer*[101]runtime.finalizer*[128]runtime.mSpanList*[304]unicode.CaseRange*[5]*unicode.RangeTable*[5][32]*runtime._defer*[8]*pprof.profMapEntry*[8]*reflect.structType*[8]*unicode.RangeTable*[][]testing.CoverBlock*[]testing.InternalTest*flate.compressionLevel*flate.huffmanBitWriter*func() reflect.ChanDir*func([]uintptr) string*func(fmt.State, int32)*func(func(*runtime.g))*func(int) (int32, int)*func(int) reflect.Type*map.bucket[uintptr]int*map.hdr[*uint8][]uint8*map.iter[string]string*reflect.emptyInterface*reflect.funcTypeFixed4*reflect.funcTypeFixed8*runtime.cgothreadstart*runtime.memRecordCycle*runtime.traceBufHeader*sync.poolLocalInternalFindReaderSubmatchIndexFindStringSubmatchIndexReplaceAllLiteralStringrtypereflect:"struct"*[16384]flate.tableEntry*[179999]*runtime.bucket*[3]testing.InternalTest*[8][]testing.CoverBlock*[]runtime.stackfreelist*[]runtime.traceStackPtr*func(*flate.compressor)*func([]uint8, []uint32)*func(reflect.Type) bool*generic.SimpleHistogram*map.bucket[string]int64*map.hdr[string][]uint32*reflect.funcTypeFixed16*reflect.funcTypeFixed32*reflect.funcTypeFixed64*runtime.cgoTracebackArg*runtime.pcvalueCacheEnt*runtime.persistentAlloc*runtime.profBufReadMode*runtime.traceAllocBlock*runtime.traceStackTable*testing.BenchmarkResult*testing.InternalExampleApproximateMovingAveragetesting/internal/testdeps*[4]runtime.stackfreelist*[]flate.compressionLevel*[]runtime.memRecordCycle*func(int) reflect.Method*func(int) syntax.EmptyOp*map.bucket[string]string*map.bucket[string]uint64*map.hdr[string]struct {}*map.iter[string][]uint32*map[int32]unsafe.Pointer*map[unsafe.Pointer]int32*reflect.funcTypeFixed128*runtime.MemProfileRecord*runtime.cgoSymbolizerArg*runtime.gcMarkWorkerMode*runtime.semaProfileFlagsfractionalUtilizationGoal*[3]runtime.memRecordCycle*[]runtime.pcvalueCacheEnt*[]testing.InternalExample*func(*regexp.Regexp) bool*func(string) (int, error)*func(uint32, []bool) bool*map.bucket[*uint8][]uint8*map.hdr[string]*flag.Flag*map[string]*pprof.Profile*reflect.nonEmptyInterface*runtime.gcControllerState*testing.InternalBenchmarkFindAllStringSubmatchIndexdedicatedMarkWorkersNeededrtypereflect:"interface"*[0]testing.InternalExample*[10]flate.compressionLevel*[]runtime.MemProfileRecord*func() (int32, int, error)*func([]uint8) (int, error)*func(io.Writer, int) error*map.bucket[string][]uint32*map.iter[string]*flag.Flag*map[interface {}][]uintptr*runtime.BlockProfileRecord*runtime.TypeAssertionError*runtime.traceAllocBlockPtrfractionalMarkWorkersNeeded*[16]runtime.pcvalueCacheEnt*[8192]runtime.traceStackPtr*[]testing.InternalBenchmark*func(interface {}, uintptr)*map.bucket[string]struct {}*map[*reflect.structType]int*map[string]syntax.charGroup*map[uint32][]*runtime._typegithub.com/go-kit/kit/metrics*[0]testing.InternalBenchmark*[1048576]runtime.inlinedCall*[]runtime.BlockProfileRecord*func() *reflect.uncommonType*func(uint32, []uint8) uint32*func(uintptr, uintptr) error*map.bucket[string]*flag.Flag*map.hdr[int32]unsafe.Pointer*map.hdr[unsafe.Pointer]int32*map[*reflect.structType]bool*map[interface {}]*sync.entry*func(*regexp.Regexp, int) int*func(int) reflect.StructField*map.hdr[string]*pprof.Profile*runtime.neverCallThisFunction*struct { F uintptr; r int32 }*func(io.Reader) (int64, error)*func(io.Writer) (int64, error)*map.hdr[interface {}][]uintptr*map[string]*unicode.RangeTable *func(*runtime.funcval, uintptr) *func([]int) reflect.StructField *map.bucket[int32]unsafe.Pointer *map.bucket[unsafe.Pointer]int32 *map.hdr[*reflect.structType]int *map.hdr[string]syntax.charGroup *map.hdr[uint32][]*runtime._type *map.iter[interface {}][]uintptr *map[runtime._typePair]struct {} *map[string][]testing.CoverBlock *map[uintptr]*pprof.profMapEntry *struct { F uintptr; is []int8 }!*map.bucket[string]*pprof.Profile!*map.hdr[*reflect.structType]bool!*map.hdr[interface {}]*sync.entry!*struct { F uintptr; is []int16 }!*struct { F uintptr; is []int32 }!*struct { F uintptr; is []int64 }"*func(*int, *[]int32, uint32) bool"*func(*reflect.rtype) reflect.Type"*func(...string) metrics.Histogram"*map.bucket[interface {}][]uintptr"*map.iter[interface {}]*sync.entry"*struct { F uintptr; hash uint32 }"*struct { F uintptr; name string }"*struct { F uintptr; ss []string }"*struct { b bool; x interface {} }"*struct { sync.Mutex; dir string }"*struct { sync.Mutex; m sync.Map }#*func(string, io.Writer, int) error#*func(string, string) (bool, error)#*map.bucket[*reflect.structType]int#*map.bucket[string]syntax.charGroup#*map.bucket[uint32][]*runtime._type#*map.hdr[string]*unicode.RangeTable#*map[runtime.typeOff]*runtime._type#*struct { F uintptr; b *testing.B }#*struct { F uintptr; ret *uintptr }$*func(runtime.neverCallThisFunction)$*func(string) (reflect.Method, bool)$*map.bucket[*reflect.structType]bool$*map.bucket[interface {}]*sync.entry$*map.hdr[runtime._typePair]struct {}$*map.hdr[string][]testing.CoverBlock$*map.hdr[uintptr]*pprof.profMapEntry$*struct { F uintptr; gp *runtime.g }$*struct { F uintptr; line *[]uint8 }$*struct { F uintptr; mp *runtime.m }%github.com/go-kit/kit/metrics/generic%*[]map[runtime.typeOff]*runtime._type%*func(*flate.compressor, []uint8) int%*func(unsafe.Pointer, unsafe.Pointer)%*struct { F uintptr; _g_ *runtime.g }&*func(*runtime.g, unsafe.Pointer) bool&*func(unsafe.Pointer, uintptr) uintptr&*map.bucket[string]*unicode.RangeTable&*struct { F uintptr; R *flag.FlagSet }&*struct { F uintptr; f *flag.FlagSet }&*struct { cycle uint32; flushed bool }'*map.bucket[runtime._typePair]struct {}'*map.bucket[string][]testing.CoverBlock'*map.bucket[uintptr]*pprof.profMapEntry'*map.hdr[runtime.typeOff]*runtime._type'*struct { F uintptr; c *runtime.hchan }'*struct { F uintptr; e *runtime.eface }'*struct { F uintptr; preemptible bool }'*struct { F uintptr; startTime *int64 }'*struct { F uintptr; x *reflect.rtype }'*struct { signalLock uint32; hz int32 }(*func([]runtime.StackRecord) (int, bool)(*struct { F uintptr; buf *bytes.Buffer }(*struct { F uintptr; c *runtime.mcache }(*struct { F uintptr; s **runtime.mspan })github.com/go-kit/kit/metrics/internal/lv)*func(string) (reflect.StructField, bool))*func(uintptr, uintptr, uintptr, uintptr))*struct { F uintptr; R testing.testDeps })*struct { F uintptr; r *int32; ns int64 }**func(unsafe.Pointer, unsafe.Pointer) bool**map.bucket[runtime.typeOff]*runtime._type**struct { F uintptr; m *runtime.MemStats }**struct { F uintptr; ps []unsafe.Pointer }**struct { F uintptr; rw *runtime.rwmutex }+*func(unsafe.Pointer, unsafe.Pointer) int32-*func(*runtime.stkframe, unsafe.Pointer) bool-*func(uint64, uint64, uint64, string, string).*struct { F uintptr; R *pprof.profileBuilder }0*func(reflect.Value, reflect.Type) reflect.Value0*struct { F uintptr; dst *uintptr; src uintptr }0*struct { F uintptr; pp *runtime.p; sc uintptr }0*struct { F uintptr; src uintptr; dst *uintptr }0*struct { root runtime.semaRoot; pad [40]uint8 }1*struct { F uintptr; sp uintptr; _g_ *runtime.g }2*[]struct { root runtime.semaRoot; pad [40]uint8 }2*struct { runtime.mutex; runtime.persistentAlloc }3*struct { F uintptr; gp *runtime.g; traceskip int }3*struct { F uintptr; oldval uint32; newval uint32 }3*struct { F uintptr; p []runtime.MemProfileRecord }3*struct { F uintptr; tests []testing.InternalTest }3*struct { mcentral runtime.mcentral; pad [8]uint8 }4*func(func(string) bool) (reflect.StructField, bool)4*struct { F uintptr; gp *runtime.g; _p_ *runtime.p }4*struct { F uintptr; gp *runtime.g; scanWork int64 }4*struct { F uintptr; siz int32; d **runtime._defer }hb6"Tđm6"TF`? 6"T q36"T&gZ6"TޥTE6"T3=6"Tbw}'r6"T9o2;6"TL >6"T@xFF6"TA~ H_6"Tؑ6"TF>!6"TO6"TR~ Ư6"Tc~cBF6"T Gm%6"T  56"T`cf[6"T 6"T,/Jl6"TG6"T6"T n;6"T> u6"TPI$6"T`=)6"T҄b4^6"Tǥa6"T&Gcɐ6"TP`ڨL6"T4Gw6"T3)e;6"T c@6"T `Y6"Tt~6"T$2@Q66"T+{!6"T !c6"T02!?"6"T`&,M6"T%P&O&z6"T4P`)C6"T^G)6"Th@+yCh6"TG@.6"Tqb/b\6"Tɞ`2g66"Tߞ5?R6"TY< 6q16"T96"T <"l6"TG<5@6"T <H$A6"T<2@=56"Tr=>#6"TX>l.!6"T<`>X6"T<>~o6"T< ?~[6"TH2?sKt6"TG?Ř6"T3A ]6"TaPD+Ad6"TAENh6"TF[dp6"TH@I3[6"Tl2@Ls-q6"TLw^6"TJM f<6"T<MKt6"T0H@OM'6"TcQ `6"T=R?6"TS6}6"TP TK6"TPT6"TY + 6"T=Yqwb6"TH`'" 6"T2@a-l6"Taik6"TC=bG6"T2 c6"TPd?@6"T`hu6"TP=h>!6"TcjUD6"TbkVSr6"TlJ6"T#cpY6"T=s46"Tы@vͿ6"T=v`FȾ6"TH xZe$Q6"Ty6"Tr`zjw,P6"TP {:6"T{h6"T= ~X/6"T 9Q6"T`Q">d6"TK;6"Tƙ6"T`L޻6"TǴ`+v6"TA6"TȒ 6"T>`Pi6"Tn6"T~`1R6"T `#Ybb6"TI)\~m#6"TT),N6"T_) yA%6"T `6"TXCX6"TxD6"Tѣ6"T`r6"T+p26"T`"v6"TD3Źt6"TV`J6"Tȕ6"T#`6"TT%?6"T\3i6"Tj)`/qE6"T:>r;6"T|  n6"T .6"T0y`+#6"THjz6"TT>g%6"T=6"Tc6"T'eP6"T(F;6"TQ!cV6"T eܮX6"T86"T` 3 a6"Ta> *6"TIr6"T/`Q6"T) V6"T) Z?\6"TQ=^6"TG6"Tn>`C*6"Tpy46"Ty@NBI6"Tm 8KЙ6"Tk96"T`m6"T)kk6"TUW6"TQ >6"T?"%6"Tf6"T&Xk6"T$ &6"T-`_6"TO6"Ty@N!6"Tu)`'s6"T{>r=6"T 6"Tּ}6"T>%sf6"TQuk6"T6"TkM6"TL`Hc;6"T 9A6"T3ŭ6"TE~W6"T`ȓQ6"T 6Y6"T 6"T 146"T`Dm6"T 76"Te6"Toɾ̜6"Tڵ`6"T |6"Trte6"T6"T`n6"TԽ A6"T{f W6"T٩36"T `6"TV d76"T@56"T686"Tӿ@:/}a6"T@?Ƽ6"T@DQ,E6"Thoh6"TQ )G̋6"T,Iچ\6"Tʆ 6"T`cf6"Tz`_$U\6"T[+6"Tӛ@,?6"T0z86"T@1}6"TӢ`hI6"T܆lLoZ6"T%0 6"T:6q6"T 1׬D6"T<F6"T36"T` p6"T`6"Ts`4ӫ!6"T㲜6"T@z5@ 6"TPz$l!E6"T:I@6"TA S6"T`z@6$46"Trrj6"T?6q 6"Th'6"Tz `?\6"T< 8SB6"TnR8QU6"TP BW6"T @ä6"T vu6"TaO6"T$ ˠ6"T':S6"TW6"T<:Ͷ6"T@;jr6"TmI6"T,6"T!=36"T` /6"T?4i6"T4(g6"TH;6"TH n.6"T<*m6"TQ`K6"T\@@6"TȲkR6"T =0(66"Tҍ`w6"T> X6"T _46"T`$6"Tl6"TW&J6"T16"Tݭ=~mp6"T"g6"Tܒ6"T#R @#6"To\6"Tǀ`>oc6"T?%?6"T`xY6"Tpt y6"Tz+M s6"T?"5#6"T 6"T@@6S6"TM76"T> `6"T2R@qV6"Tţ7&6"Tۣ 06"T1,k6"Tԕ B!w!6"TD@tTH6"TB W6"TL\n6"T M0 6"T=56"T؇`آq6"T `: .6"TW6"T#` %6"TzLE6"T>`(246"T$`CW)6"T`jh6"T)@KD]6"TDD*AL*6"T8uGF 6"T_`$]Y6"T@E 06"T}E'6"Ts*6"T ZXR6"Tо~?6"T G,?6"Tu\ 6"TɎYM_6"TwRT6"T3q66"T܎iR6"T-`H6"TI 2ع6"Ttjk6"T `8(QM6"T@[(ά6"T(I-6"T?6"T> @w6"T#Ď66"T Y`6"T S \6"Tz36"TO`{o6"T`ژ.v6"TĖ@J56"T2>A6"TzKeK6"TݹlX6"T֦6"TL 6"T(1,6"T@$h6"TP6"TN6g6"T}R `6"T{"6"TLE6"TyO;6"T ̲6"T. 6"T `6"TD56"TPLzE6"TX`AS6"TMј6"Tb QZZ6"T!`_>6"T#Id6"TK`~ɩ6"TA6"TL`K6"T"^6"T`ml6"T!z6"TE`gG<6"TnftJc6"TG`6"Tch6"T#(m6"Tl`Pw6"TYie6"T{Yg6"Th`I6"T"VD6"Tc{`ff.e6"T| k6"T7bju6"T "&]6"TD` rH6"TC@06"T6"Tmsrr6"Tdo_6"T!{`pF6"Tm?6"T(qj6"T`6"TA~o6"T`46"T .6"TA`h6"T>6"TAq6"T`{,6"TW_ ׁ6"TuO/6"TYhR/6"T0P,6"Tasq6"T`u6"T^ =6"TH`:ۙ6"ThB tՅ{6"Ta_6"TSpH6"TšT6"Tzv 6"Tx%s6"T `6"T *06"TGVo6"T˼ 6"Tp`WA̠6"TX|i6"T 6"Twv6"TlY&6"T1?@6"T x6"T.6"T$!l6"T.! t/6"T8!`&ٚ6"T6`^ŋ6"T)agh6"T6"T̍.6"T=7^6"T%@~+6"T>?@7+6"TȗYc@6"TܗZA26"Tˆ 5*[251]struct { root runtime.semaRoot; pad [40]uint8 }5*[]struct { mcentral runtime.mcentral; pad [8]uint8 }5*struct { F uintptr; bs []testing.InternalBenchmark }5*struct { F uintptr; p []runtime.BlockProfileRecord }5*struct { Size uint32; Mallocs uint64; Frees uint64 }5*struct { lock runtime.mutex; head runtime.guintptr }5*struct { size uint32; nmalloc uint64; nfree uint64 }6@"T٠An@"Tx`Ҳ@"Tx LKS@"T`85J@"T p@"T`W$@"Tw/2|@"Tƙ?O@"T@x"@"T  @"TۙB̰@"Tx+Gp@"T c@"TǴ` $LZ@"T/Q$m@"TxnX@"TȒ ݜ@"TܒF@"Tdb@,@"T@"TxcEZ@"T~`7C@"Tx͏@"T83 M@"T`; @"TBQ 6T@"T@R[j @@"TY@"T g@"T> Kچu@"T #@"T`R@"TH}@"T>`T0 @"TQQ@"T sq@"TH Z @"T~@'Z@"T"Da@"Tp'@"T(@"T~z@"T > 037@"T-> ļ&^@"T~ f@"T  7@"TI) *Ms@"TT)` v@"T_)`b0@"T p/@"T @4V@"T%.@"T`_@"T0 r@"T@,f@"T09@"TY>@"T@]@"T΅5r{@"Tx`@m@"TH5T@"T  Ux@"T 8 @"T@(#~@"TC >@"TS:@"T+ `U+h@"T:@"T;@"T1  ~@"T`^@"T =@"T̫AT@"Td ObJ@"Tx4@"T%@4%N/@"T@E}@"TY G{@@"TI@"T]w@"T`p@"TnLc4@"T~@"T`O1 @"Tn[&@"T0`0@"TswHH&@"T QӨ @"TD3`֩@"TaqY@"TPA`\@"T`-@"Ta t̥@"T`Q׺@"T@S/@"TVU0P B@"T'(V@"T VoJ@"TB X@"T#``Wj@"TTIl&@"ToQ@:@"Th @^@"T  @"TP3ԑ@"T\3 ?i @"Th3`~.8@"Tj) 3]@"T:>`K@"T? j@"Tc@"TT5@"TYa2@"TZF<@"T| 3@"T!6*struct { lock runtime.mutex; pad uint32; val uint64 }6*struct { mu sync.Mutex; m map[string]*pprof.Profile }6*struct { sync.Mutex; profiling bool; done chan bool }7*[]struct { Size uint32; Mallocs uint64; Frees uint64 }7*[]struct { size uint32; nmalloc uint64; nfree uint64 }7*struct { F uintptr; newg *runtime.g; stacksize int32 }8*[134]struct { mcentral runtime.mcentral; pad [8]uint8 }8*func(*runtime.hchan, unsafe.Pointer, bool) (bool, bool)9*[61]struct { Size uint32; Mallocs uint64; Frees uint64 }9*[67]struct { size uint32; nmalloc uint64; nfree uint64 }9*func(*runtime.hchan, unsafe.Pointer, bool, uintptr) bool9*struct { F uintptr; gp *runtime.g; gcw *runtime.gcWork }:*struct { F uintptr; p unsafe.Pointer; b *runtime.bucket }:*struct { lock runtime.mutex; free [26]runtime.mSpanList };*func(uint32, *runtime.siginfo, unsafe.Pointer, *runtime.g)<*struct { F uintptr; b *pprof.profileBuilder; addr uintptr }<*struct { F uintptr; gp *runtime.g; pc uintptr; sp uintptr }<*struct { F uintptr; pc uintptr; sp uintptr; gp *runtime.g }Qe2"T( `"TW(>"T0y xH2"TG> Uq2"Tt32"T~Q`S^\2"TmT"TH`%y"TT>Zy"T@8 W"TKT`"TzA<"TDZ{"Tך`E"TiE"T@`FHt"T̓F8FF"T`Gl"TG>°"T)."T) ۉ3@"T] 3@"Tio%3@"T(`Tx3@"TQ 93@"TIa|3@"Ty`#3@"Tm`@3@"T#3@"Tq w3@"TW3@"T`_m3@"Tb` t3@"T0 }g3@"T:<3@"TU"Y&3@"TD`^\3@"TX3@"Tر\8=3@"Tlr3@"T!oe3@"TvS3@"TLQ6T3@"Ts 3@"Ty`O3@"T ĒI3@"TV`qS"T ΀p"T`A"T$?"T-'`"T ^"T: H v"T` H TpQ`"T H i/"T`H .IH`"Th`xp"TzxȔs`"T>x8uc"TmX Zs`"TZ ,X s%"TX Ц"TX T "Tl X v<"TW`X -"T#RX TT"T `MX `"TţX {m"TWX "TI`NX @ t"T_!X zM["Tо #X "T $X k[v"T`'X m`"TO'X E^6"T()X RE"T}R*^1{"T+ x\"T!-w"T=p"T$!==J"T.! >.1"T8!`>_B>f`"T6>J"T)>\:"Tˆ@>*func(uintptr, uintptr, int, int, int, int64) (uintptr, error)?*struct { F uintptr; blockSize int64; b *pprof.profileBuilder }?*struct { F uintptr; c *runtime.mcache; spc runtime.spanClass }?*struct { F uintptr; ix *int; merged *[]int32; next *[]uint32 }?*struct { F uintptr; mp *runtime.m; src uintptr; dst *uintptr }@*func(uintptr, uint32, uint32, *runtime.siginfo, unsafe.Pointer)@*struct { F uintptr; ok *bool; oldp *runtime.p; _g_ *runtime.g }E*struct { F uintptr; h *runtime.mheap; s *runtime.mspan; acct int32 }jP"Tt~c pP"T `P"T$2 JY)=@"T`@,8IP"T%<`ݶ,@"T`Vjl@"T  iBP"T lP"T02`oP"TBGP"T 5 5 Q  @e2T~IƟ"# doTPG`dp !9`e^LT  eQjTP`  qLϪ"<d1L,T8 fjTP gb=T `   %P``j/PTh m 9T  vxT2<` <Ny3T:  ST pirT u,$I0T4P  K>F)@^G` B:tTQ  T ywb0Tȯ  K=h *1  us'&!SAg(0TCPMKTlG`ET0xGZ0 _ 9TzG`3FPG`` HT  ҌdPTt 00@ /!p!"YFL` #qb` 6(pTRP4\XȌ@T?<  NPTĦ  HuTۦ` T`lZvT PP\phɞ; }q@"0L'PTL<`TH<T  Z^@T  *0T7`R_l~Ty( @3^gߞ :]pT~ 6`@e]STN@^, TY<` c0TA@` aCTG@M TG }5G"Tf<``hz3`Te R`\PT|`@T  JxbpT( Q`dsŽT@`DLOTs< eT`l|0p~T L]k T< L.l= TG 0"1"Tw @"TG `T"T ``[ ?"T<2` P["Vr@ @"VX @,ĸb "T<`` R"T< 7"T<` 16`"TH2 `a"TG`ҖhnT  'T `{1"T3  9TG` ~pT<`xBT ~RTا 풹T<` T  ndPT`凃TaP @T 4TG`Mo TG`Њ}T<`>>4$~$A ``h:9T@x0"aT`8}aTpP j tTP` 0TH` TP qT4 ɰ1ASH`~VTp x5TK P0TT2`tT"H 3P"Vb u"T `&"T`2 k "Tl2`  ,Ya @P8k9Q|J` `@@0t ! ` PXX<`c}"T< 6"T<` Fp"Tx2`"T0H 5uT7 }h8TM`mwTm0pC@Ty tT``$T~ '04c  Mg04 T]T=`  R G !9T>H  YT=` 7`K0TP WPTը   >TP !IPTP!x`T !aK10T`!^wROT e1T`#ʕbT1`$/NWTP z(%>7T2`%}X|TH %BT2` 00z`@`9 `T 0(CiBe=`HHj@"`W`('$^T)=` ¹RT2`/TLH|Z Ty $(V'mT` TP`(@T6=`(LT_ (j/Tv`( p@T +,GT2`,欩VTZH ,TVPT ,RPTP4:T`/@nTҩ`0 A0^aH {"T2  εT2 ` @@P2 `@@@v  A@@R T,I @8УJ0C=`B"T2` l<ThH'xsT 0T`>PTP 2) TvH`)cT~0TQ`6.T`:((r@oџ((p@o` Oۅ @RxhȨ@"1npT2 (,~d@T2` PP#@`@PHszPP=`іT2`saT < rT` v TZ` c Q`=]pTb q=lT`>z T. ?_0TPx`$0 ` @Vl E `@@& T]=`@; TQ@dn@T\`@-`T| ƅpT`x`Aj@Tj=`A,0Ts BXS`T`BU5`Tа `CHMKAT#c tCT20THCt `TH` CCJTw=`Cf*M`T$QCDy|T=`D0&jT ` dT2 `X:~=`0^TH$ѹ T) HϹT?`L2|T F`;a.T`H5ӲPTϪ`Mpp۠<ы @ph V=``8 T=` *sxTU T!OTk` ,FTH` P8[pT=`P$ NT`` YTHR(!T W`j>TYX@@<& r  5jT3 @8n%@P`,{XT >0"T 3`0F; T `x`T`. ڹT+ ]@QyTB `H/HT ` |l =` I00T,3` 6ȽpTà   @"TI {s[3@"T  ^P3@"Tk9C3@"T `_)3@"T_ #cQ3@"TY53@"TBߠ3@"T``!q3@"T``Z3@"T` ĞE3@"T ``u3@"T6` y3@"Tv`)3@"T` +3@"T``!BVW3@"T` OA3@"T &3@"T` s^3@"T{r`3@"T^ &3@"TM3@"T 3@"T`&>i3@"T`_43@"T%DŽ3@"TpF3@"T  3@"T@_93@"TU_i3@"TQ`_ *3@"T` Bh3@"T9`SΥ3@"TX  @@Mh@"~``@@$u@"շ`@@4@"@x @@b3@"]b@@ @"@@py@"``@@wN@"= @@ -@"` r?@"  N@"ʺ8 <@"3Q ֗/@"H``0@"pxs5@"T>) @@"T ` 5j@"T3 @@"T3` .T@"@V@" 8vPz@": D^@"T xUS>@"=`>y @"Tx .@"T= @^@"T=` @@"TH@@%@ @"  F*struct { F uintptr; e **pprof.profMapEntry; b *pprof.profileBuilder }G*struct { F uintptr; cache *runtime.pcvalueCache; gcw *runtime.gcWork }L*struct { F uintptr; sp1 uintptr; sp2 uintptr; sp3 uintptr; _g_ *runtime.g }L*struct { lock runtime.mutex; head runtime.guintptr; tail runtime.guintptr }M*struct { enabled bool; pad [3]uint8; needed bool; cgo bool; alignme uint64 }="TV`~`mq63@"T ^3@"T0U`>3@"TA3@"T  `3@"T`  3@"TB N4P3@"T3`43@"T'` -3@"Tٸ "3@"Tɬ Y3@"Te`\3@"T`Z63@"TQ i3@"T| `_ G3@"T|`"S3@"T}`  O3@"T,`` Hմt3@"T   ؈3@"T ` ~3@"T$&3@"T rsu3@"T   N3@"T   W"Vy`"TH `m\ F "Tz H `m@]  "T( x`m* `"T` x`m -pe"T{ X PL1x"TLX P|-"T,X t["TL.X ""T 1X p"T9 2X pu"TX 'P"T>?"TdI@`mДP%:"T{`m0@'W@Z"T`mЖPON*struct { lock runtime.mutex; free runtime.mSpanList; busy runtime.mSpanList }S*struct { F uintptr; s **runtime.mspan; size *uintptr; needzero bool; noscan bool }s6"TV@~`m޶6"T`~p`R({6"TQ@'~bЇ6"Tˡ`m-6"Tk6"Tyt`m  ت6"Tyt`m 6"Tی)t`m{:6"T)`td6"TH `m\ \ I6"TzH `m@] @] e6"T`*H `m m6"T+H [ 9zط6"TH 8&  B6"Tz7x`mТТY(6"T(`x`m**76"Tx`m - -P6"T@X (56"T`9X ii76"T`X (0f0falTl6"TƭX 1QQp6"TfX P `kH`6"T{ X g>6"T`@eX (mEF6"Tù X VVy6"T"X =mt"l6"T@X ?0KKB6"TͤX (56"T`X '͇W6"T xwpkpkAV;6"Th `mPP9R:6"T>`R~`p@(@(/6"TAR`] 6"TF`Lrsk6"TUx b3l6"T U`o os6"T& p`||Q#6"TdI `mДД?:6"T{`m00Bi6"T`mЖЖկ3@"Ti  3@"T`B7#3@"T&`` %e3@"TQd ` K3@"TX'1@"T`0~!}TQ < @T?  <"V+0`f5@"T` @0XϽ5@"T``1WD 5@"Te ` 2.R5@"T(  4p5@"T@`@55@"T@`6Pv5@"T: 785@"T` @x9pʷ5@"T%``@: [5@"T`b`;A5@"T`` <^Z5@"T(`>P.D5@"T`@?PJ5@"T``@`5@"TД`` A )M5@"T` 8C QR5@"TP``E '}5@"T@`` F!5@"T  H^5@"TK@I"5@"TȌ`Jt5@"TD   KpUD0T  X  jmT2(` X  ʑw1T>? @  V*struct { F uintptr; p *unsafe.Pointer; size uintptr; align uintptr; sysStat *uint64 }V*struct { F uintptr; pc uintptr; sp uintptr; gp *runtime.g; r *[]runtime.StackRecord }X*struct { F uintptr; fn **runtime.funcval; argp unsafe.Pointer; siz *int32; pc uintptr }X*struct { F uintptr; typ *runtime._type; src unsafe.Pointer; off uintptr; size uintptr }\*struct { F uintptr; buf *[]uint8; gp *runtime.g; pc uintptr; sp uintptr; all bool; n *int }]*struct { F uintptr; srcp *unsafe.Pointer; dstp *unsafe.Pointer; n int; typ **runtime._type }h3@"Tb    s3@"T_c   1l3@"T`````Ɯ3@"T)|  ` 8hP"Tj`Hx\"T )H _ L"T +X `mOS`eFuP"T#X D"T3-X `m PS`M ?`"T/X `k0X: {׳P"TAR`l*RP"T`@F`*struct { F uintptr; n *int; pc uintptr; sp uintptr; gp *runtime.g; skip *int; pcbuf []uintptr }c*struct { F uintptr; s *reflect.sliceHeader; size uintptr; typ *reflect.rtype; tmp unsafe.Pointer }!6"T@~@@`zzp{p{q6"TH \6"TS@H `k  =m  6"TX `m M MS`΄6"TzX /jj^N@k@kDZp6"TX `mS`=yB6"TX x`kx6"TZX 0Q0QPP966"TX b@k6"T-X 'mm pp6"T3X `mS`R56"TϜDX "~6"TL@X b o6"T FX PP0撚6"T X `kX:]6"T@X 'hh jj@6"TJX c`00D6"TX b6"Tؖ LX 00NQ6"T9X b;(6"T;NX A`0|`^Xy6"T x kee(fft6"T``DTX6"T```y6"Tat``_]6"THIQ`P#P#`''6';6"TVS``.6"T@``~46"Tx@TF l@w6"Td Vx k_6"T '-  p p yP 6"Tg x'`yV`uI^6"TrIX``k``e*struct { lock runtime.mutex; next int32; m map[int32]unsafe.Pointer; minv map[unsafe.Pointer]int32 }^"V```m"VQ < o"V`<`F*`mnЇ"Vpy<`m%("V{>`l!`>"V l +2"V``l+ !F"V>lp`!"VQ`lJ#@,:"V lJ`ӳy"V`&`X `m5@"T`+``@D xL @"T 3` x ke(f"TQ`D~S%=t"VI \` X``m_),"VU`d@ d" p}"TPIx[ (`;H "TNX Զ0P6G14"V{ +` x k(d"T`Qx `mt05`k#`kq*struct { F uintptr; e *runtime.eface; f *runtime.eface; nret uintptr; fint *runtime._type; ot *runtime.ptrtype }r*struct { F uintptr; s **runtime.mspan; h *runtime.mheap; npage uintptr; spanclass runtime.spanClass; large bool }6"TQ~S%=W6"T  lX`  `m M?/6"Tך  lX`` ` `mP P 6"Ti`  lX`p p `mp p H6"T@  lX` `m !ߍ6"T̓  lX` `m0 0 i6"T  lX` `m 6"T 88 P3P3lN77VM.6"T  kPPn V6"TPx[ (ݣ6"Tׁx k`.`.--n ..6"T|X ?k g g1Sk@g@g(`g`g]6"T6 X XX WWWW VDt6"TpPX `o`opp'`n`n=6"T@X 6`k@/@/--p.p.Ң#6"TX ppbn``?6"T `X h`k`` 6"TƇfX .pMpMD`NN6"TI X ГГ@`w6"TX ԶP6G1tق6"T_X \`k   `@@n/q6"T8X '`|;y ^6"Tq`MX $p@p@S$??v6"T@O x kДДppn `s6"Tx `m05`k#`k/z6"T> Lk00`99`006"T$?@YQQRR PPٍ@"T`yx'~ k@pn P J@"T|x'~ k@pn `|"V~(@D"Tˡp@(ӡ`}]"V/`\(?`kX``mN:3@"Tz`"-"Tux(gj@"T@(`g'"T(`z@"T `I  kP@n 5\9"Ttx(ˡ .P"Tpz@X (Ͽy}0T X (] T}J"Tz*@X ({}"Tҍ X (DFm"T@X ( $9"T@X (`=ap9"T`@X (tZl"T `X (Ȥ!"Tz @X (Ȥs0T X (d6ť"VD,d@( kn f9"TVIl(ˡ yRNa"Vw<@0~(|*struct { note runtime.note; mask [1]uint32; wanted [1]uint32; ignored [1]uint32; recv [1]uint32; state uint32; inuse bool }}*struct { ityp *reflect.rtype; typ *reflect.rtype; link unsafe.Pointer; bad int32; unused int32; fun [100000]unsafe.Pointer } 2W"Vn><04 h p`MPX"TR`|tp`k&44`k`l`mp%$O"T z}H Xl 0 `@ `1B"U# .\0@VaW9"UK`. YY.0X7"UL.\@[7C T" /0}  ڼ@"U`/v SE@"U!/0v D@"UE/v  P"T0 g t,v@"UQaQá@8pU30(Qt`0(b@"l 4(Qá 6"TPy&~КК0@@p`UD6"T`y`~ kn PP H56"T|~ kn `` G6"T}~/.@@`/` 6"T~  55``^-  ߿)6"T  l?`k X`` ` `m@ @ !}6"TI@p `5 l5 JP P 0!6"TlppId" p00}Z6"TRtp`k&&44`k`l`mp%p%.?6"T z`H Xl``r6"T_RxzЭЭ 5`m(tH6"T X @D@D+`FF+pEpE7֨L6"T X ` ` 8k@ @  W%6"T#X ``  '``6"T`X $`ppE N6"TX q`.``h6"T`% x kggii( h hn ii6"Tx `;`G9"T)$t("WN"VPz %8ւ`kN$p7@@- Q_@"T` x kgi( hn i G9"T`& (p`   O|Y@"03Py`w'~@ը` 0"TQ '~@ΤjT`@(~@rL wt"T(~@N  #^"VQ )t@p`kP"m`l`mDkd l W_ی *t@z`` ؑT *H @`1 ha@"U `+H @ǡ `"V[ ,H @H   h4$@"Vӛ ,H @H``88Зu `"@-H @I@+p)$-H @I5p88FAwHػ'.H @IQpXXQ$1Xu@* /H @I`p88Z -/H @Ilpxx40/`0H @I`zp6"T` 1H @dHM#"V 1H @ס  ;Xp"V @2H @ 88}I"M2H @qP@b `88@3H @X@b `"T`  4H @Ȧ o@"Vs 4H @} ;PU@z`5@ ס@0y=@"q+`6@* ~P0 k@"\`z6@ȶ0 ,@"V? @7@_P` nXz 7x@`` N@"U< 8x@|A.9"TnR` 9x@ 4`d@" 9X @@@0՜D"V'`:X @@x@xyU<`;X @ǡ ] ["T;X @`G`q#kXH`@<X @d`8  H˰"V<X @@x S"T=X @ @"Uݭ >X @ǡ]` |"Vǀ >X @* )"T``?X @dé :cqT`@X @@L@ I:"T@X @`J"T2R@AX @ l w:N"VAX @8/ߩ/ZԕBX @ K  ,;2aT  CX @ 1`Y@V:"T$ CX @á@A"TD`!`DX @P (y"UϜ .EX @`8 "T "EX @dH88$ d}`"@FX @Hc@x` υ-@"U /FX @ [C U`#GX @@ d`5"V@ HX @` B"T-$HX @b&|r"T %`IX @ -2W"T( &JX @ Τ"TĖ`(JX @@`$`PC"T0@KX @(bTz(KX @nTؖ1LX @%2 l0%"_@"V) MX @} "Vq`PMX @8 ߩ D6T;2`NX @(N"@F0pT*OX @@@ =Pj:@"\PO x@ѩ 06'"Ty+@P x@~<@"V,dP@8Ub-Qh @>`3H"THI 5l R@ g  i6T>lR@áQܨ  @"ZV5l`S@$:@:x`E"@"T9lT@á. Vx6`TF@ߡ@%2"Vš :`@UF@H  !3"T Ux @ `z "Td 7Vx @ң``QH@"XG`; W @p` 8@"Xp;W @p`  D"V <`X @?`m6J @`@@8+AZ@"rI8tY@ϡ bV@"T$?`RtY@ˡ` 0g/"Tȗ`@@Z @& p"Tܗ@xZO@b*struct { lock runtime.mutex; free *runtime.gcBitsArena; next *runtime.gcBitsArena; current *runtime.gcBitsArena; previous *runtime.gcBitsArena }8=6"T 8 )V`mX95C6"Tyx`k`k^`k``/d[6"Tւ`kPPN$p7@``@- t>6"Tւ`kппN$p7@@- @@C6"T`ւ`k``N$p7@pp@-  6"T+5.L4@S`mvs6"TPR x.L4@S`m(;]6"TpzX m%*`m=-wwwwPc6"T*@X , x xT`||~~`wwE`0t0t6"TX r#`\K`-`k@:`^`;56"TX  6OO-PUPUVV'OO0O0T0TY6"T xk`mzzJ#zz{6"Te k@ @  R`n  %v6"T> lp+p+:P)P)\% l--`/`/&0000L46"Tz ` 9 9`77""`@8@8`99g"V @&eH4@44`m  Z֝@"T` k@ P  R` n  P aQPUc{`2f`  \q]YqPg``  gUgz`  h^Y^hX  Yc0iX  (GUiX` KCUpjX (f)pU7b2k   _6"TOkƿ l =/YcPlˡ  hBUl R;Umϡ ` KdW 40n `z -W{n KTWpo z` sZUd`4p 4 *uW!{4p|`  TY( 5Pq  TA6qħ `` ((4(@nr`EAA0'T 0s`ɫ z Ta`8s`: N` Zt#`ThB`9pt `p` rΖWa4u(Q0 ܨ *struct { lock runtime.mutex; gp *runtime.g; created bool; sleeping bool; rescheduling bool; sleepUntil int64; waitnote runtime.note; t []*runtime.timer }B/k6"TR@tp`kP"m`l`mDkd l*q6"Tj``,00h`kpp7pp ˲6"TXx)PP kppC+  `m00+(h6"Tr`cX `mj&P&P&`mP!P!r(p*p*( * *1""lNK6"TAX '`CCEEBGG%`kEEDDh( H Hu^36"T`X DDE   NK6"T@S kIkd4`mZ"k`mzzP.Ts6"T`?`myy6J tt@ v v`vv@PwPwxxA6"T,`mFFP|`kPNPN6FFw G Grk0L0LAC(@"T yt }xXӡ``0@ 3Y@"@y}~X4`n 00(10d(d~@Xס  ۡPZ"Ty`xX`( h 00LZgpuy tX`` `@({[@"T,I tXJ`r0@@8 t  H XPU@b `tp8(O~h@`H XhU@b,`dP@.q@">  H Xb@bl`pz?4T< H XȦ N Q7PVS)H XdH w P@¦b@"`H X[@bl`Ž`pK@".8 X;rQ  v=`V Xϡ8  R0cSpT:I X ,R (H.@"TA``X* 0ͻ@(@"T_R} xX*`0ͻ@9"Tׁ`Jx(ˡ kТТn   C~``T X X````!Y`X X<D  @8| 4  X XHc@x`tp!50UȲX X`  8(3@h`LX XHc,`d_ߐUƭ `X XE`l`n P@@Ć@"p X XHcv`,p((MeX X`` `@ED"T) !X X( N [DU` `X X`   3T`$ X X0 ΤP Y=0T܎$X X ةhHe,@" 0X X-  >=@Tt`%`X Xǡ k ]?3 V" X XdH@xw t}FT'X X(Ӿ< yHZ"T X X@`.  c vT`)`X X(`ν`` S8"TP`* X Xp{  } ( f] , xXl`d``00A8@"T xX`B70P00Ϊ̯u`h X`` `@ T < h X`  dTM`-h XnW 0$6~@"Z 6lX@ (QQ@"( ?` X,` _T  X(  MཌT`<0~XX  92T1? =tXd`  0\Y7pT ?` X  h@2T`?  Xf T? X  f 8 r3O@"\%? X ƣ`0b`*struct { F uintptr; p **regexp.onePassProg; visitQueue *regexp.queueOnePass; check *func(uint32, []bool) bool; onePassRunes [][]int32; instQueue *regexp.queueOnePass }XX)6@"`{ѩm^@"L{ѩm @"`p{ѩm`ppR&M@"3 0{ѩ@m`PS @",`{ѩmPP Gŵ@"{ѩm   7Y@"p{ѩm`ppo/Q@" 0{ѩ m`P<.@"  `{ѩm{K@" {ѩm [v@" p{ѩm@`PP/z@"x 0{ѩmPPuB@"xo`{ѩm`]hcq@"ڵ{ѩm \@"p{ѩm`G@"r 0{ѩm`>@"P`{ѩm@@"{ѩm ye@"Խp{ѩm`=@"  0{ѩ@mPE @"`{ѩm  @"T {ѩmppI@"Vp{ѩ`m@`$ "V+@X @ x``kP rӛ`{1{ `0 )y UdX 0 cay`Y|2pӡ/ - 0 4Nm]{0  z`0 qϚ`l|`ƪ 0 <[ e X0 V@"^9p` á` 3 0j"TXF"DJk@6"`6`m+Y+Hi6"TQ WwpFpF0p`;;'`2`2F33O`66F16"T0zH @ C`k`m`&k&`m`mki6"TzRX  `nnp%`k|`kkLPlPlMm00}mU`kg56"TzX @ C`k`m`&k&`m`mk6"T3 ~I@  K`[C`@@36"TVI``k  Nb`k""1pp`kPP0W6"TXF"DJk"`mY+pTf@ @X Xة`ǡ  P `k@@xŲ@"yEppJ` ǡP*`h:d@"Ty@xpJ`(0b`@@mP@8;a>\pp`е` ص@y``@ v{@"[l{`n@p 08 `ǡ`p@@F03`y@tp`` `@``PH*{a)`tp@@d```T H@oEH pmX@b ` pΤ{d"T܆ @H pd] 6 0(Uc;j%` H pD`$  08 &@"\j@pȶ0 `( h(ZC@"WPRxp H  @8 *@X p+`x$` E$`@`` E TW X p.`H ``0u0 XWX pJ` 0$ΪTHX p` 1 9V~F@X pH P ` `0(<~@T`X p`H 0Y@7"TX p   p  !fTù`X pҼh^ 0S,!"T_`O@X p  R ¤ >Uu#X pp{    } (b/yT %X p C   c( " (pT 'X p `x  `0\`Tݹ )@X ph`R  -0 ךTX p`ܥ J *x@0@"TX -h p`0:@ P( ט@"`3 lpQ!@Tж0-@e@"X>`l@p   "@"`x p(Q: 600(᳼W@"m : pb`c ں`0T*`@0 w,@"_˼; pp`` `0 PXH"@">Q@ pΨX` PD 00 @"s7 p׽0Q@P$1P"T^?`my0t6J t p@ v@r`vr@Pwrxps3@T`=tp`  9lT6"TF*`mpp4@44@@`m@@ pp ρ6"T(F*`m@@4@44`m @@ pp6"Th ;{PPS``*|4v6pp>%((Fxs@j#(0ӡ H 0B @( br@`!D`{B   0@((e1@c!ˡ` 0@((t@hq!p X0ϡ@ xY3Pӡ}`  0 2(( D:@b0 0@((Й@f"`` ǡ0Hz@(d@Y%"H@x   (0@A;VTY7F :ZZ b  `((L@n`E`` `0`@<6"Typ 3k  )kpp0P P  +p``5l5J`   M6"T~X #`$`h`k``6m  '`p p   <'  m` ` gFmP P }]{6"Tj@hX PP`00L`k``h PP=VO`n\6"TN@h Hpp4аа"``N`m``6iib`[`[ޥj@"y ~`0G@:`ڤԤ` gpT ~ W   Z  XH$@"Qpw``  Pp`pXC T) <Jp@NT0@rP8TgT{Rtd`` A0 @$pP@* ʆ H p`` `_@ `((VQY@iӢ `H ס 8 `0c@i@T@ @H l H  XH'@"H  P` ʩP` YT|JX `T` ` 8`0] T@( 8j*a$X B ,@ 0` @ B((@kQ X D,  7@x0@/ `!\`X h   ( $0(X5`U~X ` - "0 @80ry`X ` _A A@``(DTͤ@X `}l  ǡ0!@BWT@ * X v H  00:8B@"x  xd`Q á 0 @` PH8UO@"~@ x}` ߩ E0`80bYx@"r`, xI 0 P``8<TN`Hh  x@:P ` b'TzlQ T `  G ( p/^a9l`    ɫ 0]&T ;@   `P"T`:@& F*`mp04@p44@`m@ p PQ',P"T(@;@&F*`m@4@404@`m @ p@@<@"h1ˡyv p0`@8vp00h!vpC`` 07@x@P(\UYC3ӡ} 0 @ B 5 5 !YW_`7pé H   > 0d 8"@239"T0z`H (X @  C`kP P `m   `&kp p &`m `m  k  Oc@T`X XP % \K`-`k@:`^`b9"Tz``X (X @`/`/ C`k//`m@1@1`&k//&`m22`m22k`0`00Fv-T=`~h 0h@t+PXH@"Ɓ` x@ Ew@P``@(fP` X ! `` `@?`pp0V6`K` X H }0@Ph)źW@~` X `  #0u>`> [` X `׽@ `  007CLT `X DǡI բ0ڢ@PLq%Tۣ `X   p2 ,    ( g`U#&`X `   " ( 080 y@"w` (`X `` `0,@@ܥ`0(g8O`X ``` d0/@% P0Xg 8` ( QP 0j@,PXX.(@",t`d`  P`h`80c8s@"w<t``` `0,@@ܥ`TH6"T y|x  k4 4 !`p5 p5 ++ 7 7 6Dk05 05 @@J#@P: P: Pxf6"T`x ``'@@c/`k'PPM  Us  jV1;PW6"TTX 4*%|-|7`kU`k y/`L88T@}" 2PJX 0@  Pǡ`H8hW@"'Pǡ 0X@P` N2'@T^8P%>>"> (>( 0ط 8q6"T{  j jSS5FF]]'RRUUp}KKLLă@L@L&ss- __[V::*6"Th} x @@$`0`0`.&  \9M/~MppM`P&P&N  0(fPb)2xȵ `0`@ P` R ThP@G@"` H p`` `_@`߻`  00R,/w  X    D0 @P8 iDu]`"X  ܾ  0@VP`8 Ȓ[  #X   0@P+`0T@$X `:  @`0@` PG XTx:`%x       ( *struct { allocfreetrace int32; cgocheck int32; efence int32; gccheckmark int32; gcpacertrace int32; gcshrinkstackoff int32; gcrescanstacks int32; gcstoptheworld int32; gctrace int32; invalidptr int32; sbrk int32; scavenge int32; scheddetail int32; schedtrace int32 }@0w:@"pp'`X   "E $`0a@ס`PTZԫ6"Tt`x D$h'`  .  i X @@ ``6Bd@"@y\)е`d` 0@@@PI`` ؿHV.@"! <*J@,@08 P`l ` b d9 f(|@Zz ,X з`@x } 0> 8y :dN<?@+>"T1` -X xUJ l XH8o@" -@.X V    P@p` + tq6"T X ,m@@Ak//K``kCC'@C@C/@@JPPʐ00}m/O``P001[@"t0 @X t 0@ P00][@"ty1 @X t   0@ P00l?$@"t'3 @X t` `0@ P00 d@"t@P4 @X t 0@ P006Ґ@"t 5 @X t 0@ P00 a+@"t`6 @X t   0@ P003@"t8 @X t` `0@ P00 @"tP9 @X t 0@ P00 @"tӿ: @X t 0@ P00M @"t; @X t   0@ P00Z @"t= @X t` `0@ P00I J/@"tP> @X t 0@ P00Ga@"t? @X t 0@ P005F@"tO@ @X t   0@ P00y@"t8B @X t` `0@ P00p@"tPC @X t 0@ P00mlh@"t D @X t 0@ P00v@"tE @X t   0@ P00LQ@"t G @X t` `0@ P00$@"tPH @X t 0@ P00y [@"t@I @X t 0@ P00_u@"tJ @X t   0@ P00k@"t`L @X t` `0@ P_ 6"T@ x#AGGH<<- = = ==S p4p4VpGpGDD:J(`F`F44;P<P<(P5P5p2p2 Ť0Ty <N    H  X       (CTa`O X  I    ( 0۪ 8& @@ HH@o,@"pK Q X 8@,  0@Q Pط`p 00wךtz`R X @X t   0@ P(:bz@TS 0` `04`@k0 Ik d4`m@ Z"kP `mz P. ]TvTX @e `  %4@/*%$|P.-,|%7`k@%U`k P$y/`L%Je6"T~v$`nn,`ffKMM6AVV6\\'00JL`ll@`00:`$;`  FUU`a`a}@"Q pW waJ .b  # J'0phm @"X x` ޣ <@PKNp`hgPTɎ#@Z X   \     (H`0{@R`Pw`XXh_ %[ X D 0@PI`pB[o6"T)`A` K `` `  7 KP P  i  % r Kp p '  ,9 10 0 Vp p P6"Tx0~0AA&&p`CCh#`$$[::q`6`<<BB44`%%N0<0<}==ZO`:: P(P(F,,# ))V**T"Vz _H kRkj!le?`k0{] mr?kR`I ?`?`k ml k)OS`m*kk4kVk4`x"`mDm`mj1j8dn6"TW@z~K006`00.L``E``;F̘  Fpp;O0( lh b H }  `( *b,ة.0C @P<X0(BNhr d X }  `( *o,ة. 0C @P<X`XgAVe X ;J  0# 8@x@HP``Mp@`M`X` ƇM g X  ޫ 072@(`/P`b0 +@ 2P $2 r` p0W@"jGh X ϡ  ` `0 @P `«  `@K72@"j ȤN ס  0t@zP ` p2ȹ`@\x@"k ȤNס  0t @z P ` p2ȹ`@Ӥ@"m Ȥ`Nxס   0t@zP ` p2ȹ`@6ϼ@" n Ȥ`N`ס  `0t@zP ` p2ȹ`@\@"Ap Ȥ`N`ס  0t@zP ` p2ȹXP_ '`q H 0ZP@bȤ ` p  ^P6  h @" s 0`  :0 `@6``%   |j XPc  Dt X 0HcȤ@x`@xp@x@x^ P 6  /@"8! v X 0 `?  0ܥ@P``%/ `` p``" P>&w X 0   0 @B`P|`` p K w (@" y 0~0ؿ 0D@{P@`J`pR@PP`@j@"W@z ~Hl` X0XD@`;0H`@+`pU%`P+`k .@"z@| Hˡ  %0`@ˢ@6PТ@6` @`Pf`q@"8h{} xH  02 ``pá40@@\ x `8"Tp#$ ~ } v   1 ($ 0$ 8 @ HY P X ` h56"T؀X **@p1p1J,,--#''+<<-<<=B55-p5p56611'  tLP1P1w0404L44$&  $.##n'%%M$$0@@U # #11Qh*6"T` ppk`  !``k``m K"`"`k00K, `| 7 f00'`0`` ` `(iPT*@X ``8`` 9`0?`@`P``b`p9 ? l` @mc`0@m@`@ě`J`X `Ȥ 8 ס`  0t @z P K`2~ vc6"Ty`x k  k k !`! ! +4 +  + P$ P$ @` `m  Y+@@p`  `5  l5  J`  J#@   9u0 0 6"T!* 4 p p h  p` 5 ` ` 5pb pb # mA $u u a,c c 6w w % % ,  B` ` ,  #B0 0 0B0 0 6  ` |`# `# hCc c / * * D< < >O  6"T ? k`!``k``m y y*`Lp p K"`"`kK,`|7f'``0` `a!%@Tu)hO@mO X D N X b    l v    @mD36"T) $t00m`m!```00"|S``6YuY+p`@#J`A`H00 `@@P'U`` (```00xн@"X> ,`Y` 2@L X`0d @ Bp, Dz@SP$```(`R6"TƁ x5J[[,``*00}}%LЬЬC8  (pp8D`n`nOObMAA,/p-p-pVpVîSSP!P!pM``̊<<PaPa)22 ХХg}00`k88*struct { lock runtime.mutex; lockOwner *runtime.g; enabled bool; shutdown bool; headerWritten bool; footerWritten bool; shutdownSema uint32; seqStart uint64; ticksStart int64; ticksEnd int64; timeStart int64; timeEnd int64; seqGC uint64; reading runtime.traceBufPtr; empty runtime.traceBufPtr; fullHead runtime.traceBufPtr; fullTail runtime.traceBufPtr; reader runtime.guintptr; stackTab runtime.traceStackTable; strings map[string]uint64; stringSeq uint64; markWorkerLabels [3]uint64; bufLock runtime.mutex; buf runtime.traceBufPtr }_%pTz`: x Z b8 x`  r ( 0  c8 V@ V`< V Vħ`ں`  f   @LG=CT"`X ``` `0`@ĥ`P``ʥ`pߢ``d`j`p`v`|````5` N`0]`@R~$@"$  ؿ`0`   ܨ @ Z U `d`  PV`pPy6"TGX "m B``zU@@PP@@_d00 &,pp2    pp>00DJ``''@@BNPN''mm``m,Z6"T@y`)#  V!0 0 * Ip p !? h}*0 0 kk q`k {` X4 $50 0  <5"#0 0 |p p `o+ S`  P P  7/ `@ @  nY@"X@ ~81```p) X/Q%`X 0 @%`PӾ} % H$d"@"%`F   "  $ &r (`0`@`P```pP`DN t`0]2Z@~`pJn;6"T H %kg g Rk k k`g `g j!lh h e?`kk k 0{k k ] m0i 0i `i `i r?kg g R`i i I i i 0j 0j ?k k `j j ?`ki i  mj j lg g kj j ) h h OSPh Ph `mh h *kk k k k k 4kh h Vk@k @k 4``k `k x"`mh h Dm@g @g `mg g jg g j&X/`kPjr((1jf f 46"T@H %kl l Rp p kl l j!ln n e?`kq q 0{p p ] mPn Pn n n r?kl l R`n n I o o Po Po ?p p `o o ?`k0n 0n  mo o ll l kp p )@m @m OSpm pm `mm m *k p p k@p @p 4k m m Vk`p `p 4`p p x"`mm m Dm`l `l `m0l 0l jm m j&X/`kPjr((1jl l 鼈6"T>H %k@ @ R k j!l e?`k 0{ ] m` `  r?k` ` R`Х Х I   ` ` ? ` ?`k@ @  m l k  )G G OSJ J `m *k0 0 kP P 4k`J `J Vkp p 4` x"`m Dm `mУ У j j&X/`kPjr((1j  ~6"T'@qH %kШ Ш R k j!l@ @ e?`k@ @ 0{ ] m  r?k R` I 0 0  ? `Ы Ы ?`k` `  m l  k0 0 )p p OS `m  *kP P kp p 4kP P Vk 4` x"`m Dm `m` ` j0 0 j&X/`kPjr((1j@ @ "96"TM2H %k R kЭ Э j!l` ` e?`k` ` 0{@ @ ] m Я Я r?k  R`  I P P  ? ` ?`k  m l0 0 kP P ) OS `m0 0 *kp p k 4kp p Vk 4`б б x"`m Dm `m jP P j&X/`kPjr((1j` ` 36"T @bH %kp p R`o `o k   j!l4 4 e?`k0q 0q 0{`p `p ] m5 5 `8 `8 r?k  R`9 9 I  ; ;  = = ?Pn Pn `? ? ?`k@5 @5  m@ @ l  k@ @ )$ $ OS . . `m`3 `3 *k`A `A kB B 4k # # VkB B 4`PC PC x"`m`2 `2 Dm  `m  j    j&  X/`k  Pjf f r(  (` ` 1j   ]6"T 3H %k  R@ @ k j!l e?`k 0{` ` ] m  r?k0 0 R`0 0 I p p  ? `  ?`k  m@ @ lP P kp p ) OS `mP P *k k 4k Vkж ж 4` x"`m Dmв в `m jp p j&X/`kPjr((1j 1o@N6"TH %kq q Rt t kq q j!l0s 0s e?`ku u 0{t t ] mps ps M M r?kq q R`0P 0P I a a 0S 0S ?t t `s s ?`kPs Ps  ms s lr r kt t )`r `r OSr r `ms s *k t t k@t @t 4k@r @r Vk`t `t 4`t t x"`mr r Dmq q `mPq Pq j r r j&X/`kPjr((1j0q 0q '<6"T>` &k`!``k``mPyPyS`5@`t t L nJ"+_K"`"`ki@`r r 5` s s 0 0 K,$p p `|7A`P P f&kv v '`P  `kz z v v 0` `ZF`0 0 M6"TH 'kv v Rz z kv v j!lx x e?`k{ { 0{z z ] mPx Px x x r?kv v R`x x I y y Py Py ?z z `y y ?`k0x 0x  my y lv v kz z )@w @w OSpw pw `mw w *k z z k@z @z 4k w w Vk`z `z 4`z z x"`mw w Dm`v `v `m0v 0v jw w PD PD j&@E @E X/`kPjr((1jv v X6"T`,H 'k`} `} R k@} @} j!l~ ~ e?`kЁ Ё 0{ ] m  @ @ r?k} } R`  I     ?p p `` ` ?`k~ ~  m l} } k )~ ~ OS0~ 0~ `m~ ~ *k k 4k} } Vk 4`@ @ x"`mp~ p~ Dm } } `m| | j} } j&X/`kPjr((1j| | cc6"T-H 'k RP P k j!l e?`k 0{p p ] mЅ Ѕ  r?k@ @ R`@ @ I  І І ?0 0 ` ?`k  mP P l` ` k ) OS `m` ` *k k 4k Vk 4` x"`m0 0 Dm `m j j&X/`kPjr((1j 6"Tػ .H 'k R  k j!lP P e?`kP P 0{0 0 ] m  r?k R` I @ @  ? ` ?`kp p  m  l k@ @ ) OS `m *k` ` k 4k` ` Vk 4` x"`m Dm `mp p j@ @ j&X/`kPjr((1jP P  iB6"Tu.H 'k RЕ Е k j!l  e?`k  0{ ] mP P  r?k R` I  P P ? ` ?`k0 0  mД Д l k )@ @ OSp p `m *k k@ @ 4k Vk` ` 4` x"`m Dm` ` `m0 0 j j&X/`kPjr((1j  nƚ6"T`/H 'k` ` R k@ @ j!lЙ Й e?`kМ М 0{ ] m  @ @ r?k R` I    ?p p `` ` ?`k  m l k ) OS0 0 `m *k k 4k Vk 4`@ @ x"`mp p Dm `m j j&X/`kPjr((1jЗ З O@~6"T0H 'k RP P k j!l e?`k 0{p p ] mР Р  r?k@ @ R`@ @ I  С С ?0 0 ` ?`k  mP P l` ` k ) OS `m` ` *k k 4k Vk 4` x"`m0 0 Dm `m j j&X/`kPjr((1j /6"T)@x*?@@@H3@"*!`@`PP +"6|JdpQ{ 8+@T5p`z+J#00$@@,pppp/D`;O`ХХ^h?}`X //y ,0@$ P`cpQ` k1^ 6 `P`  ]d6"T.,ARy!R@{˝d~3 ?+Rp{"`(J6J  4k(@=Eӏ `mJ@6p~p~$P}P}6DDW? Bt&X``| 7B!"RQ#OkP$3k "`km*{ JJ2k?k0+k`mp`^9Y+pmkCd+kpC6#kT#kGe'œ7T  X (``` `0`@`P```p```F```g``~``` д`0U`@Ļ`P```p`Gk`G@ ! ! ! ! !k!-9&6"T? 2B!RQOk33k "`km*{ JJ2k?kk`mpp^Y+pmkd+k{{6#kT#kI` ` Gek8 ppVk'';``!`!(k@"!!X (`S0x`>@0׫LUD 0j@0P`Cp`P  @`p `s ::0BP `p%8@"!>` !!X (`l  @  0x 8K @á `@gef` ` Q  g  RF  $ +00$ @$P$%`$Dp$`$$$1`$$% %:@m%Q@""""X @`m`` 80~ @ H P Xx `@p C Qg\ L` u `$ `  f0 o dX >0  $ %``*struct { full runtime.lfstack; empty runtime.lfstack; pad0 [64]uint8; wbufSpans struct { lock runtime.mutex; free runtime.mSpanList; busy runtime.mSpanList }; _ uint32; bytesMarked uint64; markrootNext uint32; markrootJobs uint32; nproc uint32; tstart int64; nwait uint32; ndone uint32; alldone runtime.note; helperDrainBlock bool; nFlushCacheRoots int; nDataRoots int; nBSSRoots int; nSpanRoots int; nStackRoots int; markrootDone bool; startSema uint32; markDoneSema uint32; bgMarkReady runtime.note; bgMarkDone uint32; mode runtime.gcMode; userForced bool; totaltime int64; initialHeapLive uint64; assistQueue struct { lock runtime.mutex; head runtime.guintptr; tail runtime.guintptr }; sweepWaiters struct { lock runtime.mutex; head runtime.guintptr }; cycles uint32; stwprocs int32; maxprocs int32; tSweepTerm int64; tMark int64; tMarkTerm int64; tEnd int64; pauseNS int64; pauseStart int64; heap0 uint64; heap1 uint64; heap2 uint64; heapGoal uint64 }@606D@"#؀@%%X `E,`, A  @  H  P `  1M  `!`p!`!(,`!?`!8: !`!`!\`!6`!]`q"0&@&P&x`&zp&&4$ & &/&PiP0jPjUPPkGPk`plXgT؇ ''X (``$` `0`@p`P?```p`L`0````H``F``G` :`0`@`P``%`p`G`G ! !+ !  ! !p!1`@.`P. `.`p.`. `.`.phه@"p>`**X `H 0 @Pá`8"pY )   (a`04`@`Pp  (   r  % ` `@ ` p0o@P`j p `xq.`0P 80++Z``ͪ@m L@r `7 (   7`0 @` HP1 `2pV 8    A ` +`0r@pG z  e`ع```N```` `0 `@Jv6"T H F`k k%3`!`kR`kl`kk`~!!]RI(`k(4 l`{x`k"`kl^ ^ k_ _ *<")OS*k` ` 4k ` ` R{`J^S"m(=X""+B@-+ pJO@5"`m`a `a ##| m@m+Xl``'  40 PVd` H FXH X >`!`k  k0 %3`!`k R`k0 l`kk`~!p !]  RI( `P k` (4 l `{x`k "`k` l^ k_ *@ <"@ )OS*k` 4k `  R{`J^S"m (=X""+ B@-+ pJO@5 "p `m`a  ##| m  @m+! Xl``'0  40 x@">`::X S"t )`z<t` 0@ˡ@Ph@`l p x `   ض $ ^ 8 `  d  O `y  Ԫ 0@ `P|` Tp@7p@70 p x4  V ` x ht`px@ ()*+,-./05:<=>?@CFLMNPSZ[\ ]`hmst} ( + @ P [%!%x) )() , ->../i0s25: :]AMCcCfCoCsLlLmLoLtLuMcMeMnNdNlNoPMPcPdPePfPiPoPsScSkSmSoTZYiZlZpZs\A\B\D\E\S\U\W\a\b\d\f\n\r\s\t\u\v\w\x\z ] amgpi)msnspms us|0|1} µ G M P *( < = k= m=%: (?:...../125625: `???EOFHanLaoMayMroNaNNkoPC=PWDUTCVai\x{ ]: allandcpuendgc infintmapnannilobjpc=ptrµsμs� %#x -> <== MB) at fp= in is lr: of on pc= sp: sp=(?:)(?P<(?i:) = ) m=+Inf+inf, n -Inf-inf3125: p=AhomAtoiChamDashFAILGOGCJulyJuneLisuMainMiaoModiNewaPASSSKIPThai m=] n=baseboolcallcap cas1cas2cas3cas4cas5cas6chandeadfailfilefuncgoidheapidleint8kindmap[noneopenpipereadsbrkscvgstattrueuint -%s ... H_T= H_a= H_g= MB, W_a= and cnt= h_a= h_g= h_t= idx= max= ptr siz= tab= top= u_a= u_g=%-*s %.2fs%s-%d%s/%s(nil), ...1562578125AdlamAprilBENCHBamumBatakBuhidFlushGreekKhmerLatinLimbuLocalMarchOghamOriyaOsageRunicSTermTakriTamilWriteamd64argp=arrayblockbytescasp1casp2casp3chmodclosecountfalsefaultfloatfunc(gcinggetwdgo1.9int16int32int64lstatmatchmutexopen panicrune sleepslicespacestartuint8valuewrite (MB) Value addr= code= ctxt: curg= list= m->p= p->m= prev= span= varp=# %#x %d %s %s%c%s(...) (?m:$)(?m:^)(?s:.), not 390625<-chanArabicAugustBrahmiCarianChakmaCommonCopticFridayGOROOTGothicHangulHatranHebrewHyphenKaithiKhojkiLepchaLycianLydianMondayRejangSCHED SundaySyriacTai_LeTangutTeluguThaana[]byte typeschan<-darwinefenceempty errno etypesobjectreadatrune1 signalstatusstringstructsweep test.vuint16uint32uint64 (scan (scan) MB in Value> dying= locks= m->g0= s=nil %s#%02d%s:%d: %v %v @(?-m:$)(?-s:.)(PANIC=, goid=, sys: 19531259765625AvestanBengaliBrailleChanDirCypriotDeseretElbasanGODEBUGGranthaHanunooIO waitInstAltInstNopJanuaryKannadaMandaicMarchenMultaniMyanmarOctoberOsmanyaRadicalSharadaShavianSiddhamSignal SinhalaSwapperTagalogTibetanTirhutaTuesdayUsage: defer value=alt -> any -> cs float32float64fs gctracegs invalidnop -> panic: profiler10 r11 r12 r13 r14 r15 r8 r9 rax rbp rbx rcx rdi rdx rflags rip rsi rsp runningsamplessyscalluintptrunknownwaiting goalΔ= helpgc= is not mcount= minutes nalloc= newval= nfreed= packed= pointer stack=[%!Month(%8d %s%s, idle: 48828125ArmenianBalineseBopomofoBugineseCherokeeCyrillicDecemberDuployanEthiopicExtenderFebruaryGeorgianGujaratiGurmukhiHiraganaInstFailInstRuneJavaneseKatakanaKayah_LiLinear_ALinear_BMahajaniNovemberOl_ChikiParseIntPhags_PaSaturdayTagbanwaTai_ThamTai_VietThursdayTifinaghUgaritic[:word:][signal ----- stack=[bad instcgocheckdurationinfinitypkg: %s runnableruntime.scavengestrconv.test.cputest.rununknown( (forced) -> node= blocked= defersc= in use) lockedg= lockedm= m->curg= ms cpu, not in [ of size runtime= s.limit= s.state= sigcode= threads= u_a/u_g= workers=%!(EXTRA (MISSING)+infinity, newval=, oldval=-infinity-test.run244140625: inuse: : status=Bassa_VahBhaiksukiBigEndianCuneiformDiacriticGC (idle)GC forcedHex_DigitInheritedInstMatchInstRune1InterfaceKhudawadiMalayalamMongolianNabataeanPalmyreneParseBoolParseUintSamaritanSeptemberSundaneseWednesday[:^word:][:alnum:][:alpha:][:ascii:][:blank:][:cntrl:][:digit:][:graph:][:lower:][:print:][:punct:][:space:][:upper:]atomicor8bad indirchan sendcomplex64copystackctxt != 0funcargs(goos: %s goroutineinterfacemode: %s non-emptypanicwaitrecover: reflect: rwxrwxrwxs.nelems=test.listunhandled MB goal, actualΔ= gfreecnt= pages at runqsize= runqueue= s.base()= spinning= stopwait= sweepgen sweepgen= targetpc= throwing= until pc=%!(NOVERB)%10d ns/op(BADINDEX)/dev/stdin12207031256103515625: parsing DeprecatedDevanagariGOMAXPROCSGlagoliticKharoshthiManichaeanOld_ItalicOld_PermicOld_TurkicOther_MathParseFloatPhoenicianSaurashtra[:^alnum:][:^alpha:][:^ascii:][:^blank:][:^cntrl:][:^digit:][:^graph:][:^lower:][:^print:][:^punct:][:^space:][:^upper:][:xdigit:]_MSpanDead_MSpanFreeatomicand8casgstatuscomplex128float32nanfloat64nangcscandonegoroutine invalidptrmach errorreaddirentrune runtime: gschedtracesemacquireshort readtest.benchtest.counttest.shorttest.tracetracefree(tracegc() unknown pc (targetpc= gcwaiting= gp.status= heap_live= idleprocs= in status m->mcache= mallocing= ms clock, p->mcache= p->status= schedtick= span.list=# Sys = %d %!(BADPREC)--- mutex: -test.bench/dev/stderr/dev/stdout30517578125: frame.sp=gsignal= minTrigger= pages/byte preemptoff= s.elemsize= s.sweepgen= span.limit= span.state= sysmonwait=%!(BADWIDTH)%12.1f ns/op%13.2f ns/op) p->status=, consumed: , released: -byte limit 152587890625762939453125Bidi_ControlInstAltMatchJoin_ControlLittleEndianMeetei_MayekPahawh_HmongSora_SompengSyloti_Nagri_MSpanManualabi mismatchaltmatch -> anynotnl -> bad g statusbad pagesizebad recoverybut progSizecan't happencannot find cas64 failedchan receivecontext.TODOdalTLDpSugctdevice errorend tracegc entersyscallgcpacertracehost is downillegal seeklfstack.pushnot a STREAMout of rangereleasep: m=runtime: gp=short bufferstop tracingt.npagesKey=test.timeouttesting: %s threadcreateunexpected ) (default %q) (default %v) MB released called from heap_marked= idlethreads= in duration in zip file is nil, not is too large s.spanclass= span.base()= syscalltick= with GC prog# Alloc = %d # Frees = %d # GCSys = %d # NumGC = %d , gp->status=, not pointer--- %s: %s %s-byte block (3814697265625=== RUN %s GC sweep waitMende_KikakuiOld_HungarianSIGKILL: killSIGQUIT: quitSIGSTOP: stopTestTimerFastTestTimerSlowTestTimerUnitUsage of %s: morebuf={pc:alloc_objectsbad hmap sizebad map statefatal error: inuse_objectsinvalid UTF-8invalid base load64 failednil stackbasenot availableout of memoryresource busys.allocCount=start tracingstill in listtest.benchmemtest.paralleltriggerRatio=unreachable: value method xadd64 failedxchg64 failed has completed nmidlelocked= on zero Value to finalizer untyped args # LastGC = %d # NextGC = %d -thread limit /etc/localtime1907348632812595367431640625GC (dedicated)GC assist waitGC worker initInstEmptyWidthMB; allocated Other_ID_StartPattern_SyntaxQuotation_MarkSIGABRT: abort\.+*?()|[]{}^$allocfreetracebad allocCountbad span statebad stack sizefile too largefinalizer waitgcrescanstacksgcstoptheworldinternal errorinvalid syntaxis a directorykey size wrongnil elem type!no module datanot in ranges:protocol errorread mem statsruntime: base semaRoot queuesemaphore_waitstack overflowstopm spinningstore64 failedtest.benchtimetest.outputdirtext file busytoo many linkstoo many usersunexpected EOFunknown methodunsafe.Pointerwork.full != 0 not in range [# DebugGC = %v # HeapSys = %d # Lookups = %d # Mallocs = %d # PauseNs = %d , t.hmap.size =--- FAIL: %s %s/proc/self/maps476837158203125ASCII_Hex_DigitGC (fractional)Other_LowercaseOther_UppercasePsalter_Pahlaviacquirep: p->m=force gc (idle)malloc deadlockmissing mcache?ms: gomaxprocs=negative offsetnetwork is downno such processnon-Go functionnot a directorynot implementedrecovery failedruntime error: runtime: frame scan missed a gstartm: m has pstopm holding ptest.cpuprofiletest.memprofile already; errno= but memory size mheap.sweepgen= untyped locals # HeapIdle = %d # OtherSys = %d # PauseEnd = %d , not a function--- %s: %s (%s) --- BENCH: %s %s--- contention: 0123456789abcdef2384185791015625: value of type GC worker (idle)Imperial_AramaicInstRuneAnyNotNLMSpanList_InsertMSpanList_RemoveMeroitic_CursiveOther_AlphabeticSIGNONE: no trap runtime stack: ^\x00-\x{10FFFF}bad frame layoutbad special kindbad symbol tablebinary.BigEndiancastogscanstatuscontext canceledgc: unswept spangcshrinkstackoffgo 1.9 traceinteger overflowinvalid argumentinvalid spdelta message too longmissing stackmapno route to hostpacer: H_m_prev=policy not foundreflect mismatchresult too largeruntime: g: g=runtime: gp: gp=runtime: nameOffruntime: nelems=runtime: textOffruntime: typeOffsemaphore_createsemaphore_signaltime: bad [0-9]*to non-Go memoryvalue size wrongworkbuf is empty initialHeapLive= spinningthreads=# HeapAlloc = %d # HeapInuse = %d %d: %d [%d: %d] @0123456789ABCDEFX0123456789abcdefx1192092895507812559604644775390625: missing method GC assist markingOld_North_ArabianOld_South_ArabianOther_ID_ContinueRPC struct is badRPC version wrongSIGBUS: bus errorSIGINT: interruptSentence_TerminalUnified_IdeographattrBuf too smallbad TinySizeClasscorrupt zip file cross-device linkcycles/second=%v entersyscallblockexec format errorgot: %s want: %s index > windowEndkey align too bigmalformed profilemark - bad statusmarkBits overflowmissing closing )missing closing ]notetsleepg on g0permission deniedreflect.Value.Intreflect.Value.Lenreflect: New(nil)reflect: call of runtime.newosprocruntime: next_gc=runtime: pointer scanobject n == 0t.spanKey.npages=test.blockprofiletest.coverprofiletest.mutexprofilethread exhaustiontruncated profileunknown caller pcwait for GC cycle because dotdotdot# MSpan = %d / %d # Stack = %d / %d # TotalAlloc = %d , locked to thread--- PASS: %s (%s) 298023223876953125Caucasian_AlbanianENOLINK (Reserved)Variation_Selector[^\x00-\x{10FFFF}]bad arg in InstAltbad manualFreeListbufio: buffer fullconnection refusedcontext.Backgroundfile name too longflag redefined: %sforEachP: not donegarbage collectiongcBlackenPromptly=identifier removedindex out of rangeinput/output errorneed authenticatorno child processesno locks availableoperation canceledreflect.Value.Elemreflect.Value.Typereflect.Value.Uintreflect: Zero(nil)runtime: insert t=system page size (too many processesunknown time zone use of closed filevalue out of range called using nil *# BuckHashSys = %d # HeapObjects = %d # MCache = %d / %d # NumForcedGC = %d # %#x %s+%#x %s:%d , g->atomicstatus=, gp->atomicstatus=/usr/lib/locale/TZ/14901161193847656257450580596923828125Canadian_AboriginalIDS_Binary_OperatorMSpan_Sweep: state=Pattern_White_SpaceRPC prog. not availSIGTRAP: trace trap_cgo_setenv missingattribute not foundbad file descriptorbad flag syntax: %sbad kind in runfinqbad notifyList sizebad runtime·mstartbad value for fieldbinary.LittleEndiancgocall unavailabledevice power is offdirectory not emptydisc quota exceededfile already closedfile already existsfile does not existmarking free objectmarkroot: bad indexno STREAM resourcesnotesleep not on g0nwait > work.nprocsoperation timed outoverflow is not nilpanic during mallocpanic during panic panic holding lockspanicwrap: no ( in panicwrap: no ) in previous owner diedreflect.Value.Fieldreflect.Value.Floatreflect.Value.Indexreflect.Value.IsNilreflect.Value.Sliceruntime: pcdata is runtime: preempt g0sampling period=%d semaRoot rotateLeftskip this directorystopm holding lockstest.memprofileratetime: unknown unit too many open filesunexpected InstFailvalue align too bigwrite of Go pointer markroot jobs done to unallocated span# HeapReleased = %d --- FAIL: %s (%s) %s/usr/share/zoneinfo/37252902984619140625: leftover defer sp=EMULTIHOP (Reserved)Egyptian_HieroglyphsIDS_Trinary_OperatorMSpanList_InsertBackMeroitic_HieroglyphsSIGALRM: alarm clockSIGTERM: terminationSTREAM ioctl timeoutSeek: invalid offsetSeek: invalid whenceTerminal_Punctuation[invalid char class] # runtime.MemStats authentication errorbad defer size classbad system page sizebad use of bucket.bpbad use of bucket.mpchan send (nil chan)close of nil channelflag: help requestedfloating point errorforcegc: phase errorgc_trigger underflowgo of nil func valuegopark: bad g statusgzip: invalid headerinvalid itab lockinginvalid m->locked = invalid repeat countmalformed ELF binarymalloc during signalnon-empty swept listnotetsleep not on g0pacer: assist ratio=preempt off reason: received during forkreflect.makeFuncStubruntime: casgstatus runtime: double waitruntime: unknown pc runtime: work.nwait=semaRoot rotateRighttime: invalid numbertrace: out of memorywant %.3f, have %.3fworkbuf is not empty gp.gcscanvalid=true of unexported method previous allocCount=# GCCPUFraction = %v %s flag redefined: %s%s profile: total %d %s:%d.%d,%d.%d %d %d 186264514923095703125931322574615478515625Anatolian_HieroglyphsDYLD_INSERT_LIBRARIESInscriptional_PahlaviOther_Grapheme_Extend_cgo_unsetenv missingblock device requiredbufio: negative countcheckdead: runnable gconcurrent map writesdefer on system stackdevice not configuredfindrunnable: wrong pgcprocs inconsistencyillegal byte sequenceinvalid named capturemalformed Mach-o filepanic on system stackprogram version wrongread-only file systemreflect.Value.Complexreflect.Value.Pointerreleasep: invalid argruntime: confused by runtime: kevent on fdruntime: newstack sp=runtime: work.nwait =stale NFS file handlestartlockedm: m has pstartm: m is spinningstate not recoverablestopg: invalid statustest.blockprofilerateunknown empty Context%8d B/op %8d allocs/op/lib/time/zoneinfo.zip4656612873077392578125Inscriptional_ParthianSIGTSTP: keyboard stopaddress already in useargument list too longassembly checks failedbad arg in InstCapturebad g->status in readycannot allocate memoryerror parsing regexp: freeIndex is not validgetenv before env initgzip: invalid checksuminteger divide by zerointerface conversion: minpc or maxpc invalidnetwork is unreachablenon-Go function at pc=panic during softfloatprotocol not availableprotocol not supportedreflect.Value.MapIndexruntime.main not on m0runtime: invalid type runtime: out of memoryruntime: s.allocCount=runtime:scanstack: gp=s.freeindex > s.nelemsscanstack - bad statussend on closed channelspan has no free spacestack not a power of 2timer goroutine (idle)trace reader (blocked)trace: alloc too large is not in the Go heap ) must be a power of 2 23283064365386962890625Logical_Order_ExceptionMB during sweep; swept Noncharacter_Code_PointSIGIO: i/o now possibleSIGSYS: bad system callacquirep: already in gobytes.Buffer: too largechan receive (nil chan)close of closed channelfatal: morestack on g0 flate: internal error: garbage collection scangcDrain phase incorrectinterrupted system callinvalid escape sequenceleft over markroot jobsmakechan: bad alignmentmissing type in runfinqmisuse of profBuf.writeno space left on deviceoperation not permittedoperation not supportedpanic during preemptoffprocresize: invalid argreflect.Value.Interfacereflect.Value.NumMethodreflect.methodValueCallruntime: internal errorruntime: netpoll failedruntime: sizeof(hmap) =s.allocCount > s.nelemsschedule: holding lockssocket is not connectedspan has no free stacksstack growth after forksyntax error in patterntest timed out after %vtime: invalid duration unexpected signal valuework.nwait > work.nprocwrite profiles to `dir`/usr/share/lib/zoneinfo/116415321826934814453125582076609134674072265625Fail in goroutine after bad defer entry in panicbad defer size class: i=block index out of rangecan't scan our own stackconnection reset by peerdouble traceGCSweepStartflate: maxBits too largefunction not implementedgcDrainN phase incorrecthash of unhashable type queuefinalizer during GCrunqsteal: runq overflowruntime: t.spanKey=runtime: found obj at *(runtime: misaligned funcspan has no free objectsstack trace unavailable tabwriter: panic during to unused region of span2910383045673370361328125 ... [output truncated] _cgo_thread_start missingacquirep: invalid p stateallgadd: bad status Gidlebad procedure for programbad status in shrinkstackcan't scan gchelper stackchansend: spurious wakeupcheckdead: no m for timercheckdead: no p for timerinconsistent poll.fdMutexmach_semcreate desc countmissing stack in newstackmissing traceGCSweepStartno buffer space availableno such file or directoryoperation now in progresspanicwrap: Callers failedreflect: Bits of nil Typereleasep: invalid p stateresource deadlock avoidedruntime: program exceeds runtime·lock: lock countslice bounds out of rangesocket type not supportedstartm: p has runnable gsstoplockedm: not runnabletest.mutexprofilefractionunexpected fault address using unaddressable value1455191522836685180664062572759576141834259033203125bad CPU type in executablecorrupted semaphore ticketentersyscall inconsistent forEachP: P did not run fnfreeSpan given cached spanfreedefer with d.fn != nilinitSpan: unaligned lengthno message of desired typenotewakeup - double wakeupout of memory (stackalloc)persistentalloc: size == 0pprof: use of zero Profilereflect.Value.CanInterfaceruntime: bad span s.state=runtime: writebarrierptr *startlockedm: locked to metesting: copying pipe: %v tracing is already enabledtruncated attribute header is not assignable to type 363797880709171295166015625G waiting list is corruptedMSpan_Sweep: bad span stateSIGILL: illegal instructionSIGXCPU: cpu limit exceededflag needs an argument: -%sgcstopm: not waiting for gcgrowslice: cap out of rangeinternal lockOSThread errorinvalid boolean flag %s: %vinvalid profile bucket typelarge span treap rotateLeftmakechan: size out of rangemakeslice: cap out of rangemakeslice: len out of rangeprogToPointerMask: overflowrestartg: unexpected statusrunlock of unlocked rwmutexruntime: checkdead: find g runtime: checkdead: nmidle=runtime: corrupted polldescruntime: kqueue failed withruntime: netpollinit failedruntime·unlock: lock countscanframe: bad symbol tablesignal received during forksigsend: inconsistent statesocket is already connectedstack size not a power of 2startm: negative nmspinningstopTheWorld: holding lockstesting: zero callers foundtime: invalid location namework.nwait was > work.nproc args stack map entries for 18189894035458564758300781259094947017729282379150390625FixedStack is not power-of-2MHeap_FreeSpanLocked - span MSpan_Sweep: m is not lockedPrepended_Concatenation_MarkSIGCONT: continue after stopSIGHUP: terminal line hangupSIGWINCH: window size change_mheap_alloc not on g0 stackbad pointer in write barriercan't preserve unlinked spancomparing uncomparable type cpu profiling already in usedestination address requiredfatal: morestack on gsignal findrunnable: netpoll with pgchelperstart: bad m->helpgcgcstopm: negative nmspinninginvalid runtime symbol tablelarge span treap rotateRightmissing stack in shrinkstackneed padding in bucket (key)newProfBuf: buffer too largenewproc1: new g is not Gdeadnewproc1: newg missing stackos: process already finishedreflect: In of non-func typereflect: Key of non-map typeruntime: casgstatus: oldval=runtime: no module data for runtime: p.gcMarkWorkerMode=runtime: stat overflow: val strconv: ε > (den<g0 stackruntime: sudog with non-nil waitlinkruntime: unblock on closing polldescruntime: wrong goroutine in newstacksignal arrived during cgo execution syntax error scanning complex numbertesting: unexpected use of func Maintrace: non-empty global trace buffertruncated results; attrBuf too smalluncaching span but s.allocCount == 0) is smaller than minimum page size (2220446049250313080847263336181640625SIGINFO: status request from keyboard_cgo_notify_runtime_init_done missingall goroutines are asleep - deadlock!gzip.Write: non-Latin-1 header stringreflect.Value.Bytes of non-byte slicereflect.Value.Bytes of non-rune slicereflect: Bits of non-arithmetic Type run only benchmarks matching `regexp`runtime: allocation size out of rangesetprofilebucket: profile already setstartTheWorld: inconsistent mp->nextptesting: can't start cpu profile: %s trace: non-empty trace buffer in proc1110223024625156540423631668090820312555511151231257827021181583404541015625arg size to reflect.call more than 1GBconcurrent map iteration and map writegcBgMarkWorker: blackening not enabledmakechan: invalid channel element typeno NT_GNU_BUILD_ID found in ELF binaryrace detected during execution of testruntime: blocked read on free polldescruntime: function symbol table header:runtime: sudog with non-nil selectdonesyscall: readInt with unsupported sizetesting: %s left GOMAXPROCS set to %d 2006-01-02 15:04:05.999999999 -0700 MST277555756156289135105907917022705078125MSpan_Sweep: bad span state after sweepheapBitsSetTypeGCProg: small allocationmisrounded allocation in MHeap_SysAllocmissing argument to repetition operatornegative minwidth, tabwidth, or paddingprint memory allocations for benchmarksreceived on thread with no signal stackreflect: FieldByName of non-struct typeruntime: blocked write on free polldescruntime: casfrom_Gscanstatus failed gp=runtime: typeBitsBulkBarrier with type span and treap node npages do not matchstack growth not allowed in system calltrailing backslash at end of expression13877787807814456755295395851135253906256938893903907228377647697925567626953125bulkBarrierPreWrite: unaligned argumentscannot free workbufs when work.full != 0deferproc: d.panic != nil after newdeferheap profile: %d: %d [%d: %d] @ heap/%d received but handler not on signal stackrefill of span with free space remainingreflect.Value.SetBytes of non-byte slicereflect.Value.setRunes of non-rune slicereflect: FieldByIndex of non-struct typeruntime.SetFinalizer: first argument is runtime: out of memory: cannot allocate runtime: spurious wakeup of trace readertesting: invalid value %q for -test.cpu time: Stop called on uninitialized Timervalue size not a multiple of value align34694469519536141888238489627838134765625MHeap_FreeSpanLocked - invalid span stateMHeap_FreeSpanLocked - invalid stack freebinary: varint overflows a 64-bit integerbytes.Buffer.WriteTo: invalid Write countbytes.Reader.WriteTo: invalid Write countcan't call pointer on a non-pointer ValuegcSweep being done but phase is not GCoffruntime.SetFinalizer: second argument is runtime.makemap: unsupported map key typeruntime: blocked read on closing polldescruntime: typeBitsBulkBarrier without typesetCheckmarked and isCheckmarked disagreestopTheWorld: not stopped (stopwait != 0)strconv: illegal AppendInt/FormatInt basevalue too large to be stored in data type173472347597680709441192448139190673828125867361737988403547205962240695953369140625acquireSudog: found s.elem != nil in cachepersistentalloc: align is not a power of 2runtime: blocked write on closing polldescruntime: heapBitsSetTypeGCProg: total bitssync/atomic: store of nil value into Valuetest executed panic(nil) or runtime.Goexittesting: invalid regexp for -test.run: %s unexpected signal during runtime executiongcBgMarkWorker: unexpected gcMarkWorkerModegentraceback before goexitPC initializationheapBitsSetTypeGCProg: unexpected bit countmultiple Read calls return no data or errorrace detected during execution of benchmarkreflect: FieldByNameFunc of non-struct typereflect: nil type passed to Type.Implementsruntime.SetFinalizer: finalizer already setruntime.SetFinalizer: first argument is nilruntime: casfrom_Gscanstatus bad oldval gp=runtime: releaseSudog with non-nil gp.paramunknown runnable goroutine during bootstrap using value obtained using unexported fieldgcmarknewobject called while doing checkmarkreflect: funcLayout with interface receiver runtime: lfstack.push invalid packing: node=systemstack called from unexpected goroutinewrite a goroutine blocking profile to `file`exitsyscall: syscall frame is no longer validheapBitsSetType: called with non-pointer typereflect: internal error: invalid method indexreflect: nil type passed to Type.AssignableTorun only tests and examples matching `regexp`runtime: failed MSpanList_Remove span.npages=panicwrap: unexpected string after type name: reflect.Value.Slice: slice index out of boundsreflect: nil type passed to Type.ConvertibleToruntime: failed to create new OS thread (have runtime: name offset base pointer out of rangeruntime: panic before malloc heap initialized runtime: text offset base pointer out of rangeruntime: type offset base pointer out of rangestopTheWorld: not stopped (status != _Pgcstop)P has cached GC work at end of mark terminationaddress family not supported by protocol familybufio: reader returned negative count from Readtesting: invalid regexp in -test.list (%q): %s P has unflushed stats at end of mark terminationbufio: writer returned negative count from Writeif >= 0, calls runtime.SetMutexProfileFraction()runtime: cannot map pages in arena address spaceruntime: malformed profBuf buffer - invalid sizestrconv: illegal AppendFloat/FormatFloat bitSizecasgstatus: waiting for Gwaiting but is Grunnableinternal error: fillWindow called with stale datainvalid memory address or nil pointer dereferencepanicwrap: unexpected string after package name: reflect.Value.Slice: slice of unaddressable arrayruntime: unexpected waitm - semaphore out of syncs.allocCount != s.nelems && freeIndex == s.nelemsstrconv: internal error, rest != 0 but needed > 0strconv: num > den<status is not in scan statefunction symbol table not sorted by program counter:runtime.SetFinalizer: pointer not in allocated blockruntime: use of FixAlloc_Alloc before FixAlloc_Init reflect.Value.Slice: string slice index out of boundsreflect: non-interface type passed to Type.Implements goroutine running on other thread; stack unavailable gcControllerState.findRunnable: blackening not enabledno goroutines (main called runtime.Goexit) - deadlock!reflect.FuncOf does not support more than 50 argumentstesting: invalid regexp for element %d of %s (%q): %s bufio.Scanner: SplitFunc returns negative advance countcasfrom_Gscanstatus:top gp->status is not in scan stategentraceback callback cannot be used with non-zero skipnewproc: function arguments too large for new goroutinereflect.FuncOf: last arg of variadic func must be slicereflect: internal error: invalid use of makeMethodValuein gcMark expecting to see gcphase as _GCmarkterminationpanic test binary after duration `d` (0 means unlimited)set memory profiling `rate` (see runtime.MemProfileRate)gentraceback cannot trace user goroutine on its own stacknon-Go code set up signal handler without SA_ONSTACK flagruntime:stoplockedm: g is not Grunnable or Gscanrunnable comma-separated `list` of cpu counts to run each test withbufio.Scanner: SplitFunc returns advance count beyond inputsync/atomic: store of inconsistently typed value into Valueruntime: malformed profBuf buffer - tag and data out of syncreflect: creating a name with a package path is not supportedset blocking profile `rate` (see runtime.SetBlockProfileRate)found bad pointer in Go heap (incorrect use of unsafe or cgo?)runtime: internal error: misuse of lockOSThread/unlockOSThreadlist tests, examples, and benchmarch maching `regexp` then exitruntime: bsdthread_register error (unset DYLD_INSERT_LIBRARIES)flate: invalid compression level %d: want value in range [-2, 9]runtime.SetFinalizer: pointer not at beginning of allocated blockruntime: ReadTrace called from multiple goroutines simultaneouslystrconv: internal error: extFloat.FixedDecimal called with n == 0write a mutex contention profile to the named file after executionruntime:greyobject: checkmarks finds unexpected unmarked object obj=runtime: cannot set cpu profile rate until previous profile has finished. runtime: found space for saved base pointer, but no framepointer experiment reflect.Value.Interface: cannot return value obtained from unexported field or methodtesting: cannot use -test.coverprofile because test binary was not built with coverage enabled 00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899M ~v]0 sP   0 `  P04 =00еpc0.^ ^ R  O @X I J  N \ K @P G pU S V Y L pQ H Pl Ph0fPg gf@0`fPp~_`_ ^%F:KKNU`p`jphilh0D`@CP}`} 0`0p 0%`P^ @P@P|* `@o0 00 @PpP*pcP@ @0 ` P37@HIPCd0`0fP 0bbg0hj`{}pv5O+p$n $   (     0    %   +          dd `K`[  WEa'%       ! c`c   r  $$QQQ   #! ca +*        ba    O71)(   710   ##!`` A        !  h``@++ cc`b ! `@     2      uqpuq  `a        A@!   57=05    #"  -, a`     # <<      0   RS   `011edeeedccccc o     <   05444444  RP  y`$   a`h 9   A   K A  *8    @ xx)       20 @          PT    @8}|         @  #   $ GO   1  ("b$!    xx   @   ' $    8@9@?@0@            @  N   W_]E%U 00$   @       ZRB ;  A    PUU   !08     TD )!(  f&FVֆ   `aa  # ($  0 80       AAaQ I@   KKIAA F -+!  `a@ 30 @UAUCUCUR'P'P'dH@    K       20540  !!''&!  220//  / UUU U   kh#``(@@ ''!  PQTVPX    $,=D 0  D  @ @DC  ;?   OG @MLL,,p   A`  888 KKKKKKHKHH `(  "!!)02r &6  @!$ xxxxx    A@  |LL "  00 @B{;!+wgc@`!  )  , <,,('**   0  4 8 K BI @HhmeEUejill @!1!%< !%!@! Rf"1#xx      $  . "  QQPPQQ" @@  L LDDLDLDLDLDDDDD"??(  A!  |xp@@@@@@@@@@@@@@@`@& ``-      끃  )@@ `  @ !@A  #@ 4( ??  kkkkkkkkh`````````h``````kk6` 0`0```?`?` @@A@BaA`@]M :0 0 B@ B@N@ B @"@ "2"@ QD$ `  `0`  '@ @ @A00 ,@ ` ?owGGW}~x??+` `   4  ^`  :. < <    1I$I$5I$1I$1I$5I$!I$aI$)I$!I$!I$#I$!I$I$%@  @&22HII II 60000YYYIHH M  P0S S 00@B0 A! `>G7 ' `6@QA@@@@@ @@@D@@@@@@@@H   3 !!!      H@L``ac aa`D@@@$@    X   ,    \IBS  s  {  [  S  [  S  S @ S  W  W  W $ ! S G  bX(RJ(RJ(RJ(RJP(RJ(RJ(RJ(RJ@Y(RJP@`@@H@@D4@4B@A@@@PF00G7 ' ]`0`4] @@B@B@@@@@D@@D@@HP@ @ AQ00 000 0 0 0 003 3 00 00U@@@D@t@uPt@t0P0P0x0xpxpxppu@!< H0($"! @  SRR R@  ">$ $$$$$$ $$$$@@`aDDDDe@ c  $   V     < <   -       j@@@$@@@@@@@ @@@@@@@@ |hhh`@??? hh$T T TTTT@TTTTT@T@@@@ @@TTT@@D.@@@@@@@?@?@@@0@0@S  3 00  00  @ 00  @ 00  00   "$'),5689>*?llV???UUUUUU???UUUUUU???0B.??ffffff??+eG??@@@$@:@Y@9B.@.AeA4&k CC9B.4&k ?$acp-  )6)b188hQn! 6g- - SSSSSS( +DTЗuq7[o!--Q('<9o!o!o!t+^^ex$hj =as"+50-.T:7s"6s"y$_)" |%;|%o!-x$-:o!|o!o! t"zUa()(15.AH;5Jm!# go!u% . /pY/L#d#d#d|%}&/L0YYXXCWM#dAW  AqAA11z_0)!f!f?f*p;&_qq[q[Jq!;'00(dwS?Y*  S8(M* ( SkSJkJD7 # 44s. .=|              !# 4:C QV dgk t          &,16 ? M a k w          # 2 > I V[ js      % 9 CKP a y          ( @ Y n   %')     ; QX` mqx         " .4 > M Y m vz|       %'()+1 ;A JSY] j w &.39"%-28`>>> ?`??? @`@@@`e}`}} ~~~@` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @` @`  @` @`@ @` ` @`BB G`G C`CCC`DDD E`EEE F`FFFGG D H`HHH I`III`J JJJ K`KMKK L`LLL M`MM N`NNN O`OX Y`YOO P`PPP Q`QQ`RRR S`SSS T`TTT U`UUU V`VVV W`WWW X`XXYY Z`ZZZ [`[[Q R[ ] \`\\\`]]] ^`^^^ _`___ ```` f`fff`  jj k`kkk l`lll m`mmm`n n`@n@n@## o`oo`` @`o p `pp @` @@p` ` $`$@`U` ` `  `     ` ` @@@@@@@@@ @` @` @`aa`bg@`ppw`n`hh `i`b=i``cc`dd`e n`jj`xe@ `>`oo? `k`fk`ll`ma@=``A@Bfm`q C`g q`rD``bDr`s`suyt`t`u`vv@@!! !`!!`!! !`!!! !`!!!! !! !`!!! !!@!!!`!`!!!! !@!! !`!`!`!!!!!! ! !e p(P  `ph0HP(pP p 0x`0@8  !0" $hp$$P@%%P&&H(* +0P,, P--P. 34@79P0::0@B B0C PFFpMNOpPQhPR@TpU VXhYZ[[[ ]x_0 `@``0jx@o0rr@st8t tzzpz@{H{P|`~x8@x0@@ 8  P  H @ P ph  8 P@pXhpx000(@(@(P(0`08p0@  `X!!@"0"P"0# 8$0$%%&0''( h) * *,-p--ph..p/`/`0`11` 2  3!3" 4#4 $@5%5`&X6&6&07'7'7 '88(8`(H9(9@*:* ;+;0,0<,<, =,=,=-`>->-P?/?P4@4@A 5A@5 B5B5C 6pC9`D@:E<EP>xF@? G?G@HH0J J N(K@OKP\M`\XN]Np]PO^O_P_Q0d8RPeRfShHT iTpi@UiUiV0jVjWkW0n`XnX@o`Y`t`Z|[`~X\`\Ѐ]^^_0_`0x``a aЌbXc0dpeepHf0ggpiPipXjЮXkkвlm@nnpHoo@xp qqrrs t0t @uuv`wxPy y@z z{|@}P}~`X@ȃP`08HPXp Ph@```pX`PP` @ !(`!#h#@$P$И'(`)@*0P**- . 0.@./p/P00 33(4ȡ578:8<ؤ=PApAAx0D8DpEPEةFhLL MpN0Pح@SSSpTدUUW X(YZ[8P^^_0`ȶ0a@a0bHdPdef@f gg(hh(llmpmPn `o qPqrXss`Puup0v wh@w`wH`x{|0}00P`hЌ@ X`XpX`@xp`xh`0HС0`P08@HЧHXЪ(ЫPP pp00``е@x `@@P PPhP`0p@(phPXp@p0 p x0@p`00`(  PH    h p @  @(0@h0 PH``H`xP H  X0 0  8`8@Pp p `! !!x"!"P##% $ %x$ '8%) &*&+8','-`(p/)@9*0:+:,P<,?-P@.@.pB@/@C/CP0C00DH1G02 H2Jp3K3Kh4L5N5POP60R 7S7Th8U9V9W@:@X:P];`<bH=0d=dh>d>e`?f?PfX@f@fAfxA gAPgXBgBkCplD@mDPnHEvFw@GxG{H|IIJK`@LL0M`NNДXO`O pPQ QRИpRSSXT`UUVpV0V@HWpW0X XP YY 8Z@Z[[[8\У\]h]]0 ^`^^x_@_P`@ab0ccP0deйef g@xggXhphPi0i`0j0jpklXmPm nnn`ooppPp@qPq`@rprspss(ttt0Pu upvpwwx`xyy`zpz @{p{x|@|p8}~h ``p@@h0ȅ8 ph`؈HP(@xX0Ȍp8`X@(hP`ȓ@800X0hp00P@   p"`"Н"@0##(p$0%8%P&(&'((0)*..x.إ12@3ا4x59<<P@==(@pIIJ KxK LXpMPȱP(P^`^^hp`0 bPbPd`exePfXfиhhph ihjkmPmn8op@qоr`ssX`tuXvPv@vvwPwwhww0wxx@ xx(yz8}p0H` `PH`p 88@`pPpP0P0ЩЫX`8@0 `pp0hp8@pP0( P@00H `h00(p00@@HpH`8 (8H@PHPX0H`XX`x 8P@XP0!"@#%X % (p +0 +  , - /X P0 P122203P6@6 :p:=p>P@?`?@??`@@ABBDK@Z`ZhpZZ(P\]^0^p_`_x _ _p!0`!`P"`"@aH#a#bh$pc$ch%f&g&g'Ph'h(h(i)Pi)i*j*pk8+l+mX,`n,np-o-`o`.o.pp/ q/Pr0r1 s1s 20u2u@3u30v04v4v 5 w5y86@z6P|h7|7}`8`}8}H9}9~@::8;`;H<<P= =H>>P0? ?`H@ @ PA A0B@ CCCphDD0PEЍE0FxFЏGhGG@HH` IIJppJ@JXKKHLLP8M M(NNO`O0PPПQQpR@RSSS0T T`T U0`V@VPVp@WWWhX0XPYP[[ \@X\p\]Эh]`^0^p `x`б`bbHc 8dPdpde8fff  g0pg@ghjPl``ooo8ppp(q0xq`qprxrrs@s0@t`ttPuu0vPXvvww@xppxx0yyyHzz@zX{{|h|p|P}}(~`~Phpx  P0P@ppЇ @(@0xP`ЋpHp8( 0Pp`p `ؓH@p @h@X@ؘ0(К`0 Ȝ 0@` p `آH`8p(p (` ȧpȩ08P h0جHP(p x@X`Ȱ`p P `  Xp`x`h H@(00 x@P`H p"P#8#$0,(@./28P37@8P9 p;=`?80@PCF80GpGGx@H IIJK0NO(PVYZ8]dh0k@klH`m`n0@prXptu`y`zx {{h Ѕ P@P@h`XP(PPPИ`0`x pPxPhX@`@Т `@@  0 P !` `" "X p$ $X*(+0, /p//p/`0@`12X3P4XP5@7h79P:0;H;C@Eh@F`FPGI`0LLP`RS@pSS `UV V  W!0\"P^"P_P#`#a`$b$cx% e&y'}h(`~(~H)* +0,-`x--`.`.Ф@/p/000Ц0(101P22 2p`33``4 556pX707h88x9е:@:0;;P@< <X= =p>>p?0?px@@@xAABhCDPE@EP`FFhG`G``HHII0JJ(K@K LLM hM`M0xN0OO@XPPP`8QQ8RRHSS@ThTPUU0HVV@`W0W0PX XPZZP [px[\@\\ h]8^^"H_%_'h`+(a+a+a,0b`,b-(c-c-c.8d`.d.d.Hep3f04xfp5f6hg6gp7Ph:h:Hi<i@=@jp>j@?8kAkAHlBlEm FmFhnFnF o0GoGpH`pHpI8q0IqPIqpI@rIrJsKsNtpQuTpvpVPw WwYx \hyp^8z^z^{pf{f0|g|`k}s(yPh Pxp@H`Љ ؊PpЋ0xX Ўp` pp8ؓP@`HPhP@X0 Ȟ P Р С  8  P" x# `$ p % -  / 0 P6 Ш08 h@O  O P @Q  R R ppS @T hU pV 0W (] ^  _ 0_ a (@b b  c c  d he e XPf g 0g `h i j k @l @m hm n `o r @t hv @x y PPz z 8{ } x@ ` H   XP p (   (  @ " # X$ $ X`% % H & ( )   ) p* * p* * 0* +  3 4  > `B X`C D @E E `H PI  K h M O P P `Q  R R 0PS PT @@U V XV W H`Z Z p] 00` 0c q u v 8}  P~ ` ` 0  p `   H h  и P0   8  8 0 h 0  8` 0 P@  0  p 0 P 0@ p  0  P H`  0  `  ` @   @  @   h     p  0    Pp % ' h* 0, , P.  0 `1 6 > P@ 0B C E PF G H I J K L  N x O @P hpQ R XS pU XV @X X Y  \ ! ^ "^ "^ "`_ p#` #a p$b $c P%Pd % e 0&f &@g P'j '0k h(Pl (l `)@m )m P*n *n 0+o + p  ,p ,`q - r -s .u . v .v x/w /@w 80`w 0w 0w X1w 1w  2x 2 x 2Px H3x 3x 4x p4y 40y 85`y 5y 5y `60z 6z 07z 7z 7{ P8 { 8@{ 9`{ p9{ 9{ 8:{ :{ ;| p;0| ;`| 0<| <| <| P=| =} > } x>@} >p} 8?} ?} @~ `@0~ @P~ (A~ A~ A PBP B  C C C @D@ D` E `E EЀ (F F F0 `GP G (H H H HI I J@ pJ` J 8KЂ K L0 `LP Lp (M MЃ M HN N@ O` pO O 0PЄ P Q hQ0 Q HR R0 S` xS S 8T T U `U U@  Vp V V HW W0 XP pX X 0Y YP Z hZЉ Z ([ [@ [` H\ \ ]Њ p] ] @^0 ^ (_Ќ _ ` `@ `` Pa a (b b b `c0 cp 8d dЎ e pe e@ Hf f  g g` h hh h 8i i j@ pjp j Hk kБ (l l m m n pn n @o@ o` p xp p Hq q0  r` r r XsЕ s (t@ t uЖ pu uP @v v w xw w Hx0 xP yp y y `z@ zP h{p { 8| | } p} }@ @~` ~  x  PP p     X@ Ȃ 8  @ p` ؄ @   x 0 PP p (  00 `  h Њ 8   p@ ،p @   0 P P    P  hФ ȑ ( @ ` X   Х   h0 Е PЧ ؖ @ @ ` x  H   0 p X Щ (  @ ` ȝ 8 `  x  H  @ p  P Ь 0     p إ @@ `  x  H 0  `   Xа  (@  б h جP 8   ` Ȯ 00 P p h ذ @г   p@ в` 8   h д 0@ `  `е ȶ 0`   h ȸ0 (P p  `  (  @ h` ȼ ( и  H 0 P hp ȿ (  @ P`   p 0 8 л  `0 P  p   @   h@ ` 0  н P  0 pP p 0   X0 `  x п 8 P  h  (P p  H   h @ 0`   X   x0 P @p   h  0P   P  0 xp  H @ p p  0   P@ `     P    p    @ p   p p P 0 (  8 P`  @  x  P   (  ` p @  0      x @ x`  h  X   0 ! P`# % & 80- 00 `3  : L k `m ( p pr x s  s p  h   `  Ј   x  ``  ` ` Б    ( P  `P  X  0  P@ p p pб (@   0 ` `@  P   p  p     X! ! H" " @# #0 8$` $P % % % p&p & ' ' x( H) (* *  +0 + @, ,0 (- - (.0 . / /0 / x0 0p h1 1 h2p 2P 3@ @4 4 6 87 7 8 x8P 8 `9  9 p:` `; ; p< <p X=  =0 P> > H? ? H@ @0 A A hB" B$ C* pD+ D. E/ 8F1 FP4 G07 HH 8 H 9 8IP9 IC KD K0E KpE PLG LPJ ML 8NM N`N 0O@O OR `PT P0U xQV RW R`\ S^ 0T _ Tpc UPd UPm V0n PWo Wp pX`q Xr pYs Zpt xZt Z ~ H\  \ 8] ] (^ ^  _ _  `Є ` @a a `b b c c  d dp eP fP f 8g g0 Hh h@ i Pj j k m0 m0 xn o o p Xq q r `s` 0tp u u v ww xxy 0z z`{ {H|0|p`}0}h~ppx !"80$,3xP<X@IPXXp[\p\0bȊb@ cȋ0f`f،g`0h؍jpv`{h{ؐ}`~ ؒP0`px `8  h НhXx `@pв@ (0ȥеPмxP pp``pЭ0xx  `-ȸP1й0<hp=P@м@HB@CHxLxQh_8cpfk o@Pq`~`P@p X@Ю(вX HpH`xhнhHHpPxP08 pP xh(:P;; ==`>>p? @p@AApCPCXGHJPV[@\\ ]bhcemo8 z`P8pP 8p0xp0Ф@@@ @x P   `( p   XP`hp@ 0 h`@`(h8P0(80X@ !p!p!"#P# 8$ $0 H%` %@ @& &p P''`(@(p)p)*+@+,p,(--@8..@//H00P`1 (2p 2 2 &3*h40X546566(7P879h8:9<9D:J;J<0L<L8=M=O>Q ?R?SH@`[A0\B\pB]B]`C]CeDf`ElPF`qHGrG sXHtHvI|xJ~(K@M0MxN  O0OPQpXRRxSЪS@xTUU VVW`X@XZZ08[[0\H]]p^_0aa`hbbcde8fPg`(h i j jk Pl l0 m` m0 xn`ooqq"r@#Xsp#s#8t$t@%@up%u&0v`'v' w`(w(x(`x(x((y)y@)z*z+ {+{`,(|-|-(}P.}.(~/~@00001P3 304p6687Ѓ8@: ==`> @`B@C؈FKhpVZp[ ]^ cȎdh e؏p{ȑ0@Њ(P ȖPФHp@p @  0@00p@0Px0h`x p  p  P   @!&-P6ر7x`@xpBpDD@PEȵPLL  MM(T`VpWW]@PfHgjpkkxpllx`n qq`0sstuv w x0yy8`z{8 ||8x @`p0` 8P`(pHP0h  0HpxPx8p0dgE#sync/atomic.(*Value).Loadp_op_op%o >3   "     HgE#d{ܳȲsync/atomic.(*Value).StoreF `!   +2. +3 .)  ; !% gE#!2sync/atomic.CompareAndSwapUintptrbXgE#z}2sync/atomic.CompareAndSwapUint64n gE# 2sync/atomic.StoreUint32   gE#9<?02sync/atomic.StoreUint64gE#@2sync/atomic.StoreUintptr gE# $htype..hash.sync/atomic.ValuePnO B" `gE#|type..eq.sync/atomic.Value {  `gE#$Xruntime.memhash0 `p8gE#JQT_$hruntime.memhash8P>O Yf"'9gE#$hruntime.memhash16P>O Yl"'90gE#+25@$hruntime.memhash32P>O Yr"'9gE#$hruntime.memhash64P>O Yx"'9gE# !$hruntime.memhash128P>O Y~"'9PhgE#y$hruntime.strhashPAO \"<gE#$hruntime.f32hashP]OP/OP.O &:0/ ; XgE#ix|$hruntime.f64hashP_OP/OP.O &:0/ = pgE#$hruntime.c64hash@S? n":2HgE#Zadp$hruntime.c128hash@S? n":2PgE#$$runtime.interhashO & PK  O: `gE#v$$runtime.nilinterhashO & PK K: gE# $Xruntime.memequal0 PgE#cfiTXruntime.memequal8 gE#TXruntime.memequal16 gE#TXruntime.memequal32 XgE#lorTXruntime.memequal64 0gE#TXruntime.memequal128, ,'`gE#"%(TXruntime.f32equal" "hgE#z}TXruntime.f64equal# #gE#TXruntime.c64equal9 94gE#+.1TXruntime.c128equal; ;6@xgE#hruntime.strequal`6_`_ p"G] gE# hruntime.interequalP6OPO k" /X  `gE#whruntime.nilinterequalP6OPO k" /X  gE# !Pruntime.efaceeq2 & J3 I/ !p gE#Pruntime.ifaceeq2 & J3  M/ "gE#!.2\XXruntime.alginit@?@? !-    '  $gE#hruntime.atomicstorep0I/ N. $p$ gE#.58Cpаruntime.casp@o? t:F$*$gE#hsync/atomic.StorePointer0F/ K\ $@% gE#+25Exsync/atomic.CompareAndSwapPointerPgO l'$"%gE#\runtime.cgocall`_`6    c+R:M& gE#036Bhruntime.endcgo   &gE#HDruntime.cgocallbackg>'  % /(pFw(gE#/KOHruntime.cgocallbackg1-w !  -5  % &  P.i#   !L ! XG 9G *gE#&(аruntime.unwindm0Q/0/ "      '  )E +pgE#Druntime.cgoIsGoPointer  Ig#|4NP, gE#Xruntime.cgoInRange## ,`gE#~0runtime.cgoCheckWriteBarrier`]_`_`7_` _` _,     . '  #P-(gE#,0Cxruntime.cgoCheckMemmovePOOP5OP OP Op'  %?#-@gE#0runtime.cgoCheckSliceCopypop op op o$    )@D.0 gE#Lz~runtime.cgoCheckTypedBlock3 I; >5  5   + )?$ 6]mzIBI]m44 30 gE#FPT8lruntime.cgoCheckBits    /  /& *+yg14 gE#"&Pruntime.cgoCheckUsingType=[  &        "D % (%   "5!  "% d`-F @7gE#<runtime.makechan ~&2 .     : ; )  x"f= 9gE#$hruntime.chanbuf@A?\"3<0:gE#)hruntime.chansend1`H_M ':p(gE#aHruntime.chansendj^=  7>  #m        1   $ ! 29 '   #G I kO@ `+1/!WI /N,;_U @(gE# @runtime.send`~_`_ !(    ) =+ G@Y3 B`gE#t{\runtime.sendDirect`q_ "     Q% BgE#\runtime.recvDirect`q_ "    Q% 0C`gE#sruntime.closechanI !  "!  ?B ?  }  75f.3+o ? , !A PF@gE#SZ]ihruntime.chanrecv1P0O5 &F gE#runtime.chanrecv:+o  78#y        1     & ?    -P%( (='@ td31rA!H/_!,;?Z.G[ M0(gE#>KO0runtime.recv`_`_ &8    3 %  ;,+ r@E=4J NgE#Xreflect.chanlen   O@gE#Zimruntime.(*waitq).enqueuePiOPkOP`O  &!     ; pPgE##W<runtime.(*waitq).dequeue`_`_  !    ! H' QgE#XXruntime.init.0aa   PRgE#+BF{ĤXruntime.SetCPUProfileRateZ l&  *   9c$    + J @T(gE#(xruntime.(*cpuProfile).add !  m   #G/ pU` gE#hruntime.(*cpuProfile).addNonGo@?@& #R   VgE#)-Yhruntime.(*cpuProfile).addExtra $ }9   &Z    XgE#ĤXruntime/pprof.runtime_cyclesPerSecond !<Y(8gE#CTXxTruntime/pprof.readProfile 6 5 s /  :p ZgE#̥Xruntime.GOMAXPROCS@j?@F? $&   ! C [PgE#fmpwĤXruntime.NumGoroutine !<r[gE#Xruntime.(*timeval).set_usec   [( gE#:PTi`runtime.gogetenv" !e9 !x~" ]gE# runtime.(*TypeAssertionError).Error"| >: #N,*K  }= _p gE#(hruntime.errorString.Error]xh(N# ` gE#Xruntime.plainError.Error~@`X gE#lsvXruntime.typestring@F?a"*&4`gE#V `runtime.printany 7ELPWTSDCH.G,+$#87L&K@?<; 43P%O('0/, L # d ?77 7 0jgE#runtime.panicwrap"   9<!"j e! =@[R VY O=37  @op0gE#pruntime.Caller"FG 2$ 76?. ? GH m r(gE#$'3hruntime.Callers`&_`:_ |"6 \rgE#̥Xruntime.GOROOTPEOPO # 1GsgE# /̥Xruntime.fastlog20/0/ "' ] , tpgE#̥Xruntime.float64bits $ ^ tgE#̥Xruntime.float64frombits $ j t0 gE#ARV\runtime.memhash & 0!&#@    !   W      /77 8O 7 2 &( : }EHHHP^+n. zPgE#adg̥Xruntime.rotl_31& zgE#Xruntime.evacuated( zgE#*14@hruntime.(*bmap).overflow@@?(["  8@{gE#$xruntime.(*bmap).setoverflow@L?@?(|" " 86{gE#/:>TXruntime.(*hmap).incrnoverflow0X/0/ ("       /Q P| gE#runtime.(*hmap).newoverflow (& "D%$!! P L5%a0H, ~XgE#xԬаruntime.(*hmap).createOverflow@1?@? (&  DC T-0 (gE# `Xruntime.makemap ( &  04  %  .   "! q:N   r Tf!+8> < (gE#!% runtime.mapaccess2^ (&       2.  #$$+" ( tOd9f (gE# ]runtime.mapaccessKR () )   $ 7 3#$6?$  " j<MBb9X  gE#pruntime.mapassign (7  . &!" W"  N6R e$ )1 D?&a   F'  1    * % e- F  |;UCwo#|9J>/(<5C#@ gE#59H\runtime.mapiterinit ( &          * # N " '-0  W!:( gE#-DH4runtime.mapiternext C ( /    @:14 " @ %  %*"! 9' A,C7!A5> ; 28  $12",( 8  ;,uy 9Pa6 x gE#runtime.makeBucketArrays (+!%('    \J2"IA  gE#2CG@runtime.hashGrow (& *     &&,   ,5 572S< @gE#$Xruntime.overLoadFactoro(ojHgE#hkn̥Xruntime.tooManyOverflowBuckets9(9 gE#Xruntime.(*hmap).growing(gE#.14Xruntime.(*hmap).sameSizeGrow(0gE#hruntime.(*hmap).noldbuckets@N?@ ?(s"&.>gE#'.19hruntime.(*hmap).oldbucketmask0./(I" &gE#hruntime.growWork@_?@#? (& ' *i  gE# #-hruntime.bucketEvacuated@S?(n")A& xgE# runtime.evacuate (7?     5   $ $7$(;8 $< .! $&+ WxG,GK 0$< , + $&YND,DH -$< g1.7 ? #   'P 2 55 A$( -[G \3|e(|/)a()B  (Z~+  "()7 0 gE#B E H Xruntime.ismapkey(   gE#    Īhreflect.mapaccess`H_`_(g":& gE#% , / ? ԩreflect.mapiterinitPTO(o$(' gE#    hreflect.mapiternext !(<"  &@ gE#   Xreflect.mapiterkey( PH gE#X [ ^ Xreflect.maplen(  p  gE#   ! runtime.mapaccess1_fast32> *&    & = 74#'2+ \a6V x (gE#    runtime.mapaccess2_fast32F *|&    & E #74#'2+% \q6^ H gE#cruntime.mapaccess1_fast64> *&    &= 74#'2+ _a6V (gE#3PTruntime.mapaccess2_fast64F *&    &E #74#'2+% _q6^ P(gE#AEruntime.mapaccess1_faststrO$ * 7   '  +O&7     Y  ' F:#*   ,L )98.9O   +Oq& eo0B 3 M9\X';\ @@0gE#\'runtime.mapaccess2_faststr&W,& *7   '  +W.7     Y  ' F:#*   ,T 198.9W  ' +Wq. eo0B ; U9\h';l p gE#?8 runtime.mapassign_fast32 * , L &! O61@ C)# 6?&S   8' 1  *! W- F   N6FnKRO < 2@ #@  gE#O8 runtime.mapassign_fast64 * , L &! O81@ C)# 6?&S   8' 1  *! W- F   N6FqKRO < 2@ #@ p(gE#hruntime.mapassign_faststr * 7 L &!" W=R3@ C)+ >?&[   @'   " *! _- F   Y;INv4 < 2@ #@ gE#TXruntime.itabhash:,:.'0 gE#Aeiruntime.getitabj ,>7   36  $    : 2:!  ]!+ fykoD %"$$) 08gE#IZ^runtime.additab  , 7     ,) =+@',,,%( , 5P ]d9(kR   ) >7 O5-M302(@ dK&0(' 9> XgE#kuyhruntime.itabsinit ,(  .    ,J` gE#runtime.panicdottypeE ,&  F"$/) pgE#hruntime.panicdottypeI@>?@?,]" C0 gE# ԩruntime.convT2E`n_ ,*  8'# h gE#{Xruntime.convT2E16P6OP.O,"  &a@ gE# Xruntime.convT2E32P4OP,O,{"  &_h gE#{Xruntime.convT2E64P6OP.O,"  &a@ gE# ԩruntime.convT2Estring`7_`^_ ,&  *4 j7  h gE#~ԩruntime.convT2Eslice`6_`f_ ,&  *< i?   gE# ԩruntime.convT2Enoptr`q_ ,     8*# Ph gE#{Xruntime.convT2I64P?OP)O ,  ! e  gE#  ԩruntime.convT2Istring`@_`T_ ,!  4 i7  p gE#ԩruntime.convT2Islice`?_`\_ ,!  < h?  `0gE#+hhruntime.assertI2I2P>OPAOP O ,& ! ! hQ 0x(gE#`runtime.assertE2II ,&  >.$\6 p 0gE# # ' 9 hhruntime.assertE2I2PSOP OP O ,&   !! >o 0  gE#    ̷reflect.ifaceE2I[2 ,& !( >H !gE#!!-!1!I!4runtime.(*lfstack).pushptopo .4& "  :`'u> `!gE#!!!!Xruntime.(*lfstack).pop@T?@? .T    3H "gE#2"5"8"Xruntime.(*lfstack).empty.px"gE#"""Xruntime.lfstackPack0L0"gE#"""̥Xruntime.lfstackUnpack0TP8#gE#F#V#Z##8\runtime.lock`_`_`_ 2H!  &/       m 0#gE##$$+$(\runtime.unlock@t?@P? 2!    +   p$gE#$$$Xruntime.noteclear 2 0$gE#$$$%hruntime.notewakeup06/0//2"    W"X%gE#k%{%%%pruntime.notesleep`_`&_`6_ 2! #  &     C3" %(gE#&0&4&&Druntime.notetsleep_internalPOPOPDOP5OPOPQ2 *           = ? x yH9U=&gE#&&& '$hruntime.notetsleep`p_`_ 2! 8 F*3 0X'gE#m'y'}''$hruntime.notetsleepgpopo 2!   .   :6H 'gE#'( ((xruntime.mallocinit 4 /!   *&D!1  |      $C/    (]7S y @1 (gE#( ) )T)$hruntime.(*mheap).sysAllocXs 4&!v$-  y# - $  E:;  Z Z )gE#))))Xruntime.nextFreeFast@?@?@? 4&     [ @*(gE#\*m*q** runtime.(*mcache).nextFree 4& 7    "1 ,v v  PT * gE#+'+++A,HHruntime.mallocgcm 4 6<     <      }<     !   '' # #9+   ) W    )))D     ! #$ z    # M sI&7%-- ?/ P#&@=m ,gE#,,,-\ԩruntime.largeAllocpop6o 4 & H "7 ^[}" P-gE#c-j-m-u-hruntime.newobjectP8O4S "*3p-gE#----hreflect.unsafe_New0+/4F "&0.gE#B.M.Q.].$hruntime.newarrayPfOPO 4 &*5 7.7 p.gE#....hruntime.profilealloc0A/4\    )(/gE#6A6O6hruntime.typedmemclr@7?@)6e  '-, `&6gE#6666hruntime.memclrHasPointers@O?6T -&7gE#7!7$7Xruntime.addb8  &h7gE#{7~77Xruntime.subtractb8'7gE#777Xruntime.add18 '8gE#+8.818Xruntime.subtract18 'x8gE#8888Xruntime.(*mheap).mapBits`g_`R_ 8&  =  > (9(gE#,93969B9`hruntime.(*mspan).allocBitsForIndexPLO8Q%,`(9gE#9999Xruntime.(*mspan).refillAllocCache@C?8^"  4#(:gE#0:H:L::hruntime.(*mspan).nextFreeIndex`_`G_`?_`_`_ 8&     5 j @*:gE#:;;;$hruntime.(*mspan).isFreeP+OP1O8x" L%*`;gE#{;;;;Xruntime.(*mspan).objIndex0S/08/0/ 8&   9  * +; gE# <<< <ԩruntime.markBitsForAddrpso 8"5 &, 0,p<(gE#<<<<`hruntime.(*mspan).markBitsForIndexPLO8g"4,,< gE#===Xruntime.(*mspan).markBitsForBase8,X= gE#s=v=y=Xruntime.markBits.isMarked8 ,=gE#===Xruntime.markBits.setMarked8 ,(>gE#M>P>S>Xruntime.markBits.setMarkedNonAtomic8 ->gE#>>>>Xruntime.(*markBits).advance0C/0/8z"   `- ?gE#9?F(gE#FFFG`hruntime.heapBits.initCheckmarkSpanUo 8 &    # F @?`G(gE#GGGG`hruntime.heapBits.clearCheckmarkSpan@U?8p "  B'?GgE# HHH?Hhruntime.(*mspan).countAllocI 8 &    $ Kr7 @H gE#HHHI@runtime.heapBitsSetType -: 8 7" j #   9   63f  # "      H vy / B& S     7: "      Q%2  Y1*?_" gh"   _!u ; M V < 8 0J`J8gE#JJJKпruntime.heapBitsSetTypeGCProg 8! 0"         6-!2Y -j + v  d H& NhK gE#KKKK\runtime.progToPointerMask0 8&. >  YZD @OL(gE#L$L(LMtruntime.runGCProg" 8O 5   "   ?       G         ! $      (  C6  $   $   _   " +     +6&     ' 6  ,+6& ,    ' 7   z[rP_ P\0NgE#GNJNMN̥Xruntime.gclinkptr.ptr : `\NgE#NNNNԦԩruntime.allocmcache@? :(  ,*F ]OgE#,O3O6ODOܧruntime.freemcache@7?:R  <p]OgE#OOOO\runtime.(*mcache).refillPOPXO :!     !   eD ^8PgE#VP^PbPzPXruntime.(*mcache).releaseAll@? :# 2   i< _PgE#PPPPhruntime.(*mcentral).init ?SQSUSSxruntime.(*mcentral).freeSpan@Z?@P?@U?@s? <&   & #  C:2&"+:" fSgE#STT4Thаruntime.(*mcentral).grow <&4',) 7  - hTgE#TTTTԩruntime.sysAllocp]op0o>( 9A iUgE#U"U%U2Uhruntime.sysUnused@3?>N," 8pixUgE#UUU̥Xruntime.sysUsed>8iUgE#UUUVxruntime.sysFree0C/>HB  !iPVgE#bViVlVyVhruntime.sysFault`D_>_L"# I0jV gE#VVVVdhruntime.sysReserve`f_`_ >T"(  Q8 j@W gE#PW[W_WxWxruntime.sysMap`t_`6_ >n& 1 4l" kW(gE#WWWGXp runtime.queuefinalizer @! .   )  "     ") :') 0nXgE#XXXXԦԩruntime.wakefing0m/0/ @$    (@! n(YgE# Ѐ]gE#]]^Xruntime.(*fixalloc).free!B!  P^gE#`^l^p^^XXruntime.gcinit0/03/ D!  : 3 uX ^gE#^^^_ĤXruntime.readgogcPnOPOPO D!#  5u P_gE#b_i_m_}_hԩruntime.gcenablePlO D$ 1" 0_gE#___`̥Xruntime/debug.setGCPercent0/ D(  "  ,x H`gE#\`_`b`ĤXruntime.setGCPhaseDDD   0`gE#```Sahruntime.(*gcControllerState).startCycle D&C 3                L'' 39 b agE#aaaXruntime.(*gcControllerState).revisebDb    bgE#?bPbTbbhruntime.(*gcControllerState).endCycle D $0B /=4   #% 9'  ЌbgE#cc#cOchruntime.(*gcControllerState).enlistWorkerPOP OP OP OP OPO D &  &     7 u cgE#ccc d аruntime.(*gcControllerState).findRunnableGCWorker@?@?@?@?@?@? D !&( d c$H) a \ O)  JU"[ pdgE#dddeĤXruntime.gcSetTriggerRatio D * J    .  < -   /      . @  DQ  pXegE#deueyeexܰruntime.GC D!2  ,5 $ "   G,  ; :r  f gE# f$f(fإXruntime.gcTrigger.testD     # pf gE#fff(gإXruntime.gcStart`_`_`_ D! 4? -      -0     Yn   g-  3  ! pggE#ggggXXruntime.gcMarkDone0/0/ D! N  &$P ? >   n  , (hgE#ChThXh9iruntime.gcMarkTermination" D; 6  .-5D $           $SI'h-- # 1#  8 -&***Q #CJ !# m ! Kc-3\aNN  L igE#iiiihԩruntime.gcBgMarkStartWorkers`_ D* $  yG P0jgE#IjLjOjXXruntime.gcBgMarkPrepareD  pjgE#jjj6kruntime.gcBgMarkWorker D /9 +#& >@9 4^  . !!#   `"u zC='  ЮkgE#kkkkhruntime.gcMarkWorkAvailable0K/0/0/0&/ D&   6r 0lgE#@lMlQllHruntime.gcMarkpopo D! 5$  /   /,     #   ' u JN~ в mgE#1mAmEmmĤXruntime.gcSweep@?@4?@]? D!  &         9 : mgE#mmmnXXruntime.gcResetMarkState  D(       ,t @XngE#znnnnhsync.runtime_registerPoolCleanup0)/0/D` RngE#noo4oxruntime.clearpoolspop(o D ! 2  E' ! <D0QoU pogE#ooooxTruntime.gchelperPOPO D !     &     :  8pgE#OpZp^pppXXruntime.gchelperstart03/06/ D!  [" @p@gE#pppphruntime.itoaDivD!    3  @q8gE#SqoqsqqЧhruntime.fmtNSAsMS:k D!&   W/ b   qgE#qqqXruntime.(*treapNode).init4F4dPrgE#jryr}rrPruntime.(*mTreap).insert F&    &      q1 : ,v  sgE#>sJsNs|s4runtime.(*mTreap).removeNode@?@2? F&      wdD sgE#ssst\runtime.(*mTreap).removePpOPOPO F&    o@ `tgE#~tttthruntime.(*mTreap).removeSpan@f? F"     k 0t gE#uuu5u(hruntime.scavengetreap`_`_ F& ,&% Gd1 ugE#uuuuhruntime.(*mTreap).rotateLeft0m/02/ F&    7  0vgE#OvZv^vvhruntime.(*mTreap).rotateRight0i/02/ F&    7  vgE#v w wJwxܰruntime.gcMarkRootPrepareO Hn!  @'  @'  6   - 9/-7  c``1 wgE#wwwxhԩruntime.gcMarkRootCheck H! 9        =a @`'Vb XxgE#jx{xxxruntime.markroot H$        $| q ?L WX$  ,odG $Q $QTm :QT+k * k /, P@y(gE#Wyeyiyyxruntime.markrootBlock H)    d<% ygE#yyz'zruntime.markrootFreeGStacks`_`%_`_ H(    0   ,5$>"&I  zgE#zzzzpruntime.markrootSpans H! 8  ; 6 &WT  5z# \p13 0{gE#G{c{g{{runtime.gcAssistAllocd6  H&$  &  ^] )    ? &^k     I8'A  |gE#8|O|S||Ȼ(runtime.gcAssistAlloc1T H&'    ./7      B7 3)hEu/ l6W"YFM }gE#}"}&}8}XXruntime.gcWakeAllAssists0/ H ( %  ,o }gE#}}}}Ԧԩruntime.gcParkAssistkL H (       ( ,')  ,R95 P8~gE#Q~b~f~~runtime.gcFlushBgCredit H !  !    7 3 WB&G4EJ:F gE#8<Lruntime.scanstack"2A H :     ,f'-   YOR.LLL gE#g0runtime.scanframeworker H 7 1 &  +  '   31p !E p0AC9)x 31)x *1 `؀gE#l\runtime.gcDrain H !   3#$#$t   20 ;F   gj ov{| }| | ! mj  =< 9 uo gE# K\runtime.gcDrainNPOPO H! 4   ( C D)    gE#<Xruntime.scanblock H! %"  /X@&  = u 8gE#Lcg(runtime.scanobject H/ # J"   9L@0 ; C 6"= !L + S#& @gE#'+CḪruntime.shadeS H)8")2   ?\] @gE#Ȅ̄runtime.greyobject?  H &%.)  7+$-$1 -%#Jx-%! HG+$.O3! `p gE#runtime.gcDumpObjectn H !( %x &M #7#( # / R# e  |I(-^ XgE#q{$Xruntime.gcmarknewobjectPOP&H*+   1gE#(runtime.gcMarkTinyAllocs H*"3-     _( xgE#\runtime.initCheckmarks H!*z o.4# gE##'9\runtime.clearCheckmarks H!*z o.4# gE#XXruntime.finishsweep_m 7JRD  -PgE#Hhruntime.bgsweep`_ J^!%  ,   ,!   ) J!  gE#‰ƉԦԩruntime.sweepone J! % 6   & ,! "  pXgE#lsvԦܧruntime.gosweeponePJOJe $ EȊgE#݊ĤXruntime.gosweepdoneJ(gE#FY]}hruntime.(*mspan).ensureSweptP{OPOP OPO J!        t(4 ȋgE#Ռ<runtime.(*mspan).sweep"   JM $(  &/  (4(,.#DC +!=0 # B7: L##<$.   ' & "" !  / ! BLCD M1 *9I  c_YM@;$Fo# P@gE#[gk̥Xruntime.deductSweepCredit@?@8? J!  0    q gE# U@runtime.(*gcSweepBuf).pushO Lp+    , 1% o p1%+ M'F% gE#ÎΎҎhruntime.(*gcSweepBuf).popP;OPKO L+   k4 @0gE#QTWXruntime.(*gcSweepBuf).numBlocksL`(gE#ɏ͏`hruntime.(*gcSweepBuf).block@?@0? L&   ' Rw" `8gE#HKNXXruntime.init.1N<pgE#ҐXruntime.(*gcWork).init ; Na    = gE#7CGwhruntime.(*gcWork).put0/0Z/ N&     # 9 ȑgE# $hruntime.(*gcWork).putFastF  Nn     g`XgE#rȻhruntime.(*gcWork).tryGet@f?@G?@? N&   "  (+ + PgE#/2Fhruntime.(*gcWork).tryGetFastANq jgE#Ȼhruntime.(*gcWork).get@f?@G?@? N&   "  ,/ + 8gE#S_cXruntime.(*gcWork).dispose   N&           ? gE# .hruntime.(*gcWork).balance0X/0/0&/ N&       I2# ` xgE#Xruntime.(*gcWork).empty4N4/ gE# hruntime.(*workbuf).checknonempty0!/0/NW"  I!hgE#hruntime.(*workbuf).checkempty0!/0/NW"  I`!gE# SPruntime.getempty N!   &-$       *1 ]# #gE#ėЗhruntime.putempty0=/NX" &# gE#18;Ghruntime.putfull0=/NX" &@$gE#˜Ԧԩruntime.trygetfull@E?@?No$   (($gE#!6:Ԧԩruntime.getfullpopzop!opo N(  "   !  % ,uuu ,C 'ЙgE#|4runtime.handoffPOPO N!7  ![ (XgE#uXXruntime.prepareFreeWorkbufs0f/0/ N(    ,m `)gE#"̥Xruntime.freeSomeWbufs`B_`z_ N(  * ' , @*hgE#Xruntime.(*mspan).baseP P*ț gE#Xruntime.(*mspan).layout8P8 *8gE#L]aнruntime.recordspan PG%'!#8 5&*K   2/_0 -gE# ̥Xruntime.makeSpanClass02/PM" %! .XgE#ux{̥Xruntime.spanClass.sizeclass P 0.gE#ڝݝ̥Xruntime.spanClass.noscanP @.(gE#8IMcȦԩruntime.inheap@"?@I?@D?@P1z</gE#ǞܞȦԩruntime.inHeapOrStack@"?@I?@G?@?@PzN/HgE#Xcft̥Xruntime.spanOf0&/04/Pv"VP0gE#ٟ̥Xruntime.spanOfUnchecked<PH <A00gE#GW[$hruntime.(*mheap).init P&>;<<<"!  #  7 Z  3gE# Xruntime.(*mheap).setArenaUsed0V/Pq"  #0:3hgE#hruntime.(*mheap).mapSpansPOP OPO P&  2   Li' 4 gE#&<@p ԩruntime.(*mheap).reclaimListf P! $ - !     Dt 5gE#ڢ+hruntime.(*mheap).reclaimqP  P &9 3'D      3  p' 7x gE#@runtime.(*mheap).alloc_mpopo P !   )N   G *    qt =D  % >Y J2" :x gE#̤4runtime.(*mheap).alloc+ P ! C          ) A' < gE#6AEo8,runtime.(*mheap).allocManual`l_`f_ P &  " ,"C< = gE#wpruntime.(*mheap).allocSpanLockedt P & $  ",! 9!H  % $# ) %! f+ l08 ` PAȦgE#$Xruntime.(*mheap).isLargeSpanP pA8gE#U\_k$hruntime.(*mheap).allocLarge@=?PX " 8AgE#ϧ"runtime.(*mheap).grow1 P &  && + } ,9 3k+ 0DxgE#hruntime.(*mheap).lookupCPO0HDgE#!%A|\runtime.(*mheap).lookupMaybe@7?@A?@D?@? P& 1 < pEgE#˩druntime.(*mheap).freeSpan`I_Pd . /NEgE#5=AYxxruntime.(*mheap).freeManualPO P& #  5T F gE#ɪڪުtruntime.(*mheap).freeSpanLocked P & % &       %$ !,$  )$  %// /  /) );  OOC&9:p7' LgE#$hruntime.(*mheap).freeList3P?'8LPgE#knqXruntime.(*mheap).busyList9P9  M gE#۬#\runtime.scavengeTreapNodePLOPOPOPO P&+63    1(  mD pNp gE#ʭ(ԩruntime.scavengelist`_`_ P& 0  " /4C *^ P gE#3DHw4runtime.(*mheap).scavenge P!  6 9 w Lp @SgE#׮ۮ߮Xruntime.(*mspan).initP     SHgE#adgXruntime.(*mspan).inListPSgE#ïƯɯXruntime.(*mSpanList).initPTgE#5AEnruntime.(*mSpanList).remove`\_`_ P&       N'''> UgE#ְٰܰXruntime.(*mSpanList).isEmptyPU(gE#EQUrPruntime.(*mSpanList).insert`U_`_ P&$    ,* WȱgE#Pruntime.(*mSpanList).insertBack`X_`_ P&$     ,* XhgE#Xruntime.(*mSpanList).takeAll0/00/ P&       * YgE#*.f0 runtime.addspecial* P(   ! / 6Dd/ ZgE#׳!runtime.removespecial. P(    ; 67M"3 [x0gE#0pruntime.addfinalizer_ P(%   (     9" ,*p7%-: P^XgE#q|(аruntime.removefinalizerPoOP O P"   +) ^gE# %\runtime.setprofilebucketP{OPO P(    ,*%3 _pgE#xruntime.freespecial`{_`_ P&  9  J*L*2 `gE#!(+7$hruntime.(*gcBits).bytep@5?PP"00a gE#(hruntime.(*gcBits).bitp@M?Ph" 14-agE#*.B$hruntime.(*gcBitsArena).tryAlloc72P 0bgE#øPruntime.newMarkBits?( P!    ( )   #   @M Gn_@)< dPgE#fmpx̥Xruntime.newAllocBits0+/PF"&PdgE#߹XXruntime.nextMarkBitArenaEpoch   P(       , eXgE#s~Hܰruntime.newArenaMayUnlock`Z_`j_ P! %   J38  fgE#  Xruntime.(*memRecordCycle).add8R8   @f`gE#s$Xruntime.newBucket`_`+_ R& #    Yl g gE#(hruntime.(*bucket).stk@O?@?Rq"1/4ghgE#~hruntime.(*bucket).mp@F?@?R|" A4hgE#  hruntime.(*bucket).bp@L?@? R" G4 hh8gE#{P@runtime.stkbucketKz R!$   )3< J       9/,' 7D" lP8gE#aruXhruntime.eqsliceO  Rw plоgE#XXruntime.mProf_NextCycle _Rz$ %  (KmPgE#epsXXruntime.mProf_Flush > Rg$   (8pmпgE#xTruntime.mProf_FlushLockedpo R! $)   @BS Pn`gE#yxTruntime.mProf_PostSweeppo R( ')   ,$ET `ogE#<|йruntime.mProf_Malloc" R2: N #  @ q qgE#hruntime.mProf_Free@? R( "    ,e qgE#-8<NĤXruntime.SetBlockProfileRate ) L R"  3  J? rgE#̥Xruntime.blockevent@9?@&?Rz"5>sgE#.=AS̥Xruntime.blocksampled0$/0/00/ R+ V+ sgE#\ԩruntime.saveblockevent"C R2 !* N%  7  v} Pu8gE#Y\_̥Xruntime.SetMutexProfileFraction.R. ugE#̥Xsync.eventP+OPTO R&) MJ 0v  gE#>NRXruntime.(*StackRecord).Stack"9 R27 . 2 wgE#Xruntime.(*MemProfileRecord).InUseBytesR@wgE#:=@Xruntime.(*MemProfileRecord).InUseObjectsR`w gE#Ĥruntime.(*MemProfileRecord).Stack"9 R:= . 2 `x0gE#,0~@runtime.MemProfile R( 1 ()/8  4IL 1   %!.M ,?r; {gE# X\runtime.record`_`_ R &    G   *W"B |p(gE#lruntime.BlockProfile R (    IJ  ( ")" ,D'/> } (gE#6FJruntime.MutexProfile R (    *  J   "  ,?'/7 (gE#%`hruntime.ThreadCreateProfile R    " 0p(gE#@runtime.GoroutineProfile R < M !II %D 4+7*7 o`[:W@ 0 gE#?OSoLxruntime.saveg R )<  , P(gE# @druntime.StackG R +  8)  _( XgE#l} runtime.tracealloc R (    3(  /q ,3> `gE##-1Sruntime.tracefree R (  E,3(   ,> gE#hԩruntime.tracegc@? R (  ( #(   , 0gE#E\`w̥Xruntime.roundupsize@e?@ZZLZ VH8 wL Ќ@gE#V]`r(4runtime.ReadMemStatsPUOVp$  1$@gE#Xruntime.readmemstats_m@O?Vj &  F@gE#XdhXXruntime.updatememstats`_`_ V!        $ &      7Q  gE#,36Jhԩruntime.cachestats@]?Vx & V gE#Ԧԩruntime.flushmcache0U/0 /0 /0/ V "      L* (gE#AHKYXXruntime.flushallmcaches09/VT  *#gE#Xruntime.purgecachedstatsV        gE#5?CQhruntime.mSysStatInc@-?@V  q 7gE#hruntime.mSysStatDec@4?@V  q >pgE#6=@LXXinternal/poll.runtime_pollServerInit#X> gE#ĤXruntime.netpollinitedXgE#$(Phinternal/poll.runtime_pollOpen`_`6_ X( % ,pO" gE#hinternal/poll.runtime_pollClose0i/0Q/ X&  X` 8gE#SZ]ohruntime.(*pollCache).free AX\"    (@gE#Xinternal/poll.runtime_pollReset@U?@#? X"    /^ PgE#pXinternal/poll.runtime_pollWait@?@?@? X& %  3 gE# Vinternal/poll.runtime_pollUnblock X&  %%   @ !   5@06=  gE#hruntime.netpollready`_`k_ X!..     V@ HgE#adgXruntime.netpollcheckerrNXN   `gE#TĤruntime.netpollblockcommit FXK(gE#@GJ\hruntime.netpollgoready0>/XY)  CgE#\runtime.netpollblock36 X&   0 1& r" `HgE#`quXruntime.netpollunblock f   X    gE#lܰruntime.(*pollCache).alloc X& .    ' ,YI pgE#XXruntime.netpollinit@-?@^? Z0!F ! gE#:runtime.netpollopen ZJ$      9! ; gE#̥Xruntime.netpollclose Z x СgE# Pruntime.netpoll"!!!%!!! Z2    ( -B-9   0;& y  0gE#hruntime.unimplemented0d/\87 C gE#4;>Ehruntime.semawakeup &\+D gE#ܧruntime.semacreate@"?@(?\PN   A0gE#"-XXruntime.osinit 1\Lb (xgE#ĤXruntime.getncpu  \!;  5 @gE#%)=ĤXruntime.getPageSize \!;  9 gE#$hruntime.getRandomDatapop\2 ' 2jЧgE##';XXruntime.goenvsP#OPeO \!  # ! gE#hruntime.newosprocpopo \! ) #  F4 gE#*59MԬаruntime.mpreinit@Q?@/? \!   (J gE#XXruntime.minit\5  ЪgE#%XXruntime.unminit\hgE#{hruntime.macherror0/ \!#1 !1g gE#̥Xruntime.mach_msgh_bits\ЫH(gE#Zad`hruntime.mach_msg`Y_\t"VPgE# @ԩruntime.machcall ! \!   , 1 & %7  Y gE#ĤXruntime.mach_semcreate" \2%     "/ \ 0gE#DW[Ȧԩruntime.semasleep1p}opdopopo \!  1  MZ gE#Ȧtruntime.semasleep`Q_\V?HgE#ahk}ĤXruntime.mach_semreleasePLO\Q  <gE#XXruntime.osyield \$  0gE#@HLdȦtruntime.setsigpo\$     PIgE#Ԧtruntime.setsigstackZ\     :cK@gE#PWZf̥Xruntime.getsig`U_\Z : gE#Xruntime.setSignalstackSP\ gE#!Xruntime.sigaddset \ 0hgE#{~Xruntime.sigdelset"\"`gE# аruntime.sysargs`_`;_ \%%G2*  A" XgE#r}hruntime.panicCheckMalloc@4?@P? ^$! D r* `gE#XXruntime.panicindex0M/^g6'4,еHgE#\cfoXXruntime.panicslice0M/^gD'4,@gE#XXruntime.panicdivide0M/^gR'4,(gE#?FIRXXruntime.panicoverflow0M/^g`'4, gE#XXruntime.panicfloat0M/^gn'4,gE#"),5XXruntime.panicmem0M/^g|'4,gE#XXruntime.throwinit0%/^?1@gE#Eԩruntime.deferproc^"    7  + 4#"gE#̥Xruntime.deferclass"^" gE#̥Xruntime.totaldefersize^  PgE#hy}XXruntime.testdefersizes ^!  !  # o gE#hruntime.deferArgs@'?@%?^R&9`gE#p{hruntime.init.3PWOPO ^ { gE#8xruntime.newdefer^  ,! 4 )2- $#."(;#5 gE#runtime.freedeferX^  <9'-23*'6   @)[3;$P0gE#HORZXXruntime.freedeferpanic0%/^?1gE#XXruntime.freedeferfn0%/^?1gE#-DHx@runtime.deferreturn ^    "!  )   @b"^PgE#pruntime.preprintpanics ^!%  R\ :\  4[ +<+U<   `pgE#hruntime.printpanics0/0V/ ^& (# # # 3KV- pgE#"&@druntime.gopanic ^/   > #    - .8     .  "X   " 7_+*+#(>*+*+* a& '4 7 ;<C<lH<z<C @hgE#y̥Xruntime.getargp0+/^0pgE#$Xruntime.gorecoverQ^Q   8gE#LSV^XXruntime.startpanic #^(   gE#Ԧruntime.dopanic~^  0 T gE#,36Bhsync.throw0$/^> " 0gE#hruntime.throw0/^ (   1igE#".2Ohruntime.recovery`k_`_ ^ &    t gE# hԩruntime.startpanic_m@?@|?@? ^ !  >      #    # +(  XgE#k|runtime.dopanic_m ^ &   () )<    #   ();  < 4Ugg"1 p0gE#BUYuXruntime.canpanic0;/0/0O/0/^   *   ?@(gE#Phruntime.bytes0[/`v"=   A.0gE#HTX}$hruntime.recordForPanic`_`_ `P!" '5  ! gE#hԩruntime.printlock0P/0/ `  t  pHgE#]hk}XXruntime.printunlock 5 `b  TgE#\runtime.gwrite`_`0_` _`_ `& # N"   GuX' 0`gE#qx{XXruntime.printsp06/`Q# -gE#XXruntime.printnl06/`Q# -@gE#S^auĤXruntime.printbool0?/0%/`# #&RpgE#kĤXruntime.printfloat`_`_`,_`4_ `!%  B  %" _   34C# # #   gE#̥Xruntime.printcomplex0o/ ` (  f 8gE#K[_yĤXruntime.printuint `/( !" 2  ( gE#ĤXruntime.printint0&/0-/`n"  (+<0HgE#ZjnĤXruntime.printhex `/(      ,  * @gE# hruntime.printpointer !`<"  &XgE#mtwhruntime.printstring`M_`h", 01gE#Xruntime.printslicePO `!  5 HgE#\dhzhruntime.printeface0/ `!"'  !N- pgE#Qhԩruntime.main) b!     ,       9)9,#? L> gE#XXos.runtime_beforeExitbgE#$XXruntime.init.40+/bF 0pgE#XXruntime.forcegchelper`_ b! ,  ,(  A 0 gE#   # XXruntime.Gosched #b(  `h 0gE#x    0runtime.goparkPOPjO b!  &+)   $ !-@  (gE#   > hruntime.goparkunlockpTobo$  YP gE#    truntime.goreadyPAOb\  F gE# $ ( ` lruntime.acquireSudogb& E  " * 9d+"4! X 6 _ * gE#   G (runtime.releaseSudogb       +>F ?$ #(H ;6@V&&]   gE#    TXruntime.funcPC@/0 /bc+   C*&gE#&&&''hԩruntime.stoplockedm@?@v? b! )  ' ( j; +x'gE#''''`\runtime.startlockedmPOP6O b!   gJ ,(gE#(%()(Q(hԩruntime.gcstopm@?@H? b!        d0\ -(gE#((((l\runtime.execute@?@? b!   "      "& Ga p/P)gE#f)))*4pruntime.findrunnable  b/ >  /  ! GJ # #   :,2           # *A O" ,   * 7 $7( F-# * %"     O +A ~R)PJ  _5 -"   0_ _f @98+gE#J+]+a+{+ĤXruntime.pollWork0}/0*/0/0/ b!!"#     G 0:+gE#+++ ,XXruntime.resetspinning0T/0=/ b!!      l= :X,gE#m,y,},,p@runtime.injectglist`_` _ b!& &  %  Q='(N P<,gE# ---}-`runtime.schedule b"! pc  )        ,6O; )   NS WDI13<K" ?-gE#---.hԩruntime.dropg@l? b#*! K& P@X.gE#n.u.x..hruntime.parkunlock_c &bA#" &@.gE#...(/8\runtime.park_m`s_`_ b#!     " ! V&0-8 pB/gE#////hruntime.goschedImpl0/0)/ b$&    *NM @C0gE##0.010A0hruntime.gosched_m , bN$  1C0gE#0000hruntime.gopreempt_m , bN$  1C1gE#!1,1/1?1XXruntime.goexit1 . bP$  30D1gE#1112runtime.goexit0 b$!  & 6     ,!&& $R3 G0B  G  f Gp2gE#~2222̥Xruntime.saveCbC% < H2gE#3 33_3Эruntime.reentersyscall`_`b&    . +&!     Pc6J3gE#3333ĤXruntime.entersyscall@G?bL'/ 5K 4gE#=4H4K4_4XXruntime.entersyscall_sysmon = bu'$    (FK4gE#4444hԩruntime.entersyscall_gcwait@?@0? b'! % %    9\% LH5gE#c5p5t550runtime.entersyscallblock!b'+)`)7 L>N6gE##6.616C6XXruntime.entersyscallblock_handoff0(/02/bu(   +(FPO6gE#666 7HTruntime.exitsyscallPOPOPb(  :  & =9 &    &  8 x]7EVs"0R`7gE#y7777Hruntime.exitsyscallfastJt,b*   &#. 3aQv!]AS8gE#48>8B8X8xЭruntime.exitsyscallfast_reacquired`_`&b*-;/ ! $+6 T8gE#8888Ԧԩruntime.exitsyscallfast_pidle0h/0/0!/ b+(      ,-= UH9gE#^9j9n99ش(runtime.exitsyscall0POPpO b+!           GF$ 0" V:gE#:::3:runtime.malgp5opVo b-( -  ,)," W:gE#::::Բruntime.newprocb-!j o@X:(gE# ;;;;pruntime.newproc1 b -!     "%&   #  % )1#/ + ;  )SadO"1 f P]<gE#<#<'<g<0pruntime.gfputPOPlO b/& -  ;:D )  %"   *H}5$: `<gE#<<<.=runtime.gfget b0! / I  '  +  *$!+  $ 1 jc89lZ( b=gE#====ش runtime.gfpurgePO b0(  &:? )   ,G5$ 0d(>gE#@>I>M>]>hԩruntime.dolockOSThread@V?@*b1  d d>gE#>>>>XXruntime.lockOSThread"b"1d?gE#2?=?A?U?hԩruntime.dounlockOSThread@d?@;?b1   ve?gE#????hԩruntime.unlockOSThread0C/0bd1 9 f @gE#;@B@E@M@XXruntime.badunlockosthread0%/b?21Pf@gE#@@@ĤXruntime.gcountVbV2"   f@gE#AAAĤXruntime.mcount b 2 fPAgE#aAhAkAoAXXruntime._Systemb020fAgE#AAAAXXruntime._ExternalCodeb020 g(BgE#CBJBMBQBXXruntime._LostExternalCodeb020PgBgE#BBBBXXruntime._GCb020gC(gE#C(C,CCxruntime.sigprof"      b222##8,9t  " ?"  -  ! $o+cE  [U. kCgE#CCCDĤXruntime.sigprofNonGoPCpopsb5 % 9\plXDgE#hDwD{DDȦԩruntime.setsSPP`OP2OPO b5&  $  *s @mDgE#DE E9EԦԩruntime.setcpuprofilerate0/0%/ b6%          % V PnEgE#EEEFruntime.procresize b6!*  # ( = c)6 $  *=( 3 g$F"   G j   %  $% ) -   % `=#.3! x=7, U vGgE#GG G4Ghruntime.acquirep I bk9"    &7wGgE#GGGG8runtime.acquirep1 b9! 0   R xHgE#*H;H?HdH`runtime.releasep b9! )A  (  W''N'  {HgE#HHHHĤXruntime.incidlelocked I bk:$    (<|@IgE#SIvIzII`runtime.checkdead    b:!  -         _ t /  '- Da9( 8JgE#HJRJVJJhԩruntime.sysmon b ;/   " #      ;DG N $ >% /'!   !    = ""  R 0KgE#@KLKPKKȦԩruntime.retakepopo b=%   U    7 8 $  9 ^a ?w. LgE#LL#L9LĤXruntime.preemptall@w?@? b>%  c3 `LgE#LLLLhruntime.preemptone0F/0"/0/ b>&  ! .q MgE#M3M7MMruntime.schedtrace b?/     ),   ''#?T        O E /q@  00NgE#>NENHNXNhruntime.mput0N/bi@ @"NgE#NNNNĤXruntime.mget0N/bi@ (:OgE#%O1O5OMOhruntime.globrunqput0/0/ bA&  )  A:- ДOgE#OOOOhruntime.globrunqputhead0U/0/ bA  @> ` PgE#:PFPJPbP|xruntime.globrunqputbatch0/0/ bA&  )   A 4 PgE#PPP Q\runtime.globrunqget`_`"_`_ bA!$  '  4r XQgE#jQuQyQQhruntime.pidleput0_/0/ bB"  &.: QgE#QQQRĤXruntime.pidleget0M/bhB (9HRgE#[R^RaRXruntime.runqempty5b5B  ИRgE#RRRShruntime.runqputpop8op op o bC( )       \ D14 PS gE#eS{SSS4runtime.runqputslow"0 bC2 2"", * '  ydu TgE#T(T,TJT$hruntime.runqgetpmopcopo bD! %%  PDV T gE#TTTT ԩruntime.runqgrabpopopo bD!< W* C !S `@U gE#SUgUkUUxruntime.runqstealpopopopo bE&    +     R UgE#UUUVĤXruntime.procPin0L/bQF (4HVgE#[V^VaVXXruntime.procUnpinbF VgE#VVVVĤXsync.runtime_procPin !b&F0 WgE#8W;W>WDWXXsync.runtime_procUnpinbF@WgE#WWWWĤXsync/atomic.runtime_procPin !b&FpXgE#X"X%X+XXXsync/atomic.runtime_procUnpinbFpXgE#XXXX̥Xsync.runtime_canSpin0#/0e/0/bG #4c: XgE#Y YYYXXsync.runtime_doSpin b$G  P`YgE#~YYYYܰruntime.(*randomOrder).reset bG* (  ZeP. Y gE#ZZZ,Z(hruntime.(*randomOrder).startYbsG^ pZgE#ZZZXruntime.(*randomEnum).donebG@ZgE#ZZ[ [hruntime.(*randomEnum).next1b=G 6P[gE#p[s[v[Xruntime.(*randomEnum).position b H[gE#[[[̥Xruntime.gcdbH\gE#,\/\2\Xruntime.(*profAtomic).loadd p\gE#\\\Xruntime.(*profAtomic).stored У\ gE#\\\Xruntime.(*profAtomic).casd 8]gE#U]X][]̥Xruntime.profIndex.dataCount d ]gE#]]]̥Xruntime.profIndex.tagCountd ^gE#^^^̥Xruntime.countSubd0X^ gE#^^^إXruntime.profIndex.addCountsAndClearFlags0d0(`^gE#^^^Xruntime.(*profBuf).hasOverflowd0_gE#Q_Z_]_Xruntime.(*profBuf).takeOverflow ` di   _gE#___Xruntime.(*profBuf).incrementOverflowEdE@0` gE#D`T`X`|`ԩruntime.newProfBufc d&$ QFP)  2 P`gE#`a a2a$hruntime.(*profBuf).canWriteRecord d&3   = %      , a gE#aaaa(hruntime.(*profBuf).canWriteTwoRecords d&S = ,   ! , @bHgE#Zbwb{bb`runtime.(*profBuf).writefa d 7 9$447 % 0    8* ! G < N  Q Yyc/;  a 0XcgE#rc}ccchruntime.(*profBuf).close00/0/df"   5*cgE#cddd8\runtime.(*profBuf).wakeupExtrapkopo d!#  5*3 PpdHgE#ddd_epruntime.(*profBuf).read d7  p) Y8$2h h!   r8a   +8Z / 9zC  wB,)+ `+   7+ M>  egE#eeeĤXruntime.osRelaxf$йfgE#0f@fDfwfĤXruntime.tickspersecond`^_`_`_ h0!   $  < fgE#ffff\ԩsyscall.runtime_envsB hl,rO  @ggE#Qgagegig\ԩos.runtime_argsB hx,rO  @ggE#gggĤXruntime.gotracebackTjTL    (hgE#?jCr('hgE#hhhhhruntime.args0@/0%/jz! E$pigE# i.i2iDiXXruntime.goargs! j(Uz D igE#iiiiXXruntime.goenvs_unix! j# 3N I 0jgE#!j$j'j$Xruntime.environ%j%%`pjgE#jjjj`runtime.testAtomic64popo j!  #"$% J 0(kgE#7kHkLkkxTruntime.check j !  t:     (& 44            x p lgE#8lHlLll`runtime.parsedebugvars j/ ;(& (. E 3i%-  8 :*  9  WLN` lgE#lm mJmhruntime/debug.SetTraceback`I_`_ j&    # #   ##(  A # m gE#mmmܤXruntime.timedivwjw   PngE#nnnĤXruntime.acquirem%j%  XngE#jnmnpnXruntime.releasem6j6ngE#nnnĤXruntime.gomcachejo0gE#+o;o?o_oreflect.typelinksE j/,ANp>H " /0n}gz  `ogE#oooo$hreflect.resolveNameOff@3?jN".8pgE#PpWpZpfp$hreflect.resolveTypeOff@3?jN".pgE#pppp$hreflect.resolveTextOff@3?jN".P(qgE#?qKqOqyqhreflect.addReflectOffpoopo j! -  9'!A:   !OE:% @qgE#qqqXruntime.efaceOf l P rgE#6r9rvgE#vvvvhruntime.(*rwmutex).runlock0Z/0a/ n~+        c* pPwgE#iwpwsw|whsync.runtime_Semacquire@/?pJp" 4wgE#wwwwhinternal/poll.runtime_Semacquire@/?pJz" 4HxgE#axhxkxyxhsync.runtime_Semrelease0*/pE"  /`xgE#xxxxhsync.runtime_SemacquireMutex@3?pN" 8@ygE#byiylyvyhinternal/poll.runtime_Semrelease !p<"  &ygE#yyyyhruntime.readyWithTime07/0/pi"  <`@zgE#Tz[z^zhzhruntime.semacquire@/?pJ" 4zgE#zzz,{Pruntime.semacquire1 p!      +1'       G)}$&b {gE#{{{{hruntime.semrelease0&/pA" +p{gE#||!|_|Pruntime.semrelease1i  p&   '9@      ,; *,X984 |gE#|||Xruntime.semroot?p?:@}gE#}"}%}Xruntime.cansemacquire'p'px} gE#}}}Y~runtime.(*semaRoot).queue p )    N_#  #  I>//////*0"F2     %})  #6>v  _L f ~ gE#~~~Hruntime.(*semaRoot).dequeue p & ,.     &AGG  !! ,K 1111,1" !"111TC gE#!%qPruntime.(*semaRoot).rotateLeft p&    % &""',1E; ,7 lD',1EF ЀgE#Nruntime.(*semaRoot).rotateRight p&   % &""',1 G(7 lD',6K  gE#ƁҁցĤXsync.runtime_notifyListCheck0/0/ p & w 6 0gE#GNQYĤXsync.runtime_nanotime !p<  gE#hruntime.dumpregs@? r &bbbbbbbbbbbbbbbbbbbb] + *c `@gE#Zadghruntime.(*sigctxt).sigpc0+/r0T0gE#ʃуԃ׃hruntime.(*sigctxt).sigsp0+/rFXF&gE#258̥Xruntime.(*sigctxt).siglr r Z gE#hruntime.(*sigctxt).fault0+/rF\F&@gE#"Txruntime.(*sigctxt).preparePanic`_`_ rb%      -      `' gE#Xruntime.(*sigctxt).regst"0gE# '*-hruntime.(*sigctxt).rax0./tI&I&xgE#hruntime.(*sigctxt).rbx0//tJ(J&gE#  hruntime.(*sigctxt).rcx0//tJ*J& XgE#pwz}hruntime.(*sigctxt).rdx0//tJ,J&pȇgE#hruntime.(*sigctxt).rdi0//tJ.J&8gE#PWZ]hruntime.(*sigctxt).rsi0//tJ0J&gE#Ljʈ͈hruntime.(*sigctxt).rbp0//tJ2J&`gE#07:=hruntime.(*sigctxt).rsp0//tJ4J&gE#hruntime.(*sigctxt).r80//tJ6J&gE#hruntime.(*sigctxt).r90//tJ8J&PhgE#hruntime.(*sigctxt).r100//tJ:J&؊gE#hruntime.(*sigctxt).r110//tJJ&@gE#Ћ׋ڋ݋hruntime.(*sigctxt).r130//tJ@J&(gE#@GJMhruntime.(*sigctxt).r140//tJBJ&gE#hruntime.(*sigctxt).r150//tJDJ&0gE# '*-hruntime.(*sigctxt).rip02/t7L7 pxgE#hruntime.(*sigctxt).rflags02/tMPM& gE#  hruntime.(*sigctxt).cs02/tMRM& XgE#ovy|hruntime.(*sigctxt).fs02/tMTM& `ȎgE#ߎhruntime.(*sigctxt).gs02/tMVM& 0gE#LORXruntime.(*sigctxt).sigcodetXgE#Xruntime.(*sigctxt).sigaddrtZgE#!hruntime.(*sigctxt).set_rip02/tM^M& @hgE#hruntime.(*sigctxt).set_rsp0//tJ`J&АgE#Xruntime.(*sigctxt).set_sigcodetb8gE#X[^Xruntime.(*sigctxt).set_sigaddrtdgE#Ǒӑבhruntime.(*sigctxt).fixsigcode0!/0/ th%$( / B>0 H gE#\3runtime.sighandler@  v:$  &$  #S\f >#   #  h0 #&/( N UT     """# v f[ kA14Rv%m  PgE#XXos.sigpipe #x>"$  (gE#&)4$Xruntime.signame@xg*0`xgE#XXruntime.init.5x~ؔgE#/ĤXruntime.initsig`_` _`)x  !  6', 1  uxgE#̥Xruntime.sigInstallGoHandlerx      0gE#+/IĤXruntime.setProcessCPUProfiler@4?@? x%  "+# S 0gE#ÖǖĤXruntime.setThreadCPUProfileruZ x!$      g 00gE#ALO]XXruntime.sigpipe0(/0/xY   $.gE#ٗݗSruntime.sigtrampgo$x2  -$     ";H8    :("VI38+| XgE#˜̘Иx runtime.sigpanic x!*  7>_)    .]] 3 pgE#ĤXruntime.dieFromSignal0[/x`   BgE# Fhruntime.raisebadsignalPOP!OP;OPO x%   +# )  A; 0gE#XXruntime.crashx@gE# ĤXruntime.noSignalStack0/ x!#: !u `gE#w~ĤXruntime.sigNotOnStack0/ x!#: !u ؛gE# ĤXruntime.signalDuringFork0/ x!#: !u XgE#ktwhruntime.badsignal07/0xU  ( М gE#Q(Truntime.sigfwdgo1F1x    * ! !!Xxp"gE#ĝhruntime.msigsave@8?x=   ."gE#%,/7ĤXruntime.msigrestore@2?x7  ("gE#XXruntime.sigblock@4?x9 ! *0#gE# ĤXruntime.unblocksigPSOxX    *.#hgE#hHruntime.minitSignalStackpop)o x !   \n p$gE#1XXruntime.minitSignalMask`_ x ! "  m< 0%xgE#hruntime.unminitSignals`+_`<xl  (e%gE# Xruntime.setGsignalStackx   P&`gE#}Xruntime.restoreGsignalStack@x@  &ءgE#runtime.signalstack`l_xq   K&'PgE#ay}̥Xruntime.sigsend0/0L/0/0/0"/ z!$       ! .' ] (gE#&̥Xruntime.signal_ignored7zC<(hgE#}̥Xruntime.maxSliceCap1|1B  )У0gE#hruntime.makeslicePOP C 2(   0 G XJ= vs=H=0g < gE#7:=Xruntime.adjustpointer)~) <0gE#hruntime.gobvS~_!X@=gE#"$hruntime.ptrbitB~N=G=h(gE#άpruntime.adjustpointers ~7G   G$I(-  ,%1 E`1*e @(gE#=[_ɭXruntime.adjustframe  ~ B  *  ,$%.  "9!  - [   %M#% 9+ M a8Aa)x 31 =)x*1 pI@gE#T_bvhruntime.adjustctxt0X/0 /~} "    6'IgE#֮ޮԩruntime.adjustdefersPO ~ &2   *KU J@gE#V]`nhruntime.adjustpanics01/~L "   6 KgE#ίկٯԩruntime.adjustsudogs@g? ~ "  B9 K( gE#:=@Xruntime.findsghih~h  L gE#°hruntime.syncadjustsudogspopMo ~ &    - bUL" pMHgE#[lp$hruntime.copystack" ~ : '4"&   t C(0 ' xCc" PgE#̥Xruntime.round2#~#PhgE#zE4runtime.newstack" ~2.: +         GT )   /8  KT    Q#   ? 'LM+SQ W+  '?)/M  O$+0_^ 4 V H Q***f5; P^gE#ѳԳ׳XXruntime.nilfunc~`^ gE#7BEYhruntime.gostartcallfn@8?@+?~~" "=&^gE#hruntime.shrinkstack@>?@?@?@ ?@ ?@ ?@ ?@6? ~&         !    *m p`pgE#ʵ`@runtime.freeStackSpans ~( 0 5#  ; ,0.W/&Y b gE#4;>FXXruntime.morestackc #~(  Pb0gE#öȶжruntime.concatstringsF'0 *M  U@.0'- : (  (0 dH8gE#_fjqLhruntime.concatstring2pQoln"CB#`eHgE#Ϸַڷ4hruntime.concatstring3pToov"FB&e(XgE#?FJQhruntime.concatstring4pWor~"IB)PfhgE#¸xhruntime.concatstring5pWor"IB)f0gE#+7<X̱\runtime.slicebytetostring`_`Q_ 3 "" '"  gW+ hgE#ùιҹ޹Xruntime.stringDataOnStack0H/0/g"&:ph(8gE#>IN`Чhruntime.rawstringtmppNop2o & #"  j. i0gE#úѺֺP\runtime.stringtoslicebyte+ &' "+  6" j80gE#Schжruntime.stringtoslicerune0 &S =  ^O k0gE#@|@runtime.slicerunetostring / '  Y 6 '  ,+ tM mgE#Xruntime.stringStructOf  m gE#,\runtime.intstring2 && ! & k5* nx0gE#Hаruntime.rawstring`_`_ S&'  em o gE#3tаruntime.rawbyteslicepopDo A&= Ea6 p gE#tаruntime.rawrunesliceZ K &8 ajE qgE#"8=Q\runtime.gostring & , *X? r(gE#ĿֿXruntime.indexpopopo & f  c s (gE#29=Qphruntime.contains`N_i"#Ds(gE#phruntime.hasprefix`(_`)_l'>Y `t gE#Xruntime.atoi       1ugE#$hruntime.atoi32PEOPOw"0@vgE#"%);hruntime.findnull??  8PvgE#̥runtime.gostringnocopyPDOI2vgE#Xruntime.add  vPgE#hoszXXruntime.badsystemstack0%/?x1wgE#hreflect.memclrNoHeapPointers0+/F"  0Pw@gE#RUYĤXruntime.fastrand--  wgE#̥Xruntime.fastrandn -2$wgE#"%)Xruntime.noescape  whgE#}Xruntime.getcallersp  wgE#$Xruntime.round x gE#259̥Xruntime.bool2int   xxgE#ĤXruntime.sbrk0   x gE#(ԩruntime.CallersFrames (3 ,5R x`8gE#HXruntime.(*stackExpander).init 1 yPgE#&runtime.(*Frames).Next M  zxgE#hruntime.(*stackExpander).next]w' D3.#  Q W  w! | }@gE#\tyruntime.(*pcExpander).init &6$  #$ T#<   7  5 2 HgE#,PU|runtime.(*pcExpander).next"1 X C 3 5$'  40( *)  3;2  d(  gE#"'X`Truntime.expandCgoFrames /(   %h  V >) 4 m$/"o gE#Xruntime.(*Func).raw  gE#*15?аruntime.(*Func).funcInfo@K?f"*&#0gE#$Xruntime.activeModulesCCgE# C`runtime.modulesinitI (6"HW ,  !+ ,H-+ gE#hԩruntime.moduledataverify0;/V$  /  gE#;LQruntime.moduledataverify1"  : A  H  & =RW)5*"(F! c    vRQ:a j<A 0gE#CJNV̥Xruntime.FuncForPC@C?^ "5&1gE#$hruntime.(*Func).NamePROPO  "? +W gE#148̥Xruntime.findmoduledatap<<  PgE#TXruntime.funcInfo.valid  `gE#TXruntime.funcInfo._Func  pHgE#Zjo\ԩruntime.findfunc`_`7_`>_  &     5?H   *B> 8gE# 38runtime.pcvaluet0  6 # +.O=H 9{| $ O#}4 7"% Y7 &4 gE# /hruntime.cfuncname@I?@%?@?  "- 0S x gE#hruntime.funcname@M?h "601(gE#-hruntime.funcnameFromNameoff@l?@?@?  &' 4-F x(gE#hruntime.funcfile@|?@?@?  &M 4=I 8gE#/4Rhruntime.funcline1d,  &E?-,"- 4e @0gE#\hruntime.funclineVq "5?+(gE#-=B_0runtime.funcspdeltac  &  Zg1 0gE#hruntime.pcdatavalue#v  %)B _< P0 gE#BRWqԸ,runtime.funcdataP$OPOPJO  %  5@ a.?, pPgE#"غhruntime.steppopopo  & '    2 . *0$    Pp gE#(hruntime.readvarintR^    W gE#"(hruntime.stackmapdata@]?@? !A L9 PpgE#hruntime.gostartcall0L/0/|""   nЩgE#AԦԩtime.Sleeppopo d& 5-, &)   vKKF ЫgE#htime.startTimer !<"  &gE##+htime.stopTimer0*/E"&`xgE#hruntime.goroutineReady@;?@?r) @+gE# %hruntime.addtimer A\$   (@pgE#Ԭаruntime.addtimerLocked & C     WK  gE#2CHhruntime.deltimer`Z_`_`_ &   % /    #"  3+ gE#\xruntime.timerproc !#D )E  !/  (' %8,[ Lk  81 s* `gE#Ԧԩruntime.timejump0j/0[/0/ ! %     <4 pHgE#]mrHtruntime.siftupTimer !% "K;  ;< gE#VHruntime.siftdownTimerl !%87 %  % 3N;   $  ;~* 0gE#ĤXtime.runtimeNano !<pgE#),0̥Xruntime.traceBufPtr.ptr   pgE#Xruntime.(*traceBufPtr).setgE#Xruntime.traceBufPtrOf  8gE#L]bPruntime.StartTrace   6  23 R   C G "Lt & >  5 (0 g . CO.S[a! @G J ," 8 @@gE#Sfkhruntime.StopTracewl (         '   i    ' ~ 5j3  gE#3fkhruntime.ReadTracex  +  (8   & 8 (8?N ?@ 5 @ :" v3   ]   HW /]g p@gE#UdiԦԩruntime.traceReader@(?@U?@f? !     br) gE# hruntime.traceProcFree01/0tȦԩruntime.traceFlushpopo  !)   %(      ~@B (gE#runtime.traceStringL  &9; { *"% U=a p8gE#Xruntime.traceAppendC  5L #<  0gE#!?hruntime.(*traceBuf).varintbu      ggE#hruntime.(*traceBuf).byte9E   >gE#̥Xruntime.traceStackPtr.ptr  ` gE#}(hruntime.(*traceStack).stack:F 5?`(gE#Wоruntime.(*traceStackTable).put#   &*=B "   !   *- Je(> 0gE#ж0runtime.(*traceStackTable).find`_`_`_  &/!0   =Ks HgE#mtx$hruntime.(*traceStackTable).newStack@C?^ " &>0gE#runtime.allFrames"  9 0({JA SIxE' pgE#<Lruntime.(*traceStackTable).dump8   HAh9//(   '2TJC* !I41 nf3Q2c7" Z 0hhgE#Pxruntime.traceFrameForPC  !  #"   7   maa pgE# #'̥Xruntime.traceAllocBlockPtr.ptr  hgE#Xruntime.(*traceAllocBlockPtr).set gE#,\runtime.(*traceAlloc).allocPOPhO  &! *+  3u&= 0gE#ԩruntime.(*traceAlloc).dropPrO   #1 gE#!(,:ĤXruntime.traceGomaxprocspVoq 6 [@gE#XXruntime.traceProcStartpco~P hgE# %=(\runtime.traceProcStop !  7   !/G pgE#XXruntime.traceGCStartpgo C  [  gE# *XXruntime.traceGCDone`@_[- E`xgE#XXruntime.traceGCScanStart`@_[- EgE# XXruntime.traceGCScanDone`@_[- E hgE#XXruntime.traceGCSweepStart0_/0/ "   5Y gE# .Ԧԩruntime.traceGCSweepSpanpaop9o !" 2 9m  xgE#hԩruntime.traceGCSweepDoneY !" ] 9  gE#(/3=XXruntime.traceGCMarkAssistStart`@_[- EgE#XXruntime.traceGCMarkAssistDone`@_[- E@gE#(-=hruntime.traceGoCreate & "BZ W PgE#hԩruntime.traceGoStart !3C X _~y P(gE#<CGQXXruntime.traceGoEnd`@_[- EgE#XXruntime.traceGoSched`[_v - `0gE#(/3AXXruntime.traceGoPreempt`[_v - `gE#̥Xruntime.traceGoPark`L_`4_ &0 2 UC `gE#/4Jhruntime.traceGoUnparkb ! D Y q gE#XXruntime.traceGoSysCall`@_[- EgE#(27IĤXruntime.traceGoSysExit &j !  gE#(\runtime.traceGoSysBlock !  7   !/G (gE#@GKUXXruntime.traceHeapAllocpVoqC [gE#XXruntime.traceNextGCZE ! : C cT  gE#7?DmXXruntime.tracebackinit@? ~( ((((((((((((((((! / 8 gE#!0Truntime.tracebackdeferso /(     9 F.[ V"m>e xXgE#Pruntime.gentraceback"        4: $ .  0 +#D 12   E#9 d>13##j$*(ah $  "+   6;R 2"#N   j+' iK^ (G!MIQ>@ % O 12 # K  &IG$L-/;2 =-=2  gG   +'7 BY5    $1 !*1 Q+ +ydg! (HTsE} kZq ( 7=+ P(8gE#<LQT̺runtime.getArgInfoB  & <71/  =,1 m21> @0gE# J$ runtime.tracebackCgoContext"   .  2%.  " + + R u gE#@runtime.printcreatedby^  , H,q # 9  <"v1P#1Cp PH gE#[bf|hruntime.traceback`H_c " M gE#hruntime.tracebacktrap`H_c " M0H(gE#\mrhruntime.traceback1"  2K # W # k% %  !(gE# 6Pruntime.callers  &  X       * "0gE#Xhruntime.gcallers  ) # #(gE# " ' D h0runtime.showframeE  ! $<  hh7 % gE#   Xruntime.isExportedRuntime@@ ;% gE#  % [ 8\runtime.goroutineheader  & $ 6 r),   # #J#3 ,  *X4Rwy ( gE#     runtime.tracebackothersn  ! /( $(   /( ) !Ga"FU +h gE#|   TXruntime.topofstack + gE#   Xruntime.isSystemGoroutineuu   ,H gE#c t y  `ȵruntime.printCgoTraceback !0!  #O  6,s -  gE#   E ԩruntime.printOneCgoTraceback + D( O (  Q4 / gE#    (\runtime.callCgoSymbolizerPLOP"O  " <. P0  gE#7MRn`runtime.cgoContextPCs2 !!   )  ^5? P1gE#$hruntime.(*_type).string@r?@?@? \&- . 1m 2@gE#[_dXruntime.(*_type).uncommonl 21>. # ! < _J ; # $ 3 2gE#XXruntime.reflectOffsLock #>$  (2HgE#cjnxXXruntime.reflectOffsUnlock #>$  (03gE#-lruntime.resolveNameOffh %   3   1. ? P6gE#$hruntime.(*_type).nameOff@3?N".6gE#49rruntime.resolveTypeOff %  2  *    !8) ^6 :gE#$hruntime.(*_type).typeOff@3?N".p:@gE#Zrwlruntime.(*_type).textOff & .   !+ *    ! X;# 6 = gE#(38F(hruntime.(*functype).in@`?@? "I 9B p> gE#(hruntime.(*functype).outPOPO &  S Jt @?gE#/26Xruntime.(*functype).dotdotdot`?gE#$hruntime.name.data@5?P"0?gE#  Xruntime.name.isExported ?XgE#nuzԩruntime.name.nameLenPhO "Z /!, `@gE#ԩruntime.name.tagLen`?_`{_ &W 3t, @APgE#crwȬxruntime.name.namePTOP9OPO 8&!  AB? BgE#Ȭxruntime.name.tagPOOPLO 8&!  <U# BXgE#n~$hruntime.name.pkgPath`/_`_`_ &# 6*  T9 DgE#"{pruntime.typelinksinit"   2 $ P  B "'3#*;K":10L6<# " "_  yG6>q.B1\4 K gE# runtime.typesEqual"zT{^N$! :$a  K ) *J*: J*:S )#/6* ~3&( ) 2u`m ~ OG#,.J)  D42I E wWJ+O8( t2(tn/O>(8(833(#&48^84DB/r&' @Z@gE#WZ^Xruntime.isDirectIfaceV`ZgE#Xruntime.readUnaligned32  pZgE# Xruntime.readUnaligned64  Zh(gE#|`hruntime.decoderunelh  0- ! @; P\ (gE#4IN`hruntime.encoderune7?Re              ]gE#$hruntime.writeErrP8OPOZ"  =^@gE#]`cXruntime.cgocallbackg1.func1  0^gE#XXruntime.cgoCheckWriteBarrier.func1PO V.x 3 _8 gE#Z a d n XXruntime.cgoCheckTypedBlock.func1P;OV- @`_ gE#    XXruntime.cgoCheckTypedBlock.func20%/?1_8!gE#T![!^!f!XXruntime.cgoCheckBits.func10%/?1_!gE#!!!!XXruntime.chansend.func1 &AA+0` "gE#8"?"B"F"XXruntime.chanrecv.func1 &AA+`"gE#""""XXruntime.(*mcache).nextFree.func1@(?4C%  -`#gE#(#/#2#<#hԩruntime.mallocgc.func1PIO4d 2! A@a#gE#####hԩruntime.persistentalloc.func1`R_`_ 42* @4 a$gE#9$D$H$Z$hruntime.writebarrierptr_prewrite1.func1`V_`M_ 6-" * _"3 b$gE#$$$$hԩruntime.writebarrierptr.func1PO 63x 3'e pc(%gE#P%W%Z%^%XXruntime.writebarrierptr_prewrite.func10%/6??1c%gE#%%%&hpruntime.typedslicecopy.func1 6E-&!8Z /;B&;]   fP&gE#j&q&u&&hԩruntime.freemcache.func1@{? :*   .F g&gE#&&&'XXruntime.SetFinalizer.func1 $@?!  )gP'gE#l'w'{''XXruntime.SetFinalizer.func2pUopo @1.  Q3 Ph'gE#(((Xruntime.(*gcControllerState).findRunnableGCWorker.func17D7  hX(gE#o(v(y((XXruntime.gcStart.func1D0 h(gE#((()hruntime.gcMarkDone.func1.1 )DD" .iH)gE#b)i)l)v)XXruntime.gcMarkDone.func1 #D>$  (Pi)gE#))))XXruntime.gcMarkTermination.func1 #D>!  (i@*gE#a*l*p**hԩruntime.gcMarkTermination.func20_/0{/ D*         M]#% j*gE#+++++ܶhruntime.gcBgMarkWorker.func1pIopoo D&   -- -=!) pkx+gE#++++`runtime.gcBgMarkWorker.func2pop[o D3  #   $-: 521  F5S.5 l(,gE#I,L,O,̥Xruntime.gcMarkRootPrepare.func1H~m,gE#,,,,xruntime.markroot.func1phopo H!  4' h0 `n8-gE#U-\-_-i-XXruntime.gcAssistAlloc.func10)/HD% .n-gE#----$hruntime.scanstack.func1@8?HS %8o(.gE#B.I.L.V.hԩruntime.gosweepone.func10-/JH& &`o.gE#....hԩruntime.getempty.func1`N_Ni-+ Fo/gE#5/>/B/`/xruntime.freeSomeWbufs.func1 N!  $    `&C p/gE#////hԩruntime.(*mheap).alloc.func1`P_Pk 6$ H q00gE#Q0a0e004runtime.(*mheap).freeSpan.func1 P*(   R Pr0gE#0111XXruntime.mProf_Malloc.func10)/RD% .rX1gE#x1111hruntime.GoroutineProfile.func10-/0-/Ru &HE s1gE#1222XXruntime.GoroutineProfile.func2PGOPORi -$ Ls`2gE#u2222xruntime.Stack.func1H R !   e+ +   0u3gE#"3)3,363XXruntime.tracealloc.func1P;ORV ) @u3gE#3333XXruntime.tracefree.func1P;ORV ) @u3gE#444(4XXruntime.ReadMemStats.func1 V;!  %0vp4gE#4444hԩruntime.semacreate.func10//\JV& &v4gE#55 55hԩruntime.semasleep.func1@4?\O* .v`5gE#5555XXruntime.mach_semrelease.func1@3?\NN8 w5gE#566!6` runtime.newdefer.func1 ^H r 2    Ln)5 yx6gE#6666hԩruntime.newdefer.func2`m_`_ ^* 1 2a @z6gE#7!7%7S7`@runtime.freedefer.func1B ^8HCA5  =8R P|7gE#7777XXruntime.preprintpanics.func1@+?@?^a" &4|(8gE#?8F8I8S8XXruntime.dopanic.func1@2?^M ) 7}8gE#8888XXruntime.main.func10,/bG$ 1`}9gE#$9/929@9hruntime.main.func2b>  0}9gE#9999XXruntime.goready.func1@.?bI% 3}:gE#:":&:1:XXruntime.casgstatus.func1PO b ! 1 ~:gE#::::XXruntime.casgstatus.func20%/b? 1:gE#;;";-;XXruntime.reentersyscall.func1`_ b&% ? x;gE#;;;;XXruntime.entersyscallblock.func1 b(@ Q `<gE#!<*<.<9<XXruntime.entersyscallblock.func2 b(. Q <gE#<<<<XXruntime.exitsyscall.func10%/b?)1=gE#='=+=?=xxruntime.exitsyscallfast.func1PO b*<    <+( =gE#====XXruntime.exitsyscallfast_reacquired.func10F/ba+!"  0* >gE#,>3>6>@>hԩruntime.malg.func1P=ObX-) ,%>gE#>>>>XXruntime.newproc.func1`G_bb--$ L?gE#???)?hԩruntime.gfget.func1P>ObY0&" -%Pp?gE#????`runtime.(*rwmutex).rlock.func1`A_`f_ nT*    09 @gE#*@1@4@<@XXruntime.morestackc.func10%/~?1`@gE#@@@@hԩruntime.callers.func1  5h   AgE#A*A6AEAXXruntime.init@?@? PvI9PN(!98 xAgE#AAAruntime.skipPleaseUseCallersFramesL AgE#AAAruntime.rt0_go    0CgE#CCCruntime.asminit@HCgE#XC[C_Cruntime.gosave== CgE#CCCruntime.gogo0w{  DgE#'D.D2Druntime.mcallS  f   pDgE#DDDruntime.systemstack_switchDgE#DDDruntime.systemstack     0xEgE#EEEruntime.morestack      ЍFgE#"F%F)Fruntime.morestack_noctxtXFgE#fFiFmFreflect.callF gE#FFF2runtime.reflectcallЏ@GgE#IGPGTG0callRetP+O0 G gE#GGGG010runtime.call32PTOP~~9/H gE# H,H0H4H10runtime.call64T~~9/H gE#HHHH00runtime.call128u PAH gE#I III10runtime.call256u SA``I gE#qI}III10runtime.call512u SAI gE#IIII`00runtime.call1024u SA@J gE#RJ^JcJhJ00runtime.call2048 u SApJ gE#JJJJ`10runtime.call40964@u@ @iA@ K gE#2KAKFKKK10runtime.call81924u iAK gE#KKKK00runtime.call163844u iAL gE##L2L7LOC  X gE#XXXruntime.aeshash 0XgE#XXXruntime.aeshashstr P0YgE#EYIYNYruntime.aeshashbody   x[gE#[[[runtime.aeshash3233   [gE#[[[runtime.aeshash6444    0\gE#B\E\I\2runtime.checkASM@\gE#\\\runtime.memequal$$p\gE#\\\runtime.memequal_varlen##8]!gE#J]M]Q]runtime.eqstring$$Э]gE#]]]runtime.memeqbody^(gE#^^^runtime.cmpstring0^gE#^^^runtime.cmpbody pH`(gE#_`b`f`strings.indexShortStr!!`8gE#```bytes.indexShortStr!!б`gE#aaaruntime.indexShortStr  b(gE#bbbbytes.IndexByte c gE#3c6c:cstrings.IndexBytepcgE#cccruntime.indexbytebody `d1gE#mdpdtdbytes.Equal))!Pd gE#dddstrings.countByte!pegE#ee$eruntime.countByte!fgE#)f,f0fruntime.return0$`fgE#pfsfwfruntime.goexit$fgE#fffruntime.prefetcht0  $fgE# gggruntime.prefetcht1  $ HggE#\g_gcgruntime.prefetcht2  $0ggE#gggruntime.prefetchnta  $@ggE#gghruntime.duffzerohgE#hhhruntime.duffcopykgE#6k:k?kruntime.memclrNoHeapPointers  xlgE#lllruntime.memmove  D                      8  `ogE#ooo_rt0_amd64_darwinogE#ooomain  pgE#&p)p-pruntime.exit* `pgE#oprpvpruntime.exit1< pgE#pppruntime.open  JqgE#qqqruntime.closefd`PqgE#^qaqeqruntime.read  r0qgE#qqqruntime.write!!`qgE#r rrruntime.raisep@rgE#SrZr^rruntime.raiseproc@-?2 rgE#rrrruntime.setitimerrgE#sssruntime.madvise@sgE#RsUsYsruntime.nanotimeLL  @sgE#ssstime.nowPOP5O       0htgE#}tttruntime.sigprocmask## `tgE#tttruntime.sigaction-- u gE#(u/u3uruntime.sigfwd "xugE#uuuruntime.sigtramp`;?ugE#uuuruntime.mmap**00vgE#@vCvGvruntime.munmap PvgE#vvvruntime.sigaltstack!! vgE#vvvruntime.usleep0;/@ @wgE#Zw]wawruntime.bsdthread_create66wgE#wwwruntime.bsdthread_start !3 @(xgE#DxGxKxruntime.bsdthread_register..pxgE#xxxruntime.mach_msg_trap# 1ygE#yyyruntime.mach_task_self  XygE#qytyxyruntime.mach_reply_port  ygE#yyyruntime.mach_semaphore_waitzgE#*z-z1zruntime.mach_semaphore_timedwaitpzgE#zzzruntime.mach_semaphore_signalzgE#zzzruntime.settlsP!O&  @ {gE#0{3{7{runtime.sysctl55{gE#{{{runtime.kqueue{gE#{{{runtime.kevent--8|gE#M|P|T|runtime.closeonexec|gE#||||$htype..hash.runtime._funcPcO~~9%p}gE#0};}?}C}htype..eq.runtime._funcP:OP0O 0B  }gE#}}}}$htype..hash.runtime.uncommontypePcO~~9%~gE#~"~%~TXtype..eq.runtime.uncommontype777h~gE#~~~~$htype..hash.runtime.modulehashPvO 0A `~gE#~ TXtype..eq.runtime.modulehash`c_`]_ F PXgE#v}$htype..hash.runtime.bitvectorPcO~~9%gE#TXtype..eq.runtime.bitvector)))0gE#JRVZ$htype..hash.runtime.FramePO =] gE#̀ЀԀTXtype..eq.runtime.Frame`_`o_ T  gE#ahkn$htype..hash.struct { Size uint32; Mallocs uint64; Frees uint64 }PcO~~9%pgE#TXtype..eq.struct { Size uint32; Mallocs uint64; Frees uint64 }:::8gE#}Xtype..hash.[61]struct { Size uint32; Mallocs uint64; Frees uint64 }PTOooA' ЂgE#TXtype..eq.[61]struct { Size uint32; Mallocs uint64; Frees uint64 }VVV`gE#}$htype..hash.runtime.MemStatsPO =f P؃gE#htype..eq.runtime.MemStatsPOP.O =~ 0PgE#w$htype..hash.runtime.TypeAssertionError@? 4T ЄgE# htype..eq.runtime.TypeAssertionError`_`_ #y PXgE#sz~$htype..hash.runtime._panicPO =A ЅgE#htype..eq.runtime._panicPIOPNO { HgE#cjmp$htype..hash.runtime._deferPcO~~9%@gE#نhtype..eq.runtime._deferP7OP*O||e8gE#W_cg$htype..hash.runtime.sysmontickPO =J pgE#ŇȇˇTXtype..eq.runtime.sysmontickHHHgE#,369$htype..hash.runtime.specialP>OYY9 gE#htype..eq.runtime.specialP=OXX9gE# $htype..hash.runtime.markBitsPcO~~9%`gE#{~TXtype..eq.runtime.markBits<<<@ȉgE#$htype..hash.runtime.mcachePcO~~9%@gE#Ydgjhtype..eq.runtime.mcacheP+OP&OllY 0gE#Ҋي܊ߊ$htype..hash.runtime.hchanPcO~~9%(gE#@KOShtype..eq.runtime.hchanPCOP0O 9B  PgE#ċNj$htype..hash.runtime.sudogPcO~~9%gE#(37;htype..eq.runtime.sudogPCOP0O 9B  pgE#$htype..hash.runtime.cpuProfilePcO~~9%gE#(+.htype..eq.runtime.cpuProfileP:OP*OhpxgE#$htype..hash.runtime.dbgVarPZOuu0%gE# TXtype..eq.runtime.dbgVar`H_`-_ s hgE#$hruntime.(*errorString).ErrorPOOPOP@*gE# $htype..hash.runtime.finblockPcO~~9%`gE#{htype..eq.runtime.finblockPCOP0O 9B  0؏gE#$htype..hash.runtime.forcegcstateP>OYY9PgE#ovy|htype..eq.runtime.forcegcstateP=OXX9ȐgE#$htype..hash.runtime.functypeP>OYY9P@gE#[behhtype..eq.runtime.functypeP=OXX9gE#֑ޑ$htype..hash.runtime.gcControllerStatePO =| 0gE#T`dhTXtype..eq.runtime.gcControllerStatePOPO = `gE#ϒْ֒ܒ$htype..hash.runtime.gcSweepBufP>OYY9(gE#ELORhtype..eq.runtime.gcSweepBufP=OXX9 gE#œȓ˓$htype..hash.runtime.gcTriggerP>OYY9gE#4;>Ahtype..eq.runtime.gcTriggerP=OXX9gE#$htype..hash.runtime.heapBitsP>OYY9@gE#TXtype..eq.runtime.heapBits)))p`gE#z$htype..hash.runtime.hiterPcO~~9%ЕgE#TXtype..eq.runtime.hiterPfOPO 9I HgE#fmps$htype..hash.runtime.treapNodeP>OYY9gE#ܖhtype..eq.runtime.treapNodeP=OXX9@0gE#MTWZ$htype..hash.runtime.mcentralPcO~~9%gE#×Ηїԗhtype..eq.runtime.mcentralP:OP*Oh@ gE#BILOXtype..hash.[2]runtime.gcSweepBufPTOooA'gE#Øǘ˘TXtype..eq.[2]runtime.gcSweepBufP]OPO T, @gE#gnqt$htype..hash.struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }PZOuu0%gE# TXtype..eq.struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }@P?@?oo080hgE#ÚƚɚXtype..hash.[134]struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }PUOpp@)gE#bnrvTXtype..eq.[134]struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }`_`_ aJ `gE# #&$htype..hash.struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }PcO~~9%hgE#œŜTXtype..eq.struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }::: gE#elorXtype..hash.[67]struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }PTOooA'gE#TXtype..eq.[67]struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }VVV`gE#{$htype..hash.runtime.mstatsPO = 0؞gE#htype..eq.runtime.mstatsPOPO =/8 XgE#u$hruntime.(*plainError).ErrorPOOPOP@*@؟gE#$htype..hash.runtime.rwmutexPcO~~9%PgE#juy}htype..eq.runtime.rwmutexPCOP0O 9B  `ȠgE#$htype..hash.runtime.semaRootP>OYY9@gE#[behhtype..eq.runtime.semaRootP=OXX9 gE#̡ӡ֡١$htype..hash.runtime.sigTabTPZOuu9(gE#BMPShtype..eq.runtime.sigTabT`@_`#_~~g gE#ĢǢʢ$htype..hash.runtime.stackmapP>OYY9gE#3:=@htype..eq.runtime.stackmapP=OXX9gE#$htype..hash.runtime.sweepdataPcO~~9%`gE#'+/TXtype..eq.runtime.sweepdataP`OPO 9C xgE#$htype..hash.runtime.traceStackPcO~~9%pgE#  TXtype..eq.runtime.traceStackP]OPO9@hgE#$htype..hash.runtime.traceStackTablePcO~~9%pgE# htype..eq.runtime.traceStackTablePWOP2O  hgE#Xtype..hash.[14]runtime.dbgVarPTOooA'gE# TXtype..eq.[14]runtime.dbgVar vJ ``gE#$htype..hash.struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }PZOuu0%gE#R]aehtype..eq.struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }PEOP.O s gE# Xtype..hash.[251]struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }PUOpp@)XgE#TXtype..eq.[251]struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }`_`_ , gE#%(+Xtype..hash.[2]stringPSOnn@'0xgE#TXtype..eq.[2]stringpyopo t, gE#Xtype..hash.[32]runtime.sigTabTPTOooA'P`gE#~TXtype..eq.[32]runtime.sigTabTpopo , gE#Xtype..hash.[33]float64PPOkk='HgE#^adTXtype..eq.[33]float64555gE#ŬȬˬXtype..hash.[3]stringPSOnn@'0gE#,7;?TXtype..eq.[3]stringpyopo t, gE#Xtype..hash.[4]stringPSOnn@'PgE# TXtype..eq.[4]stringpyopo t, hgE#~Xtype..hash.[5]stringPSOnn@'pخgE#TXtype..eq.[5]stringpyopo t, HgE#^ehkXtype..hash.[6]stringPSOnn@'gE#̯ׯۯ߯TXtype..eq.[6]stringpyopo t, @(gE#>EHKXtype..hash.[9]stringPSOnn@'gE#TXtype..eq.[9]stringpyopo t, `gE#JQTW$htype..hash.struct { runtime.cycle uint32; runtime.flushed bool }P>OYY9gE#ر۱ޱTXtype..eq.struct { runtime.cycle uint32; runtime.flushed bool }((((gE#$htype..hash.struct { runtime.enabled bool; runtime.pad [3]uint8; runtime.needed bool; runtime.cgo bool; runtime.alignme uint64 }PcO~~9%pgE#TXtype..eq.struct { runtime.enabled bool; runtime.pad [3]uint8; runtime.needed bool; runtime.cgo bool; runtime.alignme uint64 }PYOPOxx98سgE#08<@$htype..hash.struct { runtime.full runtime.lfstack; runtime.empty runtime.lfstack; runtime.pad0 [64]uint8; runtime.wbufSpans struct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }; _ uint32; runtime.bytesMarked uint64; runtime.markrootNext uint32; runtime.markrootJobs uint32; runtime.nproc uint32; runtime.tstart int64; runtime.nwait uint32; runtime.ndone uint32; runtime.alldone runtime.note; runtime.helperDrainBlock bool; runtime.nFlushCacheRoots int; runtime.nDataRoots int; runtime.nBSSRoots int; runtime.nSpanRoots int; runtime.nStackRoots int; runtime.markrootDone bool; runtime.startSema uint32; runtime.markDoneSema uint32; runtime.bgMarkReady runtime.note; runtime.bgMarkDone uint32; runtime.mode runtime.gcMode; runtime.userForced bool; runtime.totaltime int64; runtime.initialHeapLive uint64; runtime.assistQueue struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }; runtime.sweepWaiters struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }; runtime.cycles uint32; runtime.stwprocs int32; runtime.maxprocs int32; runtime.tSweepTerm int64; runtime.tMark int64; runtime.tMarkTerm int64; runtime.tEnd int64; runtime.pauseNS int64; runtime.pauseStart int64; runtime.heap0 uint64; runtime.heap1 uint64; runtime.heap2 uint64; runtime.heapGoal uint64 }PO = gE#htype..eq.struct { runtime.full runtime.lfstack; runtime.empty runtime.lfstack; runtime.pad0 [64]uint8; runtime.wbufSpans struct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }; _ uint32; runtime.bytesMarked uint64; runtime.markrootNext uint32; runtime.markrootJobs uint32; runtime.nproc uint32; runtime.tstart int64; runtime.nwait uint32; runtime.ndone uint32; runtime.alldone runtime.note; runtime.helperDrainBlock bool; runtime.nFlushCacheRoots int; runtime.nDataRoots int; runtime.nBSSRoots int; runtime.nSpanRoots int; runtime.nStackRoots int; runtime.markrootDone bool; runtime.startSema uint32; runtime.markDoneSema uint32; runtime.bgMarkReady runtime.note; runtime.bgMarkDone uint32; runtime.mode runtime.gcMode; runtime.userForced bool; runtime.totaltime int64; runtime.initialHeapLive uint64; runtime.assistQueue struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }; runtime.sweepWaiters struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }; runtime.cycles uint32; runtime.stwprocs int32; runtime.maxprocs int32; runtime.tSweepTerm int64; runtime.tMark int64; runtime.tMarkTerm int64; runtime.tEnd int64; runtime.pauseNS int64; runtime.pauseStart int64; runtime.heap0 uint64; runtime.heap1 uint64; runtime.heap2 uint64; runtime.heapGoal uint64 }POPO =, HgE#$htype..hash.struct { runtime.lock runtime.mutex; runtime.pad uint32; runtime.val uint64 }PcO~~9%` gE#HKNTXtype..eq.struct { runtime.lock runtime.mutex; runtime.pad uint32; runtime.val uint64 }::: gE#X_be$htype..hash.struct { runtime.note runtime.note; runtime.mask [1]uint32; runtime.wanted [1]uint32; runtime.ignored [1]uint32; runtime.recv [1]uint32; runtime.state uint32; runtime.inuse bool }P>OYY9gE#nux{htype..eq.struct { runtime.note runtime.note; runtime.mask [1]uint32; runtime.wanted [1]uint32; runtime.ignored [1]uint32; runtime.recv [1]uint32; runtime.state uint32; runtime.inuse bool }P=OXX9`gE#`gjm$htype..hash.struct { F uintptr; runtime.buf *[]uint8; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr; runtime.all bool; runtime.n *int }PcO~~9%gE#NY\_TXtype..eq.struct { F uintptr; runtime.buf *[]uint8; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr; runtime.all bool; runtime.n *int }PYOPOxx98`gE#  $htype..hash.struct { F uintptr; runtime.c *runtime.mcache; runtime.spc runtime.spanClass }P>OYY9XgE#htype..eq.struct { F uintptr; runtime.c *runtime.mcache; runtime.spc runtime.spanClass }P=OXX9 gE#qx{~$htype..hash.struct { F uintptr; runtime.h *runtime.mheap; runtime.s *runtime.mspan; runtime.acct int32 }P>OYY9gE#/69<htype..eq.struct { F uintptr; runtime.h *runtime.mheap; runtime.s *runtime.mspan; runtime.acct int32 }P=OXX9gE#$htype..hash.struct { F uintptr; runtime.newg *runtime.g; runtime.stacksize int32 }P>OYY9@0gE#htype..eq.struct { F uintptr; runtime.newg *runtime.g; runtime.stacksize int32 }P=OXX9gE# $htype..hash.struct { F uintptr; runtime.preemptible bool }P>OYY9`gE#TXtype..eq.struct { F uintptr; runtime.preemptible bool }+++0gE#!$'$htype..hash.struct { F uintptr; runtime.r int32 }P>OYY9hgE#TXtype..eq.struct { F uintptr; runtime.r int32 })))gE#$htype..hash.struct { F uintptr; runtime.s **runtime.mspan; runtime.h *runtime.mheap; runtime.npage uintptr; runtime.spanclass runtime.spanClass; runtime.large bool }P>OYY9 gE#htype..eq.struct { F uintptr; runtime.s **runtime.mspan; runtime.h *runtime.mheap; runtime.npage uintptr; runtime.spanclass runtime.spanClass; runtime.large bool }P=OXX9gE#_fil$htype..hash.struct { F uintptr; runtime.s **runtime.mspan; runtime.size *uintptr; runtime.needzero bool; runtime.noscan bool }P>OYY9gE#5<?Bhtype..eq.struct { F uintptr; runtime.s **runtime.mspan; runtime.size *uintptr; runtime.needzero bool; runtime.noscan bool }P=OXX9@gE#$htype..hash.struct { F uintptr; runtime.siz int32; runtime.d **runtime._defer }PcO~~9%0gE#~TXtype..eq.struct { F uintptr; runtime.siz int32; runtime.d **runtime._defer }::: gE#(errors.NewP{OPO :i >^ 0gE#MPTXerrors.(*errorString).Error++&gE#XXinternal/race.Enable:gE#  ĤXinternal/race.ErrorsVPgE#_kpx ܰsync.newEntryPOP O nO5=D 0gE#)sync.(*Map).Load"/  R{ 0!   d}VlB&  gE#̥sync.(*entry).load0f/0&/0%!' (gE# #(psync.(*Map).Store"  | r  $   ~  =QZMb?`WW:5\"*  p"gE# ,TĤsync.(*entry).tryStorep:opEop-opo &3  uU P#xgE#hsync.(*entry).unexpungeLocked`J_e"<B#gE#(hsync.(*entry).storeLocked0-/H 2$p@gE#(sync.(*Map).LoadOrStore" R < v$#  (~   dMbhdf`X=`\"! ,h0gE#@4sync.(*entry).tryLoadOrStorez;M; F/< :<1/5 b @.(gE#@V[u,0sync.(*Map).missLockedb !1 j!  "L /gE#@sync.(*Map).dirtyLocked"4# 2sl  iT$L5  2xgE#Ĥsync.(*entry).tryExpungeLockedpnop4o &4  cX P3gE#38hsync.(*Mutex).Lock4 !    1   # J I     AMb$: E  l+a % 7 gE#6IN|hsync.(*Mutex).UnlockP`OP\OP:OPO !     .169 h @8gE#xsync.(*Once).Do`._`_`_`_ H!*6  6j6 P9`gE#r0sync.(*Pool).Put !\  +  > 0Xl p;gE#"38tDsync.(*Pool).Get 3, #!5$"   >Nc(!*  =gE#'sync.(*Pool).getSlowD 3L 5$   R   `?xgE#\sync.(*Pool).pin|& * ,' *LE 0@gE#49h@sync.(*Pool).pinSlow ; ';D<E K % ;NGox$ PCgE#xsync.poolCleanup% /;%''6A1   "b   ^d) FxgE#XXsync.init.0 #>$  (0GgE#Ĥsync.indexLocal 38pGHgE#U\`kXإsync.init.1`D__h$  IGgE#hsync.(*RWMutex).RLock0M/0/jX   N@H8gE#Q]bhsync.(*RWMutex).RUnlock@?@? ~! #       QT( IgE#hsync.(*RWMutex).Lock@?@? ! &+  .e IXgE#p|hsync.(*RWMutex).Unlock`_`_ !    Lv JgE# (XĤsync.init@ ?@i?@? _(" _(" Et Kp8gE# io.WriteString S  N8gE# io.Copy S x OhPgE#w`io.copyBuffer"  V  9! B  B1 PVHgE#QbwXXio.initP OPOPO _8 _6CCCC CC?8  5 E Y8gE#,Ч\syscall.readIntY 5 0 Zx(gE#`hsyscall.readIntLE@W?@Y?@?@?@k? T* & J   wW V ]8`gE#Mej`syscall.ParseDirent" n  .W,M9WW W0"e#c !@Q?@X  2   6  # d gE#1AFrxsyscall.copyenv/ J6B')5GD " C # U h(gE#2syscall.GetenvN5 V6 .]7'&u 66 f9#d 0kgE#ĤXsyscall.CloseOnExecp3oNN8k gE#!;إإsyscall.SetNonblock 9w  Z  i lgE#̥Xsyscall.rsaAlignOf E f*" `mgE#&$إsyscall.itoa5 3 y6 K `npgE#$$syscall.uitoa G$ >& % D @p8gE#,1Iĭsyscall.ByteSliceFromString  fk')R ]U  _ r(gE#`\syscall.BytePtrFromString@ S 6H  pt(8gE#<FKVsyscall.ReadDirent S  ~ u gE#إ,syscall.Getwd"5 .iBFF[G|   y@(gE#S]bj`hsyscall.direntIno 2z aK `z(gE#`hsyscall.direntReclen 2z aK {0(gE#FPU]`hsyscall.direntNamlen 2z aK {pgE#usyscall.getAttrList"= n"  4     %" 0 V(VL"(L \ +    K&B 1  (gE#`Ȧsyscall.PipeO  3"   { `gE#u$إsyscall.Errno.Errortw  3. v  v ЅgE#"@$Xsyscall.errnoErrpUop+opEop+op+opo 3  "B " "  8gE#Ȧsyscall.Read E  ~X 8gE#!&7Ȧsyscall.Write E  X 0gE#0hsyscall.fcntl ES  (  kO-  gE#&+A hsyscall.pipe Nd   (  qm- (gE#`syscall.Chmod 9 { E (  v)- (gE#7GL^Dhsyscall.Close 38 "  W)' @gE#ĤXsyscall.Exit<W) A gE#'7<N\syscall.Fstat 3C "  b)' `@gE#ر4syscall.Getdirentries S "   ( ON 8(gE#G^c}syscall.Lstat  < { P (  y)0 8gE#syscall.Open  S {b  ( O3 Ph@gE#wDHsyscall.Pread S "   ( ON 8gE##EHsyscall.read E  c  (   OE P0gE#0hsyscall.Seek ES  (  kO- P(gE#5:Tsyscall.Stat < { P (  y)0 И8gE#Hsyscall.write E  c  (   OE 00HgE#>NSh@hsyscall.mmap E  (  O- ` gE# hsyscall.munmap 39 "  X)' 8gE#FVkXXsyscall.init` _`_`1_ ]: >  ]2: >1 E p8gE#3syscall.Syscallbb"   0PgE#BEI3syscall.Syscall6hhT   P8gE#2syscall.RawSyscallSS   0gE#HUY]$Ȧsyscall.(*Errno).Error`k_`_ `R4PgE#$htype..hash.syscall.attrListP{O F/  gE#;FJNԦtype..eq.syscall.attrListptopo j  gE#Xtype..hash.[106]stringpo p4 @gE#.26Tإtype..eq.[106]string^ 8 `gE#$htime.startsWithLowerCase0./0//0jcТ8gE#Чtime.nextStdChunk"w kn'F 72ZAB U, O9  1 ) C 565> T (Kh  ot s m A( #p *7$z T{|4 72ZAV T(WX, QT     N @gE#(8=vxPtime.appendIntk  S 9 $ *   *5F)A,  C HgE#0ptime.formatNanou S ;   ;@ >A  M `(gE#time.Time.String   GZ  l`$% e f!e',7A A  {;p H8gE#Zjo<\time.Time.FormatO G$ & eC 1 XgE#` time.Time.AppendFormat"   B JV       @ j "e4  % 9   A5 >W!5 >J% 9 !  9 A; AB A5 > + h h!(A+,+$%& h/29h9 6A3!< h= e    @ hAD9 hOJ9 h]XW` had heh ei l empqt} GG 5 cM[ b~~~~eF' @`  gE#n {   (htime.isDigit03/05/0u n 8gE#   ' Чtime.leadingIntov,D ! fZZp 0gE#    Ȧtime.leadingFraction2 ! $K  %*'P (gE#,   B dtime.ParseDuration"ab V  !  ?64("8?  $* 4Lf=E  n '  + | 8     ! gE#    ̥Xtime.whenP;OPKOPO <*   6k `" gE#4 ? D P htime.(*Timer).Stop@K?@? "2 C: " gE#    Ptime.AfterFuncpopDo *q- 4 3$"$ p$(gE#5@DPhtime.goFunc@  @F(gE#CFJ̥Xtime.Duration.Nanoseconds `FgE#̥Xtime.Duration.Seconds0/ !/4G8gE#T|Xtime.Time.Adda  ?'D +   j I8gE#p$time.Time.Sub;#  ;(   "" c"")  0LX gE#dns{\time.Since -y -X! L0gE#WXtime.absDate] _ ! ! ! !(  # +"   "  6 u  PgE#$time.Now H<t H R(gE#'/4$time.unixTime@?)eS gE#ܤXtime.Time.Unix@9?T+"/pS gE# ܤXtime.Time.UnixNanoPaO|+J/FS`(gE#k{$time.Unix E%$d  S `UgE#̥Xtime.isLeapV@ gE#V a f z Xtime.(*Location).get0c/0/ *  `3 V gE#    $Ԧtime.(*Location).String@P?k/58, W@!@gE#Y!~!!!time.(*Location).lookup8  s  Z C'  5 %  %!  K& M V ) * 0\P"gE#r""""htime.(*Location).lookupFirstZone *" b3-6(   3 P^#gE#(#8#=#إtime.(*Location).firstZoneUsed0 " P_# gE#####(htime.fileSizeError.Error ,3i y# `$(gE#$,$1$L$time.(*data).readpopopo N<, % .T(  a$gE#$$$$\time.(*data).big4z} d.5   @ b0%gE#C%X%]%n%\time.(*data).bytet( v+5  . =x c%(gE#%%%%`\time.byteStringj 9$#| R  eH&0gE#[&&&'time.loadZoneData"Y 'VlSZ; ,KZx&")+ # "Z EE"EEZaE9- ;9YZZ ZaE9,:ZJOI   Z HX8%;h $X(GA ! W1  LIc-)F[ y(8gE#(1(6(X( time.loadZoneFile"%  Vp    }( gE#(((((htime.get4 6 { `~) gE##)0)5)A)(htime.get2 6 A K~)8gE#)))*Ptime.loadZoneZip" ,i (V/PgIvszDf(0Efgvsvsvsfs1G F6&eh >    / zDw7A/5C' b`iby` +gE# +=+B+y+X8time.initLocaljH f/ w# ' =_ A' [ +(gE#+++,@time.loadLocationT S"/,5 9 s p,gE#{,,,,htime.init,  } C<a }CCCl1oooooouu(C@- 0 8gE#<8G8L8Z8$Ȧinternal/poll.(*FD).decrefppopo 36 >K 8gE#8888$Ȧinternal/poll.(*FD).readLockp]op:o 3&; C@- 09gE#P9[9_9o9hinternal/poll.(*FD).readUnlockPGOPOd$ -9gE#9999$Ȧinternal/poll.(*FD).writeLockp]op:o 3&; C@- е@:gE#a:l:p::hinternal/poll.(*FD).writeUnlockPGOPOd$ -@: gE#:;; ;xinternal/poll.(*pollDesc).init, H:<  B  JN p;gE#;;;;Xinternal/poll.(*pollDesc).close $ *jd  F;gE#<$<(<5<hinternal/poll.(*pollDesc).evict $ \v  FP<(gE#<<<<`Ȧinternal/poll.(*pollDesc).prepareH` 3': xI = gE#7=?=C=K=(Ȧinternal/poll.(*pollDesc).prepareReadc~/HJ-= gE#====(Ȧinternal/poll.(*pollDesc).prepareWritec~/HJ-  >(gE#@>O>T>b>`internal/poll.(*pollDesc).waitm` 3:': X > gE#>>>>(Ȧinternal/poll.(*pollDesc).waitReadc~/HJ-0? gE#U?]?a?i?(Ȧinternal/poll.(*pollDesc).waitWritec~/HJ-?gE#???Xinternal/poll.(*pollDesc).pollable0 @ gE#:@M@R@l@إ̥internal/poll.convertErrpJop>op+op[o 3   5 " B t p@0gE#@@@Xinternal/poll.(*FD).eofErroroo"(A0gE#BARAWAkA\Ȧinternal/poll.(*FD).Initpopopo \3  F ^ @AgE#AAAḀinternal/poll.(*FD).destroy`_ v3/ Ba 8BgE#SBcBhBvB$internal/poll.(*FD).Close: 3!6; >3h B8gE#BC CHCinternal/poll.(*FD).Read|D  S2B/ : TB1# zQC=   ! _R6GFREQ C@gE#CCCDinternal/poll.(*FD).Pread S,61# C7   _m/e XD8gE#sDDDDinternal/poll.(*FD).WriteLJ  S2B/TB  ,CW C A)   _R6Eg PPE8gE#pEEEEinternal/poll.(*FD).ReadDirent5 S,</ zN=   _F6EKL @F gE##F8F=FMF,internal/poll.(*FD).Fstat^s 3)(L <*-$C PFgE#FFFFXXinternal/poll.initP OPOP.O nw' n"?8)*! E 0GgE#MGTGWGZG$htype..hash.internal/poll.FDPLOggBGgE#GGGGԦtype..eq.internal/poll.FDpPokkH`H8gE#1HAHFHRHЧos.(*File).Readdirnamese Tkf  `H8gE#HHH0I8os.(*File).readdirnames"j+  ^n      C&f#.(%, %"  Fp<A  I gE#IIII(os.Getenv 3H XA IgE#JJJ"J$os.(*PathError).Error 8a/ pJgE#JJJJ$Ȧos.(*SyscallError).Error HJ_# J0gE#JK KKos.NewSyscallErrorPOP;O R3 M# hKgE#wK~KKKhos.IsNotExistP=OXt"/5@K gE#KKKos.underlyingErrorpoppopmop#op& m#L#I # "" XL0gE#mL{LLLЪhos.wrapSyscallError 3-@ ? LgE#LLLMhos.isNotExistPOPEO "&, 9 HMgE#YM\M`MXos.(*File).Name11`1 MgE#MMMMos.(*LinkError).ErrorL G a8 `0N8gE#ANRNWNfNtlos.(*File).Read SA6n ty9 0N@gE#NNNO os.(*File).ReadAt SD9Z T  t*{   pO8gE#OOOOos.(*File).Write  HA3 % T   iF: P0gE#0P:P?PHPTos.(*File).WriteString X vq~ @P(gE#PPPP`os.Open E r PQ(gE#QQ"Q+Q`os.Create E r `xQ8gE#QQQQ|ļos.(*File).wrapErrpopopGo 3VH    w R(gE#R"R&R*R`Ȧos.Chmodc~~J-xRgE#RRRR̥Xos.syscallMode`_`_ B)&     8 S(gE#S"S'S4Sos.chmod[ b9" L#(3, S(gE#SSSXos.(*File).checkValidJJ S gE#SSSXos.fixLongPath''"@@T gE#LTSTWT_TԦos.NewFilepRom&@HT(gE#TTTT os.newFileB 0    NA0 !@ h PPUgE#_UjUoUUhos.epipecheckh$ Q $ p4 U8gE#UUU.V,os.OpenFile S' B  ) g/  H1 O 0VgE#VVVV$Ȧos.(*File).Close`b_`!_ 3 ;" MO WgE#W"W'WJW`os.(*file).closem 3.> 1 = " _N,U @W8gE#WWWW\os.(*File).read E   ^ 0X@gE#*X4X9XFX \os.(*File).pread E   ^ 0X8gE#XXXX\os.(*File).write E   ^ Y gE#YgYlY Zos.Getwd"                     x   6b /,5>  % (GCfHHJp HJ  3 / C]"( 9G(#G( B~.Z\ ZgE#ZZZZXXos.init.00//0/hZZgE#[[[TXos.useSyscallwdDarwinPPKPX[gE#l[o[s[̥Xos.IsPathSeparator p[ gE#[[[[(hos.basenamepop:* 2 ":  @\ gE#I\Z\_\y\`os.Pipe _M|  |q-Q @\gE#\\\\XXos.init.1@K?@?}$6 W8]gE#A]L]P]a]ĤXos.Exit 4 Qx   )! ]gE#]]]/^os.fillFileStatFromSys $Ut!. # ###  # #  #  #  #  = x^(gE#^^^^$os.timespecToTime} Z<Y OF ^(gE#^__-_os.(*File).StatV  NFA6G = hj.;U G "_0gE#____os.Stat >UF:"G  Yc.'U  %`0gE#"`9`>`R`os.Lstat ZUF:"G  Yc.'U  '`gE#```ah|os.FileMode.String( G0 (?  (  G   W +`agE#savazḁXos.FileMode.IsDir+agE#aaḁXos.FileMode.Perm+bgE#%b(b,bXos.(*fileStat).Name+++,pbgE#bbbbhos.(*fileStat).IsDir@C?^^+,`,b(gE#bcc cos.SameFile &GD/ > -`cgE#ucxc|cXos.(*fileStat).Size2-cgE#cccXos.(*fileStat).Mode4-d gE#(d+d/dXos.(*fileStat).ModTime>>6>.pdgE#dddĤos.(*fileStat).Sys EJ8J`.dgE#dddTXos.sameFileGG<B.(egE#8e;e?e$Xos.glob..func1  * .egE#eeeehHos.init  x<"K4{ xCCCCCHkgE#k k$k(k$htype..hash.os.fileStatPO =^ @?xkgE#kkkktype..eq.os.fileStat 1 AkgE#)l0l4l8l$htype..hash.struct { sync.Mutex; os.dir string }PrO B& AlgE#lllltype..eq.struct { sync.Mutex; os.dir string }  % BmgE#-mJmOmmXXinternal/cpu.init.07 $!  -$$$$$$$$$K 4  $1$$ ) ) EmgE#mmm$Xinternal/cpu.isSet''t" F8ngE#KnVnYn\nXXinternal/cpu.init/hh>#FngE#nnn`2internal/cpu.cpuidFngE# ooop2internal/cpu.xgetbv8F`ogE#}oooo$htype..hash.internal/cpu.x86PPOkkF0GogE#ooopԦtype..eq.internal/cpu.x86pXossPG@pgE#JpMpQp̥Xmath.AbsTT  HpgE#pppp̥Xmath.InfPbOPO $&   * U2 HqgE#"q)q-q0qĤXmath.NaN@A?\:\4!IpqgE#qqq̥Xmath.Float32bits0IqgE#qqq̥Xmath.Float32frombitsPI rgE#2r5r9r̥Xmath.Float64bits$pIxrgE#rrr̥Xmath.Float64frombits,IrgE#rrrrXXmath.init<Q Q >0J8sgE#BsFsKs2math.ExpP    K t(gE#9tbtgtt`hunicode/utf8.DecodeRune`G_`_`c_`D_`C_`A_`C_`>_`D_`*  @1   +  8 E   *Nt gE#uBuGuu(hunicode/utf8.DecodeRuneInString`G_`_`c_`D_`C_`A_`C_`>_`D_`*  @1   +  8 E   *pQu(gE#uvv]v`\unicode/utf8.DecodeLastRuneXP C ; $ &    (= $    Tv gE#vvv=w(Ȧunicode/utf8.DecodeLastRuneInStringUJ C 8 ! #    (: !    pVwgE#www̥Xunicode/utf8.RuneLen          Wx(gE#!x8x=xx`hunicode/utf8.EncodeRune R r   [  " %"  "" [Yx gE#xxy\y(hunicode/utf8.RuneCount#  ! 13 7& / ,   # \ygE#yyy0z$hunicode/utf8.RuneCountInString# ! 13 5$ , ,  #p^pzgE#zzz̥Xunicode/utf8.RuneStart^zgE#zzz̥Xunicode/utf8.ValidRune<< ^@{(gE#S{q{v{{İdstrconv.ParseBoolQ  83/!/!1 U  P4.. X)P8    pf|gE#||#|$Xstrconv.FormatBoolII, fp|(gE#||||phstrconv.equalIgnoreCasep=opop+op$ $!     g} gE#)}^}c}}(hstrconv.special5KyRk& L2 $ >1@(  >1@ >1@ <(    `k~ gE#~P~U~ hstrconv.(*decimal).setku 7 .!+ "1D-H-  ) .J , X s6 8)0 ) >"5+  %  [ sh(gE#{`hstrconv.readFloattu<  _ .   !'   &)2M , X s6 )0 ) > 9(  %' F y؀ gE# hstrconv.(*decimal).floatBits  C   ,cO 6   '   2 '   55  =&) =+! =  (gE##(bXstrconv.atof64exact@>?@]?@?@^?@]?@ ?@8 @  GF%* /. P gE#ۂإXstrconv.atof32exact0>/0]/0/0]/0^/0 /08 =  GG#( -, `(gE#pP@strconv.atof32"  VYA 0MIP,6?;P #V7 o/ H(gE#XӄP@strconv.atof64"  VY7 0MCP,6?;P #\7 o/ 00gE#DUZilstrconv.ParseFloat Sp=  PgE#ӅXstrconv.(*NumError).Error9 .G b38 pH(gE#]invl0strconv.syntaxError@?@3? 61 5   Ȇ(gE#܆l0strconv.rangeError@?@3? >1 5   H8gE#[sx+strconv.ParseUint VS     @  "!'    G    45]  * /l  '&   ?d ' )   8gE#È10strconv.ParseInt"U  V   &? `OR2 #$  5 #?0###   (gE#خstrconv.Atoi" S~R'7   `gE#+CH$strconv.(*decimal).String"     .J## D +#2 .##$ -. 7D! >F  gE#+5:G(hstrconv.digitZeroPOP|/gE#Ëhstrconv.trim  I#  pgE#+;@nhstrconv.(*decimal).Assign !   5$   0gE#̌Lhstrconv.rightShiftp /   #    2""&) )   ?#F%  0gE#čɍhstrconv.prefixIsLessThanPTOPOP-OP";I  0gE#CSXÎ\strconv.leftShift1 /- &O*  )   2/ G8  F gE#*6;chstrconv.(*decimal).ShiftP,OPO !   s/62 gE#Ǐݏ$hstrconv.shouldRoundUp(E0DH - HgE#bqvhstrconv.(*decimal).RoundP!OPfOPO ! '  h'+ ؐgE#hstrconv.(*decimal).RoundDown ! F   m ``gE#|hstrconv.(*decimal).RoundUpP!OPOPfOP  ";  $ gE##9>fhstrconv.(*decimal).RoundedInteger; *  B60  J p gE#ϒߒ0Xstrconv.(*extFloat).floatBitsR 5+-7  + : 0,]?  (    > pXgE#Xstrconv.(*extFloat).AssignComputeBounds`_`_`eB_4m Z*N PgE#/EJXstrconv.(*extFloat).Normalizeg 0. $  Д gE#Xstrconv.(*extFloat).Multiply51+$$% PX0gE#{hhstrconv.(*extFloat).AssignDecimal 7  ( 2:AL! ) ,  ! I !8 )  XgE#u$hstrconv.(*extFloat).frexp10 33 7    F0 C @ gE##(:strconv.frexp10Many *6IF  3qF ` gE#ϗԗyxstrconv.(*extFloat).FixedDecimal"; : &2    *(!0  H ! &"*5%J]-- $M)  '93  f Ș0gE#F\strconv.adjustLastDigitFixedlQ )'-.1' P     Q (gE#ۙhstrconv.(*extFloat).ShortestDecimal" :$ #!# "L &R'2&K&K 8%%2" *(0+8z"$  "0'5& *1 '-5/[   8gE#/4^Ч\strconv.adjustLastDigitp1opop!opwop #j #1  0gE#Ư̈̀ԛstrconv.FormatFloat ZG ` P PgE#5?DL\strconv.AppendFloat fE E @PgE#Pstrconv.genericFtoa"              nV    ,:T2/    ,)"08DF *N/  /   ,Dd/ %>    3:'   (% (% (XgE#9JOstrconv.bigFtoa"  V>+"8 78 6#  /   !1&    / ' ] 0 xgE#JOstrconv.formatDigits"  V    ,     >;    t   gE#7<strconv.roundShortest"C<5[  2"[>/  9 5, + %% %7    +. ?3  @g '\} , P xgE#/4dstrconv.fmtE  S9 !=9 + 5>@   =JG A > EA A A A A"   pgE#/4strconv.fmtF   S9 (5>9"."9 > GA 5 EA*   آPgE#$0strconv.fmtB S9 9%9GA H A v pgE#}$Xstrconv.min00   ȣgE#գأܣ$Xstrconv.max00   ( gE#<SXiإstrconv.FormatUint G%Hp* x P"  gE#ˤإstrconv.FormatInt  0G7H*   # HgE#V]ah$̥strconv.ItoapZouB/?A-`$ gE#ɥΥߥ$̥strconv.small`_` t  t % (XgE#<TYDstrconv.formatBits"  n * 6 .&E7   :4W A  - 4* /ax $>  /34     c y - X(gE#kuz`strconv.quoteWith G ox / ЧgE#$$strconv.quoteRuneWith $3 pl 0 HHgE#bsxPstrconv.appendQuotedWith   ,S@"! B ~tNVR  <GHA  H)# P6 8gE#.?D[Чhstrconv.appendQuotedRuneWith TB1 c58 ; zY 08 8gE#éĪstrconv.appendEscapedRune"# .hV9DGHA 4DGA H@C  h] (EA r$E r$E;       (Y@5  F    ~~~~ ~  { ~~~~S$T @O ` gE#ow|(Ȧstrconv.Quoteg /L N- O Ы@gE#\strconv.AppendQuote E E P H gE#^fks(Ȧstrconv.QuoteToASCIIg /L N- @Q @gE#ܬ\strconv.AppendQuoteToASCII E E R @gE#SZ^f$̥strconv.QuoteRune`[_v/@B-R 8gE#ɭӭحЧ\strconv.AppendQuoteRune Ev vE pS (8gE#HRW_Ч\strconv.AppendQuoteRuneToASCII Ev vE @T gE# $hstrconv.CanBackquote"&. &<6     O U X(gE#kuz`hstrconv.bsearch16POP$!   pV (gE#`hstrconv.bsearch32POP$   0W hgE#yPpstrconv.IsPrint"P8O  :&?o?e :`Ad - w ] XgE#q̥Xstrconv.isInGraphicList*  &  <] xl ^ gE#$XXstrconv.initP OPOP.O _w' _?8 E _ pgE#$htype..hash.strconv.NumError@? =L _ gE#type..eq.strconv.NumError 8 a hgE#$htype..hash.strconv.decimalPLOggB@b سgE#Ԧtype..eq.strconv.decimalpPokkHb HgE#elor$htype..hash.strconv.extFloatPLOggB c gE#۴Ԧtype..eq.strconv.extFloatpPokkHc 0gE#NUY]$htype..hash.strconv.leftCheatPrO B& d gE#ĵԵصܵtype..eq.strconv.leftCheat   e (gE#@HLPXtype..hash.[11]float32po p4 e gE#TXtype..eq.[11]float32@q?@?Pf gE# $(Xtype..hash.[23]float64po p4 g hgE#~TXtype..eq.[23]float64@r?@?g طgE# Xtype..hash.[61]strconv.leftCheatpo t4 `h XgE#xTإtype..eq.[61]strconv.leftCheat~ ; i ظgE# Xtype..hash.[87]strconv.extFloatpo t4 j HgE#grvTXtype..eq.[87]strconv.extFloat@w?@w?k gE#Xtype..hash.[8]strconv.extFloatpo t4 @l 0gE#NY]TXtype..eq.[8]strconv.extFloat@w?@w?@m gE#ĺɺԺ̥Xunicode.IsPrintp>opFo f& #G  m  (gE#,<ASDunicode.In2 )h   Y n gE#Ż߻̥Xunicode.IsSpacePEOPOPFO &    /  o ((gE#6\a`Ȧunicode.is16I"D3!7   $!%4    r (gE#!a`Ԧunicode.is32C%C3!4   $/+    @t gE#ѽֽ$unicode.Is ,$GK%/J  v @gE#Zw|$unicode.isExcludingLatin 7$g%/M  @x 0gE#F@hunicode.to0E   %5 (" '. !.+y gE#$Xunicode.Toa|%PZPz gE# -̥Xunicode.ToUpperPMOP,O %  + s z xgE#̥Xunicode.ToLowerPMOP,O %  + s { gE# .3k̥Xunicode.SimpleFold09/! ) +  %-   J1"  e } gE#Yunicode.init",! q  q1G(41(1C(1 (1vv D4H \'n–n%nn   = y  @ @gE#(reflect.makeMethodValue" V -Q[ < Ib {1* z"&% ` gE#Hhreflect.Swapper"(r >E8:  4#4 4 % 4 4 4 49:#! WJ@a2rR!dLUL?'*  gE#Xreflect.(*structField).offset  (gE#EHLXreflect.(*structField).anon gE#$Ԧreflect.name.dataPCO^&19P gE# Xreflect.name.isExportedp hgE#~ܧreflect.name.nameLen`z_ &h 8!5  gE# treflect.name.tagLenQ *,!m <5  hgE#{|reflect.name.namePOPO 3    (     gE#1Ȭreflect.name.tagVy 3 >  <kQ  gE#$reflect.name.pkgPath GC($% 6B ns  (@gE#9JO|reflect.newName"   > / D2.n-+C 6! tV7 " gE#%:?O$̥reflect.Kind.Stringqw  3>v t #  gE#(reflect.(*uncommonType).methods  < Tq $  gE#<CGOhreflect.resolveReflectName@5?P %$.$ gE#$Ȧreflect.(*rtype).nameOff`T_o &B71`% gE#*15=$Ԧreflect.(*rtype).typeOffPAO\ &/7% gE#$Ԧreflect.(*rtype).textOffPAO\ &/7 & gE#JOXreflect.(*rtype).uncommonP6OPSOP#OPOP#OP#OP-OP#OP*OP#OPO  *0*  ?Z Q 2 W B E  %  W ( gE#$reflect.(*rtype).String  3CD J ) XgE#orvXreflect.(*rtype).Size  ) gE#hreflect.(*rtype).Bitsb  *  BAx6 p* HgE#`cgXreflect.(*rtype).Align * gE#Xreflect.(*rtype).FieldAlign * gE#"&Xreflect.(*rtype).Kind * hgE#Xreflect.(*rtype).pointers * gE#Xreflect.(*rtype).common + 0 gE#Rpup0reflect.(*rtype).exportedMethods"?  V 0)($0W)`/AG#445 =* 3 (gE#DY^rreflect.(*rtype).NumMethod^%?  *  "@ 3% 4 `gE#QXpreflect.(*rtype).Method"       Tl82Q)3 ).f(f'T [#% `Ki-<->dJ))E, > pgE#9Preflect.(*rtype).MethodByName"]9  \  0(N)y:: h #z `B gE#$reflect.(*rtype).PkgPathHo  3Q i'\ `C (gE#?UZx$reflect.(*rtype).NameH) 3"  O   i D gE#Ԧreflect.(*rtype).ChanDirPSOPO &"  /O @E HgE#epuԦreflect.(*rtype).IsVariadicPUOPO ""  +U E gE#@$reflect.(*rtype).ElemYf_Y# G+  C  C   I  I  C "# S@ `H xgE#dreflect.(*rtype).Field ]) i> I gE#7GL]dreflect.(*rtype).FieldByIndex" `, l[ K gE#reflect.(*rtype).FieldByName" h, t M 8gE#Zjoreflect.(*rtype).FieldByNameFunc" h, tw O  gE# (reflect.(*rtype).In% 6& r ?+ P XgE#n{$\reflect.(*rtype).Key~ 3" 7 <-K P gE#Ԧreflect.(*rtype).LenPSOPO &"  /O `Q `gE#{Ԧreflect.(*rtype).NumField`X_`_ &"  /T R gE#  Ԧreflect.(*rtype).NumInPSOPO &"  /O R pgE#reflect.(*rtype).NumOuty *" ; 3'U PS  gE##3(reflect.(*rtype).Out% 6& r ?+ PT  gE#إreflect.(*funcType).in < p _ @U  gE#!16M(reflect.(*funcType).out  <   V gE#Xreflect.add V gE##(@$̥reflect.ChanDir.StringN((w 3     v m W `gE#0reflect.(*interfaceType).MethodR Q&-4-" h 2;  qk| `Z 8gE#\cgXreflect.(*interfaceType).NumMethod 055Z pgE#reflect.(*interfaceType).MethodByName1 Y  <%y  ] pxgE#,reflect.(*structType).Field ]=147' 1'i =;  >P2% 0` 0gE#T^creflect.(*structType).FieldByIndex" `= ~4 Q.  nb{ 0c gE#treflect.(*structType).FieldByNameFunc"     h1~1 1 35N,) #!E?5IK$%1.>"<99@=9$)ab}A 1-z 1)[ 71)a9_ S9Y&HY T# q 8gE#[x}pxreflect.(*structType).FieldByName""  hN,q#    u  gE# %/إreflect.TypeOfl 46 S- v xgE#reflect.(*rtype).ptrTo"u >G;# ; &Sp*8+ nvp# } X(gE#fot`إreflect.fnv1`P~  gE#Īhreflect.(*rtype).Implements`_`__ &+e J<{ ` P gE#ozг\reflect.(*rtype).AssignableTo`l_`d_ &U* `7Q `  gE#ĪȦreflect.(*rtype).ConvertibleTo`h_`A_ & 1* ]d 0 XgE#ux|Xreflect.(*rtype).Comparable::5p gE#\reflect.implements"U> :& ) 0-@-%"1 + 1+ 1C &5<  8(-@N)"1 + 1+ QC &7=1 FX+d0A0hO1w+dk0hY- ` @gE#\w|reflect.directlyAssignable.eu & WB 4  O 0gE#3`0reflect.haveIdenticalType| )_p w:1]'$$  gE#FK\reflect.haveIdenticalUnderlyingType" F  \  +        h                  |          r     :*       ::= B :   W\ 8<,1qHJ#' 0 10 1C 4r u+^BT^+^p^^ +^#+^ M+^0{{mb gE#$Ԧreflect.rtypeOffPCO^&19 (gE#/?D0reflect.typesByString"   V$+&%  +D4-(,8O  X@  &s HgE#! reflect.FuncOf" 'J &0 $,8GW.iW.i& 4=. '4=. C+4Y.r[7  -,,,",'*,/2G #* I D0D0;S;SK(+Z $ %# и gE#9Lreflect.funcStr"     JLE. 989 ( 5eA A A. ~A~EG}{C~b'."8# 0 gE#Ĥreflect.toType K l/  $ (8gE#<TYreflect.funcLayout" /n,@8` % 3(".  ! 3(". (  8  y`_   7*1] z9+7> 9=66% pgE#Xreflect.ifaceIndir1 gE# 'Ȼ reflect.(*bitVector).append 1/7 U  xgE#0reflect.addTypeBits' 1! !  "Q%> ;     ,  9#F3 6? fB0=0  HgE#[^b̥Xreflect.flag.kind 0  gE#hreflect.Value.pointer@k?@?@ ? *3   Gi 0(gE#CTYPreflect.packEface 6  " " "6! '#$")*# eM,| 0 (gE# ,lreflect.unpackEfaceL E   kK o xgE#$Ȧreflect.(*ValueError).Error <y >, ` gE#,1Ḁ$reflect.methodName 31 ; 0 gE#Xreflect.flag.mustBe1 !${ 1 *<S= @ gE#7HMep reflect.flag.mustBeAssignable /o0 >)?f  gE#Xreflect.Value.Bool0=/X"40 00gE#EQVf\Ȧreflect.Value.Bytespopo <C+ N 0gE#\Ȧreflect.Value.runespopo <C+ N  ( gE#?BFXreflect.Value.CanAddr0 HgE# 0reflect.methodReceiver"  V &-].A<!bJM&74    o@&G X7k7% p gE#reflect.storeRcvrl  !  ( /"' /^ EB @ gE#$7<xreflect.callMethod"#  ?.D8F E   #:%  #sk%:A#p (gE#xreflect.Value.Complexm/  0 . &  9[1 p0gE#reflect.Value.Elem"_  V %!E@X     * ` !<? b^:  @8gE#Ufkreflect.Value.Field  S#t  . *'(4  _#^wVp,   gE#4$reflect.Value.FloatX$  *    3m[1 P 8gE# <reflect.Value.Index"  V   / O6 1KP % b^:a ` ` gE#s$dreflect.Value.Intl#""6  *   n   1 3^ 0  gE#4@ES$reflect.Value.CanInterfacePOP0O &L0 =AL  (gE#Ȧreflect.Value.Interfacej /O Q-  0gE#0LQ{<reflect.valueInterface_eX GR) `&<1 X b! 7  aD:  gE#2$dreflect.Value.IsNil`;) &     k 1! /[T ` x gE#Xreflect.Value.IsValid  gE# hreflect.Value.Kind@9?T&'/ P  gE#c    $Lreflect.Value.Lenoc))6 -   Z t Z    1! 9~: @  HgE# = B r reflect.Value.MapIndex_ S {  p* (` ha8^z @  0gE#   > xreflect.Value.MapKeys"   V  '5 /D ' ( !). .^% 27 k!y'1h%U7n    gE#    $reflect.Value.NumMethod`>_`&_`_ *  . | _j0  8  gE#P W [ g Ĥreflect.Value.NumFieldPMOh& 8)   gE#   ! $reflect.Value.PointerJXC - A  "/ !2n/* + 217 9Iz  p 0gE#    8\reflect.Value.SetBytes. !C4  *%  0gE#&+A8\reflect.Value.setRunes. !C4  *%  (gE#`Ԧreflect.Value.SetString@c?@? +  &Z p @gE#-EJreflect.Value.Slice  S        8P ? l '    !&  Q-6  z/RI6^:a % (gE#&<AVreflect.Value.Stringr7 <  ( . H ' (gE#xreflect.Value.Type| G R/ & 'M !bJ)00 ! fD^G * p gE#$dreflect.Value.Uintl""""6 *     n   1! 3^ , 0 gE#ADHXreflect.arrayAt"" , (gE#reflect.ValueOfG  B _H a . (gE#49Rpܹreflect.ZeroeA !E' d*  rY% 0 (gE#xpreflect.NewA !?. * m-% 1 (PgE#@X]8reflect.Value.assignTo"  !Vl 232J(? 845 G@X+S*+7 6 gE# 8Ĺtreflect.convertOp",(Tu q,(d,,h(( ">1   v2 ^". -&i   *  + > ?^ J  _` J  KLK JWP  > 8gE#reflect.makeIntz #E'      `W @ 08gE#CSXsreflect.makeFloat* $E$     ]P 0B @gE#reflect.makeComplex5 $E' )  !  `_ C X@gE#lv{ܭȲreflect.makeString $Ew9, ^F E HgE#Ȳreflect.makeBytes $EwF, ^F PF XHgE#kuzȲreflect.makeRunes $EwF, ^F G @gE#T\reflect.cvtInt $E b@O H P@gE#akpyT\reflect.cvtUint $E b@O I @gE#T\reflect.cvtFloatInt %E bHO J @@gE#VfktT\reflect.cvtFloatUint %E bZj K @gE#T\reflect.cvtIntFloat %E bIO L 8@gE#N^clT\reflect.cvtUintFloat %E bRm N @gE#T\reflect.cvtFloat %E bDO O 0@gE#DNS\T\reflect.cvtComplex %E h_O @P @gE#T\reflect.cvtIntString %E edO pQ  @gE#7AFOT\reflect.cvtUintString %E edO R @gE#Treflect.cvtBytesString %E kO S @gE#0:?HTlreflect.cvtStringBytes %S yU pU @gE#Treflect.cvtRunesString %E kO V  @gE#0 : ? H Tlreflect.cvtStringRunes %S yU @X  @gE#    l8reflect.cvtDirect %E ' "  n  j/, Y (!@gE#8!I!N!i!reflect.cvtT2I &S:D13 E# nJ4fp \ !@gE#!!!!reflect.cvtI2I &S=<7  y0dU ^ H"gE#Y"d"h"z"hreflect.escapes0H/0/|' &l ^ "gE#""""̥Xreflect.Swapper.func10(/B,B4^ 8#gE#O#Z#^#i#̥Xreflect.Swapper.func20//0/h0Z`_ #gE#####Ȧreflect.Swapper.func31 N ` 0$gE#G$W$\$`$Ȧ<reflect.Swapper.func41 V a $gE#$$$$̥إreflect.Swapper.func5`_`bb  %gE#7%A%F%J%̥إreflect.Swapper.func6`_`hc %gE#%%%%̥إreflect.Swapper.func7`_`nPd &gE#&!&&&*&̥إreflect.Swapper.func8`_`t e p&gE#&&&&Preflect.Swapper.func9 E811"""  1,""- f 'gE#1'>'C'H'$Ȧreflect.(*structType).FieldByName.func1u o @g 'gE#''''@reflect.FuncOf.func1 N$}Ch 7>Q=<  j 0(gE#J(Q(U(](̥̥reflect.funcLayout.func1PWOr183A*0k (gE#((((X̥reflect.initp opop:o l]3 l ]  3 E Pl ()gE#A)J)N)/0reflect.methodValueCall 0//0L2 l )gE#))))$Ȧreflect.(*ChanDir).String`k_`_ `R4@m *gE#0*=*A*E*$Ȧreflect.(*Kind).String`k_`_ `R4m *gE#****$htype..hash.reflect.uncommonTypeP{O F/ n +gE#'+*+-+TXtype..eq.reflect.uncommonType\\\n p+gE#++++hreflect.(*Value).Kind`e_`_ `[%o +gE#+ ,,,hreflect.(*Value).Len`e_`_ `[% p `,gE#|,,,,hreflect.(*Value).NumMethod`e_`_ `[%p ,gE#,---hreflect.(*Value).NumField`e_`_ `[%`q P-gE#i-y-}--$Ȧreflect.(*Value).String} h4 r -gE#----$htype..hash.reflect.MethodPO ={ s @.gE#Y.i.m.q.TPtype..eq.reflect.Method!  u .gE#....$htype..hash.reflect.ValueErrorPrO 9/ v 8/gE#U/e/i/m/Tإtype..eq.reflect.ValueError > v /gE#///Xreflect.(*arrayType).uncommonw 0gE#-00030Xreflect.(*arrayType).String###@w p0gE#000Xreflect.(*arrayType).Size`w 0gE#000Xreflect.(*arrayType).Bitsw 01gE#L1O1R1Xreflect.(*arrayType).Alignw 1gE#111Xreflect.(*arrayType).FieldAlignw 1gE#222Xreflect.(*arrayType).Kindw X2gE#u2x2{2Xreflect.(*arrayType).commonx 2gE#222Xreflect.(*arrayType).NumMethod x  3`gE#=3@3C3بXreflect.(*arrayType).Method000Px 3pgE#333Xreflect.(*arrayType).MethodByName555x 3gE#4 4 4Xreflect.(*arrayType).PkgPath###x H4gE#c4f4i4Xreflect.(*arrayType).Name###x 4gE#444Xreflect.(*arrayType).ChanDiry 5gE#)5,5/5Xreflect.(*arrayType).IsVariadic0y p5gE#555Xreflect.(*arrayType).Elem###`y 5xgE#555Xreflect.(*arrayType).Field999y 06gE#S6V6Y6Xreflect.(*arrayType).FieldByIndex999y 6gE#666Xreflect.(*arrayType).FieldByNameAAA0z 7gE#&7)7,7 Xreflect.(*arrayType).FieldByNameFuncAAAz h7 gE#777Xreflect.(*arrayType).In###z 7gE#777Xreflect.(*arrayType).Key###z (8gE#B8E8H8Xreflect.(*arrayType).Len{ 8gE#888Xreflect.(*arrayType).NumField { 8gE#99 9Xreflect.(*arrayType).NumIn@{ H9gE#e9h9k9Xreflect.(*arrayType).NumOut`{ 9 gE#999Xreflect.(*arrayType).Out###{ : gE#):,:/:Xreflect.(*arrayType).Implements{ p: gE#:::Xreflect.(*arrayType).AssignableTo{ : gE#::;Xreflect.(*arrayType).ConvertibleTo{ @;gE#a;d;g;Xreflect.(*arrayType).Comparable| ;gE#;;;Xreflect.(*chanType).uncommon0| <gE#$<'<*<Xreflect.(*chanType).String###`| h<gE#<<<Xreflect.(*chanType).Size| <gE#<<<Xreflect.(*chanType).Bits| (=gE#C=F=I=Xreflect.(*chanType).Align| =gE#===Xreflect.(*chanType).FieldAlign| =gE# > >>Xreflect.(*chanType).Kind} P>gE#l>o>r>Xreflect.(*chanType).common } >gE#>>>Xreflect.(*chanType).NumMethod@} ?`gE#,?/?2?بXreflect.(*chanType).Method000p} p?pgE#???Xreflect.(*chanType).MethodByName555} ?gE#???Xreflect.(*chanType).PkgPath###} 8@gE#R@U@X@Xreflect.(*chanType).Name###~ @gE#@@@Xreflect.(*chanType).ChanDir0~ @gE#AAAXreflect.(*chanType).IsVariadicP~ `AgE#zA}AAXreflect.(*chanType).Elem###~ AxgE#AAAXreflect.(*chanType).Field999~  BgE#BBEBHBXreflect.(*chanType).FieldByIndex999 BgE#BBBXreflect.(*chanType).FieldByNameAAAP BgE#CCC Xreflect.(*chanType).FieldByNameFuncAAA XC gE#pCsCvCXreflect.(*chanType).In### CgE#CCCXreflect.(*chanType).Key### DgE#1D4D7DXreflect.(*chanType).Len xDgE#DDDXreflect.(*chanType).NumField@ DgE#DDDXreflect.(*chanType).NumIn` 8EgE#TEWEZEXreflect.(*chanType).NumOut E gE#EEEXreflect.(*chanType).Out### E gE#FFFXreflect.(*chanType).ImplementsЀ `F gE#FFFXreflect.(*chanType).AssignableTo F gE#FFFXreflect.(*chanType).ConvertibleTo 0GgE#PGSGVGXreflect.(*chanType).Comparable0 GgE#GGGXreflect.(*structType).uncommonP HgE#H!H$HXreflect.(*structType).String### `HgE#|HHHXreflect.(*structType).Size HgE#HHHXreflect.(*structType).Bits  IgE#=I@ICIXreflect.(*structType).Align IgE#IIIXreflect.(*structType).FieldAlign IgE#JJ JXreflect.(*structType).Kind HJgE#fJiJlJXreflect.(*structType).common@ JgE#JJJXreflect.(*structType).NumMethod` K`gE#.K1K4KبXreflect.(*structType).Method000 pKpgE#KKKXreflect.(*structType).MethodByName555Ђ KgE#KKKXreflect.(*structType).PkgPath### 8LgE#TLWLZLXreflect.(*structType).Name###0 LgE#LLLXreflect.(*structType).ChanDirP LgE#MM MXreflect.(*structType).IsVariadicp `MgE#|MMMXreflect.(*structType).Elem### M gE#MMMXreflect.(*structType).In###Ѓ  NgE#;N>NANXreflect.(*structType).Key### NgE#NNNXreflect.(*structType).Len NgE#OOOXreflect.(*structType).NumField@ HOgE#eOhOkOXreflect.(*structType).NumIn` OgE#OOOXreflect.(*structType).NumOut P gE##P&P)PXreflect.(*structType).Out### hP gE#PPPXreflect.(*structType).ImplementsЄ P gE#PPPXreflect.(*structType).AssignableTo 8Q gE#]Q`QcQXreflect.(*structType).ConvertibleTo QgE#QQQXreflect.(*structType).Comparable0 RgE#-R4R7R:R$htype..hash.reflect.funcTypePLOggB RgE#RRRRԦtype..eq.reflect.funcTypepPokkH RgE#SSSXreflect.(*funcType).uncommon0 PSgE#lSoSrSXreflect.(*funcType).String###` SgE#SSSXreflect.(*funcType).Size TgE#*T-T0TXreflect.(*funcType).Bits pTgE#TTTXreflect.(*funcType).Align TgE#TTTXreflect.(*funcType).FieldAlign 8UgE#RUUUXUXreflect.(*funcType).Kind UgE#UUUXreflect.(*funcType).common UgE#VVVXreflect.(*funcType).NumMethod@ XV`gE#tVwVzVبXreflect.(*funcType).Method000p VpgE#VVVXreflect.(*funcType).MethodByName555  WgE#=W@WCWXreflect.(*funcType).PkgPath### WgE#WWWXreflect.(*funcType).Name### WgE#WXXXreflect.(*funcType).ChanDir0 @XgE#`XcXfXXreflect.(*funcType).IsVariadicP XgE#XXXXreflect.(*funcType).Elem### YxgE##Y&Y)YXreflect.(*funcType).Field999 hYgE#YYYXreflect.(*funcType).FieldByIndex999 YgE#YYYXreflect.(*funcType).FieldByNameAAAP 8ZgE#]Z`ZcZ Xreflect.(*funcType).FieldByNameFuncAAA Z gE#ZZZXreflect.(*funcType).In###Љ [gE#[[[Xreflect.(*funcType).Key### `[gE#y[|[[Xreflect.(*funcType).Len [gE#[[[Xreflect.(*funcType).NumField@  \gE#;\>\A\Xreflect.(*funcType).NumIn` \gE#\\\Xreflect.(*funcType).NumOut \ gE#\\\Xreflect.(*funcType).Out### @] gE#`]c]f]Xreflect.(*funcType).ImplementsЊ ] gE#]]]Xreflect.(*funcType).AssignableTo ^ gE#3^6^9^Xreflect.(*funcType).ConvertibleTo x^gE#^^^Xreflect.(*funcType).Comparable0 ^gE# ____$htype..hash.reflect.funcTypeFixed128PrO 9/ h_gE#____type..eq.reflect.funcTypeFixed128 V  Ќ _gE#```Xreflect.(*funcTypeFixed128).uncommon P`gE#t`w`z`Xreflect.(*funcTypeFixed128).String### `gE#```Xreflect.(*funcTypeFixed128).Size@  agE#BaEaHaXreflect.(*funcTypeFixed128).Bits` agE#aaaXreflect.(*funcTypeFixed128).Align agE#bbbXreflect.(*funcTypeFixed128).FieldAlign `bgE#bbbXreflect.(*funcTypeFixed128).Kind bgE#bbbXreflect.(*funcTypeFixed128).common 0cgE#WcZc]cXreflect.(*funcTypeFixed128).NumMethod c`gE#cccبXreflect.(*funcTypeFixed128).Method0000 dpgE#*d-d0dXreflect.(*funcTypeFixed128).MethodByName555p pdgE#dddXreflect.(*funcTypeFixed128).PkgPath### dgE#ddeXreflect.(*funcTypeFixed128).Name###Ў @egE#eehekeXreflect.(*funcTypeFixed128).ChanDir egE#eeeXreflect.(*funcTypeFixed128).IsVariadic fgE#:f=f@fXreflect.(*funcTypeFixed128).Elem###@ fxgE#fffXreflect.(*funcTypeFixed128).Field999 fgE#gggXreflect.(*funcTypeFixed128).FieldByIndex999 XggE#gggXreflect.(*funcTypeFixed128).FieldByNameAAA ggE#ggg Xreflect.(*funcTypeFixed128).FieldByNameFuncAAA` 8h gE#Xh[h^hXreflect.(*funcTypeFixed128).In### hgE#hhhXreflect.(*funcTypeFixed128).Key### igE#)i,i/iXreflect.(*funcTypeFixed128).Len pigE#iiiXreflect.(*funcTypeFixed128).NumField igE#iijXreflect.(*funcTypeFixed128).NumIn @jgE#djgjjjXreflect.(*funcTypeFixed128).NumOut@ j gE#jjjXreflect.(*funcTypeFixed128).Out###p k gE#8k;k>kXreflect.(*funcTypeFixed128).Implements k gE#kkkXreflect.(*funcTypeFixed128).AssignableTo k gE#ll!lXreflect.(*funcTypeFixed128).ConvertibleToБ `lgE#lllXreflect.(*funcTypeFixed128).Comparable lgE#lmm m$htype..hash.reflect.funcTypeFixed16PrO 9/ XmgE#zmmmmtype..eq.reflect.funcTypeFixed16 V  mgE#mnnXreflect.(*funcTypeFixed16).uncommon @ngE#cnfninXreflect.(*funcTypeFixed16).String### ngE#nnnXreflect.(*funcTypeFixed16).Size ogE#1o4o7oXreflect.(*funcTypeFixed16).Bits xogE#oooXreflect.(*funcTypeFixed16).Align@ ogE#p p pXreflect.(*funcTypeFixed16).FieldAlign` HpgE#iplpopXreflect.(*funcTypeFixed16).Kind pgE#pppXreflect.(*funcTypeFixed16).common qgE#>qAqDqXreflect.(*funcTypeFixed16).NumMethod q`gE#qqqبXreflect.(*funcTypeFixed16).Method000 qpgE#rrrXreflect.(*funcTypeFixed16).MethodByName5550 XrgE#|rrrXreflect.(*funcTypeFixed16).PkgPath###` rgE#rrrXreflect.(*funcTypeFixed16).Name### (sgE#LsOsRsXreflect.(*funcTypeFixed16).ChanDir sgE#sssXreflect.(*funcTypeFixed16).IsVariadicЕ sgE#tttXreflect.(*funcTypeFixed16).Elem### `txgE#tttXreflect.(*funcTypeFixed16).Field999@ tgE#tttXreflect.(*funcTypeFixed16).FieldByIndex999 8ugE#`ucufuXreflect.(*funcTypeFixed16).FieldByNameAAAЖ ugE#uuu Xreflect.(*funcTypeFixed16).FieldByNameFuncAAA v gE#7v:v=vXreflect.(*funcTypeFixed16).In###P xvgE#vvvXreflect.(*funcTypeFixed16).Key### vgE#wwwXreflect.(*funcTypeFixed16).Len HwgE#mwpwswXreflect.(*funcTypeFixed16).NumField wgE#wwwXreflect.(*funcTypeFixed16).NumIn xgE#;x>xAxXreflect.(*funcTypeFixed16).NumOut x gE#xxxXreflect.(*funcTypeFixed16).Out###0 x gE#yyyXreflect.(*funcTypeFixed16).ImplementsP Py gE#yy|yyXreflect.(*funcTypeFixed16).AssignableTop y gE#yyyXreflect.(*funcTypeFixed16).ConvertibleTo 0zgE#WzZz]zXreflect.(*funcTypeFixed16).Comparable zgE#zzzz$htype..hash.reflect.funcTypeFixed32PrO 9/ @  {gE#B{R{V{Z{type..eq.reflect.funcTypeFixed32 V  P {gE#{{{Xreflect.(*funcTypeFixed32).uncommonp |gE#+|.|1|Xreflect.(*funcTypeFixed32).String### p|gE#|||Xreflect.(*funcTypeFixed32).Size |gE#|||Xreflect.(*funcTypeFixed32).Bits @}gE#b}e}h}Xreflect.(*funcTypeFixed32).Align }gE#}}}Xreflect.(*funcTypeFixed32).FieldAlign ~gE#1~4~7~Xreflect.(*funcTypeFixed32).Kind@ x~gE#~~~Xreflect.(*funcTypeFixed32).common` ~gE#  Xreflect.(*funcTypeFixed32).NumMethod H`gE#knqبXreflect.(*funcTypeFixed32).Method000 pgE#Xreflect.(*funcTypeFixed32).MethodByName555  gE#DGJXreflect.(*funcTypeFixed32).PkgPath### gE#Xreflect.(*funcTypeFixed32).Name###P gE#Xreflect.(*funcTypeFixed32).ChanDirp XgE#Xreflect.(*funcTypeFixed32).IsVariadic gE#Xreflect.(*funcTypeFixed32).Elem### (xgE#JMPXreflect.(*funcTypeFixed32).Field999 gE#Xreflect.(*funcTypeFixed32).FieldByIndex999@ gE#(+.Xreflect.(*funcTypeFixed32).FieldByNameAAA pgE# Xreflect.(*funcTypeFixed32).FieldByNameFuncAAA  gE#Xreflect.(*funcTypeFixed32).In### @gE#`cfXreflect.(*funcTypeFixed32).Key###@ gE#Ȅ˄΄Xreflect.(*funcTypeFixed32).Len` gE#58;Xreflect.(*funcTypeFixed32).NumField xgE#Xreflect.(*funcTypeFixed32).NumIn gE# Xreflect.(*funcTypeFixed32).NumOut H gE#hknXreflect.(*funcTypeFixed32).Out###  gE#׆چ݆Xreflect.(*funcTypeFixed32).Implements  gE#ADGXreflect.(*funcTypeFixed32).AssignableTo0  gE#Xreflect.(*funcTypeFixed32).ConvertibleToP gE#"%Xreflect.(*funcTypeFixed32).Comparablep hgE#$htype..hash.reflect.funcTypeFixed4PrO 9/ gE# !type..eq.reflect.funcTypeFixed4 V   hgE#Xreflect.(*funcTypeFixed4).uncommon0 ЉgE#Xreflect.(*funcTypeFixed4).String###` 8gE#X[^Xreflect.(*funcTypeFixed4).Size gE#ÊƊXreflect.(*funcTypeFixed4).Bits gE#),/Xreflect.(*funcTypeFixed4).Align pgE#Xreflect.(*funcTypeFixed4).FieldAlign ؋gE#Xreflect.(*funcTypeFixed4).Kind @gE#behXreflect.(*funcTypeFixed4).common gE#͌ЌӌXreflect.(*funcTypeFixed4).NumMethod@ `gE#258بXreflect.(*funcTypeFixed4).Method000p xpgE#Xreflect.(*funcTypeFixed4).MethodByName555 gE# Xreflect.(*funcTypeFixed4).PkgPath### PgE#psvXreflect.(*funcTypeFixed4).Name### gE#ێގXreflect.(*funcTypeFixed4).ChanDir0  gE#FILXreflect.(*funcTypeFixed4).IsVariadicP gE#Xreflect.(*funcTypeFixed4).Elem### xgE#Xreflect.(*funcTypeFixed4).Field999 XgE#Xreflect.(*funcTypeFixed4).FieldByIndex999 ȐgE#Xreflect.(*funcTypeFixed4).FieldByNameAAAP 0gE#[^a Xreflect.(*funcTypeFixed4).FieldByNameFuncAAA  gE#đXreflect.(*funcTypeFixed4).In###Ф gE#"%Xreflect.(*funcTypeFixed4).Key### `gE#Xreflect.(*funcTypeFixed4).Len gE#Xreflect.(*funcTypeFixed4).NumField@ (gE#ILOXreflect.(*funcTypeFixed4).NumIn` gE#Xreflect.(*funcTypeFixed4).NumOut  gE#Xreflect.(*funcTypeFixed4).Out### X gE#~Xreflect.(*funcTypeFixed4).ImplementsХ  gE#Xreflect.(*funcTypeFixed4).AssignableTo 0 gE#Y\_Xreflect.(*funcTypeFixed4).ConvertibleTo gE#ƕɕ̕Xreflect.(*funcTypeFixed4).Comparable0 gE#4;?C$htype..hash.reflect.funcTypeFixed64PrO 9/ gE#–Ɩʖtype..eq.reflect.funcTypeFixed64 V  Ч gE#58;Xreflect.(*funcTypeFixed64).uncommon xgE#Xreflect.(*funcTypeFixed64).String### gE#Xreflect.(*funcTypeFixed64).Size@ HgE#iloXreflect.(*funcTypeFixed64).Bits` gE#Ҙ՘ؘXreflect.(*funcTypeFixed64).Align gE#?BEXreflect.(*funcTypeFixed64).FieldAlign gE#Xreflect.(*funcTypeFixed64).Kind gE# Xreflect.(*funcTypeFixed64).common PgE#vy|Xreflect.(*funcTypeFixed64).NumMethod `gE#ۚޚبXreflect.(*funcTypeFixed64).Method0000  pgE#ILOXreflect.(*funcTypeFixed64).MethodByName555p gE#Xreflect.(*funcTypeFixed64).PkgPath### gE#Xreflect.(*funcTypeFixed64).Name###Щ `gE#Xreflect.(*funcTypeFixed64).ChanDir ȜgE#Xreflect.(*funcTypeFixed64).IsVariadic 0gE#QTWXreflect.(*funcTypeFixed64).Elem###@ xgE#Xreflect.(*funcTypeFixed64).Field999 gE#),/Xreflect.(*funcTypeFixed64).FieldByIndex999 pgE#Xreflect.(*funcTypeFixed64).FieldByNameAAA gE#  Xreflect.(*funcTypeFixed64).FieldByNameFuncAAA` P gE#oruXreflect.(*funcTypeFixed64).In### gE#Пӟ֟Xreflect.(*funcTypeFixed64).Key### gE#8;>Xreflect.(*funcTypeFixed64).Len gE#Xreflect.(*funcTypeFixed64).NumField gE#  Xreflect.(*funcTypeFixed64).NumIn PgE#svyXreflect.(*funcTypeFixed64).NumOut@  gE#ءۡޡXreflect.(*funcTypeFixed64).Out###p   gE#GJMXreflect.(*funcTypeFixed64).Implements  gE#Xreflect.(*funcTypeFixed64).AssignableTo  gE#"%(Xreflect.(*funcTypeFixed64).ConvertibleToЬ hgE#Xreflect.(*funcTypeFixed64).Comparable أgE# $htype..hash.reflect.funcTypeFixed8PrO 9/ XgE#ytype..eq.reflect.funcTypeFixed8 V  ؤgE#Xreflect.(*funcTypeFixed8).uncommon @gE#behXreflect.(*funcTypeFixed8).String### gE#ȥ˥ΥXreflect.(*funcTypeFixed8).Size gE#036Xreflect.(*funcTypeFixed8).Bits xgE#Xreflect.(*funcTypeFixed8).Align@ gE#  Xreflect.(*funcTypeFixed8).FieldAlign` HgE#hknXreflect.(*funcTypeFixed8).Kind gE#ҧէاXreflect.(*funcTypeFixed8).common gE#=@CXreflect.(*funcTypeFixed8).NumMethod `gE#بXreflect.(*funcTypeFixed8).Method000 pgE#Xreflect.(*funcTypeFixed8).MethodByName5550 XgE#{~Xreflect.(*funcTypeFixed8).PkgPath###` gE#Xreflect.(*funcTypeFixed8).Name### (gE#KNQXreflect.(*funcTypeFixed8).ChanDir gE#Xreflect.(*funcTypeFixed8).IsVariadicа gE#Xreflect.(*funcTypeFixed8).Elem### `xgE#Xreflect.(*funcTypeFixed8).Field999@ ȫgE#Xreflect.(*funcTypeFixed8).FieldByIndex999 8gE#_beXreflect.(*funcTypeFixed8).FieldByNameAAAб gE#ˬάѬ Xreflect.(*funcTypeFixed8).FieldByNameFuncAAA  gE#.14Xreflect.(*funcTypeFixed8).In###P pgE#Xreflect.(*funcTypeFixed8).Key### ЭgE#Xreflect.(*funcTypeFixed8).Len 0gE#TWZXreflect.(*funcTypeFixed8).NumField gE#Xreflect.(*funcTypeFixed8).NumIn gE#"%(Xreflect.(*funcTypeFixed8).NumOut h gE#Xreflect.(*funcTypeFixed8).Out###0 ȯ gE#Xreflect.(*funcTypeFixed8).ImplementsP 0 gE#X[^Xreflect.(*funcTypeFixed8).AssignableTop  gE#ɰ̰ϰXreflect.(*funcTypeFixed8).ConvertibleTo gE#69<Xreflect.(*funcTypeFixed8).Comparable xgE#Xreflect.(*interfaceType).uncommonг gE#Xreflect.(*interfaceType).String### HgE#gjmXreflect.(*interfaceType).Size gE#DzʲͲXreflect.(*interfaceType).Bits@ gE#(+.Xreflect.(*interfaceType).Align` pgE#Xreflect.(*interfaceType).FieldAlign سgE#Xreflect.(*interfaceType).Kind 8gE#Y\_Xreflect.(*interfaceType).common gE#´ŴȴXreflect.(*interfaceType).PkgPath### gE#'*-Xreflect.(*interfaceType).Name### hgE#Xreflect.(*interfaceType).ChanDir@ еgE#Xreflect.(*interfaceType).IsVariadic` 8gE#WZ]Xreflect.(*interfaceType).Elem### xgE#Xreflect.(*interfaceType).Field999е gE#'*-Xreflect.(*interfaceType).FieldByIndex999 hgE#Xreflect.(*interfaceType).FieldByNameAAA` зgE# Xreflect.(*interfaceType).FieldByNameFuncAAA @ gE#]`cXreflect.(*interfaceType).In### gE#ĸXreflect.(*interfaceType).Key### gE#!$Xreflect.(*interfaceType).Len0 `gE#Xreflect.(*interfaceType).NumFieldP ȹgE#Xreflect.(*interfaceType).NumInp 0gE#QTWXreflect.(*interfaceType).NumOut  gE#Xreflect.(*interfaceType).Out###  gE# #Xreflect.(*interfaceType).Implements ` gE#Xreflect.(*interfaceType).AssignableTo Ȼ gE#Xreflect.(*interfaceType).ConvertibleTo 8gE#]`cXreflect.(*interfaceType).Comparable@ gE#üXreflect.(*mapType).uncommon` gE#!Xreflect.(*mapType).String### `gE#y|Xreflect.(*mapType).Size gE#ٽ߽ܽXreflect.(*mapType).Bitsи  gE#:=@Xreflect.(*mapType).Align gE#Xreflect.(*mapType).FieldAlign gE#Xreflect.(*mapType).Kind0 @gE#[^aXreflect.(*mapType).commonP gE#ĿXreflect.(*mapType).NumMethodp `gE#!بXreflect.(*mapType).Method000 `pgE#Xreflect.(*mapType).MethodByName555 gE#Xreflect.(*mapType).PkgPath### (gE#ADGXreflect.(*mapType).Name###@ gE#Xreflect.(*mapType).ChanDir` gE#  Xreflect.(*mapType).IsVariadic HgE#adgXreflect.(*mapType).Elem### xgE#Xreflect.(*mapType).Field999 gE#),/Xreflect.(*mapType).FieldByIndex9990 pgE#Xreflect.(*mapType).FieldByNameAAA gE# Xreflect.(*mapType).FieldByNameFuncAAAл @ gE#WZ]Xreflect.(*mapType).In### gE#Xreflect.(*mapType).Key###0 gE#Xreflect.(*mapType).LenP XgE#ux{Xreflect.(*mapType).NumFieldp gE#Xreflect.(*mapType).NumIn gE#369Xreflect.(*mapType).NumOut x gE#Xreflect.(*mapType).Out###  gE#Xreflect.(*mapType).Implements 8 gE#Y\_Xreflect.(*mapType).AssignableTo  gE#Xreflect.(*mapType).ConvertibleTo@ gE#'*-Xreflect.(*mapType).Comparable` hgE#Xreflect.(*ptrType).uncommon gE#Xreflect.(*ptrType).String### (gE#ADGXreflect.(*ptrType).Sizeн gE#Xreflect.(*ptrType).Bits gE#Xreflect.(*ptrType).Align HgE#gjmXreflect.(*ptrType).FieldAlign0 gE#Xreflect.(*ptrType).KindP gE##&)Xreflect.(*ptrType).commonp hgE#Xreflect.(*ptrType).NumMethod `gE#بXreflect.(*ptrType).Method000 (pgE#ILOXreflect.(*ptrType).MethodByName555 gE#Xreflect.(*ptrType).PkgPath###0 gE#  Xreflect.(*ptrType).Name###` PgE#lorXreflect.(*ptrType).ChanDir gE#Xreflect.(*ptrType).IsVariadic gE#),/Xreflect.(*ptrType).Elem###п pxgE#Xreflect.(*ptrType).Field999 gE#Xreflect.(*ptrType).FieldByIndex999P 8gE#X[^Xreflect.(*ptrType).FieldByNameAAA gE# Xreflect.(*ptrType).FieldByNameFuncAAA  gE#"%Xreflect.(*ptrType).In### `gE#x{~Xreflect.(*ptrType).Key###P gE#Xreflect.(*ptrType).Lenp  gE#=@CXreflect.(*ptrType).NumField gE#Xreflect.(*ptrType).NumIn gE#Xreflect.(*ptrType).NumOut @ gE#X[^Xreflect.(*ptrType).Out###  gE#Xreflect.(*ptrType).Implements  gE#!$'Xreflect.(*ptrType).AssignableTo@ h gE#Xreflect.(*ptrType).ConvertibleTo` gE#Xreflect.(*ptrType).Comparable 0gE#ORUXreflect.(*sliceType).uncommon gE#Xreflect.(*sliceType).String### gE# Xreflect.(*sliceType).Size PgE#knqXreflect.(*sliceType).Bits gE#Xreflect.(*sliceType).Align0 gE#147Xreflect.(*sliceType).FieldAlignP xgE#Xreflect.(*sliceType).Kindp gE#Xreflect.(*sliceType).common 8gE#X[^Xreflect.(*sliceType).NumMethod `gE#بXreflect.(*sliceType).Method000 pgE##&)Xreflect.(*sliceType).MethodByName555 hgE#Xreflect.(*sliceType).PkgPath###P gE#Xreflect.(*sliceType).Name### (gE#FILXreflect.(*sliceType).ChanDir gE#Xreflect.(*sliceType).IsVariadic gE# Xreflect.(*sliceType).Elem### PxgE#lorXreflect.(*sliceType).Field9990 gE#Xreflect.(*sliceType).FieldByIndex999p gE#:=@Xreflect.(*sliceType).FieldByNameAAA gE# Xreflect.(*sliceType).FieldByNameFuncAAA  gE#Xreflect.(*sliceType).In###@ HgE#behXreflect.(*sliceType).Key###p gE#Xreflect.(*sliceType).Len gE#'*-Xreflect.(*sliceType).NumField hgE#Xreflect.(*sliceType).NumIn gE#Xreflect.(*sliceType).NumOut ( gE#BEHXreflect.(*sliceType).Out###  gE#Xreflect.(*sliceType).Implements@  gE#Xreflect.(*sliceType).AssignableTo` X gE#|Xreflect.(*sliceType).ConvertibleTo gE#Xreflect.(*sliceType).Comparable 0gE#fmps$htype..hash.struct { F uintptr; reflect.hash uint32 }PLOggB gE#TXtype..eq.struct { F uintptr; reflect.hash uint32 }===P 8gE#nuy}$htype..hash.struct { F uintptr; reflect.name string }PrO B& gE# type..eq.struct { F uintptr; reflect.name string }   `gE#wXtype..hash.[27]stringpo p4 p gE#Tإtype..eq.[27]string^ 8 HgE#$htype..hash.struct { reflect.b bool; reflect.x interface {} }PrO B& gE#,04type..eq.struct { reflect.b bool; reflect.x interface {} } " xgE#Xfmt.(*fmt).clearflagsp gE# xfmt.(*fmt).init0>/0/iv Cp XgE#qlpfmt.(*fmt).writePadding".8 22q \3"^# /  gE#(8=]xfmt.(*fmt).padplopopPo !(1 ? 1  1  u,_$1  gE#Dxfmt.(*fmt).padString`b_`_`F_ !(' 5 '  '  k"U$'  PgE#hsxhfmt.(*fmt).fmt_boolean@C?@%?  # # F6 p gE#~lpfmt.(*fmt).fmt_unicode" e  22 0 #D N#:v##9 @# ####  ^    + tFF P 0gE# fmt.(*fmt).fmt_integer"  2'2%&D $ ( ( 2):H5#   ,# ## #% ;#    241 9  F  '( .'         ,  0 h(gE#}ثfmt.(*fmt).truncaten  <z H@-  M gE#*xfmt.(*fmt).fmt_s`k_ 6"  :6 x@gE#9hfmt.(*fmt).fmt_sbx @ /  4  &O2e&9e'  H' A A DB)'A)   $#  lK ()W (gE#`hfmt.(*fmt).fmt_sxdQ i` 0gE#$)3hfmt.(*fmt).fmt_bxeR j gE#fmt.(*fmt).fmt_q /E<r.   U?d%_G_ (gE#:JOilpfmt.(*fmt).fmt_c  / +HV   `! gE#fmt.(*fmt).fmt_qcz / +v p S5M P(gE#f` fmt.(*fmt).fmt_float"K 2*UX *@8 U *(      &*' !   5 >GNVG7 8 (! 5 >/   '  5  p   gE#fmt.(*buffer).Write / uP P PgE#k{fmt.(*buffer).WriteString / uP  gE# hTfmt.(*buffer).WriteByteB !/} ~O  hgE# fmt.(*buffer).WriteRuneo" /=-5 >c U  gE#0>CUԦܪfmt.newPrinter 10* 5m. gE#Ԭfmt.(*pp).free`_`G_ !-50+ !  gE#18<Xfmt.(*pp).Width INNp xgE#Xfmt.(*pp).Precision INN gE# Xfmt.(*pp).Flag B *  * / "   .  .   p8gE#thfmt.(*pp).Write`}_ <.+ e0 PgE# 0fmt.Fprintf EG EPJP  `@gE#lv{̨fmt.Printf S x  8gE# fmt.Sprintf 9;B$ 9DP)  H8gE#T^clfmt.Errorf 9 pU  @gE#fmt.Fprint E- E6JP  8@gE#FPUffmt.Fprintln E- E6JP @ 0gE#fmt.Println E r ` (8gE#6FK[Pfmt.getFieldD EPg1@ r;'  gE#̥Xfmt.tooLarge 8gE#"'GЧhfmt.parsenumPSOPOP]OPO 8"l"2      gE#гfmt.(*pp).unknownType. !6{ %  >Kn>  (gE#;LQfmt.(*pp).badVerb $(|5 =G( X  gE#hfmt.(*pp).fmtBool@C?@#?    F4  PgE#clqXfmt.(*pp).fmt0x64 !A { 0 gE#G$hfmt.(*pp).fmtIntegerX !2 3<  E67 E" # E E & '.% E E  _ !  gE#(hfmt.(*pp).fmtFloatpkopo ! ;  ; ;     ; r `# 0(gE#FTY`hfmt.(*pp).fmtComplexE !I I%   a$ %  gE#,hfmt.(*pp).fmtStringpmopo ! =$ ( ( ( ( =  t & x8gE# Lfmt.(*pp).fmtBytes"  2< S=JG - ( '  (D' +< pADE4 s5 6 S9  bcWY%V \% | 0- p(gE#fmt.(*pp).fmtPointer ! :5* (+4 )./ *  *' % %  )* )  P+$7 0 X gE#nPfmt.(*pp).catchPanic! )'(   ((-5: 1 -<;77\p `3 gE#1z`|fmt.(*pp).handleMethodsDC  7R@ R_B) RdbRd $ $1 NUIH| Mh|  Mt : H gE#\]fmt.(*pp).printArg"u # 28<    %nm] 4 ^"-ahaFXGJzm+ L[RO.+/jEz:.;Z&+'Y5CT"+#v>+?U,Q6*7*++uB6Cs,X2+3].5)  ,   1 r:g4s  L 0gE# ,fmt.(*pp).printValue"     = 2m+ 0H ( (  Y 8f f!$ n%( n) , -0 1   EI$CR=H .}(X(" X" ++ vC R2S( (k :( R(S. gn(9 T S  e 4 {5r X(- "t 1   jy.;>;JC:CDa=a|'It; ,$Jb I*6 IBSPT:? k 8gE#ĭPfmt.intFromArg  Dl&  +6 #,,  ? m h(gE#|`hfmt.parseArgNumbertKP O0 ',w!>L0  p  HgE#% A F g fmt.(*pp).argNumber|Z D501AH  pr  gE#    hfmt.(*pp).badArgNum@u? %%  == s 0 gE#F M R ` hfmt.(*pp).missingArg@u? %%  == s  0gE#   H `fmt.(*pp).doPrintf" "2 " B~"!"((3 . ( ' 3 SaL C  0FC 6(z ! R!(  ("#$#-  %; /1 w6 U F    gE#    Pfmt.(*pp).doPrint /S- "   P# 8  gE#M W \ u  ȸfmt.(*pp).doPrintln $ -"   /< `  gE#    ̥Ĥfmt.glob..func1@P?kk:*Ј 0gE#:JYlXXfmt.initP OPOP.O xw' x?8 E  gE#$htype..hash.fmt.fmtP{O F/ (gE#:JNR\type..eq.fmt.fmt {@" gE#Xsort.Searchpo x*   nD `   gE#4>CVXsort.insertionSort 8!#Z+ | (gE# Xsort.siftDownC  L!   ZC2    8 gE#GQVqXsort.heapSort p!  '6 -6   ` (gE#hsort.medianOfThree`_` _ !:(:(7(  G Б P0gE#^ot\hsort.doPivot"  J'RF^ E :n nq . qn(12 1 -9 H E? ) 1 4 1% c H(gE#Xnshsort.quickSortw !8 `!B B *A28 # Z gE# hsort.Sorty H  /O `gE#ovz̥Xsort.maxDepthPnOs  gE#Dsort.Slice !9%,l 79,v P 8 gE#NUYXsort.StringSlice.Len *// 0gE#Ȧsort.StringSlice.Less  ) P (gE#/;@Eİsort.StringSlice.SwapPOP1O  gE#$sort.StringSlice.Sortc~~P' gE#"&$sort.Stringsc~~P' p gE#Xsort.insertionSort_func !#O  n (gE# $G Xsort.siftDown_funcC (!   O8'     gE#Xsort.heapSort_func N!  '6"6   @ (gE#1=Bahsort.medianOfThree_funcPOP O j!/,,  < p 0gE#[\hsort.doPivot_func"  J'RF^ E :` `c  $c` #2 ##9 : 71 #& # U (gE#hsort.quickSort_funcw !8 `!B  B '3$8   Z б hgE#s~XXsort.init/hh>#@ gE#hsort.(*StringSlice).Len`e_`_ `[% H gE#brvz(hsort.(*StringSlice).Lesss k# gE#$hsort.(*StringSlice).Swap`a_`_ `f0 8gE#KNRXflag.newBoolValue""  ` (gE#flag.(*boolValue).Set 6d! [n @  gE#:AEI$Ȧflag.(*boolValue).String`U_pp<- gE#̥Xflag.(*boolValue).IsBoolFlag   gE# Xflag.newIntValue##  X(gE#nx}flag.(*intValue).Set 9~$ vt gE#$Ȧflag.(*intValue).String`V_qq=-p @ (gE#X b g s flag.(*int64Value).Set 9~$ vt p  gE#    $Ȧflag.(*int64Value).Stringp_ozzF- 0!gE#C!F!J!Xflag.newUintValue##  !(gE#!!!!flag.(*uintValue).Set 9~$ vt "gE#2"9"="A"$Ȧflag.(*uintValue).Stringp_ozzF- "(gE#""""flag.(*uint64Value).Set 9~$ vt #gE#$#+#/#3#$Ȧflag.(*uint64Value).Stringp_ozzF- # gE#####hflag.newStringValue0L/0/w&&i #(gE#$$!$-$hflag.(*stringValue).Set0]/0/ /& z 0 p$gE#$$$Xflag.(*stringValue).String+++` $(gE#$$% %flag.(*float64Value).Set 9v$ jz P X%gE#u%~%%%$Ȧflag.(*float64Value).Stringo V- %gE#%%%Xflag.newDurationValue##   0&(gE#K&U&Z&f&flag.(*durationValue).Set 9f$ ^t &gE#&&&&$Ȧflag.(*durationValue).String`V_qq=-p (' gE#8'H'M'w'|flag.sortFlags" Vg G+Xm"B   'gE#'''Xflag.(*FlagSet).outWW 0(gE#J(T(Y(h(<0flag.(*FlagSet).VisitAll $  6. ( gE#(((4)tPflag.isZeroValueD8co 7m$,`   !J ?' R) )(gE#)))*flag.UnquoteUsage  _"',+,Y  nJ  >;r 6Q;!   h*gE#****Ԭȯflag.(*FlagSet).PrintDefaults`w_`_ !d4 3  *gE#+ +++XXflag.PrintDefaults #> ( `+gE#~++++L`flag.(*FlagSet).defaultUsage /i  Sk!V  0 ,8gE#,#,(,2,Hflag.(*FlagSet).BoolVar !p  3Y ,8gE#,,,,,ԩflag.(*FlagSet).Bool  4I 8S -0gE# ---!-Ԧflag.Booll  &Z b 0 h-8gE#----Hflag.(*FlagSet).IntVar  !q  4Y -8gE#-. ..,ԩflag.(*FlagSet).Int  4J 8T h.0gE#r.{...Ԧflag.Intm  &[ c 0 .8gE#.../Hflag.(*FlagSet).UintVar  !q  4Y P/8gE#f/p/u//,ԩflag.(*FlagSet).Uint  4J 8T /0gE#////Ԧflag.Uintm  &[ c 0 80@gE#S0]0b0l0`Hflag.(*FlagSet).StringVar  !~  >\ 0@gE#0000ԩflag.(*FlagSet).String  4Z 8d 818gE#E1O1T1\1|Ԧflag.String  -k w! p 18gE#1111Hflag.(*FlagSet).DurationVar  !q  4Y (28gE#B2L2Q2]2,ԩflag.(*FlagSet).Duration  4J 8T 20gE#2222Ԧflag.Durationm  &[ c p 38gE#-3>3C3y3 flag.(*FlagSet).Var"   2J & _NLeW J'-|d-o@-Mj=! P 3@gE#444-4@flag.(*FlagSet).failf  GY* %4 @ 4gE#4444hflag.(*FlagSet).usage 5 `  ; 5 gE#5o5t5+6flag.(*FlagSet).parseOne"|u  . R030A (_0BR d',J!}X0e0Q%S  Z)$  6? b+   `wT`xf-`j ``&`E)[ 60gE#666,7Tflag.(*FlagSet).Parsey- 9 AZ   $   / "#!  p7gE#777Xflag.(*FlagSet).Parsed 7gE#7778X$flag.Parse !s    P8gE#]8d8h8p8ĤXflag.Parsed@5?P"'- 8gE#8888XXflag.init.004/0/f !  XP (9gE#?9F9J9T9XXflag.commandLineUsage7  %  9 gE#9999flag.NewFlagSet`_`M_ 1^ - 5  (:gE#::J:O:^:xTflag.glob..func1 / s   :gE#:::+;hflag.(*FlagSet).PrintDefaults.func1"   ; v{A- <v   }[G"%[/m[-h2  ` ;gE#;;;;XXflag.initP OPOP8O }1 }< M   E  0<gE#X<_<c<g<XĤflag.(*FlagSet).(flag.defaultUsage)-fm0%/@@* <gE#<<<<$htype..hash.flag.Flag@? =r   =gE#4=D=H=L=type..eq.flag.Flag B p =gE#====Xtype..hash.[2]interface {}po p4  >gE#*>:>>>B>Tإtype..eq.[2]interface {}L 5 0 >gE#>>>>Xtype..hash.[3]interface {}po p4  ?gE#"?2?6?:?Tإtype..eq.[3]interface {}L 5  ? gE#????(\bytes.(*Buffer).BytesPOPj ?gE#@&@+@9@$\bytes.(*Buffer).String r3 I  @gE#@@@Xbytes.(*Buffer).Len >CC @gE#@@@Xbytes.(*Buffer).Reset990 HA gE#jAxA}AA(hbytes.(*Buffer).tryGrowByReslice@?@?@/- AgE#A BBUBbytes.(*Buffer).grow":  >"O>  :N;h 4  JN1 B8gE#BBBBbytes.(*Buffer).Write@ SN2 d " 8C0gE#UCeCjCC\lbytes.(*Buffer).WriteString@ SN2 d $ C0gE#CDDTD dbytes.(*Buffer).ReadFrom" @P  V+H- O HN ( 0'  "  * D gE#DDDD\bytes.makeSlice <% Z  O| + 0E0gE#IEeEjEE`bytes.(*Buffer).WriteTo>"' S+)  *.$%  . . E gE#FFF,F(hbytes.(*Buffer).WriteByte* 3= "! T / xF(gE#FFFF`\bytes.(*Buffer).WriteRune8 E.=1"! iT 1  G8gE#6GSGXGGPbytes.(*Buffer).ReadO S+N ,  x P4 G(gE#GH H4H`bytes.(*Buffer).ReadRune ^(Y 1$D)5   07 H gE#HHHH@0bytes.NewBuffer@?@'? 5 8 I8gE#I!I&I/IX\bytes.HasPrefix  ) * 9 pIgE#~IIIXXbytes.init.0(((    P9 I8gE#IIJNJJHbytes.Index"Mz91,Y 8>   q!aw! W !1}  , "- 2]dK"614@%     T C @K gE#OK\KaKK(hbytes.hashStr!-  D KgE#KKKXbytes.(*Reader).Len0G/0-/z4",0E (LgE#>LELILXbytes.(*Reader).Size 05J5pE L8gE#LLLL bytes.(*Reader).Read  NS(N, P G (M(gE#BM`MeMMPbytes.(*Reader).ReadRune ^(Y7$D, k PJ M0gE#MNN,Nbytes.(*Reader).WriteToG S(4b) ,   L xN gE#NNNN(ԩbytes.NewReader@?@? 5t M NgE#NOO#OXbytes.makeSlice.func1q &$3  *y `N pOgE#|OOOOXXbytes.initP OP~OPO i8 iX8WXW E @O O0gE#PPPQP strings.explodeN &S( G%BjB F % V= l"# R PgE#PPPP$hstrings.hashStrX!-  T (QgE#=#W R(gE#RSStSpstrings.LastIndexYm;@4  ;  ( d!Z>+31=   * `\ S gE#SST"Tstrings.IndexRunelOt -E : P c9J9 ^ pT gE#TTTT(hstrings.LastIndexByte@g?@&?@$  _ THgE#U U%UcUstrings.genSplitv S4zM J B  NiwT    "% # pc U8gE#UUUU\strings.Split E Pd 0V8gE#>VhVmVVhstrings.Join" {  J       C J# ( A4'M#D.^   .  Pm W(gE##W3W8WAWpȦstrings.HasPrefix  ) , 0n W(gE#WWWWstrings.TrimLeftFuncpA  31I Uu o X(gE#/X?XDXbXstrings.TrimRightFunc(  9:2T B     d p X(gE#XXXXijstrings.TrimFunc  3v P,- `q (Y(gE#;YKYPYbYxstrings.indexFuncW  -y'@   r Y(gE#YYYYpȦstrings.lastIndexFunc  -W+  v s HZ gE#[ZcZhZpZ(Ȧstrings.TrimSpaceg  /L N- pt ZgE#ZZZXXstrings.init.0(((    t [(gE#'[[[.\<strings.Index"Mm;6.^ 8>   d!Z]! O !1c  ,t "-2]d>3+1="      T ~ \(gE#\\\\phstrings.CountH  *"LE zp  ]gE#])],]/]XXstrings.init>ww>2 x]gE#]]]]XXruntime/debug.init>ww>2 ] gE#]^ ^^Ȧruntime/trace.StartpNopGo .3 3Z! h^gE#|^^^^XXruntime/trace.Stop0R  ^gE#^^__$runtime/trace.Start.func1i 6"#   !\ `_gE#t____XXruntime/trace.init4mm>( _gE#___`$testing.(*B).StartTimerp)opo ! ]  L ``gE#x````$testing.(*B).StopTimer ! BB   Q Є `gE# aaa8a$testing.(*B).ResetTimerpopo ! ]   C agE#aaaahtesting.(*B).nsPerOp@:?@V?@? *^ dE bgE#b#b(bTbhtesting.(*B).runN ('1@ ,) bgE#bbb$Xtesting.min00   bgE#bcc$Xtesting.max00   HcgE#]cecjc̥Xtesting.roundDown10po%  cgE#cccd̥Xtesting.roundUp@G?@%?@$?@$?@? * 3 `dgE#sddddtesting.(*B).run1"   : E #& 69= &l(  8e0gE#JeZe_eue ȯtesting.(*B).run# Qj!<   6\  p e0gE#eeeexXtesting.(*B).doBench@? N" < ka P @fgE#Ufkfpffhtesting.(*B).launch $ " U %0 f  D7 P f0gE#g g%g1gXtesting.BenchmarkResult.NsPerOp@1?@D?@? * L RC xg0gE#ggggXtesting.BenchmarkResult.mbPerSec@0?@s? *X mO h0gE#%h2h6h@hXtesting.BenchmarkResult.AllocsPerOp.0k 8d0 h0gE#hhhhXtesting.BenchmarkResult.AllocedBytesPerOp.0k 8d i8gE#8iIiNiixtesting.BenchmarkResult.String"   J=;"   vMQ]nH9n-  @ i8gE#j+j0jAjTptesting.BenchmarkResult.MemString& GvDm& sB j(gE#jjjj`testing.benchmarkNameU G0 BM k8gE#/kFkKkkxtesting.runBenchmarks"K :  + M$T|B:(y,O<6a K( &!1* -)96 G  lgE#>lHlMlltesting.(*benchContext).processBench"  2 J&  I:;">/&.&K &IL&&! -&LS (6Irp 1 }(+4 S- @m(gE#Rmimnmm\testing.(*B).Run  7', #+7u8  C+ &@ Tub&&L1 0  n0gE#2nBnGnin$0testing.(*B).add0 ! ^ ^^ &   0 ngE#nnn oشptesting.(*B).trimOutputF / 6.  or= XogE#ko{oooh testing.mustBeNil /     ogE#o ppptesting.coverReport"@4 2 /W?() 0   V0 & &/*  T%H* " p(gE# qqqHq0htesting.runExamples" @B"  )"'  8[  q gE#qqqqtesting.sortLines n9Ke a173 r8gE#$r:r?r}r`testing.runExample"<  z: t s   %+B{;B C!  F x T   r0gE#rrs5stesting.newMatcher"\ :>$Ef( (Q  P  8D~  s8gE#sssttesting.(*matcher).fullName fW 5* 'Z Y x" &    ' }gvLW ` pt(gE#tttutesting.splitRegexp"  V  '0 23  M X#$# 6 % &F( p Xu8gE#suuuutesting.(*matcher).unique" &  Jk T&P0 & m4eQ  v gE#v)v.vav`testing.rewrite"   J15> &   E^ v-Hs N = vgE#vvv̥Xtesting.isSpace E  > - ,   !   PwgE#mwwww@testing.(*common).frameSkip"$% >0rY ( U% 3  kirr%  x(gE#  ~gE#~~~~htesting.callerName"%  Q"  mPo0 U`% @gE#QglXtesting.tRunner  !Ff Y"^] ]  )   p(gE#Ktesting.(*T).Run   7 #& +8 M( 2#( S s#J 4Y &" pgE#Ѐ܀0testing.newTestContext`_`:_  1#: > @gE#epuhtesting.(*testContext).waitParallelPvOPXO  !   0O< !gE# (htesting.(*testContext).releasePkOP[O  !    0D<  "x`gE#`testing.MainStart@?@F? 4 F 8 0$gE#16ttesting.(*M).Run" >  !'  >* h)   /   ,gE# #T 0testing.(*T).report"  2.%&%&&  _< B2 3PgE#˄ۄ&@testing.listTests"   0 M  [.[([(%+  ]>]8]8% P<(gE#8testing.runTests  ? z&&3B 3+(, @3 &q- @PgE#e |testing.(*M).before"' 2e N --"L    Q7 IXgE#l}t<testing.(*M).after"    2 e -  -   + + + b      d 7*0- PX gE#ɈΈ(testing.toOutputDirmvG G0 40' B7 p[@gE#T_dvXXtesting.startAlarm@c?@? !;   PD \gE#ӉމXXtesting.stopAlarm08/0/U ;p\@gE#Vgl<testing.parseCpuList"  2(,  &6 { &S#~ ` "n  0bgE##*.8htesting.(*B).run1.func1.106/Q# ;bgE#htesting.(*B).run1.func1@X?@?    :% cgE# 05N`testing.(*B).run.func1 8 V   0fgE#ŒƌЌhtesting.(*B).launch.func106/Q# ;fgE#5?DSHtesting.runBenchmarks.func1 8/" 7 ggE#ƍʍȦtesting.coverReport.func1`C_^^&10hgE#2BGgptesting.runExample.func1! 6J F  :8 8,  jhgE#ڎF testing.runExample.func2"  2!S #52  9#&M%  &N. 7 2p>WF58C2>-P-J*#' pvȏgE#ߏJptesting.tRunner.func1  /)C# %&.&-  /Tw0 `{gE#ɐ͐ѐhtesting.runTests.func1.103/NN8{gE#0:?P8@testing.runTests.func1 8/" % G }gE#đɑԑtesting.startAlarm.func1 6 C:. ~(gE#6MdʒXXtesting.init   G "^UQQ ^QU^^^^U^^U^U^UWp 8    ! E gE##&)Xtesting.(*T).Name###PhgE#{~Xtesting.(*B).Name###ȓ8gE#testing.(testDeps).MatchString-fm O HgE#k~$Ȧtesting.(*BenchmarkResult).String v4 `ДgE#$htype..hash.testing.CoverBlockP{O F/ HgE#equyԦtype..eq.testing.CoverBlock`_`_ " ȕ8gE#testing.(*indenter).Write y HgE#dlptXtype..hash.[4]interface {}po p4 gE#ږTإtype..eq.[4]interface {}L 5 @gE#\dhlXtype..hash.[7]interface {}po p4 pgE#җTإtype..eq.[7]interface {}L 5 8gE#mtx|$htype..hash.struct { F uintptr; R testing.testDeps }PrO B& ȘgE# type..eq.struct { F uintptr; R testing.testDeps } " `gE#~Ԧregexp/syntax.patchList.next \  |,+ u`gE#1Ԧregexp/syntax.patchList.patch  < +      x gE#ܚԦregexp/syntax.patchList.append`-_`_`_`_ V)   ,     ! ~ ( gE#?GL^`0regexp/syntax.Compilepo <(<& N gE#țӛ؛Ԧregexp/syntax.(*compiler).initPlOPO (+  ,I 8gE#[regexp/syntax.(*compiler).compile"S~~_XXoXasF >,LL L K  A & '*ww/2QQQ;>QQC FQ 6E:QT  Y\  L  ..{ &  {.&^7r ~V{VVA gE#0AFVpregexp/syntax.(*compiler).inst ;*- +O gE#ǞΞҞޞhregexp/syntax.(*compiler).nopPUOp&# 45 gE#@GK̥Xregexp/syntax.(*compiler).fail 38!gE#ßȟ$hregexp/syntax.(*compiler).capPOP O *# . 8 0 gE#OZ_o(hregexp/syntax.(*compiler).cat`A_`]_ * # #/ 4  gE#נ(Ԧregexp/syntax.(*compiler).alt6# *  #+/ z2 ` gE#(Ԧregexp/syntax.(*compiler).quest  *#2   /   8K  gE# ,1O(Ԧregexp/syntax.(*compiler).star`_` _ *#2   #   8?  gE#Ǣ̢Ԣ(hregexp/syntax.(*compiler).pluspxo &f HD  gE#AMRb$hregexp/syntax.(*compiler).emptyPOPO *#/  8d @0gE#У/\\regexp/syntax.(*compiler).rune -#.: )  MW     J ;G# вgE#$Ȧregexp/syntax.(*Error).Error ,< V,  gE#Xregexp/syntax.ErrorCode.String''b hgE#\regexp/syntax.(*parser).newRegexp@?@C? * #/   " 0gE#'27Ghregexp/syntax.(*parser).reuse0]/0 / !("  ~ еgE#ͦҦaregexp/syntax.(*parser).push  ;{_ - 5'](G    X8k6^[1  0ȯ8gE#uD regexp/syntax.(*parser).factor" 7  :V@ $ 00$"   !' *, 0 k@zX# ##O X 3^0 0 0 "IB 3 ( Q,zX)"#OX -H0 00`  0"}OLX+zX &X &a9 ,z#$X 9%F0 0H}X 0(  - A  ' &:# &2;I9 =&&2;I&2&C  0gE#GUZnhregexp/syntax.(*parser).leadingString  >  0,!,?  gE#_regexp/syntax.(*parser).removeLeadingString<  ;3'81  4  )F 2   14  * gE#߳Ԧregexp/syntax.(*parser).leadingRegexp05/0b/0/0/0  &   ` gE#,regexp/syntax.(*parser).removeLeadingRegexp  ;35  4   '  8  @ @ gE#]ns@regexp/syntax.literalRegexp  B^b/s  3   D F[<* 0gE#}O regexp/syntax.Parse"g s C V?<o M6 3F A ?Q T9 Y< #5?! < . 2<?5j ! ?<  t    ?_\Uj  v N3 7  ,  *  *P@gE##,1Xregexp/syntax.isCharClass _ 85@gE#Ľ$hregexp/syntax.matchRune`|_`_`0_`_`_`_`Q *U  B8gE#bmr$hregexp/syntax.(*parser).parseVerticalBarPdOPO /  8N @CоgE#TXregexp/syntax.mergeCharClass"  2 h   +, (   ,  \db*9 HgE#^regexp/syntax.(*parser).swapVerticalBar8^ ),,D/ ,,0 DA 0   O8F LgE#K8regexp/syntax.(*parser).parseRightParen  G#C*/6( V,  -0 SJ # Q@gE#?D pregexp/syntax.(*parser).parseEscape"ECRCJCe/ m@3"  H M3?  J ,S  ; ; ; ; ; ; 3  3  H #63 \- m}     * _xPgE#Xregexp/syntax.(*parser).parseClassChar j &  c0XgE#^{`Pregexp/syntax.(*parser).parsePerlClassEscaper k>  pfhgE#6;g`regexp/syntax.(*parser).parseNamedClass"  Nm c   Vq kXgE#'0hregexp/syntax.(*parser).appendGroup Es"7s &\)2jj [s  o gE#regexp/syntax.unicodeTable 3p" =S=L IGIH Pq(hgE#S( regexp/syntax.(*parser).parseUnicodeClass"^  ( @0Y@*8 ? p_*x!_2KG,>y$y  0 ?I/+ L   Gj42AU? `~8gE# regexp/syntax.(*parser).parseClass"               )b?#h 8 ?E .diHP!HPP Hi?HV bmtbE bE8z?D>:@H*  E    WdVNd6 T 8 gE#Rin(4regexp/syntax.cleanClass1 S+' : $R-'*  * b  y1 8gE#%*6Чregexp/syntax.appendLiteral} E~~  P8gE#Ч\regexp/syntax.appendRange^ S {(38@   : p88gE#Yw|Чregexp/syntax.appendFoldedRange H$e  e !bb=  S3u HgE##38Kxregexp/syntax.appendClass E'1 r HgE#xregexp/syntax.appendFoldedClass E'1 r 0HgE#Rbgxregexp/syntax.appendNegatedClass  E'^^  \7  k 8gE#4regexp/syntax.appendTable"   V6 b, b 9 b, b @)  8gE#regexp/syntax.appendNegatedTable"   V6 d  , d  9 d  , d  b@C p Юh0gE#hregexp/syntax.negateClassi S 'a&2  !8 GA  J  gE#3>CP(\regexp/syntax.ranges.Less`_`!вgE#Xregexp/syntax.ranges.Len AF/ gE#(->$\regexp/syntax.ranges.Swap!  gE#pregexp/syntax.checkUTF8 3<'3   Wa (8gE#@W\qregexp/syntax.nextRune  \B*h rv gE#̥Xregexp/syntax.isalnumCC>gE#-04̥Xregexp/syntax.unhex__    pgE#$Xregexp/syntax.InstOp.String N < n BgE#&38p̥Xregexp/syntax.EmptyOpContextPOPO &         7 `gE#̥Xregexp/syntax.IsWordCharWWRgE#6BGUXĶregexp/syntax.(*Prog).Stringpopo :F= >U=  gE#(Ԧregexp/syntax.(*Prog).skipNop  ( #(gE#BKOXregexp/syntax.(*Inst).op E L н gE#Pregexp/syntax.(*Prog).Prefix% D;D# JO77 h  k&s  XgE#yԦregexp/syntax.(*Prog).StartCond0/0/0'  $  gE#)04<$hregexp/syntax.(*Inst).MatchRunePCO^"53$gE#:$\regexp/syntax.(*Inst).MatchRunePos_2yX:( 0%    "4).+   %2.  -!  gE#XĶregexp/syntax.(*Inst).Stringpopo :F= >U= p gE#*49GLregexp/syntax.bw /y% 4 gE#<regexp/syntax.dumpProg" 2<(%qp x"$ HgE#[bfn$̥regexp/syntax.u32pYot/>@-gE#j\regexp/syntax.dumpInst" !2# @;& #   # #    /02 34# 78 ;<; p/ %/ ./%/%Z), J5G8%" G PgE#7̫regexp/syntax.(*Regexp).Equal"srAMI8% ~:$ 2*(TQ.J %KLK6+g78 -AB8L(- -X   % a# XgE#sDregexp/syntax.writeRegexp"{  2,&&  &+&  4&&0]2m3i'' 0e'' 1 `&ad&e h&il&mp&qt&u|&u && &-*5 8&&$   \&\  )   &&.   . I 3 `OgC q*  ? * 0xgE#XĶregexp/syntax.(*Regexp).Stringpopo :F= >U= gE#5:regexp/syntax.escapeZ !"+  #6 # # # #+ " #M#1 # # #  (oN$*p pgE# %CDregexp/syntax.(*Regexp).MaxCap * f \  gE#(regexp/syntax.(*Regexp).CapNames ?b,+ H0  gE#:JOiregexp/syntax.(*Regexp).capNames !Tf-  7 gE#38regexp/syntax.(*Regexp).Simplify"    #      l       s    o   (> 318 M.'  5p)  7 5W^a`+M / a`(M&?<a?|U'   ?1B I6a*X,m6[Ia%   6aqR7 2,#y&9aJH-  gE#pregexp/syntax.simplify16Hb *5o i4  hgE#|g`regexp/syntax.init",H H 41 (.78 5 \ 9i :gE#$Ȧregexp/syntax.(*ErrorCode).Stringptopo p_4P;HgE#hosw$htype..hash.regexp/syntax.Error@i? 9& ;gE#ltype..eq.regexp/syntax.Error  |( =@gE#`mqu$Ȧregexp/syntax.(*InstOp).String`j_`_ `Q4= gE#(hregexp/syntax.(*ranges).Less`a_`_ `Y#`>@gE#]jnrhregexp/syntax.(*ranges).Len@S?@?@I%>gE#$hregexp/syntax.(*ranges).Swap@O?@?@Tp?@gE#W_cgXtype..hash.[11]stringpo p4 @gE#Tإtype..eq.[11]string^ 8 @A(gE#?NS`hregexp.maxBitStateLenPnOPOPO `*= 3f AgE#0regexp.newBitStatePOP>QV0 I 2 ;P'5K>(A #)/(.(9<)%V (   NghI(&($#( (+ ( 0/  A PxHgE#H\regexp.(*Regexp).doMatch 7 I pgE#:?lregexp.(*Regexp).doExecute  S <P( G$#4.@  4W 4;I  < 6A __nT}/ 31HP(  gE#<Adregexp.onePassPrefixV RO6 ] ** a# JR7M  3 ?   X * PgE#($hregexp.onePassNextPaOP'OPOPO )"'  <w pgE#|Xregexp.iop E L pgE#Xregexp.(*queueOnePass).empty##HgE#enr~hregexp.(*queueOnePass).next \ h' agE#Xregexp.(*queueOnePass).clear00gE#Q^cp$hregexp.(*queueOnePass).contains 6 ~ gE#hregexp.(*queueOnePass).insertP:OPOm' .1p@gE#bothregexp.(*queueOnePass).insertNew0-/0r/0 &' 0gE#`regexp.newQueue: 4B: LB. XHgE#nregexp.mergeRuneSets`%  w&BI<  " 4 p4 Q4 4 p3K2A !3I_vU$= Ф@gE#Wglregexp.cleanupOnePass /" R V    gE#pregexp.onePassCopy" R >{[ /<' 11DJ)& 55  MP $'0JT qL   p7 ?  gE# Xregexp.runeSlice.Len *//@P0gE#gptxhregexp.runeSlice.LessP ``Y(gE#`hregexp.runeSlice.Swap  @0gE#DZ_@regexp.makeOnePass"W}  > )& ^ #^&H<g o )MCf gE#FKregexp.compileOnePassO[-n ;=: /  3 "   (%   G gE# Xregexp.(*Regexp).String++@H (gE#X b g p `regexp.Compile E r @ 0gE#   . hregexp.compile"  V<5}<    r/ 5f M-   gE#    tregexp.(*Regexp).gety *-58  ;*r 8 gE#N _ d u regexp.(*Regexp).put !V  2l0[   gE#    (Ȧregexp.(*inputString).step 5%  v `` gE#   ̥Xregexp.(*inputString).canCheckPrefix  p gE#    Ȧregexp.(*inputString).hasPrefixn "` f X  gE#u    Ȧregexp.(*inputString).index * %  gE# F$regexp.(*inputString).context* )%- F"( T .   m  gE#(\regexp.(*inputBytes).step" 8"(  ! | P0gE#UX\̥Xregexp.(*inputBytes).canCheckPrefix  `gE#\regexp.(*inputBytes).hasPrefix &|  ( gE#DTYb\regexp.(*inputBytes).index - ( gE#$regexp.(*inputBytes).context* 7(0 S%+ m 4   s @` gE#|إregexp.(*inputReader).stepD: 8v  !#"! v gE#!%̥Xregexp.(*inputReader).canCheckPrefix  hgE#$Xregexp.(*inputReader).hasPrefix   gE#إXregexp.(*inputReader).index  8gE#WZ^$Xregexp.(*inputReader).context    gE#hregexp.(*Regexp).MatchStringt "f l (gE#7DIWXlregexp.init.0 wL! gE#xregexp.mergeRuneSets.func10#/0~/ ! **  0 gE#Ldi@`regexp.mergeRuneSets.func2 [m#2'~  X@L# (gE#<D regexp.makeOnePass.func1"C Hv4+# // <%  H..  B-.#  2 SVK,A@" 9 H SVH,QP" 6Y6 & %"' B9"D'@>e `H, As %):"D'@>e `K, A  H %) %)K)         =xYxh|h    )nn    @gE#XXregexp.initW >K gE#!$Xregexp.(*onePassInst).String###hgE#$htype..hash.regexp.jobP{O F/ gE#TXtype..eq.regexp.job___0gE#IPTX$htype..hash.regexp.entryP{O F/ gE#TXtype..eq.regexp.entry===gE#'+/$htype..hash.regexp.inputReaderPO =^ xgE#Tإtype..eq.regexp.inputReader y_ gE#"&hregexp.(*runeSlice).Len`e_`_ `[%Pp gE#(hregexp.(*runeSlice).Lesss k#gE# $hregexp.(*runeSlice).Swap`a_`_ `fh gE#(hencoding/binary.littleEndian.Uint16Xoh Ha gE#.(hencoding/binary.littleEndian.PutUint16Smr   Xx gE#(hencoding/binary.littleEndian.Uint32~0 gE#(27Q(hencoding/binary.littleEndian.PutUint32#  # gE#(hencoding/binary.littleEndian.Uint64%wW@0  gE#X b g  (hencoding/binary.littleEndian.PutUint64? !!! ? gE#   ̥Xencoding/binary.littleEndian.String(((8!gE#_!b!f!̥Xencoding/binary.littleEndian.GoString(((! gE#!!!!(hencoding/binary.bigEndian.Uint16Xo Hap0" gE#U"^"b"t"(hencoding/binary.bigEndian.PutUint16Sm   X" gE#""""(hencoding/binary.bigEndian.Uint32H# gE#m#w#|##(hencoding/binary.bigEndian.PutUint32#  #P# gE#$ $$+$(hencoding/binary.bigEndian.Uint64%yU x$ gE#$$$$(hencoding/binary.bigEndian.PutUint64? !!! ? %gE#:%=%A%̥Xencoding/binary.bigEndian.String(((0 %gE#%%%̥Xencoding/binary.bigEndian.GoString(((` %gE#&&$&3&XXencoding/binary.initP OPyOPO i8 i8 E @ &(gE#&&&&hencoding/binary.(*bigEndian).Uint16`g_`_ `]% '(gE#0'='A'E'hencoding/binary.(*bigEndian).PutUint16P[OPOP`p '(gE#''''hencoding/binary.(*bigEndian).Uint32`e_`_ `^"((gE#@(M(Q(U(hencoding/binary.(*bigEndian).PutUint32PYOPOP^((gE#((((hencoding/binary.(*bigEndian).Uint64`i_`_ `_%@()(gE#P)])a)e)hencoding/binary.(*bigEndian).PutUint64P[OPOP`)gE#))))$Ȧencoding/binary.(*bigEndian).StringPcOPO PK3p8*gE#_*l*p*t*$Ȧencoding/binary.(*bigEndian).GoStringPcOPO PK3*(gE#****hencoding/binary.(*littleEndian).Uint16`g_`_ `]%H+(gE#s++++hencoding/binary.(*littleEndian).PutUint16P[OPOP`@+(gE#+, , ,hencoding/binary.(*littleEndian).Uint32`e_`_ `^"X,(gE#,,,,hencoding/binary.(*littleEndian).PutUint32PYOPOP^p,(gE#----hencoding/binary.(*littleEndian).Uint64`i_`_ `_%h-(gE#----hencoding/binary.(*littleEndian).PutUint64P[OPOP`-gE#.%.).-.$Ȧencoding/binary.(*littleEndian).StringPcOPO PK3@x.gE#....$Ȧencoding/binary.(*littleEndian).GoStringPcOPO PK3.gE#/#/(/Ĥcontext.(*emptyCtx).String S .    /gE#////XXcontext.init.0 #> (/gE#/00;0XXcontext.initP OPOPbO n[ nCV.*,U E 0 gE#0000pbufio.NewWriterSizeM -M-  H:   . 01gE#A1H1L1T1Ԧbufio.NewWriter`L_g&:BP1gE#1112$bufio.(*Writer).Flush"l<_3  J1(0,)0-  (   | `2gE#{222Xbufio.(*Writer).Available >C Cp 2gE#222Xbufio.(*Writer).Buffered  038gE#G3^3c33tlbufio.(*Writer).Write"  VQ % W ,   1, (!"   q &30gE# 4$4)4[4bufio.(*Writer).WriteString"  V Q,C >)5  z *40gE#444?5@bufio.(*Writer).ReadFrom"h  V% (2   .)N"+-   b" 05gE#5556XXbufio.initP OPOPO db d*CCCCnCCCC?h8gm) E 4H6gE#j6{666`text/tabwriter.(*Writer).addLine :0X 56gE#6777htext/tabwriter.(*Writer).reset  !$  0 6h7HgE#7777xtext/tabwriter.(*Writer).Initpop:o -3./     1% P88 gE#18A8F8[8خtext/tabwriter.(*Writer).write0v /)  Z  98(gE#8888\text/tabwriter.(*Writer).writeN !,'V  c :@9 gE#g9999(\text/tabwriter.(*Writer).writePadding<z, ! R  n  a   <9(gE#:-:2::dtext/tabwriter.(*Writer).writeLines"1 >&Q(5 (W ( #%S %S  ' :()GN5    1 D:(gE#;!;&;; text/tabwriter.(*Writer).format   ;&QB QL' '  KBR W0X 'bZ /# dbC J; gE#;;; <Xtext/tabwriter.(*Writer).appendx 23  JB JX<gE#~<<<<8(text/tabwriter.(*Writer).updateWidth  $2   LKek 0L<gE#===Xtext/tabwriter.(*Writer).startEscape 4 2k   Lx=gE#====Xtext/tabwriter.(*Writer).endEscapepopfo !$,  % p M >gE#H>Y>^>s>text/tabwriter.(*Writer).terminateCell ;J}'7 U O>gE#>>>? 0text/tabwriter.handlePanic+ 7'q-  ; Q`?gE#????$Ȧtext/tabwriter.(*Writer).Flush`Q_l/68-R?gE#@@@7@\xtext/tabwriter.(*Writer).flushpopopo 31< =" PK S@8gE#@@@jA text/tabwriter.(*Writer).Write # [<  ) 2!5 !, B   KP KH   C> 7b ' er  1 gO `[A@gE#AAAAȦtext/tabwriter.NewWriter 4 8d! 0\@BgE#UB`BcBfBXXtext/tabwriter.init4mm>(\BgE#BBBB$htype..hash.text/tabwriter.cellPLOggB](CgE#FCMCPCSCԦtype..eq.text/tabwriter.cellpPokkH]CgE#CCC̥Xmath/bits.Reverse16<<5]D(gE#*D:D?DDcompress/flate.(*compressor).fillDeflate" X >000 02,+(( ((%D2-D  #  * eD8gE#E/E4EREthcompress/flate.(*compressor).writeBlock* 9 i[5"  e fE gE#EEE@F compress/flate.(*compressor).fillWindow"4 =  2: p   d C`0".3 4E*   3 lF@gE#FFF7Gcompress/flate.(*compressor).findMatch  O  Q  2Z9) /3 '% F * `qG0gE#GGGGhcompress/flate.(*compressor).writeStoredBlock`_``_ 3H/2/ [|4 r H gE#6H@HEHLH(hcompress/flate.hash4 sH0gE#HHHHhcompress/flate.bulkHash4p%opop$ u,"  t0I@gE#II\IaIyIcompress/flate.matchLen:o ! vIgE#I JJdJcompress/flate.(*compressor).encSpeed"(  2  K .I K): u # |JgE#JJJKcompress/flate.(*compressor).initDeflate= (nn$   > ~hKgE#KKKMcompress/flate.(*compressor).deflate"   6       k +2H&,-* -  ## .,->.   1  9) * R,-<. 4 #<&# Ui!.>,36 Cj   f&# - !e )#Y   jj7 d jf M(gE#MMMMcompress/flate.(*compressor).fillStore  ;/  ` 0NgE#@ -;e! !   PbBg(l! AA)k ~2 XHgE#XXXX0 compress/flate.emitLiteral HlK(>= c @(Y0gE#PYYYZXcompress/flate.(*deflateFast).matchLen"AT`Af  =  Z_$3< ' & _^*,)3< iA3<* #1` T PZgE#uZZZZhcompress/flate.(*deflateFast).reset0y/0/ !#   ZgE#[[[1[hcompress/flate.(*deflateFast).resetAll@?@. 0x[gE#[[[[Xcompress/flate.newHuffmanBitWriter BI@9  XI@+  0\gE#Z\f\k\}\xhcompress/flate.(*huffmanBitWriter).reset0/0'/ !.b-   0\gE#\] ];]\compress/flate.(*huffmanBitWriter).flush7 ! )  ^  ! ] gE#]]]]compress/flate.(*huffmanBitWriter).write( !   S (^gE#V^l^q^^$compress/flate.(*huffmanBitWriter).writeBits7@ /G,%%c!!!!!s !&   @8 p_ gE#7_S_X__\compress/flate.(*huffmanBitWriter).writeBytes(i ! 8 ) a/   C _(gE# ``"``Tcompress/flate.(*huffmanBitWriter).generateCodegen" 2> 7,3> r3> 3!  '  'H  #+& P'B   q   #+&#+& ;<*        0@a0gE#paaaahcompress/flate.(*huffmanBitWriter).dynamicSize 9 \g FF   FF bgE#>bGbLb^b$hcompress/flate.(*huffmanBitWriter).fixedSize *EE  `E/ `b0gE#bbbФXcompress/flate.(*huffmanBitWriter).storedSize0\/0/0/ % 8cgE#fc|ccccompress/flate.(*huffmanBitWriter).writeCode7@ /G,%%c!!!!!s !&   @8 d(gE#Odfdkdd`hcompress/flate.(*huffmanBitWriter).writeDynamicHeader+ ! ",)*"L#  0& !P  I I F+@   * egE#Ne^ecee$hcompress/flate.(*huffmanBitWriter).writeStoredHeaderP(OPOPO !  %  zS egE#fff1fhcompress/flate.(*huffmanBitWriter).writeFixedHeaderP(OPEOPO     s xf@gE#fff.g  compress/flate.(*huffmanBitWriter).writeBlock"7  2<l d %|" k "( a} ":8 >  ; A ! 8HN8) g@gE#ggghhtcompress/flate.(*huffmanBitWriter).writeBlockDynamic7M  /<la}:8; A 8M9) `hh0gE#hhh i$compress/flate.(*huffmanBitWriter).indexTokens" B  JK)E) y& }  :L(  ``       `W `iPgE#iiii`compress/flate.(*huffmanBitWriter).writeTokens71  /k T I) )# D)&#%&   1 @jgE#Wjcjhj|jhԩcompress/flate.init.0popo  !  'C 27] j(gE#k'k,kkcompress/flate.(*huffmanBitWriter).writeBlockHuff"7 `  2E) Y0 ` E}p:89F4G, %((t!'''''y 5 "DQP  3  Ku l0gE#"l.l3lGlcompress/flate.histogram `6  lgE#lllXcompress/flate.(*hcode).set  l lgE#mmmĤXcompress/flate.maxNode OTtT0 XmgE#zmmmmxcompress/flate.newHuffmanEncoder' x1 I. ` mgE#n%n*ndnԦHcompress/flate.generateFixedLiteralEncoding *  h/ %.7 2 0 ngE#nnn oԦHcompress/flate.generateFixedOffsetEncoding *0[ 2dz `Xo(gE#oooocompress/flate.(*huffmanEncoder).bitLength o="o@gE#$p5p:pqcompress/flate.(*huffmanEncoder).bitCounts"  V)O  /%%E? - #  + $) + #534 "6 CI 'Y@ @=X'  0 1G    / N Pq8gE#qqqqcompress/flate.(*huffmanEncoder).assignEncodingAndSize /# y>o(3$   r(gE#Krcrhrr<$compress/flate.(*huffmanEncoder).generate"  2 Q  `. 1+ <!>(@j_Aj.   x2i1 "s gE#*s5s:sHsHcompress/flate.(*byLiteral).sort@a?@? /  f @#s gE#sssXcompress/flate.byLiteral.Len *//p#t0gE#t(t,t2thcompress/flate.byLiteral.Less[ kZd#xt(gE#tttt`hcompress/flate.byLiteral.Swap  $t gE#u"u'u5uHcompress/flate.(*byFreq).sort@a?@? /  f @%xu gE#uuuXcompress/flate.byFreq.Len *//p%u0gE#vvv)vhcompress/flate.byFreq.LessQHSR&pv(gE#vvvv`hcompress/flate.byFreq.Swap  `'vgE#w www̥Xcompress/flate.reverseBits@J?e$:@'`w gE#wwww(hcompress/flate.InternalError.Erroro V`# `(wgE#www̥Xcompress/flate.literalToken(8xgE#SxVxZx̥Xcompress/flate.matchToken(xgE#xxx̥Xcompress/flate.token.literal(ygE#y y$y̥Xcompress/flate.token.offset(`ygE#}yyy̥Xcompress/flate.token.length)ygE#yyyy̥Xcompress/flate.lengthCode4@@9@)@zgE#[zlzqzz̥Xcompress/flate.offsetCodeD:* (+2*zgE#zz{{XXcompress/flate.init0 /0/0./ v<' v E +`{gE#{{{{hcompress/flate.(*byLiteral).Len`e_`_ `[%+{ gE#||||(hcompress/flate.(*byLiteral).Lesss k#`,h|gE#||||$hcompress/flate.(*byLiteral).Swap`a_`_ `f-|gE#}}}}hcompress/flate.(*byFreq).Len`e_`_ `[%-h} gE#}}}}(hcompress/flate.(*byFreq).Lesss k#P.}gE#~~~~$hcompress/flate.(*byFreq).Swap`a_`_ `f.h~gE#~~~~$Ȧcompress/flate.(*InternalError).Errorptopo p_4/~gE#"&$htype..hash.compress/flate.literalNodeP{O F/ @0hgE#TXtype..eq.compress/flate.literalNode===0gE#XXhash.init/hh>#0@gE#UafXXhash/crc32.ieeeInit0K/0/ !$  ! 1Ѐ0gE#Hhash/crc32.UpdatexuN , JJM uB4j P3XgE#vy}ĤXhash/crc32.archAvailableIEEE""3ȁgE#XXhash/crc32.archInitIEEE0S/09/ !&  Bb 04P(gE#k\hash/crc32.archUpdateIEEEb5 : pW a  Y p6gE#*Ȧԩhash/crc32.simpleMakeTable@V?q&-1 6xgE#ăhhash/crc32.simplePopulateTable`_`6     70gE#!*/0إhash/crc32.simpleUpdateV ` 8gE#фȦԩhash/crc32.slicingMakeTable v1!. 5 : 0gE#:PUhhash/crc32.slicingUpdateS ,  "J  R 5 =(gE#hhash/crc32.ieeeInit.func1]x%LV=XgE#ixXXhash/crc32.init0 /0`/0/ b& b& Ek `>ІgE#2hash/crc32.ieeeCLMUL @0gE#,Pcompress/gzip.NewWriterLevel zS05 X:: `B gE#͈0compress/gzip.(*Writer).init& / #(?< j  C0gE#<TYr\dcompress/gzip.(*Writer).writeBytes GFx *y* rM F(gE# Icompress/gzip.(*Writer).writeString"  JL ?W=>? |  UIu4 K8gE#NJcompress/gzip.(*Writer).Write" VD b7cEc&(((  EE xE wE Y\     n>  pVgE#16c$compress/gzip.(*Writer).Closew> G8( \8up8  ,8  ZgE#ČԌXXcompress/gzip.initP OPOP.O }w' }>?8AB= E [@gE#TdwXXpath/filepath.initP OPOP.O n?8 n ?8 E ]؍@gE#io/ioutil.readAll &gb"^W `D2a ^`8gE#tio/ioutil.ReadFile"K dn W, (  $ cgE#!7<Vش,io/ioutil.readAll.func1! .& (   *TM3 dgE#ÏǏˏXXio/ioutil.initR >F e0gE#2 Hruntime/pprof.elfBuildID"px) ,,iBN/N%L{#  # L&%N Nk$LN5 >L_ LL L       i6mvfQ p{0gE#)AF4runtime/pprof.(*profMap).lookup"  :> .  P7:!3? ,ST (n$cS,?nru38 X.(  ((L  !# Sh]eQ&* 0XgE#txruntime/pprof.lockProfiles3 ( .uuuuq    ,S gE#%)3XXruntime/pprof.unlockProfiles #>$  (gE#xruntime/pprof.Lookup`_`_ *%F *N2 gE#Xruntime/pprof.(*Profile).Name++Њh0gE#ʕruntime/pprof.(*Profile).WriteTo"%  JmlmXe  H;MSZ    gE#@GKXruntime/pprof.stackProfile.Len *//8gE#ÖЧhruntime/pprof.stackProfile.Stackbnng (gE#)5:?İruntime/pprof.stackProfile.Swap`_`1_  0gE#Ǘ̗runtime/pprof.stackProfile.LessS ,:<P 3   8HgE#Ypup runtime/pprof.printCountProfile" Z "QTe81$$IGh  [ T.&K &+A+IM$U% ,: >h.(G&)X[ UT8NG)9Rgh#m<) H6Nt#? 6&3 "% ФgE#Xruntime/pprof.(*keysByCount).Len 055gE#).3ԯruntime/pprof.(*keysByCount).Swap1  p gE#ҚԵruntime/pprof.(*keysByCount).LessM  7 "N  A2 p 0gE#@W\runtime/pprof.printStackRecord"Y U 5      NJ_ Dtxt  gE# (,4Ȧruntime/pprof.WriteHeapProfiled/IK-gE#ĤXruntime/pprof.countHeapYt&3E( (gE#/484runtime/pprof.writeHeap8S ]`$PbD! +S'"E-())) "49Z E-45Z.N&&" NK&&&%&&%!R# %S{v<SiKKKKKKKKKKKcceMMMMMMMMMMH|&&&_  pgE#ĤXruntime/pprof.countThreadCreateTo &.@((gE# (Ȧruntime/pprof.writeThreadCreate  6n t0 @pgE#ĤXruntime/pprof.countGoroutine0//J &&(gE#&runtime/pprof.writeGoroutinews  9Ft \ p gE#ΡL8runtime/pprof.writeGoroutineStacks  NB :!}*` ddE  @gE#CSXuruntime/pprof.writeRuntimeProfile  G$MYD!  Y@  gE#Xruntime/pprof.runtimeProfile.Len */ /88gE#\jotЧ\runtime/pprof.runtimeProfile.Stack  ]C p gE#ߣ,hruntime/pprof.StartCPUProfileac  :'[ ,)1  >B,;@ @pgE#̤طruntime/pprof.profileWriter  /(   !  H-  gE#>NSkXXruntime/pprof.StopCPUProfile@?@?@?  (#    , PgE#ҥڥޥĤXruntime/pprof.countBlockTo &.@(0gE#JRV`ĤXruntime/pprof.countMutexTo &.@(0(gE#¦Ҧצ:runtime/pprof.writeBlock"   B  J$Kb?!+ 'T NE,.  &K  ,# %|V<)8 J ! `(gE#ҧOruntime/pprof.writeMutex"   U  J$Kb?!+ 'T NE,.  &K  .% %|V R<) 8 J  % بgE#XXruntime/pprof.lostProfileEvent000HgE#^aeTXruntime/pprof.funcPC  6   gE#ݩ мLruntime/pprof.(*profileBuilder).stringIndex ;n qT v'3^ `gE#Ĥruntime/pprof.(*profileBuilder).flush !5L  4 p 0gE#%.3Cruntime/pprof.(*profileBuilder).pbValueType ! UU* 2,U] @gE#ƫ˫`runtime/pprof.(*profileBuilder).pbSamplepopo ! ==  )  2G=6 88gE#ajoruntime/pprof.(*profileBuilder).pbLabel ! UU)* 2,U Ь gE#(hruntime/pprof.(*profileBuilder).pbLinePO ! ))* 2 `PgE#runtime/pprof.(*profileBuilder).pbMapping ! ))))X[*  2[] gE#*HMӮ runtime/pprof.(*profileBuilder).locForPC"  >@'w L1J#,/M 0W 1#/,#/ggg, .! j  5X#3 lI@, ) @!@gE#arw@runtime/pprof.newProfileBuilder  ;?2\Q &S f6k+I  &HgE#,Y^ʰruntime/pprof.(*profileBuilder).addCPUData" J<!g;.g0$x{ %U '".8y-  *(ig.g+ QV V %   - gE#GW\runtime/pprof.(*profileBuilder).build"& ]gdDDDE M$*+?  %-: > l; C>`X(a ] +r;  P6gE#EUZh(runtime/pprof.(*profileBuilder).readMapping /a{ ^ 7 gE#ٲW0runtime/pprof.parseProcSelfMaps"> 2,$u: T 3"3) 3NM  "`^iF 5dd  Y  # `@@gE# Xruntime/pprof.(*profileBuilder).addMapping /! >a pBXgE#zruntime/pprof.(*protobuf).varint $A>w RI pDgE#!%0$hruntime/pprof.(*protobuf).length0K/f.  8DgE#$hruntime/pprof.(*protobuf).uint640G/b8 4PE(gE#+BGruntime/pprof.(*protobuf).uint64s"   D2+- (%  k: PLضgE# $hruntime/pprof.(*protobuf).uint64Opt@?@+?fl  " PL`gE#$hruntime/pprof.(*protobuf).int64P?OZz " D MgE#!$hruntime/pprof.(*protobuf).int64Opt@?@+?f  " PMh(gE#߸runtime/pprof.(*protobuf).int64s"   2+- (%  k: T8 gE#Zjo~runtime/pprof.(*protobuf).string /5 _uP `Vй(gE#Lruntime/pprof.(*protobuf).strings !y2"  1 pWPgE#xXruntime/pprof.(*protobuf).startMessage0N/SWкgE# 2$runtime/pprof.(*protobuf).endMessage" 1  2 -$   z  ]@gE#'runtime/pprof.writeHeapProto"#  J+</DDDDX$#u &  %: >  ']A0B )!H(K cIr>OP Pf(gE#ҼXruntime/pprof.scaleHeapSample`E_`8_`_ 3 ,ID s g (gE#GQVlpPruntime/pprof.printCountProfile.func1" VU(K b6? jgE#߽\ԩruntime/pprof.writeHeap.func1`_` _ V63 pk@gE#`ins$Ĥruntime/pprof.writeBlock.func1 p  ykgE#ؾ$Ĥruntime/pprof.writeMutex.func1 p  ypl0gE#`ims̥Ĥruntime/pprof.(*profileBuilder).locForPC.func10a/0m$IflgE#hruntime/pprof.(*profileBuilder).build.func1 AH  `nPgE#wruntime/pprof.parseProcSelfMaps.func11 Q2 *4'^9O4 tR qgE#4CHWXĤruntime/pprof.writeHeapProto.func1v x/ C  y qgE#XXruntime/pprof.initP OPOP.O w' ?8 E 0s08gE#ox}Ԧruntime/pprof.(*profileBuilder).(runtime/pprof.addMapping)-fmq v sgE#$htype..hash.runtime/pprof.newFunc·1PO FL tPgE#sltype..eq.runtime/pprof.newFunc·1 ~- ugE# hruntime/pprof.(*runtimeProfile).Len`e_`_ `[%v`(gE#`\runtime/pprof.(*runtimeProfile).Stack F wgE# $(hruntime/pprof.(*stackProfile).Len`e_`_ `[% xp(gE#`\runtime/pprof.(*stackProfile).Stack F ygE#)-1$hruntime/pprof.(*stackProfile).Swap`a_`_ `fyx gE#(hruntime/pprof.(*stackProfile).Lesss k#`zgE#$(,Xtype..hash.[5]interface {}po p4 {xgE#Tإtype..eq.[5]interface {}L 5 |gE# (,0Xtype..hash.[8]runtime/pprof.newFunc·1po t4 |xgE#Ttype..eq.[8]runtime/pprof.newFunc·1  gE#^eim$htype..hash.struct { sync.Mutex; runtime/pprof.profiling bool; runtime/pprof.done chan bool }P{O F/ gE# TXtype..eq.struct { sync.Mutex; runtime/pprof.profiling bool; runtime/pprof.done chan bool }}}} X8gE#Իtesting/internal/testdeps.TestDeps.MatchStringT~ 6>+* Z J D5 @ gE#DKOVȦtesting/internal/testdeps.TestDeps.StartCPUProfilep[ovL/@B-gE#XXtesting/internal/testdeps.TestDeps.StopCPUProfile0T 0 gE#elpwȦtesting/internal/testdeps.TestDeps.WriteHeapProfilep[ov\/@B-p8gE# htesting/internal/testdeps.TestDeps.WriteProfileTo d9w L13 0PgE#̥Xtesting/internal/testdeps.TestDeps.ImportPath++r`gE#XXtesting/internal/testdeps.init9rr>-H@gE#{testing/internal/testdeps.(*TestDeps).MatchString v (gE#$(,(Ȧtesting/internal/testdeps.(*TestDeps).StartCPUProfilepwopo pb4xgE#htesting/internal/testdeps.(*TestDeps).StopCPUProfile1bb7P(gE#@MQU(Ȧtesting/internal/testdeps.(*TestDeps).WriteHeapProfilepwopo pb4@gE#TȦtesting/internal/testdeps.(*TestDeps).WriteProfileTo : @gE#r$Ȧtesting/internal/testdeps.(*TestDeps).ImportPathPcOPO PK3gE# github.com/go-kit/kit/metrics.NewTimer  *){  *- hgE#hgithub.com/go-kit/kit/metrics.(*Timer).ObserveDurationpopo 2!D  +  Bc pgE#58<Xgithub.com/go-kit/kit/metrics.(*Timer).UnitFgE#XXgithub.com/go-kit/kit/metrics.init/hh>#gE#8?CG$htype..hash.github.com/go-kit/kit/metrics.TimerPrO 9/ gE#Tإtype..eq.github.com/go-kit/kit/metrics.Timer |  gE#ITWZXXgithub.com/VividCortex/gohistogram.init/hh>#0HgE# @github.com/go-kit/kit/metrics/internal/lv.LabelValues.Withw S.cb d). `gE#XXgithub.com/go-kit/kit/metrics/internal/lv.init/hh>#gE#"-2:Ԧԩgithub.com/go-kit/kit/metrics/generic.NewSimpleHistogram@f?@? 1d 5Y 00gE#`github.com/go-kit/kit/metrics/generic.(*SimpleHistogram).With* 9uq#!* . @gE#hgithub.com/go-kit/kit/metrics/generic.(*SimpleHistogram).ObservepopHo !.QH ,Y pgE#KV[ihgithub.com/go-kit/kit/metrics/generic.(*SimpleHistogram).ApproximateMovingAverage@n?@? **" 5A  gE#XXgithub.com/go-kit/kit/metrics/generic.initM >A @gE#rشgithub.com/go-kit/kit/metrics_test.TestTimerFast( /-b& /#/  PgE#*:?[<github.com/go-kit/kit/metrics_test.TestTimerSlow( 0/$ g& /#  gE#<github.com/go-kit/kit/metrics_test.TestTimerUnit( H/$ g& /#%  xgE#XXgithub.com/go-kit/kit/metrics_test.initC||>7pgE# 'XXmain.init.00:/0/sR'epgE#{XĤmain.main ^!! : gE#XXmain.initH >< d${;Mm5Nb)  { C    ` &   y B    Z    { B  Y f#u>Wv@Y!x;{Dm:n6Q]l5SR~Lu? i8a+r@ i.Sv=Z$LwDh/xAYbxASe!QWa%u8{3ugithub.com/go-kit/kit/metrics/_test/_testmain.go/Users/lorenzocanese/Projects/subito-envs/src/github.com/go-kit/kit/metrics/timer_test.go/Users/lorenzocanese/Projects/subito-envs/src/github.com/go-kit/kit/metrics/generic/generic.go/Users/lorenzocanese/Projects/subito-envs/src/github.com/go-kit/kit/metrics/internal/lv/labelvalues.go/Users/lorenzocanese/Projects/subito-envs/src/github.com/go-kit/kit/metrics/timer.go/usr/local/Cellar/go/1.9/libexec/src/testing/internal/testdeps/deps.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/protomem.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/protobuf.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/proto.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/pprof.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/map.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/elf.go/usr/local/Cellar/go/1.9/libexec/src/io/ioutil/ioutil.go/usr/local/Cellar/go/1.9/libexec/src/path/filepath/path.go/usr/local/Cellar/go/1.9/libexec/src/path/filepath/match.go/usr/local/Cellar/go/1.9/libexec/src/compress/gzip/gunzip.go/usr/local/Cellar/go/1.9/libexec/src/compress/gzip/gzip.go/usr/local/Cellar/go/1.9/libexec/src/hash/crc32/crc32_amd64.s/usr/local/Cellar/go/1.9/libexec/src/hash/crc32/crc32_generic.go/usr/local/Cellar/go/1.9/libexec/src/hash/crc32/crc32_amd64.go/usr/local/Cellar/go/1.9/libexec/src/hash/crc32/crc32.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/token.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/inflate.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/huffman_code.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/huffman_bit_writer.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/deflatefast.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/deflate.go/usr/local/Cellar/go/1.9/libexec/src/math/bits/bits.go/usr/local/Cellar/go/1.9/libexec/src/text/tabwriter/tabwriter.go/usr/local/Cellar/go/1.9/libexec/src/bufio/scan.go/usr/local/Cellar/go/1.9/libexec/src/bufio/bufio.go/usr/local/Cellar/go/1.9/libexec/src/context/context.go/usr/local/Cellar/go/1.9/libexec/src/encoding/binary/varint.go/usr/local/Cellar/go/1.9/libexec/src/encoding/binary/binary.go/usr/local/Cellar/go/1.9/libexec/src/regexp/regexp.go/usr/local/Cellar/go/1.9/libexec/src/regexp/onepass.go/usr/local/Cellar/go/1.9/libexec/src/regexp/exec.go/usr/local/Cellar/go/1.9/libexec/src/regexp/backtrack.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/perl_groups.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/simplify.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/regexp.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/prog.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/parse.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/compile.go/usr/local/Cellar/go/1.9/libexec/src/testing/testing.go/usr/local/Cellar/go/1.9/libexec/src/testing/match.go/usr/local/Cellar/go/1.9/libexec/src/testing/example.go/usr/local/Cellar/go/1.9/libexec/src/testing/cover.go/usr/local/Cellar/go/1.9/libexec/src/testing/benchmark.go/usr/local/Cellar/go/1.9/libexec/src/runtime/trace/trace.go/usr/local/Cellar/go/1.9/libexec/src/strings/strings_amd64.go/usr/local/Cellar/go/1.9/libexec/src/strings/strings.go/usr/local/Cellar/go/1.9/libexec/src/bytes/reader.go/usr/local/Cellar/go/1.9/libexec/src/bytes/bytes_amd64.go/usr/local/Cellar/go/1.9/libexec/src/bytes/bytes.go/usr/local/Cellar/go/1.9/libexec/src/bytes/buffer.go/usr/local/Cellar/go/1.9/libexec/src/flag/flag.go/usr/local/Cellar/go/1.9/libexec/src/sort/zfuncversion.go/usr/local/Cellar/go/1.9/libexec/src/sort/sort.go/usr/local/Cellar/go/1.9/libexec/src/sort/search.go/usr/local/Cellar/go/1.9/libexec/src/fmt/scan.go/usr/local/Cellar/go/1.9/libexec/src/fmt/print.go/usr/local/Cellar/go/1.9/libexec/src/fmt/format.go/usr/local/Cellar/go/1.9/libexec/src/reflect/asm_amd64.s/usr/local/Cellar/go/1.9/libexec/src/reflect/value.go/usr/local/Cellar/go/1.9/libexec/src/reflect/type.go/usr/local/Cellar/go/1.9/libexec/src/reflect/swapper.go/usr/local/Cellar/go/1.9/libexec/src/reflect/makefunc.go/usr/local/Cellar/go/1.9/libexec/src/unicode/tables.go/usr/local/Cellar/go/1.9/libexec/src/unicode/letter.go/usr/local/Cellar/go/1.9/libexec/src/unicode/graphic.go/usr/local/Cellar/go/1.9/libexec/src/strconv/quote.go/usr/local/Cellar/go/1.9/libexec/src/strconv/itoa.go/usr/local/Cellar/go/1.9/libexec/src/strconv/ftoa.go/usr/local/Cellar/go/1.9/libexec/src/strconv/extfloat.go/usr/local/Cellar/go/1.9/libexec/src/strconv/decimal.go/usr/local/Cellar/go/1.9/libexec/src/strconv/atoi.go/usr/local/Cellar/go/1.9/libexec/src/strconv/atof.go/usr/local/Cellar/go/1.9/libexec/src/strconv/atob.go/usr/local/Cellar/go/1.9/libexec/src/unicode/utf8/utf8.go/usr/local/Cellar/go/1.9/libexec/src/math/exp_amd64.s/usr/local/Cellar/go/1.9/libexec/src/math/floor_asm.go/usr/local/Cellar/go/1.9/libexec/src/math/unsafe.go/usr/local/Cellar/go/1.9/libexec/src/math/bits.go/usr/local/Cellar/go/1.9/libexec/src/math/abs.go/usr/local/Cellar/go/1.9/libexec/src/internal/cpu/cpu_x86.s/usr/local/Cellar/go/1.9/libexec/src/internal/cpu/cpu_x86.go/usr/local/Cellar/go/1.9/libexec/src/os/executable_darwin.go/usr/local/Cellar/go/1.9/libexec/src/os/exec_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/types_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/types.go/usr/local/Cellar/go/1.9/libexec/src/os/stat_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/stat_darwin.go/usr/local/Cellar/go/1.9/libexec/src/os/proc.go/usr/local/Cellar/go/1.9/libexec/src/os/pipe_bsd.go/usr/local/Cellar/go/1.9/libexec/src/os/path_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/getwd_darwin.go/usr/local/Cellar/go/1.9/libexec/src/os/getwd.go/usr/local/Cellar/go/1.9/libexec/src/os/file_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/file_posix.go/usr/local/Cellar/go/1.9/libexec/src/os/file.go/usr/local/Cellar/go/1.9/libexec/src/os/error_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/error_posix.go/usr/local/Cellar/go/1.9/libexec/src/os/error.go/usr/local/Cellar/go/1.9/libexec/src/os/env.go/usr/local/Cellar/go/1.9/libexec/src/os/dir_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/dir.go/usr/local/Cellar/go/1.9/libexec/src/internal/poll/fd_unix.go/usr/local/Cellar/go/1.9/libexec/src/internal/poll/fd_posix.go/usr/local/Cellar/go/1.9/libexec/src/internal/poll/fd_poll_runtime.go/usr/local/Cellar/go/1.9/libexec/src/internal/poll/fd_mutex.go/usr/local/Cellar/go/1.9/libexec/src/internal/poll/fd.go/usr/local/Cellar/go/1.9/libexec/src/time/zoneinfo_unix.go/usr/local/Cellar/go/1.9/libexec/src/time/zoneinfo_read.go/usr/local/Cellar/go/1.9/libexec/src/time/zoneinfo.go/usr/local/Cellar/go/1.9/libexec/src/time/time.go/usr/local/Cellar/go/1.9/libexec/src/time/sys_unix.go/usr/local/Cellar/go/1.9/libexec/src/time/sleep.go/usr/local/Cellar/go/1.9/libexec/src/time/format.go/usr/local/Cellar/go/1.9/libexec/src/syscall/asm_darwin_amd64.s/usr/local/Cellar/go/1.9/libexec/src/syscall/zsyscall_darwin_amd64.go/usr/local/Cellar/go/1.9/libexec/src/syscall/syscall_unix.go/usr/local/Cellar/go/1.9/libexec/src/syscall/syscall_darwin.go/usr/local/Cellar/go/1.9/libexec/src/syscall/syscall_bsd.go/usr/local/Cellar/go/1.9/libexec/src/syscall/syscall.go/usr/local/Cellar/go/1.9/libexec/src/syscall/str.go/usr/local/Cellar/go/1.9/libexec/src/syscall/route_bsd.go/usr/local/Cellar/go/1.9/libexec/src/syscall/exec_unix.go/usr/local/Cellar/go/1.9/libexec/src/syscall/env_unix.go/usr/local/Cellar/go/1.9/libexec/src/syscall/dirent.go/usr/local/Cellar/go/1.9/libexec/src/io/pipe.go/usr/local/Cellar/go/1.9/libexec/src/io/io.go/usr/local/Cellar/go/1.9/libexec/src/sync/rwmutex.go/usr/local/Cellar/go/1.9/libexec/src/sync/runtime.go/usr/local/Cellar/go/1.9/libexec/src/sync/pool.go/usr/local/Cellar/go/1.9/libexec/src/sync/once.go/usr/local/Cellar/go/1.9/libexec/src/sync/mutex.go/usr/local/Cellar/go/1.9/libexec/src/sync/map.go/usr/local/Cellar/go/1.9/libexec/src/internal/race/norace.go/usr/local/Cellar/go/1.9/libexec/src/errors/errors.go/usr/local/Cellar/go/1.9/libexec/src/runtime/sys_darwin_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/rt0_darwin_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/memmove_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/memclr_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/duff_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/asm_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/asm.s/usr/local/Cellar/go/1.9/libexec/src/runtime/select.go/usr/local/Cellar/go/1.9/libexec/src/runtime/write_err.go/usr/local/Cellar/go/1.9/libexec/src/runtime/utf8.go/usr/local/Cellar/go/1.9/libexec/src/runtime/unaligned1.go/usr/local/Cellar/go/1.9/libexec/src/runtime/typekind.go/usr/local/Cellar/go/1.9/libexec/src/runtime/type.go/usr/local/Cellar/go/1.9/libexec/src/runtime/traceback.go/usr/local/Cellar/go/1.9/libexec/src/runtime/trace.go/usr/local/Cellar/go/1.9/libexec/src/runtime/time.go/usr/local/Cellar/go/1.9/libexec/src/runtime/sys_x86.go/usr/local/Cellar/go/1.9/libexec/src/runtime/symtab.go/usr/local/Cellar/go/1.9/libexec/src/runtime/stubs_nonlinux.go/usr/local/Cellar/go/1.9/libexec/src/runtime/stubs.go/usr/local/Cellar/go/1.9/libexec/src/runtime/string.go/usr/local/Cellar/go/1.9/libexec/src/runtime/stack.go/usr/local/Cellar/go/1.9/libexec/src/runtime/slice.go/usr/local/Cellar/go/1.9/libexec/src/runtime/sigqueue.go/usr/local/Cellar/go/1.9/libexec/src/runtime/signal_unix.go/usr/local/Cellar/go/1.9/libexec/src/runtime/signal_sighandler.go/usr/local/Cellar/go/1.9/libexec/src/runtime/signal_darwin_amd64.go/usr/local/Cellar/go/1.9/libexec/src/runtime/signal_amd64x.go/usr/local/Cellar/go/1.9/libexec/src/runtime/sema.go/usr/local/Cellar/go/1.9/libexec/src/runtime/rwmutex.go/usr/local/Cellar/go/1.9/libexec/src/runtime/runtime2.go/usr/local/Cellar/go/1.9/libexec/src/runtime/runtime1.go/usr/local/Cellar/go/1.9/libexec/src/runtime/runtime.go/usr/local/Cellar/go/1.9/libexec/src/runtime/relax_stub.go/usr/local/Cellar/go/1.9/libexec/src/runtime/profbuf.go/usr/local/Cellar/go/1.9/libexec/src/runtime/proc.go/usr/local/Cellar/go/1.9/libexec/src/runtime/print.go/usr/local/Cellar/go/1.9/libexec/src/runtime/panic.go/usr/local/Cellar/go/1.9/libexec/src/runtime/os_darwin.go/usr/local/Cellar/go/1.9/libexec/src/runtime/netpoll_kqueue.go/usr/local/Cellar/go/1.9/libexec/src/runtime/netpoll.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mstats.go/usr/local/Cellar/go/1.9/libexec/src/runtime/msize.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mprof.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mheap.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgcwork.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgcsweepbuf.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgcsweep.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgcmark.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgclarge.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgc.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mfixalloc.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mfinal.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mem_darwin.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mcentral.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mcache.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mbitmap.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mbarrier.go/usr/local/Cellar/go/1.9/libexec/src/runtime/malloc.go/usr/local/Cellar/go/1.9/libexec/src/runtime/lock_sema.go/usr/local/Cellar/go/1.9/libexec/src/runtime/lfstack_64bit.go/usr/local/Cellar/go/1.9/libexec/src/runtime/lfstack.go/usr/local/Cellar/go/1.9/libexec/src/runtime/iface.go/usr/local/Cellar/go/1.9/libexec/src/runtime/hashmap_fast.go/usr/local/Cellar/go/1.9/libexec/src/runtime/hashmap.go/usr/local/Cellar/go/1.9/libexec/src/runtime/hash64.go/usr/local/Cellar/go/1.9/libexec/src/runtime/float.go/usr/local/Cellar/go/1.9/libexec/src/runtime/fastlog2.go/usr/local/Cellar/go/1.9/libexec/src/runtime/extern.go/usr/local/Cellar/go/1.9/libexec/src/runtime/error.go/usr/local/Cellar/go/1.9/libexec/src/runtime/env_posix.go/usr/local/Cellar/go/1.9/libexec/src/runtime/defs_darwin_amd64.go/usr/local/Cellar/go/1.9/libexec/src/runtime/debug.go/usr/local/Cellar/go/1.9/libexec/src/runtime/cpuprof.go/usr/local/Cellar/go/1.9/libexec/src/runtime/cpuflags_amd64.go/usr/local/Cellar/go/1.9/libexec/src/runtime/chan.go/usr/local/Cellar/go/1.9/libexec/src/runtime/cgocheck.go/usr/local/Cellar/go/1.9/libexec/src/runtime/cgocall.go/usr/local/Cellar/go/1.9/libexec/src/runtime/atomic_pointer.go/usr/local/Cellar/go/1.9/libexec/src/runtime/alg.go/usr/local/Cellar/go/1.9/libexec/src/sync/atomic/asm_amd64.s/usr/local/Cellar/go/1.9/libexec/src/sync/atomic/value.go |--- {((@S 4ФP@w++// EE E( ( ) ) 0909!~az ~AZ@!# DFFKP|h8jO0.4',.,0,^,0JA0000-//Pv@[^^  `l#  Pz`   H `0S__-0>ŨΨ٨P Pmptª۪ߪ:@[Ƥ////`!o!$$     /dev/urandom  AZaz  1-111p,,,,ͩЩ٩ީߩ7;IMO` JMO`lnprs0-g-o-p---09AFaf....// 09AZaz09AFaf4  5 9 ? jjjj0coo46C6@MPY\_ P S c f  @UW_` r x  @ U X _ > 9 ? ?     DPY      * . f i iq!!.!.!00   / _ 000 +0;@@DO ^`|    ( )    pr_? @ T 34MO?? ^ : .. . ..!.09AZ__az!/:@[`{~09AZ__az         / _ 0+0?1VY_aMRo@E6@U`gp      oDoPo~ooo w@j^j`jijnjojY[[]]            oop09AFaf!&AF0IPip m   9 .. . .. .   ( ) / _ 000JPY^_@<vcTH@޶Ї#x@D3@D3k ت  B AV;^P@=_ Ld&GW@Zfatal error: cgo callback before cgo call 000011223W3foqGIlqIIsswwyyj o )#*#00!0)080:04MN՟mp@DOO_`e e d1d1`!!!!0!0"0)080:0 ? ABzD@FPG$tIK L(knNP߿)`WM?/`H`!ߍi`>@ACDFO      : = D F H J O T c f  4MN՟!!#$')UD H5`vz`%Q_eZ֝jp|!#$&*֦4@ sz !kEkPkYk[kakckwk}kk]]BkCkooDF--  ..00cc ee   ( ) / / _ _ 00'  !(O  "C`....//0000!0)080;04MN՟mpS   * . ` d f o -]B   ..:.;.@.0000p12Xc   $]d[$]t>$@^C  578<<??            $~ |  ?F  8Ui5Oo           ( * 9 = D F H J M U V X Z ` c f o x  ""''  9 : B.B. 0000ADbc )vB/kX`$1                            .0/011122`2~2`|S   * . ` d f o sz !gi{                &(:<=?MP]      ( * 0 2 3 5 9 < D G H K M V W \ ] _ c f w p֦4@  e` eQ',  > > W W     > > W W    .0/0      ( * 0 2 3 5 6 8 9 < < > B G H K M Q Q Y \ ^ ^ f u          3 8 : ? G P X                 >>WWeenr ij//IIhhVVXXbb--q q H!I!|,|,  (08@P`poKUppQ R   *0-000 -EEzz,jxxq q    p!!$$|,},pp\_   ?AJVoqPP=Pptv--  S S { {  ""....:.;.@.@.0000000012XXcc  )]4};=_F ~ 8 #{ #*#i'u'''!'')))))#.&%.). 000000>6DHZ\^ =4]c 0@P`p @`@  %&(*058@HJPU`jp@@FF  CC66{{0010500000 ϩϩppݪݪpp^`u800 ![WP>@([3{:<_  E } 8 #{ #)#h't'''!'')))))".&$.(.B.0 00000?"57CGY[];3[_bb"#VW&'Z[*+^_ d'@Bʚ; TvHrN @zZƤ~o#]xEcd #NJ ';> 6V   5)14Z\ 7o$_jZkbkUԝԭԺԼ:?EQՠ"% #(38:HJLPSXZ\^`cksx}/?!/:@[^``{~ ' 0 > A S U ^ !_$%u''+..000 00000>?EF r w  x ~ X ^ p x *3i|p t y  P!_!!`$a$$$$v'',111 2)2H2O2Q2_2222205  0@`  0@`  0 (*02359<DGHKMPPWW]cflpt?$@Y@@@@j@.AcAחAeA _BvH7BmB@0BļB4&k C7yAC؅W4vCNgmC=`XC@xDPKDMDAZaz%,\bekwyq q    *!+!2!2!N!N!`!!`,,"0Z\d!:AZ@P$HJMPVXXZ]`Z]|------------------  &(.     psuwz}&*]afj EHMPWYY[[]]_}&!&!eefo6?PYPY09PY`jijPkYkPY09`if o  f o  f o  f o  f o  PY )@IFOPY@IPY )Ш٨ Щ٩PYtzY@ $(q F6Clxy},jx#q   |,},o-/.010,2050;00b00^00 spϩpݪm\_p. !"#$$%%&&'''((()**+++++,,,,,,----......///0012222222222333333333344555566666777777777778888888888999999::::::::::::::::;;;;;;;;;;;;;;;;<<<<<===========>>>>>>>>>>??????????????????????@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB@ `P0pH(hX8xD$dT4t L,l\<|B"bR2r J*jZ:zF&fV6vN.n^>~A!aQ1q I)iY9yE%eU5u M-m]=}C#cS3s K+k[;{G'gW7wO/o_?  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`ABCDEFGHIJ*!LMNOPQRTUVWXYZ{|}~#4D+<=>|~ D R z |  !@!(A!D!K!!E!!!!!!!! !!!! !" #!#|######%% %%o&'Q'''''')))))))*0+D+G+L+)b9df \^uӺ?c?yڌX?9?-^? h?:D?Kx? !? ?8G?2Sg?hz?:?Е1?z?G?g!?Kx?4&?̈Gj?TNK?sp (??P??2Ut?Uᢜ>?&m??l??sjbƈ?UϋE???*UUUUI$I88 . ؉ $I$ q(ffffa]tBUUUUQNh/$IFXiDDDDB!!!..??d e JKbbghnn56  DEZ[^_;<~< = G I ....<.<.00vwΨϨ//ȩɩ]_RRVWaaV W GHAC89;<KLAB<>ABnjojjj7k8kDkDk0`?  ) 1 4 7 = ]  ) 1 4 ^   ) E I W   E I HIWY mq_XZ\^ #+/,_,&---------.@0122Ω'/7=?BESgu`_ 3KkSsk*!s+!0011SE&!24>!A"B*J24>ABJbcc!"*bJ`aa`E&!*!K+!JKK  34ss56<<MMflptBBFF??++??jjoogimr{DFHJWW  V W   : ?   GMAC8<KM[[AB<>ACqqp$t$njojjj7k9kDkDk3ux #X_y        @ G } ~     X _ x      `~Re:;Zl[kak`q !!,,..:;??~~     0>^^d e Z[ JKahmn56 DEZ[]_;?~< = G I ....<.<.A.A.00 vwΨϨ//ǩɩ]_ߪߪPRTW aadd(O  3NTVg7Rk";Vo6NPUp"W#C09`if o   f o  f o r w  f o x ~  X ^ f x  PY 3@Ii|FOPY@IPYp t u y  P!!!!`$$$$v'',0 !0)080:011 2)2H2O2Q2_22222 )05Ш٨ Щ٩PY    % 9  u+ w % # 9 g u+ O   9   %  9   %  9 1   )    1       o     %  7  M `~!"$$'')24799;;BBGGIIKKMOQRTTWWYY[[]]__abddgjlrtwy|~~1oW ?  P X   q  9 ?   GM@Ctu8=KLO[]AC`l<>AEpqp$t$njojj7kB8k;kDk[Q^_'  4Mh  89;>@DFJKPl!<Up4Vn6!^^  2 4 @ @ a d } ~      !!!! !!!!!!$!$!(!)!,!-!/!1!3!8!>1oW ?  P X   q  9 ?   GM@Ctu8=KLO[]AC`l<>AEpqp$t$njojj7kB8k;kDk[Q^_s##sf f Q!Edd!@"@"""$ $%% -)];^@r..     .,V,.235>?ADGHKMWb c567@AEk0r12;<>n j!&/>QoRRo~oefmr@[`{tt~~  @@d e ??56  d f p t ~   !%!'!)!,!1!3!M!O!_!!!!#$&$@$J$`$')s+v++++++++++.D.//00000 00070<0?00000001111 2_222X33MM!09..ϩϩ[[>?0RTfhk ;@[epp3@x #AJ X_y        @ G } ~     X _ x      `~Ro6?PYPY0;Pl$n$`jijPkYk[kak`qPY  ; 8> @ I L N O       ,> @  ;    6 > ;@ G H K L W      *  A D         > @ F H J L W + L   >?+,18;<VWb cdgm #&)+0138UWacdm nr51;=>ACD=$1%+45.0;/0#w$'èRS1/034M{.}nvz      8E'2,477>>>DGHKLWWbc5ACE0>@@*/68>0k6kQo~o!#$&*GG0IPip  p v   O y *48@ajt|!!!!! !!!!!!#!%!)!.!:! ;!J!L!M!O!!;!! !!!!!!!!!!!!!!!!!!## ##"#(#+#{#}######$&$@$J$$$%%%%%%&n&p&g'''((+/+E+F+M+s+v++++++++++,,....////000 0 6070>0?011111122*2G2P2`2a22222233MMƤ(+679w>xyAZ.269GJxy}2:;=>ACDFHNEp+rv /`.1V(/8?HMY_ho&!*!+!2!!,} ,.,`,b,c,d,g,m,n,p,r,u,~,,,,,,,@NyBl".2ny}~!kW":az*/37:HKwz~#3<?@BGOPTVWY[\`aefhiloqru} Eqsw{|}0_a/ay} '07@EQW`gp}N!!60,^,a,e,f,l,s,v,,,,,,- -%-'---Am#/3oz|SpqAZAZ69GJxy}2:;=>ACDFHNprv /`.1V(/8?HMY_ho!! ! !!!!!!!$!*!+!-!0!3!>!?!E!!>,.,`,b,c,d,g,m,n,p,r,u,~,,,,,,,@NyBl".2ny}~!kW":!#%'*./: ;?@\~Z[_7    jKkm, 0>^d e p OZ [qJO`eahmn56 DEZ`;?~ C ! ' 0 8 ; > A C G Q S U V ^ ,,,,p-..... .........*. +...0.9.<.?.A.C.D.000=00 s~ twΨϨ.2/_0ͩީߩ\_ުߪ%R0EFILPRTW_ahjk   <adee!#%*,/:;?@[]_{}$~ Z_    jKkm, 0>^d e p OZ [:&;=KJO`eahmmn-O56 DEZ`;?~ = ' 0 C E Q S ^ } ~  # #)#*#h'u''''')))))),,,,p-....0.D.00000000=0 00[ s~ twΨϨ.2/_0ͩީߩ\_ުߪ>SQ?0RTachjk   ;=?[]_`e778?y0wx ?w @KP^az*78HIwz~349<?@BGOPqsw{|}041_a/a+kwy '07@EPW`gp} !!!!/!9!?779:9;u|44DDks67x},j,,/./.*0/00000oo|}!ĨĨ+.SS{}ª[_ />>@@pp7?y0wx ?w @KP^$+<>^`|~ uq     p   O y ?48@eajt|D R z |   !!!!! !!!!!!#!%!)!.!:! ;!@!A!D!J!M!O!!;!!!# #(#+##$&$@$J$$$%g''''''))))))s+v++++++++++,,....////000 0 6070>0?00011111122*2G2P2`2a22222233MMƤ !(+69wy[)Obdefi >@\^TV  9;>@DFFJPR46NPnp!"$$'')24799;;BBGGIIKKMOQRTTWWYY[[]]__abddgjlrtwy|~~vz      8 : ?   8F'4s ,7><>?DGHKMWb cfglpt5F0@+/68?jj0k6kQo~oooeimr{BD6;lu!#$&*DJ37?&)fjzV`qTV  9;>@DFFJPR+0 .0kp;@HPQs GPY` '003>@KP^ EEKWY_pp0?#%'), : ; > L N O U W b c         > B G H K L Q Q p q u u        > D G H K L V W b c        > D F H J L U V b c         > D F H J L W W b c      114:MMq+688;>VY^`bbghqt__23RSrs +08U^at5C$5$$--t{#'èŨŨ&*GR)6CCLM ~wzVY JM-0[^^     9 < B G H K M Q Q Y ^ f u     9 < D G H K M V W \ c f w 9 = M U Z ` c f o x  : = O T c f  :?[lqMP]`Z]| 6@S`s  w+0;@@Dmpt|KP|7;IM EHMP} ' 0 ^ p q t !!!&$@$J$`$s+v++++++++,,,'-----0-g-o-p----D...////00001-1111111MM՟ƤФ+@+09@wŨΨ٨S_|٩ީ6@MPY\ª۪  epװmp?P kpvz      8 : ?   8F'+-4s 5/1467><@flpt8?BDFm3:=?@kf"%'+068=?Sjj0k6koogi{BD6;lu!#$&*DJ  oK_pf01J#%')-Y[ : < A H M Q R W b c  ;     < :A B G H K M Q p q u        < ? A D M V b c  > 3> @ F H J M U V b c  ;    A @B D M b c g  1[4:GN59q~-g.0279:=>XY^`qt]^_24RSrs .   w!"'(29:;V;X^`bels|1467:<Bks,367   ,,--a--*0-000otu} %&ĨŨ&-GQ)).1256CL |4+ 1O /oK_pf01J#%')-Y[ : < > O Q W b c          < > ? B G H K M Q p q u         < > ? D G H K M V W b c  <    )  > D F H J M U V b c          > D F H J M W b c  G    145:GN59>?q+e,>VY^`bdgmqt ]_24RSrs .   w!+0;U^`|14Dks$7 ,,--a--*0/000ort} #$'Ũ&-GS)D*6CL M{.|}* /MP]37#0JPz'0coo6@U`g8<<?  9 ? ?        3 8 : ? G P X `       5 9 U X r x       H       `~MRoCPv> 9<DGHKMPPWW]cflpt]DPY`l+0?EPlp #$t$$C%0.4DFFh8j@jijnjojjjjjkEkPkwk}kkoDoPo~ooooopjp|&)r{EV`q  FJ*JPY^_$';BBGTWdg+0 kp;@HPQs GPY`'003KP^֦4@ < ?AJnoq /M@X 9 = P X a r               ( * 0 2 3 5 6 8 9 Y \ ^ r s t               ( * 0 2 3 5 9 = \ ] _ ` a q            5    ( * 9 = X Y Z ` a        !      : = N T V _ a z       023@E@@AGIl*?PQUZ]aefnopuBHJMPVXZ[]`Zlo  1@Q`lnp D!BDwPmpt T3EK#MOZw5!8!0-g-------------------0<06A000000011-111111114MN՟Ф *+n2h  "@s %0F`|(@BDK`oqvz~ª۪ܪ  &(.mp (*68<>@ACDFG=Pptvfoq  &(:<=?MP]0@BIPuP'0c6@U`g  578<?@U`v   9            3 ` |        5 @ U ` r    H 7&Prv + (*02359=P]a4GJ/D< .@r2s #$C%0.4DFFh8j@j^jjjk/kckwk}kkoDoPoppjp|!"$')2479;BGIMNOQRTWYabdgjlrtwy|~֦4@ Տ<v>ᮺWvU0 r5]JBό-;eUkE=ƚpOܼw kAV<Ѝ,U1(\QFɦqaˋ#w"{mSx@I̮Wζ]y<7VM6OH8oꖐ:%˅tφ* 455*g8P;?Ȅk'DŅ%Οkb}$lۺ_ Xf&ޓ J|l_b%S04`?U&NZ~)p$wt帟ߦ}t_ϛpDk11eU%{?;+*\.Ӓsi$$Icd~̈Po ̼,eXѳ@bx x9?{Η8p\{2~Sh髤8mE"&'O'1cȌ8eްeǃqB]X,iM pd'JwmBk}{x \wyTwś[[=]S5Ȭ\*_F%94›\rξTSܷ1A"Lx\ӛ fS!{Z:0ܵ\S٨@ACDFG=Pptv!:AZf  &(:<=?MP]0@BIPu'0c6@U`g  578<?@U`v   9            3 ` |        5 @ U ` r    H     7&Prv + (*02359=P]a4GJ/D< .@r2s #$C%0.4DFFh8j@j^jjjk/k@kCkckwk}kkoDoPooCooop pjp|TV  9;>@DFJKPR46NPnpC!"$')2479;BGIMNOQRTWYabdgjlrtwy|~֦4@ AZ az yy/00911279HJwxxy~Oaa88  ~"3::+*;<==]>>(*?@?*?*ABCC=DDEEEGFOPP**QQ**RR**SS..TT22VW33YY66[[55\\OO``33aaKKcc11ee((ffDDhh//ii--jjDDkk))llAAoo--qq))rr++uu**}}))&&&&**&&''%%EETTpsvw{}t&%@?  ~P/ 0OP_`/1V0a```З‰‰yy}}A '(/078?@EHMQQSSUUWWYY[[]]__`ghopqJJruVVvwddxyz{pp|}~~   &!&!*!*!A+!+!2!2!N!N!`!o!p!!!!$$$$,.,00,^,`,a,b,b, c,c,d,d,e,e,f,f,g,l,m,m,n,n,o,o,p,p,r,s,u,v,~,,,,,,,,-%-'-'-----@m"/2oy|}}u~ZZZZZZZZZSS``p0h0h!: AZ'((O(  @   !""C@ȣ`""" "" "`"`" "" " "`""" "`""" "`"`"" "`"""`" "`""`""" "`""""" """"" "`" """ "`"`""" "`""" """ "`""""" "`"" "`""" " """ "`""" "`""" "`""" "`" "" "`"" """ " "`"" "`""""" "`"" "" "`"" ""`"`""" """"`"""`""" "`""" "`"" "`""" "`"""" " "`"`" "`"" """`"""" "" "`"""" " "`"`"""`""`"""""`""" "`""" "`"" "`"""" "`"""`"`""""" "`""`""" " "`""" "`"! $M]`!"`! "`!0"`!"`!"`!@"1J5 D<?U!`!!h!!p!!!!`! !,,!,,P $ $""ؐ!!! $!!!!!!!0!! !!!!!!!! !!" "`!**`"Д! ! !@! !`!RR3" K"zz@"==! !!x!!"w"00"!XXأ" """"4/42e! " 0p+ H?8x(h@$!!f"eeo""pp!## $!`!!##! $`!!,!! $!Б!! $ !@!#" ">> $!4!!/Dx$Gi - 8fkM_BBr".- I\*m!Km!gi TMXlm!dc\{%cc25<! # # & ) ) , /&/2M4t77:= = ?B F F I L P P R U V ,X [ [ _ oc |ff'i l! m!1r"au#u#w$]{%c}&}&x'((i)*#*NwT2:N <G J8>D<TaJa9' 9G . ' 8n!2L05bAd1/N+ JH,1' 'j -6j TGaff]5meSKiKXUNda/IAd2Kv#k ~Q^T[Oi q!@~;q!; + 5B?<:1U?Hkq!77K>5HdSV<QSn!kC2</?* І)r"#Vh Hh<;VG>' gB1e;?1+ 0Bn! 61I@ %.@ ? 4 I? 4 I I U  8 IR I  !I7 ; $> R I R IR RR IR IR RRIR  R R R  R Ii4 /usr/local/Cellar/go/1.9/libexec/src/sync/atomic/value.go/usr/local/Cellar/go/1.9/libexec/src/sync/atomic/asm_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/alg.go/usr/local/Cellar/go/1.9/libexec/src/runtime/atomic_pointer.go/usr/local/Cellar/go/1.9/libexec/src/runtime/cgocall.go/usr/local/Cellar/go/1.9/libexec/src/runtime/cgocheck.go/usr/local/Cellar/go/1.9/libexec/src/runtime/chan.go/usr/local/Cellar/go/1.9/libexec/src/runtime/cpuflags_amd64.go/usr/local/Cellar/go/1.9/libexec/src/runtime/cpuprof.go/usr/local/Cellar/go/1.9/libexec/src/runtime/debug.go/usr/local/Cellar/go/1.9/libexec/src/runtime/defs_darwin_amd64.go/usr/local/Cellar/go/1.9/libexec/src/runtime/env_posix.go/usr/local/Cellar/go/1.9/libexec/src/runtime/error.go/usr/local/Cellar/go/1.9/libexec/src/runtime/extern.go/usr/local/Cellar/go/1.9/libexec/src/runtime/fastlog2.go/usr/local/Cellar/go/1.9/libexec/src/runtime/float.go/usr/local/Cellar/go/1.9/libexec/src/runtime/hash64.go/usr/local/Cellar/go/1.9/libexec/src/runtime/hashmap.go/usr/local/Cellar/go/1.9/libexec/src/runtime/hashmap_fast.go/usr/local/Cellar/go/1.9/libexec/src/runtime/iface.go/usr/local/Cellar/go/1.9/libexec/src/runtime/lfstack.go/usr/local/Cellar/go/1.9/libexec/src/runtime/lfstack_64bit.go/usr/local/Cellar/go/1.9/libexec/src/runtime/lock_sema.go/usr/local/Cellar/go/1.9/libexec/src/runtime/malloc.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mbarrier.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mbitmap.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mcache.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mcentral.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mem_darwin.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mfinal.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mfixalloc.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgc.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgclarge.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgcmark.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgcsweep.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgcsweepbuf.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mgcwork.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mheap.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mprof.go/usr/local/Cellar/go/1.9/libexec/src/runtime/msize.go/usr/local/Cellar/go/1.9/libexec/src/runtime/mstats.go/usr/local/Cellar/go/1.9/libexec/src/runtime/netpoll.go/usr/local/Cellar/go/1.9/libexec/src/runtime/netpoll_kqueue.go/usr/local/Cellar/go/1.9/libexec/src/runtime/os_darwin.go/usr/local/Cellar/go/1.9/libexec/src/runtime/panic.go/usr/local/Cellar/go/1.9/libexec/src/runtime/print.go/usr/local/Cellar/go/1.9/libexec/src/runtime/proc.go/usr/local/Cellar/go/1.9/libexec/src/runtime/profbuf.go/usr/local/Cellar/go/1.9/libexec/src/runtime/relax_stub.go/usr/local/Cellar/go/1.9/libexec/src/runtime/runtime.go/usr/local/Cellar/go/1.9/libexec/src/runtime/runtime1.go/usr/local/Cellar/go/1.9/libexec/src/runtime/runtime2.go/usr/local/Cellar/go/1.9/libexec/src/runtime/rwmutex.go/usr/local/Cellar/go/1.9/libexec/src/runtime/sema.go/usr/local/Cellar/go/1.9/libexec/src/runtime/signal_amd64x.go/usr/local/Cellar/go/1.9/libexec/src/runtime/signal_darwin_amd64.go/usr/local/Cellar/go/1.9/libexec/src/runtime/signal_sighandler.go/usr/local/Cellar/go/1.9/libexec/src/runtime/signal_unix.go/usr/local/Cellar/go/1.9/libexec/src/runtime/sigqueue.go/usr/local/Cellar/go/1.9/libexec/src/runtime/slice.go/usr/local/Cellar/go/1.9/libexec/src/runtime/stack.go/usr/local/Cellar/go/1.9/libexec/src/runtime/string.go/usr/local/Cellar/go/1.9/libexec/src/runtime/stubs.go/usr/local/Cellar/go/1.9/libexec/src/runtime/stubs_nonlinux.go/usr/local/Cellar/go/1.9/libexec/src/runtime/symtab.go/usr/local/Cellar/go/1.9/libexec/src/runtime/sys_x86.go/usr/local/Cellar/go/1.9/libexec/src/runtime/time.go/usr/local/Cellar/go/1.9/libexec/src/runtime/trace.go/usr/local/Cellar/go/1.9/libexec/src/runtime/traceback.go/usr/local/Cellar/go/1.9/libexec/src/runtime/type.go/usr/local/Cellar/go/1.9/libexec/src/runtime/typekind.go/usr/local/Cellar/go/1.9/libexec/src/runtime/unaligned1.go/usr/local/Cellar/go/1.9/libexec/src/runtime/utf8.go/usr/local/Cellar/go/1.9/libexec/src/runtime/write_err.go/usr/local/Cellar/go/1.9/libexec/src/runtime/select.go/usr/local/Cellar/go/1.9/libexec/src/runtime/asm.s/usr/local/Cellar/go/1.9/libexec/src/runtime/asm_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/duff_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/memclr_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/memmove_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/rt0_darwin_amd64.s/usr/local/Cellar/go/1.9/libexec/src/runtime/sys_darwin_amd64.s/usr/local/Cellar/go/1.9/libexec/src/errors/errors.go/usr/local/Cellar/go/1.9/libexec/src/internal/race/norace.go/usr/local/Cellar/go/1.9/libexec/src/sync/map.go/usr/local/Cellar/go/1.9/libexec/src/sync/mutex.go/usr/local/Cellar/go/1.9/libexec/src/sync/once.go/usr/local/Cellar/go/1.9/libexec/src/sync/pool.go/usr/local/Cellar/go/1.9/libexec/src/sync/runtime.go/usr/local/Cellar/go/1.9/libexec/src/sync/rwmutex.go/usr/local/Cellar/go/1.9/libexec/src/io/io.go/usr/local/Cellar/go/1.9/libexec/src/io/pipe.go/usr/local/Cellar/go/1.9/libexec/src/syscall/dirent.go/usr/local/Cellar/go/1.9/libexec/src/syscall/env_unix.go/usr/local/Cellar/go/1.9/libexec/src/syscall/exec_unix.go/usr/local/Cellar/go/1.9/libexec/src/syscall/route_bsd.go/usr/local/Cellar/go/1.9/libexec/src/syscall/str.go/usr/local/Cellar/go/1.9/libexec/src/syscall/syscall.go/usr/local/Cellar/go/1.9/libexec/src/syscall/syscall_bsd.go/usr/local/Cellar/go/1.9/libexec/src/syscall/syscall_darwin.go/usr/local/Cellar/go/1.9/libexec/src/syscall/syscall_unix.go/usr/local/Cellar/go/1.9/libexec/src/syscall/zsyscall_darwin_amd64.go/usr/local/Cellar/go/1.9/libexec/src/syscall/asm_darwin_amd64.s/usr/local/Cellar/go/1.9/libexec/src/time/format.go/usr/local/Cellar/go/1.9/libexec/src/time/sleep.go/usr/local/Cellar/go/1.9/libexec/src/time/sys_unix.go/usr/local/Cellar/go/1.9/libexec/src/time/time.go/usr/local/Cellar/go/1.9/libexec/src/time/zoneinfo.go/usr/local/Cellar/go/1.9/libexec/src/time/zoneinfo_read.go/usr/local/Cellar/go/1.9/libexec/src/time/zoneinfo_unix.go/usr/local/Cellar/go/1.9/libexec/src/internal/poll/fd.go/usr/local/Cellar/go/1.9/libexec/src/internal/poll/fd_mutex.go/usr/local/Cellar/go/1.9/libexec/src/internal/poll/fd_poll_runtime.go/usr/local/Cellar/go/1.9/libexec/src/internal/poll/fd_posix.go/usr/local/Cellar/go/1.9/libexec/src/internal/poll/fd_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/dir.go/usr/local/Cellar/go/1.9/libexec/src/os/dir_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/env.go/usr/local/Cellar/go/1.9/libexec/src/os/error.go/usr/local/Cellar/go/1.9/libexec/src/os/error_posix.go/usr/local/Cellar/go/1.9/libexec/src/os/error_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/file.go/usr/local/Cellar/go/1.9/libexec/src/os/file_posix.go/usr/local/Cellar/go/1.9/libexec/src/os/file_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/getwd.go/usr/local/Cellar/go/1.9/libexec/src/os/getwd_darwin.go/usr/local/Cellar/go/1.9/libexec/src/os/path_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/pipe_bsd.go/usr/local/Cellar/go/1.9/libexec/src/os/proc.go/usr/local/Cellar/go/1.9/libexec/src/os/stat_darwin.go/usr/local/Cellar/go/1.9/libexec/src/os/stat_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/types.go/usr/local/Cellar/go/1.9/libexec/src/os/types_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/exec_unix.go/usr/local/Cellar/go/1.9/libexec/src/os/executable_darwin.go/usr/local/Cellar/go/1.9/libexec/src/internal/cpu/cpu_x86.go/usr/local/Cellar/go/1.9/libexec/src/internal/cpu/cpu_x86.s/usr/local/Cellar/go/1.9/libexec/src/math/abs.go/usr/local/Cellar/go/1.9/libexec/src/math/bits.go/usr/local/Cellar/go/1.9/libexec/src/math/unsafe.go/usr/local/Cellar/go/1.9/libexec/src/math/floor_asm.go/usr/local/Cellar/go/1.9/libexec/src/math/exp_amd64.s/usr/local/Cellar/go/1.9/libexec/src/unicode/utf8/utf8.go/usr/local/Cellar/go/1.9/libexec/src/strconv/atob.go/usr/local/Cellar/go/1.9/libexec/src/strconv/atof.go/usr/local/Cellar/go/1.9/libexec/src/strconv/atoi.go/usr/local/Cellar/go/1.9/libexec/src/strconv/decimal.go/usr/local/Cellar/go/1.9/libexec/src/strconv/extfloat.go/usr/local/Cellar/go/1.9/libexec/src/strconv/ftoa.go/usr/local/Cellar/go/1.9/libexec/src/strconv/itoa.go/usr/local/Cellar/go/1.9/libexec/src/strconv/quote.go/usr/local/Cellar/go/1.9/libexec/src/unicode/graphic.go/usr/local/Cellar/go/1.9/libexec/src/unicode/letter.go/usr/local/Cellar/go/1.9/libexec/src/unicode/tables.go/usr/local/Cellar/go/1.9/libexec/src/reflect/makefunc.go/usr/local/Cellar/go/1.9/libexec/src/reflect/swapper.go/usr/local/Cellar/go/1.9/libexec/src/reflect/type.go/usr/local/Cellar/go/1.9/libexec/src/reflect/value.go/usr/local/Cellar/go/1.9/libexec/src/reflect/asm_amd64.s/usr/local/Cellar/go/1.9/libexec/src/fmt/format.go/usr/local/Cellar/go/1.9/libexec/src/fmt/print.go/usr/local/Cellar/go/1.9/libexec/src/fmt/scan.go/usr/local/Cellar/go/1.9/libexec/src/sort/search.go/usr/local/Cellar/go/1.9/libexec/src/sort/sort.go/usr/local/Cellar/go/1.9/libexec/src/sort/zfuncversion.go/usr/local/Cellar/go/1.9/libexec/src/flag/flag.go/usr/local/Cellar/go/1.9/libexec/src/bytes/buffer.go/usr/local/Cellar/go/1.9/libexec/src/bytes/bytes.go/usr/local/Cellar/go/1.9/libexec/src/bytes/bytes_amd64.go/usr/local/Cellar/go/1.9/libexec/src/bytes/reader.go/usr/local/Cellar/go/1.9/libexec/src/strings/strings.go/usr/local/Cellar/go/1.9/libexec/src/strings/strings_amd64.go/usr/local/Cellar/go/1.9/libexec/src/runtime/trace/trace.go/usr/local/Cellar/go/1.9/libexec/src/testing/benchmark.go/usr/local/Cellar/go/1.9/libexec/src/testing/cover.go/usr/local/Cellar/go/1.9/libexec/src/testing/example.go/usr/local/Cellar/go/1.9/libexec/src/testing/match.go/usr/local/Cellar/go/1.9/libexec/src/testing/testing.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/compile.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/parse.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/prog.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/regexp.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/simplify.go/usr/local/Cellar/go/1.9/libexec/src/regexp/syntax/perl_groups.go/usr/local/Cellar/go/1.9/libexec/src/regexp/backtrack.go/usr/local/Cellar/go/1.9/libexec/src/regexp/exec.go/usr/local/Cellar/go/1.9/libexec/src/regexp/onepass.go/usr/local/Cellar/go/1.9/libexec/src/regexp/regexp.go/usr/local/Cellar/go/1.9/libexec/src/encoding/binary/binary.go/usr/local/Cellar/go/1.9/libexec/src/encoding/binary/varint.go/usr/local/Cellar/go/1.9/libexec/src/context/context.go/usr/local/Cellar/go/1.9/libexec/src/bufio/bufio.go/usr/local/Cellar/go/1.9/libexec/src/bufio/scan.go/usr/local/Cellar/go/1.9/libexec/src/text/tabwriter/tabwriter.go/usr/local/Cellar/go/1.9/libexec/src/math/bits/bits.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/deflate.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/deflatefast.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/huffman_bit_writer.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/huffman_code.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/inflate.go/usr/local/Cellar/go/1.9/libexec/src/compress/flate/token.go/usr/local/Cellar/go/1.9/libexec/src/hash/crc32/crc32.go/usr/local/Cellar/go/1.9/libexec/src/hash/crc32/crc32_amd64.go/usr/local/Cellar/go/1.9/libexec/src/hash/crc32/crc32_generic.go/usr/local/Cellar/go/1.9/libexec/src/hash/crc32/crc32_amd64.s/usr/local/Cellar/go/1.9/libexec/src/compress/gzip/gzip.go/usr/local/Cellar/go/1.9/libexec/src/compress/gzip/gunzip.go/usr/local/Cellar/go/1.9/libexec/src/path/filepath/match.go/usr/local/Cellar/go/1.9/libexec/src/path/filepath/path.go/usr/local/Cellar/go/1.9/libexec/src/io/ioutil/ioutil.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/elf.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/map.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/pprof.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/proto.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/protobuf.go/usr/local/Cellar/go/1.9/libexec/src/runtime/pprof/protomem.go/usr/local/Cellar/go/1.9/libexec/src/testing/internal/testdeps/deps.go/Users/lorenzocanese/Projects/subito-envs/src/github.com/go-kit/kit/metrics/timer.go/Users/lorenzocanese/Projects/subito-envs/src/github.com/go-kit/kit/metrics/internal/lv/labelvalues.go/Users/lorenzocanese/Projects/subito-envs/src/github.com/go-kit/kit/metrics/generic/generic.go/Users/lorenzocanese/Projects/subito-envs/src/github.com/go-kit/kit/metrics/timer_test.gogithub.com/go-kit/kit/metrics/_test/_testmain.go ss8s#sq~= iss7 Yn'nnAA}nA fFAAAAA9OA7-;AA7%~x)A~s5As5As5As5As5AtBHVVU#V`_#wtHB"mtHB"m-k7U93zo{-kU93{o| A.A.A.A.AAAA$A$s/WsUsUk_3{o~k7_3zo}.wjUURX-77-pn~5A2D;5A 5ABћmAùW -BiR(5cAUAiilncifcY<s  ~#; AOrPt}<wd4~ sPsYiE2;mvippl1O{OA{Miqmsupno͝æ~no /*.>v}nooV1$&}#}}#7- Yz;zdKAgEohd~> m3AjfjK_l$A5%gzUEl/ wvU$4B-}i~PqEqnj va.-}i~Pqii~>n wq(~9y1U;~}P"A!x<1 #t EoG)'sA '_I$$M'UiiA]Es87dב-7ׅ}ki>H!S{dS-g<Y}i`ir/v_$KYH(N\(~msUko!7%n&w}E_{nvE#_}nim 'sPAk_'Q+  'vPAk_'!VU}EEn~F5A  |'O$G'UibiA]Es5]B7i-7}_iN3QSqx-Pp-5d<Y#}i`i{y<8wCz}<-IL>Me'#(ww7sUko!Qj24E;v}i`fZnACf iEs5_77-7o5 iA-_l-bjw4=K5}]i5< zx~}+]  Wi}ioU!KyZ Yiy}in j#?jU{m#xn}#?L}:m#}%~%S %se\"}8 _`B~~<&Ai͛?#'[i7} ~xi͛A~As"A i- ~2iKM"3P)"U8{63~Zn>A?A?AA?As.5#X%Zb<||`n(v rhz!^dFf( tijx2#\pz(l( v24~Bz?0w!$isRDkNik&(QUC:~U>Az!c (i__'~/{0~ vA}A}AP~Za}EyPgi_7U_UU_UU_Uzd7sw wXdKwvwO}}}w_U7U7U7c)UU\_U7uZE#-zZC__U~Z";AA-sA]sAsqvoχtxns~n Ou w2,BtxdE~d8|,+ YIKINSKSOCU-7s5__Lng|nRVK#")}ққ))~((~({Z8>s_7i+9AU?A+C|E?A_.=<ErU Enzs~PwQ*zv6%_77+9A_+u|w_.WrU Ed:A~wQ*}p:mtis]s?Es]A+u6C$cK.Q}ZE-k_'S_U7A+Es}n!A$~9m277A7"!ssw .B-cAùuz i.!!pxn._.)b1.7s2 1)tZ{2EfnO !-`Hkcws}E y_w(}ͼiYF|}n57swPi?7tiK+D7-7_L$.AknUz?xnpi'BTEALA0A0s_+ s]eCŢ5~s4m'5s׵as?iu|< $!KAKBX+i;Dm4.nXZ7E0<03}$i͛DE48W"E-<-0}$PhZ(+177+r yw|Zwj8E3CiZEn*~EmPV`A1s5A?A& 4BcsipAw~dv㔈4wA-9&xEh(>}*vC{,㔈4wA-9.xEhx>}*v{,㔈4wK-9&xEh(>}*vC{,㔈4wK-9.xEhx>}*v{, -_8it_BAtpx#\}7A+9s-k_${E5-unU Eg *g8 OP-7K{ -_@it_BAtpx#\}7A+9s-k_${E=-unU Eg *g@ O-?K{m5tiצ]s7EABcKb-r_'Z_U7A+sy#7dXnn.sB>Bi9Eåm`D#egzdg?~<xk()(}ynA Dnggt#i}Ap!Ui-}n-ś  ;m_z E{dE{<Eszn Yim|<EA|As[oǛ{1Vb<{<1t<nkoͭA}vD1DD}|E!A%Uun%]As]A-xn m77k8Y487yL_A77EB757}}7i}(.s7gAAujV!~sAs]A>A0A+Av-/Asi:}~nvUA*8vrntU_8>wwn2YU58\vA#}"  #0}!lY}+7iRO{jP.cm  c7Usv:7}-8> iY__ynx-ÑnjsBYw7+EAiv79378x pxqF<7E YwН7|<|qmn8͞`<mK`sAiʄp{Po|6iUUQi~G Bp iU}Ai;-S_.m-UEKA>ifw<;- ~t1u*iLst/n(wmPu-kEĺ1q#q$p$p%o%o&t-BbM!C9BxcB-tYB o]u}(h(]{iiU_C7U-a'i# ymvPrP }-s57__U_7p~P>jU}a'c7k}}}5pw<A~7!mc#U|nvi}- 7AUnikKtiy4}#gU____c,s#Yis{m&xEjw}}i4543vu Y?s7?Cin`#z|df<~ksIvOKU}t|FymiE#(AcjlB#VUmBm1i AEXii-WP2Yi{niPm?=?|<{ijnA|niUk7BЀmK#dniUU&m&n2EAFi}n$#U}_uiA_Rّ--MK7:~}YiKmmDmB;1pDUQE}}Lzi E5554:}b< Yms{nP?M<?mדEwnss!5s}jX'"8K*U=K$EisFr<~<E|<+E~w2]|(ůiWC} YBEjl/ۀCp?v?rdg~<=<}i=?=pPu!i}Bû}g?{P}E}dE~?<Aja)ѹ-K7As4QEPQןU4?|~K|P"oAU____U4k.#5f&'Kn͛ii.#ka~#'|Ymk(t1'#W!iic_{QY}Pwd!w_Aki+V'x(wsi-ii+$#5$_+$#5&unk?+77V77-A87A8-A97Bi;na~(S+'h(57-WA8-77A8-A97Bi;na~(S+'h(#~i}(S'(S'~tsgnmhy?i1k-A7!mi|g$}e2I-siii}1{ 19-#9cKCed!1XZ'1_L-Ev`m9Z93%EM980~|ni_UAAiwܵ ms!u1$$twXD%wnixbr(us'VAj1.m*U.&}E9p?dqSy*EN%p?{vy?isioim2b9slliרxPsiy< 1ytP3wAidzlib}X#W}nn~6i;UlikUb(-j&#z(%-rY"wvA4}{>% -k7__Mz(Ewd ' O}fc/;R~dsPPws*4bOwnt5wkESzPg_P(iͨzW`cp?x<|]=o%}D2sm'x<mEj-i;_LP37kn<7){<UiA]--_uA117a_jASE|<t'pP(&6Aiu7og-l}-#gvFi[3> ErP-B}m-mi-mzni}(&yț*EnP-Cl_2-mi-mxni}(&yț*ElP_gEV7igE`A`A`tnee>asgni pA$skp*skp*jǜi -_C'm#z|i}#ydk-sososi~cK aLK?%! sK䛼Kxwiqi;]y2]|2]z'wjU7 i~P i7i| iii>.p'~xAA_7}Bw0j}_M lv3ynx$sAvAAAKAwAKAC7U.| csA<-0&#$$%vP 'Uis{UU#|nh&w}2ErnCU_#iCP0nuSyP jA wmii+ulu<c~<]<!K!,AAi_vijnwvPP$ii%wAA"Eviw?e`Pi7}-#7K7F EK(5'#ù!e<EtK_i_xqBwjv7_K7__t{=7!KK7 ѓ `#5_kgi0iK_U77}u2wy<Kqnki.'|yPSRu)n~PA1tBHi0E7#5i7Knle~ZEgP$ BU!AˉKAPAA?A?7ln 5BzC-}i}nw;iz? '#t<'#7c7ka__쑇_U EisE7}!Eiy E|PunzZ~<~non#sͻ#ino#2E7~<EŶ}7EjK#mvn!#~d mus5AIYsgA_l-2ƩmU~2A_lYltiriuZiy]3s? ij7sivnSj}bXqiK~l~(sAmlKFE}-i7|s~2jssuU*sU*iK}Q E|KsVUjP'2i7K}Y}K}R&}P|<<gp5뻹} li|n iinAR is#]}yn ms#]iun-"eD6s}7m)uPisi|n t-yn{ sŢSAUACj-i6Ui}EzPAA-bWWCS}c~aA1"%c~lB|'U.3cl'U+~<&Ok_!'_znixs<E]P,i?AU/KgiS78$vP%i+u giV1uKc2qwPion 'RyP{Pi+'gi}m{Ai}_2q}P iun'P{PSBi+uAqV4A|&$5K+mj%-t21,}vn;Bh'yPhP,SA5AA$KpQwNi~n'%?okz'!?!iybkEi~n{<Y<i}-Dכivn i}i}iyn)y_,&~RQ*0| ăCA|nYA?Eyn1i7X}}}#Kfkm'~1}a0AUU-.lKx E~P;sUhn[PC7|'yn sC7uinnpS UUnC__}}iKl m1YY+{<-#emC77}___w)ʹ)) s{B7ins5Au}b}] 5AwAuȡ7}iCp P(ftzZi89vvoA\A\ Aqn85B4BosA;-vt'iX-M|vFUt(vsA5E-My<'Oaz}mU_UeiUip,|i:_._cCi{dc͇!7sw'EK.i33mn'm<!7v$} Ef<;}Pau-[A?A5AUoc͛stWuD}n j_#}wj_#} VoSiE}n*{ m_}E-~:orx3wiAq!1BA|dAiIA5A{779t484848484848* iis-U Ym:|wqhs5-H=A_jA79C|<'kpl9i|< ;uy<'k__57KAC9?z_B:79EwF ')-_E<;-8_Ust_U_-ƛ8_;s-0A#A7#K+0Ķ2~.{ii,A7A7A7A7A7A7A+cwsι_i77 ;ChmA'~QRv(.YAAt:AAtiBAi7$OrLA#gVwi!~onK t< wwx ESSwUOgp<>$mB*cB*ci_C#cis~dA(E~{ 'm7 l_iii78//Kq~nyp5z<'ёjU;wh(Tx}&x|қw~ Ei7ȑ7wiiUs5AmIA5AitAU UWc77__xn|is_s&}isjAnEC}tns}n<>>'iio'&n?d~drsUf<u<#E}w$=,Ǟimősm/z&_ii~niBU?Kp*s-A|n~PA9ACgi6sPA~nwSyP A}pA}pB>##py!ckIBs?!'#A\/2OiCUB?+-+s-Tn$5'#-4-4A5M7K74jFcb}n}>}nAIKqKpisO|'~PPsDin*!mEP_O7}7}׬R}PP wsips5ApjmniIAqAp0~imtCw<c}ƯABOXn}wv$H!og|()(r(dApicxUi%i؛{&ii}Ui~n!5A?A?A?A5AspbAA?An#j.A_S7i~nRmUi#'7C.p(SVrdE0i{x]EAVX}d8E~P ; m ۧͷCA>z~[<&EUU[grZwi!EUYnRvEznEiwU~Pin(wEny'~i(wiBipwiqilNi#t_--_~Rq EUiE&Oٹwk~(~z~~q~U>u.iAiji%A&E '-_~tSyd'Oi7iv{?mnlmUABŒ_hn(7Uwyn'y;2S͛5A7--iii7it}ijű'szPכ--}r))gB mf2'&K}c'lsi'v))r(z(iuiUigYwOi~{{nogtP|-xn2ooijA-unA=Eu(iUDͥA|)ijvUiAg}d}(iA}U~Ys5Kv~<E~n~?p}<E&imiili` '4E<i E~sV'; EK٧iwwdE}cSu<u 's4\si~ҹv<-}#hnsUo/u<4=Am<8}qdsi{ZP?{ m:j%3D7__Xk?%_xP Eu2 Ei7AYUi_{{dɂ}}<(;iiif iii_0ig~ǛU_U-__8HEAY wnzOAsnA! Ǜc}K}q1_UegPD_~cUowg?s x7U(9k5A}rAijJA{(#j{n 1i1#i|fiij~1XAAnsxiqg}<;}҇~Z iSil_#OKm& c7_~K5CUBXA}~ͼ`~?So<k<|w.-fA(y(x0#i'y_#_#,~jqn}nU_Z"iv~wK1}'ipp/_k~#'wnE7_5%3i%!t73___UF3|<*/`K##A#A7K5]ig<3q<w2g-77AAAB}n}op-#hg-A77AAB}n}opp0hNo_A8{xJJJJJJJJJJJJJJJJJJJJEnn89V{EEn7}}zPqwM(EwP9d`8888888888888889)8888_`88_` EElP7u:m`>`>XmiIk K'0v~Z)1KNE'~5 '# C|}wuPyEiz{zP6=Y%1~<҅{F}sstrn^.VPyP;xiplC.!O|'b-jC%fpEknq|'o?XU5UIkznV#-*Ni7i9#sld}kU-U3rx())~S 5AbU7} $kEoP!w{d;U`_psPD}#-82_xnPd'W-w|_mizn~Pi## U'QwD}udw7z'%-ET%~2V<}C.ztPiz()~i}-##*}mbnw_zE͔wKwd`<'wuP2ye)Bbwc9?+jb(/`_ii#0UA2t1$~}Eq7k(+7lXA+cm qcii "s<_XwVn7_Y5rq<zE~grt}]s{Aiyno w}773mynuyCinu74l}n BK_'NPA'PA'uV_m<."U;v|'+ EKK˕UM]bwp(L#+#`'͇ #őc9jm`%Y&_UU`_lc_^d%cU-bb_[}5s|PgdiHt<4];[()}vhu(X͇#H'o25~(#-tA+E͵o mcnUZYvё/miwsn{n|nn)w=BA-ͥ}V_?ifnk?v6C{d'>(%}"}PSwPz(s+s.bs1s1A mwso3w<~2s=zniR#ws B>BA-UmK7U9y5+_I-μLIA8#`~;vd 9?x<7_ EsP+C-7rn 'O=}A%~n-P&|<2]w<&~P!@-+~9i:U-/[~f}P|P(_sjYxQ~?j&om}~)AsUC*#s0?B! UAۛ~ng#SnP7Un#+.*7It1 m7Ai_%:?o ci<uA7oEiOL}StQwPPSS{P|smsC'4MAA:_948Y!9;d;PP(P{PxP57_\7Me1'|(! 'F9'b_\}7yZEx'h(wxqPtP~Ahs5AUs5A4B8P4B5VP4B9-'L{nyP s5A?A{A?_?_W >7W*7Uk(~< d&Ns;}4=/<==P}P|PQ8'~F}UiO| mi)*Cys17s|(E7qzDl#Aᛯnt~pvins57q5gBin8s+`oUUf}j-i7A_L1lif yvSRSPyPiiïa-siAUj1%tP E ~EBVPiU!EUN{SRSkP;iiiU}URi~4zi'|FiMs-3$~nQPR i'hF-`k;imk-6$vxx xPSPS|PQ)AE~xAjOj:mEPs+/~}t4\EAE&}}W#CjAy{PiAujCUכ' ~<jCƱaAGiO}_gpiA:))(DiL7i 17i z7i dV6_'57(i(~"nyU_^|FKe~E_q'%*g{K}nqu"B$i9c5|< EqPAI75{$iAq8Hi-7eQǹ}fDZ(&+_si}7U#5}͛si~mPAViW~E}~P sqAm!_`5c2$K)j 0K*a!A{'*P!~~17W-p<2+ c<s1>YK7-zkP&kt{CssiVA~ZE~P~P#iCKU`SBv~(A#UG~nwAg7pA8plk2EsUi{nwA+oApApApCsAo( isisUE )ApAp}t*B~ni,oU@SAP ApAinAin9o!i-oUAAp׹Rsnk2EsUi{nwA+pi#p+!Fxiln`A7jiÇ!x_Ab-.tExCt'"%  ;_c}8#5}-E5kZ1b~1iI~1_'-}"_M&'|AA=}RS(/c~'~1uw2~$:7_w<}"a 1 OKE}<'01tO^F}z/s5x19&|(7}{=~}A{P iC2XUOiszEKfmili~A-AUB͏QidEir7E|n1y-k7_|u=~[<B1K{np ifswKvnwxPGwiQAk<1'rn~nsnEwTn EEfnwr Eym0Aki}i'dAvd EmE~nLKi'kjy#rA1mLJ'w '%wAB3~n?A${p&pi_~$UEzn'p Û77ift({p0qS(il2UM|'W}ͣg~P$7p7p*|iip-|ppc.8~0i[__i}R_!17C+*]Vi{RRRsp*p0|np_Wf?!mpipA+ c("A+c$Xqxn!jtnKppsp6hïVAm}nå͛xd >A+F|ZPqSz9L"ODm}M"Nk--77ADU_77-9###-OK#K#K#UXA#LKVKVKVKVKVKVKXKX-#A#$KXKVKVKWU#$---$UXU-$-U%U-K79'UDUK#XUiW.8B7-AAAACU#AB};AA-77_87-#Bi7:C7-#77iAC7.i-777U___7YCi77A779i7--#U#i7--#U#Bi87-L--$U-%U'U7779i87U-/--&i7Ui7_--# Ei7-i#A%7i#A&A7A8i9777A7:-i7A# 7UY7AAAAthh8#-#EAA7AA-Ei77A7_87-#AAB1i7#7-i-#7-%-Ai;77A7-A--&A7Ai.777iA--#A-7Y i7#7-$_U#8i;-;-77 ;Ui779AA--.A7AEA0i--77;i7-i77:7#U%Ei'iYi7##-##`A7AU#-$.#7-AAA77AAAAAAAAA7-AKAA7_B7##7#7KUKC-$77&A-UB7AAA7K-UK&A77&_C7M79AAAAAC7777___AAB7AKL7778AAABAAABAAAB7777777777_______AAAAAACAKKKUUUWAAAAAAACKKKKKKKLKKKKKKKLKKKKKKKMAAAAAAAA777777_______AAAAAACUUUUUUUWAAAAAAAC-:KKKKKKKM7AAAKKKKAAAAKKKLK-MKKKKKKKKKKKKKKKKKKKKKKKLAAAAAAAAAKKiiiKAKUiiiK"UU-KA$;AA-#AABAAA-#7ABAAA-#AABA7K7KU&7K77AAAAAA77777777777K#-7#77AA7777777K#--07#--777-#-AA--7$_.7%-%A07#-$A/-.-/AAAAA Y-K--77L7#UKB7#7777K#777%77$77$797----_-7#---$AA-&---7-7_-_-%7#-$A./7#-$A..---#7-7_------A-7777KLAA77KLAA77KLAA77KL7777KE77AA77A#77A$7777#&-D-D-BAAA-AAAAA-A-K7L7#7B--K7-#B7#77B--#7-#B7-K7-#B7#-B##K7-#B7#A-7.###7-#B7#K7-#B7#7B--K7-#B7#A-A8--#7-#BA-K7-#B7#AB777UK7-#B7#A-KB777U#7-#BK77UK7-#D7#AB777K#7-#$A-KB777K#7-#$K77K#7-$.U-$UK;K7AKAAU1N-#--#U-#8.--0AA7AAA7AA77B7$.7LA&888-$8-&-777-%U----%77$777-###-K77##--#-UKAAB77A#7-#-77A#-U7-----uAA-#AAABAcAA7AA77B7$..7LA&8888.8-%7&U-U-0778-7.--%77&#U-9888-9-UU-U-/L88/7-UKAAB7777-7-&-&-77807U-K-.-7----/# BuA-aA-aA-aA-OmZ-7778-7778-7778-7778-7778-7778-7778-7778-7778-7778-7778-7778-7778-7778-7778-7778-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8-7-8P|AA0-K7K7K7KK7K77K7KUKUKUO7AAAAAAA________UUU#C:U$7AAAUUU#KKKK-7-77-.7AAAUUU'-KKKK-#7-A#7--A7K7AKK7AAAKKKK7AAAAAAAKKKKKKKKQ~AAE-K7K7K7KK7K7K7KUKUMUO-'UMU%##A%-#-77-E---'---7877.77--C#7#77###----#7#7---A-A7K7K7AKK7AKK7AAAKKKK7AAAKKKK7AAAAAAAUUUUUUUU7AAAAAAAUUUUUUUUU7AAAAAAAiiiiiiii7AAAAAAAiiiiiiiiUUUKE-..MUO7.AAV78AL-.KL.KM8-/7AAA-7AAA--$--A-AAAKKKKK7KAAKKKKK7-77----7VUY7AAAU7AAAUU%-A-AAAKKKKK/7A-AK7-KK7KK..A-.U#VAAAAUAAAAUU$A-7AAKKKKKVUUAAAAUAAAAUU#-A-7AAKKKKKR|FA7U>USId7A#}w7A#}uA77A##A77A##A7u7A7A##A7AA7A##A7A#-7AA#7AAA#AA7A$ v7-##7777'7---A-U-ABv77-##7777#777'7---A--U-E-#-U1-7s-7AU-7v-##A#7#79UA77AAA##}7AAAAA##}9A7AA-7#-7A-AAU#A7A#/AA7AAAA#AWAAA##}%AAU##}#7A#79###--A#wAAAU--U##-7#7.7B7-i7A#AU##---U##-7#71A77AAAA#A##7A#7EA#7E7A#7777A#7l7A#7VA#A7AAAAA##-7#7###A##-7v7A7AAAA##-7:7UUA#{Phxh(hh(XHhh8HHh(hXhhhhhhhHHHHHHHHHhxHHhhXxhXXh(XHhhHHhhHHhxhhhXhXXXX(XXXXXHhhh(HHhhHHHHHHHHHHHHhT)"QUO V/cV7:wc swivEs#.U%"7$%U{SxiKq%Rip>w[!TA~I< %;|ZW}jU%n'iAAi9AÑv'S8>Z;`{%'A%~'} '%_n%AבcC_1~'{<;Acd],EEa|=}d=u<1nFSi'7;q7p&tYk'g{X~i&ïp&!~Y0wi'AD'%~n<Axp%A'G{s2&|EqSxPAU4&pz1SP|Pßy $ù$K,$-}3Az{ RqPq#)~7yw{YJ}P|PiplZ~Ao[|ZA&`&&|ni'}}'`~'%|n~i'%'|nzFi'-'7%wnzxVH?@V?w@\;~; ?7?%_ 'xKy ']%=!sX>*EtP}\H,,,,,+]'| u]\|}i^KI%%u}ss2'}<v_!-?]yZESSRSRSRuV?5%!??x E? 'Mr%Kii&(?:--dE@}3}<}<>wPQwPS|P_h*0,}'ww~(+= Or|PSP>lE]|SRwP`9!_t'Boax_%[ 'bab/i&Y{PPcS:E=4%s4W_wY En EPSPQR}P|PtP4q%nqxfEU'^~#Ri;s|n;*sosn?-k'%wn w-%k%%yng-;%o6Ls%o!ict-%o}( q%o .Ap?+q%o #;q'}%AQ$ic8%};icJ%|;q'm%AQ-iS'K%oAQ-;%o$ic8%}-iS'K%oAQ -k%o!q%o u_Fa"zdc&{d_{kh AAAA---AK##iiAAAAiAAAAAAAAAK##iiAAAAiA!mAAA---AK##iiAAAii͹%V/MMMMF!;QB*=ב7N!}Eig%~<=+miEiO<9EM^/YL5JMUE)}MX'{2xE=x<8Ǒ<F9E'MMMMEQB)&Y=MX'E'9A>EAE<P~PRSPSSSSSSSSSSSPSQQQPRSQRSRSPPSSRS~SRSR;!'i-n;aA/o)E}PPwP-;#[;ͅ%#M('&)}?=E|P|PP/CAAA&THiMf&NiMp'))}<=EvP(0_'{M+< ?ik%'(aUR'sM&YEs!'hr*&Xi&3!'hg%_r'!%u)#)*}*&y<EwE<zEz ёPu EPsE)nEn< YqEPlE!%Pg)j<mPeEM|Ass]%r~C=mPcE!U%P\ E&!U%PU'EX+ёPS-EPQ/EMO1MM3EK5EBCBE;EBCB<<d|d?>E`PRPR`PQ~PQiPuP%K,i-is'NzCVBx OvPmiA-is '3t}~A$UA$AqFYpP"m?_Ci}i' '%uA 'AP'}%4N&--~'_A2Y}<y}|wd9w}% ~<;EPS|PwPSwPuPPQ|PjvÇB-%(sZwҫAq5k~l}Cإji%'N}#y|Wg|<vP-bAp/ig%R5<|Yt EtPl9_i7YiUUv{'}vn!A7}R&n!U~S~U~U~i$/3#RI9Av$'}yn&Wm{(<~PIP0$]k~P'q2--'L!wAmvÉ#% [L-_~'B~'U+K#'~ isi_p;n'3-~]2&wP|PuP~PSoPwJ'tȌ |PSS}P}wn~Q $7}'<~P}&s~}&~!}d:SR>U;B$3BasxuC..v..CI-A"$!AB%u '=BC I-A""B%2U7%71v 'q q?~nC %m0@ #%P~!'=At/)<~cRQSsPQRQSyPPXPkP~PP>MX%}=]%|%<>u8O2^[c,N-.'P%^[^[^[N[`cMQ&jikililmc,_vDh2>c2l<QSSiPSSSSSSSbPSSpPo~`}u{ '~%4G|E}#D)I:uP;v!v? "wif,,,1WWWWWW]]|mxn+~o$ZhboOn%m'i'N{}}xXXp}'q 7_iK{| 7_:7:yx{7iK]~ -iii'7_i͡'}qY{yi{~Fl(-iii'7l%}%[!zYxi{ s"wk4#U%2w4#A%o!4#A%o!r~"$&*'y2 At͛~nAtn8"0l0l#"w0l0mA/si7ss~n'*zs%ݹtEs{%.2~Fmz#;+"~'<+{%7ib9 '+%~D <xdsP<{%g%+~<}/XCcPw0HxO4 s_U#z5#x2#~xO|nyK(%GIzuy{)(/;)qV;,"B'A<|<tP0)qÅ%UI&<&~=<>@-->I%0koq$w|h}%%&n  !unÉ}~P6O(wU`'~w&7 ){}Es(y-U9?%e ;Al?!'i7*yEl~n ''&Ozl?f%#p&k'F%q=p-usow-sow-uso~~nJ''#&~ mii'/+'UN%~1712X'12mij{&bZF ~gP/>r</>xsA7A3A0_!_s"&}FESPSzG5ejvA&%wA='~n!U=U\i|x '{%{%{%w&K0'i|<͹>wRPPR~PqPRPR|PzPRzPHk7&'AAiiii_}As|'A# &U'=]&{y<'$5%i'-Ai[!!'oZ'&%_xnf B|&|q>gy<_wRPPR~PqPpPxPR{P+ik-i'K7%=-'i`<.iDiAig'K|Y'Uig'-|Y _-K'%D/%<'%={usA*p5178%x'(#78%Utr>>=<">A p5+A8%x'(#A8%UtrD>=<3;X&|/;iÅ&jAKm''tiAR'iKCiKB.iK<`<PE~PE#iKEUsE#~l<TK>&}dzEzd'#x# #d<-E}PpP}PoP?Å'Kt'_A''iH7:5!}%s}]%~<|n}A' BvE{{~xRSSuP(<f:%y~x2#-{%-{l,j#BA}y'vu}r E$mE5hd=ERSPRSPSRRsP"߻1{M%oi/i-KAnY_97n|P|Piki}__:'usU~U'{Y%'d}vOzPQ{PqPs%#1:S&/i7-'zn; $'-'{nY $'-%`EwPPzPS)j 'wn:|':v(q9-ל0'|'QP wiq9'pAq9͛~nۛq;KsK#p3synR ii*/7%~A}P}n' ''#iZ'E'%o}Ey~<|<~<+*#HU'B6'n8{}&&&&&ï&-~<<<<<w i'u#)'4%-miB'_۹8&{s<x<'1}sPEPPRoP_#7 s ;s'#'/xPvP1.qSR"-ѹKkiͯ&_i'iKZ;U0UtכKBmUs-yYq 'EX%~]o<~Z=gPx{PwPSj|͹I!%-G'8'x2 EP}P{G"-}-i}-nYs4Ut:M%-t'34&34'!KtWͯ&$ K/bx w07UUsABBzykPm<i<OlPSSVPQ~PvPئ}RUu~΢'y{/->ס'"<*'(E#~(Et('s`V ,.X}y"'l_~~_EZ}*',LxqE~_%}DU~[jx$"py&sh-U }'r_~~_EZ'}f'kE_%{FE~U~_Exp>>i}~׭'%͑#%?;#%z<~<|d;f~}x?$ D'&7ii!'A_%A_': 'KK%Kz'KK{n<'}<EPp<)EQREP<!'Ag%&!iͥp&A&{ '(g%A'&2'/})&#~-{)<=){˃))) EzP{P2<!'A&'!sAq%!c&d'/z){<}-y)EvP{P<!'"!%/)0})>i~i~|x/0%X?/0%hq'__]%\%Vj''-Yqw"X''|zc:?'txE=E$/0u)YSS~PQ*aKK ]#>_#!,/0)ѹ,/)5''(bADExEx< '$PEt-)C~##Z-yE?##Z-t Ef<w|EEv Ev:D%1Jd{u{&- y&"iUsP'gU{}z'Vqzz{z2 Ezzg<# sxiA 1lA/P%iUts_ppU8s&p} /+%%*< ````b>yKuA A%'xy?-H )&/zEr2<2iP3 _sp&(|<L>ͯT& 9i_pxlOuhOy<{zDqxQU}wDLEw<ͯvKu6sa39:"z#yP8W9~2 8s_&7mP}P usUsus(U/s+s+~Ys1s1s+u rEnUHٯUPٯUPٯUsZUwusUusUusUusUus#UsZUw$i%X $i%D~PiusQsWs~P'^{9wP}# BP)Ac}oX',m!7@>E(}xP|PP2{׾'0_?Ri%i?RMKK'%!m%!m,A!ZCh?z<t<{m|ExEt EpElE`<Ey2w2U{x}_24%-??&D<>?E! !'%>?E-%M)z)- C?d)xERP|PRSQQR_cV) Ii%}'o﯑%ioj% ''bHyG}<hv<Ek2UP2UA1%oK*kCPiu ms9q'fn_9~'t_9v!}.jAEdPgi~isusssn'vn'Agw}Er E$onEr|$-u_%S3$b7WPic%pX{~s$,U$,U A1>CF)u'w-kJ35hE}E~QQU"is.s'~no'#~'{- .'.7'B '}#qw<~2Ass'| >-Ag'-U5%(\@C'q&}k~Hs<'d ;}\%akxA!DwQU~AsUs('| >_}l7op^#'~yFqF)sss;V}s#sszEu547/;#H&$'\@}'Js~<> |-sq%&uwF ;Svz EsA1-ssB ;\{sBt_twZ Es;#dͭ'Xů7a-usxHv<$>#~i%,iKwa-'s}{'Fq~EPRhP5wÉds-s)tUq%s;Vlsn2Ehi,qUi,qUAqT'r2''t =I{<Ei)&_UUs~P 6'S'FqUV9Q;S%P'w2Oҹ_UUs~PxE_UU~Pn_Rd*Em3sQsR!T+EyFj3sQsR!^!E^F?-#'p}ss~Es|Q -ͥ 'pso w-ͥ'psdo-_!w-_.-_.----w----w---w;-w;-ssss'V} ;",'-C~xw;%$'~A%!lx9A9 -!sss} 6e%+PA3 gUEyy`7AAAg<Hx^^^^^^^^(^^((88^^^^^^^^^^^^^^^^(^^((88^^^^^^^^^^^^^^^^(^^^^^^^^^^XX^^^^^^^^(^^((88^^^^^^^^x^^^^^^^^(^^((88^^^^^^^^x^^^^^^^^(^^((88^^^^^^^^x^^^^^^^^(^^((88^^^^^^^^x^^^^^^^^(^^((88^^^^^^^^x^^^^^^^^(^^((88^^^^^^^^x^^^^^^^^(^^((88^^^^^^^^^^^^^^^^^((88^^^^^^^^^^^^^^^^(^^((88^^^^^^^^^^^^^^^^(^^((88^^^^^^^^^^^^^^^^(^^((88^^^^^^^^X(xx1jAApA7Y'A?&DqF2<> ERRrPit'}'}n? it}'}n? A}{'py!ii},'6}"^}|x'!2Y(};}~Ûwrr2{<*mPRPPPPRRRnP6U&,'iÛ')o2'0zOz ! 'z'ÛwvzEz%qD#yxE{n?~ ]%0>~E}P]%^'X<> &='AÜ) =ni}}g'B_>!}dD#}E}'`"'>/z; }Gus~<&l=>wdn?}dE}PRPQxPSPiPSPPSPRS}P}55ie%SoAU}'uK7SyP&5i#99ss~;{sssz $-/tn;!#*w!t-tn-tn- -8P(4B0 tTAq%<1}nbPP ic~noK#d'{%m/|E#z<A_i>'nj#!i)ni;ijF'uni-tO#h'i-z EirFi-|Ei-xiIpEqM- C?;i-vqii#~'ni#|%i#Y#zj9i#S kå2}1{'xn'#y#+ii%x 'niv ;#t'i|Ai E'i%zqi;e '`x%Z'w Ex%,'nEiXcY#aEi[iAi;gq#ii"'in'no'#lmfipKl'{ E='y ''o}<L#}n!p;18Ki2'kn<'w_:(_;G'oF#_:LK#_:L{~2x E7k, %}xm~'#2'MF#~*tS/EySP#@`| %bUͭ '4V$E\Fh#lS#-|c#fC#pB##+z= #r_#d>#v:#ht#n^#b\ #tA#jF#xo}i'j#2otUͭ '1y '~i'#2'sAw# ~ ENu ENs sVqEsVotmEtkc-1+:'|x% Eq0}<'e:@%sEwEE@%sEnnvd<< 'uUr ErFm<z<_~E_{C_Fpw<5==EyPqPfP~PlPvPkPvPP{PA<M}dufEy x%s'|xXa' ||5Co:'vdi}B+&~nis7ׇ'{nB%,xnYn}d ii-unj"&"'n>2.:.F'.#Ws7WZ'7ZWy'}yW>~<m<"i1.(o E~<=}<yW><q<>iA tIi*{Y*'/)!& |'znrAK0oi i!Tnih}i}7]&~nis7ׇ'{n7%!xnYn}Fii-syn i?%A? 'n ?2-:.F'-"Is7IL' 7LI} '}~}zW>>r<!i# tE}<><}zW><{<>;iA tHi*}Y*'-!& ~'|nt~XiLeYi!fi!fii!fi!fiխ5 !^yi!Ni9>Oiv/@Us*yE~PP  wpW8 UH':aii2!'}{<>'>EXpPHsAqp;&-V# 'v3#~('#|($#z([}<#(:#x($yvmSSRP iMjn+ApmQ'C7iXp1BiYp2CiYp2CifpBS iYp 2C2'C%G6Aw5M?x/A>A'n!Y:A%*i-G '*;LA2Ai%e@!'%M9Aq;~?'ǝBo E~BACx<}<(yG|2,En}PRSPPSPQPSP!})7B}'is|'s~ 'rn sA1j[qRsYEiq-fhF\|A!#x'^'c*}%!CD<^<>|f%5xEyxP(x.VP9#c7&&.s&7C''"zͷ%71a7'rz'0A6'}%p Y3<=< ESQSuP%B ;-ƹv 'qlP%s3g%~P -%mp4gDSzP;ι׭%6~'ץ% z3FA'K-~P}P}{'yw&i7sYiI5%7K7_%ii?ie8}'?%-tm2Y{nEU2-'3_sW{59(-2YNx2ERSPRwP{P~PQQRwP~PK_i%'{Ps%);6%׬d'FA&7-׬P~P);%J}W٬I2UP%p ~R' X'EX ;]k/*R*. >%%xPRS|K_i%'{ YK__%'{c%i7$_0~YxPs&#isLiB5%3&Ky2 '&A_?9K%?2by2wSSPRvP~P#-gi#LU8#xK;c5l2i*s'6Q_<}Y}< ESQSq:2}is) ;5,?CFu<xESSSPPPPP_81!"<'*~&;PSR^a!)~-?Y~R4yܑ{'yw&i7sLiB5%3&K7E%ii7iK8}'?9-\tm2Y{EU2-'&_7o59%q2Ybx2wRSPRwP{P~PQQRwP~Ps49-#RhiU|w2 -AfvPA7sWx9&|nkYi~iEDi#i**'}n!iKiE'n!FA7Û77(%vi~i~`;i-#x "`-  '|}K-+%&!Q>1e>?$9Sf'$} 6s_$w=tA'Ow(X< 't~nvP#Ç4Û9@&&2%%#u'C~g=0^,U/#7&ik?!'5<d*"!a?Y7y$J3x mkv)wi2i1".#|ny'&l3%_&_!E =vd{>!Z/ -%|7^U x w'A%+>(vF=&iFŹ'9FFn~<~<ï&!!&Q~P|&?!K'_?'#i!%l~F}'>=~<g%l<ES~PRuPV*`t&zw]?'p!3M"5Ji'&Y{ ccfObsoii_|'jY%_x''}K}5i=@r ErU_ E_tC_KgD'}SqPP$27S=x<Y{8~27!&MU}E<#E~.FR|P ͑f5 'xf'{z2E& v<ZAKAi'={{EjZc{2t/0 mB)%&'3yfz,- B&-{d ESyPR~Pi}DK# ;"}'?xYESSxP/-i%}!i%Ļ}~'| '#QiWo0sS:sY<U8W(i/.Wn*wE7}U~=}7 {6} '}z~>;y6~"iAKtKAzniKtK_zn6.'75'BAUAw3'q|2epw?>'|! DC~< 5w'C!&C!&C!&q?'_hic*wn{!%) j%CM}<'C6}<'%%s4&Gewdw<=?&+%?%&AM&y'&s&z'&s&z'?%?>F=?>d==?2/ '%pPi#'!Aͭ%o!Ul&_cyEﳪ;}fu<xA}pEpN %A}p yu}Hz2n&.?e i<_}|'z'|!D{zA6EA6xhZ+&}/a$$o+z2'%xF Dv Em~A|E͹vZ8} yw|w F=::G9=FFFF=FF=F=F=?Y y{!!!!!!!!!!!!!!~~!!sxx͇͇s ;s'{nss_7KK'ׇq'o2YsP!$$~o&_4_4}A4%i3 ')!w}p____lY_9_9_9f_9_9bm_9}-"[%}}W)Y}}A4%i!cE}i{cB*ERRPhP4$}sY}sK% Qć{}{s$s%}!7_zP }}sp's!R }}sp'}s!R N}sR}"&vp'|Z6?nC$q~nEE{2 RR{PQR~$"Oïs}'( isq#dG5%}F'5]f'(U*V8W8mG5'tF|E&XY*Y8~;2}qZE}2'~2'293B4AIAI|n~PRSSRSSQPRS'_Fs-x PP~PS~PA}%=ժ=__]!&y A/pi J('&{'sÛN!7<0HlgEQS|PRRP}PSQ*Us%ĥy 'QV{~<<EwP#a.M<E&cyDSQP$.MA'E&iz|<EPSQP}RV;;"w'2 '|PPP&%En*!W/DkKG '~('UiUsirkipc 'NnE$b DA}}}}7$}7t E@nj>*E is1+4MxcVRV'[E$b DAot$}7v E@mnEiH|c;se%\!E@n#b CAs@q!7I!7ubr E@}!qEi0w 9eD@QzPPSRSQP~P{PmPR~PwPQcPRQPuP~PQpPg%'~K# Kt  'zZs|FE#.y>?;# 'Z!gkE}PSQzPRP K;}#w#%i'~Zs}(q3? ;I% t'}PRQ*FJl[&<'~Ot~, >'%X5_A_#})''['~Z%Yg}B%<;}'sE|n7#%E}%'i0E_i}>''%_@Z5E_ Yit<'i}<Oiz<Eiw}(EmExPSS|PPU(# ;-'0~6'7q{<'3<wn7#E;'i#i#i#i#Yi#i#@Bi}7B}'B0wKBiBrYׇ?aDEPSQ|PmPSR}PS'wQS n7UK{2;PPS -[! 'w[EDRy ER zXqk%<%5{2 n~ig%(A(' ''X#G!'`sG?3/&au Ea wȃ}uds'1t E5n2~<!R}PSzPS|PQ~PSwJ'}Q (-~'AMCQ18sE'18D8D_1`Q'1>}'JM5EJza}AJ-!8(,&"%(K0>~-~#8R-~#8R-_FF%n$!wD%~Q >sJJ~E!sJJ~E(o>_sL%s}'-L%nz E!sL%s}'-L%nz EJ%(b%;_iI'}n$!wi '/)?PSRPiù"iq$%V'4~PD*%P%PA4_qn_5%4AB_>'A'}%'~2E~oAD".%U͑z*Q͛7}>&O,$U,27lP{yPA#7Z'x8_;#'z_x'vPsm#_'} ';i_$ Y~n'm ESzPQsPP".%aW$Y%AX%-vy=E{QR &}}'f}Dxm}~E}}|E}}|z}|xE}v E}&|%lE?|t<Y}jE}}hE}fEf?~"_'%ty%'[` '}^!E^YOhE}cEt %4m~n#''PP~PzPqP0_'_~_#E}%oIv E~E}>&A'UEVQC n B'MC vnk+_S-E_Q/_O1E_M3_K5E_I9EI;m_C=E_A?}'%E E K'#_ 'Eu_O_~E}DD 'tE z}<FPY}{K!FE}%FwPS_P{PPjP".%is%n'iz'rnizx'i~x;#}͑%s<'}5kxEixxCixEi|x{n"iͭ%NU?!U&|> 'Ji<%NWnAR}x&#~ '#5{>Im`Xo;Zl'@GIH57t]!'UIH57''$I'8d=z'l||Z}<!z<d<k<>;yP{PuPů%WlQhȡCzP~s~hOixxh)W%PMV')W'^'!}|<!]~<[EQ}PRwP_æWy!:|gh~r&Et}{E~~}~<' }\<7E}6'}~<Otx< E_$?%}EA'i%W%#{<~?<_}E<}>u#}<W<.Y}6B#}E}6}B#}t<}6?#}A<EpRgP~PS[lPmFL~tPSSS|PK'~$_%e'i+U~Z'A%U&s{> _oUE_mE_k<E_i~P'E_vxPPS|PQ4#`h]:s !7}qq}'oZ}`uEq~}<}_q{E{#?m}'?%cE?o<[}qwEm<}$mzPRSvRQSPP5"K$9>%A?'-IUW&&9>'71O_f#E_%^7E_c<}}&'_g_o<y&''}A_}6P/E_x Y_t ErZE_}n~nz<>ElP|PStPuPR~P;-i$'78'l-/?r<--(z E-y?E-#Ax<1 E$'cP}7!7Eù;UI2:5lͅV9[''ZPSzPQPSsUQ͛7}>& OA#p8%|Ap!w#q%#pS*"_+1$w2wi.'yx;X|E9~E#|E~n Xj3|c-]!u}:CU>~?ESRP 'cCE$~,3oA?'}'-]!#E~A Bp2Cx<#%EKZ!S|PPQRSP{P}P=H'AS'G}F0X%$O 'Z|<X~P#W&S"Om}S~ w_}$vP##}QEM%q}PPSP}nO- >%e%~Fw7u'Z'CwNv$A ~SQ i>p=UKBt'HPRwAsHp. 's< ' >ERPRP sK`'fPRAd; '͇U ' >ERPRP ^}j}zn#g? AAiA sN_4kp|io$CU%}UfkQS^_ͭ%7}}#7_'!'U$*&'0__7*_>m2E }}n<<<E};?3cEpgnm};>0[#Eqw}W}A?%syk?m*!s,(U'M~'H0E|)'|E|<J<Y}A?%#s,(U'M~'H3E|*l|1}A?%kE}A?%3EERSQPRSR}P|PPRSR}P~P~PRQRSPRS~PRU~PyPS{PR}H(-͑0bKgSSwׯi777gSSSS_!-?]_SSۇ-iiiKKKKgSSSSSSSS͑0b7#gSSwׯi#77gSSSSa!-=]_SSۇUiiiKKK#gSSSSSSSS~R xxxxxx_iUP'Ap}dW,&}EY~59Ål0"=g> "2%߫my+w~P}P9c>9i'_?xY}E}< '_s< EPP|P>i9#+U?''z<E~PQQ>'i7\'i&A%7s ' m2Y~}< EuPzM+++,2,+|++(/ P!'|M!!!oiAA|n믯+~&|}})x:B~i-:>qPiu:Vxn I~n}P&:'? ~'A};|E w;%yZEop<m`":}'}{PRPQ~PvPQ3#:1*A9.5?&?| ;''g'3*:X+~pdu<,EB~lPQrPP6wAo{ Ǜm_~'n_#_ mi_|'כ~n~Z#_C? #2enRYEl~ %&'%{n!C%r$mj{} !m{FӾw~^#Ep^Yzx~%bEhn,E$q%|Q4Eoe 'z|PuPxPkPyPq{XXYU!&LK'K!'!uy'>m<==>EPRPRrPQ#!-_Q%C5E~nP #AX&_U}q%Lz'+H__9|njE3Ea<E}PwP~07i&:_A'ͯ&BK!_ 'x| '$?pd?|<}<|<EzPSPSuP~P/0uq%]U7p}ncSQS#KKW_mRSKL#K'}#}3}Ev'1}'3ᬬ=oȬERPzPRwP wVVÛùq}1Ñt$}'}x''{<'&~'Us&Uk'"-v'-':%}!q'-r'xYOYxw<eE&jEqbR9}#UgU.A7-%ox~'CQd=$88y<4o<>{<5<EtPrPWPvP~|F~}P#>i&o7Ri@q%b-puP-8r7Yn}P25-b'm7b|E8b!^u E!!#1mE#izPwPi}i'onsA~'#5S_Aùn? QvP}%w./-- miH-'}n}{zTcKST_!-?]]LSS_?7'-}'__# ;`_7_s'U%(&(<#Mi_s E';K9J_E*O7-UiYc)o@2EQNPP0T3'%%U'BG$v|ws0GF%$w#0Q)$>:}r2>k2+ERSwPRRRSvPQSS|P6iB%o~ Ap~+1(!}E|iJpitUS'|Y'FpzP}Pwitnq/K-iiiii[f&s'~|2 'QSSSSSSyPit qUUYI%n#~PzP&] &uZ&tiii}~0iq%}zV}<#'*9uiKdE wiq%}zVE}}dfE'_;}PR|PR}PRyPR}PR}P~PRRRQR|PR!DNOUUP`UUPU85LS=E..s-\cwn--A-f7%/K-iiiii[f&s'~|2 'QSSSSSSyPit_]%ss4zvi7å'sn9ss1xYs1#s.x<n<EPPPP~PvP'it_]%U_}n Au_}]%Un~ $ULdttVS8yn 'Ie}'s" '?'&}<}<f<* PsP$UIesw" '$yz)23-haue|Eqw"+:4+M'HH|=E~PPPSPPQR%Si<c1sz'ׯ,UzqE{ ERS~PRS~P~Pi__+R-BIl-eYw" '!.j/~\iBaidE w,[#E}PPSSSSSSzPPjP~P}PAHK8pRzI7UUVđU 'PlUAUA$qPEhP7CP#iWK%!s&>8'OLM-(}{z!pw}7͛zB'~$~ '8 ',1i%A(wxn(ze'Ew2xow$vEkn`<EPRP{PxPS}SQ|P}PPPR~PXSSlPSUv~b&{Wt EQPyP':jiH!E%i&)SGcRD~PRQSQ~P}P%AUpHAUp0<:9RS"}ya_a``)בQ_KFEr(Yi7A4'|m5|4s22#5zAi&}"b#X?'I%I{<;S~~xA_!'{<psH]MwAiK2QP sgy}Up77 92V{n'%:v'QSP%4KKAB7AAA7777L`777BKKKMAKKLKKKV777BAAAB7777N`7KK787KK787KK797&A7KK7A777&7KA87aBA7K8`77K7K8K8~2;~s{%'%|>/K.%`az 3Al4U?X(?l%&(m'|d}y<>-j,K-R%%%''K.i-'`-'_-'W)EhA~<<< B}==={</!D!]X ~ |<~f( c eW ( }}t OKz<wF?xVr@j{? B}iAu'n\w|oyQ*774d}F'i}v|5y{'7zcyv'A7SyyAzEU4%7{i E|y}E4T}y|5ytA#4|_~FA#4}}Q~PQSPPSQS~PQPPSRPSPyPPP|P'in#>#a#8 "k'>w;<'\'V%K;'V%Z^ t@'\B 4A~> EQS}PSsPrPi|]]]]Y  ipmA.O2VTUAN{|X"$85'!9SRS:<N Ur1/Pl|~:C<3)25=U"}m'Px `o!'VP(pt6{=q7i_sA'xx%62uCAEG{w1cI8:J,i't;s-w!lC-C6j{&si63qqs$YtPrPtPcV?!/\7*"7i'ey&>&Hz|P05:A,i'wYtP#DU{w7p}%7sXq;t~Ucc237J'i&͇<R'6-p}'%3w~<{YrP}P&337J'i&͇<R'6-p}'%3w~<{YqP|Pyi#V<Y&nHi_==ni_%%q%nwi_==~ni_ni_@Dyn &){xE&;PSQQQqPR~P7EPL,,,-'5('y%Ux "v m&}ETfE+EH@#S= SuP6Ic^ 7"s<'sUzEBB>B66< ;HFOEoi<C-;-1vPPP}PWPm}fz|)i&_A_oB7nw+{ 'h~SSzPAtsnAssoAtsnw+{ 'h~SSzP4iaunKIjSSP2$,,,-@A}]~:<'U$"u &z?E#'iE%c 5>5~2%o<m{RS^P:5M2,v>=k3~i'h{5)09sUF!7U%!SSS}P}+%o!J ' uvx|i&un'B!2(-AfX(!_LFhXcZi,g%n bXxY;K%JCP|YL"^Y-ykiK90+*ïq~nyJ%O%}O%|bi"Aj{j~nW| ,~Wp_~Ap_~Ape~I,~Wf~Af~AfF~I~D~Z ~L~N~D$ ~Stn~J$~Wl~AlD~I` ~J$pY~St~~G$Y~St~~G$0Y~St~~G$Y~St~~G$Y~St~~G$P\~StA~G,~Wt]~Ato~Atn~J,~Wt_~Ato~Atn~J$pn~SvS~G$n~SvS~G4P~Wh~AhO~AhS~Ah~I4~Wh~AhO~AhS~Ah~I~E~Y~Z~W~Z0,~k`"~a#~b9~x;~z$@p~Srv~Ar_~F$k~Stv~AtZ~F$ k~Stv~AtZ~F4|~Wf~Afr~AfQ~Af~I4!~Wf~Afr~AfQ~Af~I,"~Wv~Av~J$ $N~DxI~@$p$t~Dvo~@$$K~DxF~@$@%l~Dtg~@$%~Dr~Aru& ~_$&-~Df~Af}4(y~W`~A`X~A`m~A`w~I$*~SxQ~Ax^~J4 +!~Dl~AlN~AlN~AlN~@P,#~b<,~Dr]~Ar\~Arw~ArI~ArI~@4P-~DtO~Atu~AtI~AtI~@4-~Dp~ApI~ApI~ApI~@D.>~GX~AX~AX.~AX~AXs~AXW~AXF$ 3f~Dla~@D4~Wf~Af}~Af~Af[~AfQ~AfI~Af[~I,@7~Wn~Anu~I$9\~SvA~G$0:M~DrH~@L:L~_\j~A\~A\~A\~A\^~A\}~A\~I,@;~Wr~~Ar~I$B~Srq~J$B~Srq~J,0C~Wj~AjI~I$PF5~Dtp~@TF~_X~AX~AX~AX~AXz~AX~AXk~AXo~I,M~Wr~Ar ~IN~\,OW~Wti~Atk~At`~I,pPo~Wr~Ar~JQa~`,PR~Wh~Ah~AhZ~I$@T"~Wh~AhU~I$pU~Dv~Ave,V4~Z^~A^~I$X<~Sza~G,Y~_Z~AZ~I,Z~Wvj~AvF~J$[<~Sza~G[ ~L,[C~Wh~Ah[~Ahb~I< ]q~b~A~A|~AN~I$_x~Sn]~G `~T$@`a~SvF~G,` ~_P~AP~I$0j ~b~I4@o~b~AF~AG~J$r|~Srf~Arz~G$r~StE~At^~G$s~Wx~Ax_~It ~Jt ~L, t~W`M~A`~Jz~Nz~S$z[~Sv@~G$@{|~SvL~AvU~F${~SxX~AxS~J,P|~Wb~Ab~I$~~Wvq~Av~I,"~Wh4~Ah~I4~Wd~Ad^~Ad~Ad[~I4~Wb~AbR~Ab~J,~_V~AVJ~I4~Wf~Af~Af~I4-~_Tl~ATS~ATC~I,~Wls~Al~I,~WhM~Ah~I@o~n9~x~S~R$0s~SvN~AvJ~F$I~Sxn~G$~Wv_~Avc~I$n~SvS~G,  ~_D~AD ~I~V$ g~SrH~ArD~F$o~StT~G$<~Sza~G@~MP~\4p~Wh~Ah~~Ah<~Ah[~I4 ~Wh~AhF~AhD~Ah[~I4~Wh~Ah~~Ah<~Ah[~I4~Wh~AhF~AhD~Ah[~ITP~_Xy~AX^~AX~AXO~AX~AXd~AX~AX^~AX[~IT@'~_X~AXf~AX ~AXW~AX~AXl~AX~AXf~AX[~I,pu~Z^~A^<~I,x~Z^~A^<~I,p~_Z~AZE~I:~y<T~_Z~AZl~AZW~AZj~AZ~I,0~_B~AB~I$~Wj~J$~Wh~I$]~Sv~~AvD~F$0~Srn~J$~Stv~Atn~F$@{~Stt~Atl~F$~Stv~Atn~F$@~Wrw~Ar^~I$~Wrv~Arf~I$~Srq~J$P~St~Ati~I,~Wr@~ArT~I$~Wr~Ar\~I,`~Wt~~AtA~At`~J,03~WnI~An~I,p~WtS~At`~At`~J$0~Wn[~Anr~I,~~Wpt~Ap~I$`~SvT~AvR~J~R~]0~R,P~Wrx~Ar^~Ar[~I,0~Wvt~AvP~I  ~L$0~Sxv~Axo~F,C~Wr~Arf~Arv~I<{~Dt~At~AtD~Atu~AtW~AtP$~Wrp~Ar[~I$0~Wp~Ap[~I,~_Rb~ARq~I4~WlX~Als~Al~I, ~Wv~AvR~AvR~J, ~Wh.~AhN~ID |~_V~AVy~AV~AV~AVm~I,b~Wp ~Apv~I$S~Stx~G$pF~Sxk~G$~Wtf~At^~I$p\~SxA~G$~Wv~AvV~J$~Wn~J4`~Wn~An~Anv~I$`~SxA~Axm~I$~Dpl~Ap`~@,~Dr_~ArF~Ar\,` ~DxN~Ax`~AxY$ ~DrL~Ard$!P~Svu~G,"x~Wn~An~I$#~DvX~Av~4 $~G\~A\H~A\i~A\J$%e~Dvw~Avh$`&T~DvO~@&~R&~R'~M'~M, '~Wrg~ArR~J$(Q~DtL~@$`(^~SvC~G<(t~Wr~ArG~Ar~ArN~Ar[~I$@*x~Stk~Atq~G,*~WxS~Axx~AxR~J$+~Sps~J$0,g~StL~G,~\,~V,~M,~Q$-z~SxC~Ax\~F-3~r,-1~WrP~Ar~I</7~WjY~Aj~AjD~AjO~Aj~I$P4[~Dxl~Axi~@$4o~SvT~G 5~R$@5=~Dvx~@5M~L5D~CD 6~Dj~Ajx~AjI~AjI~Aj~Aj~AjZ$9!~Dp~@,@:~Dj~AjI~Aj,<l~Wn~An}~An[~I,P>~WnU~Ano~J$@?p~SvU~G,?~Wn~AnI~ID@~ ~_D~AD~ADm~ADz~ADO~AD~I,0J~Wb{~AbH~I$ N~Wl~Alp~I,@O ~b~A ~IP\ ~J$`\~Wv~J$]R~Svw~G,p]R~Wt~AtX~I$^~Wv~J$_Z~Sz~G4_E~Wn~AnV~An~I,0d~Wvp~Av~I4Pe~WvZ~AvP~AvU~Avs~I,f~Wl;~AlR~AlU~I$h~Dp]~App~@$ iN~Svs~Gpi~@$iH~DxC~@$i_~SrD~G$0j~Srf~ArN~J$j~Wrt~Arv~I,k~Wl~Al~I$0n~Sxm~AxH~I$nk~Sxv~AxZ~F$@o~_X~IL`t~bi~A ~AO~A~A~AF~I<|~Wpc~Ap{~Ap~Apg~ApN~I,`~~Wv~~AvT~I,`m~WpL~Apa~Ap~IЀ!~`$~Wx~Axs~I,~Wtn~AtQ~AtQ~J$~Stl~J$0~Wx~JD~C,0~~Wl~Al~Ib~a, ~Z^~A^~J<Ќ@~Wt~AtI~AtI~AtI~AtI~AtG~ID~Wv~Av~AvR~AvR~AvR~Av[~I,Z~WhU~Ah~I,p?~Wl~Al~I~,p9~Wr~Ar~ArN~J,,~Wx/~Ax~J, ~b ~A~I$~Wr~JP~T,p[~_Z~AZ~I4Ю~WxK~AxN~AxN~Axf~J,;~Wp~Ap~I,в~Wv~Avt~Av]~I$~Wz~J$@`~Sxi~Ax\~F,~Wp~Aph~I,p8~Wt~At~I$~Sxs~Axv~I$@~D|~A|T4 ~Wl~Alz~Alk~AlG~I4~s,~WnV~AnE~I$0~Wv~Avr~I,~Wtp~AtR~At[~I$~Svf~J$0~Wr~ArR~J$ ~Wxm~Axr~I$~Wxi~Axr~I,.~Wn~AnO~I,~Wl~Al"~I,Q~Z^~A^T~I$P~Wn~AnU~J, h~Wr~Are~Ar^~I,~Wd~Ad~I4 ~Wl~Ald~Alv~AlI~J40~WhT~Ah~Ah~I$~Wx~J,~Wl~Alk~AlL~J,PS~Wlv~Al~J<~br~Am~AA~A~I4~_X~AXH~AXI~I,`S~Wl!~Al~I,~Wt~At~I$~W`~J4~_\%~A\N~A\[~I,@5~W`S~A`~I<~Wl~Al~AlI~Al~Al~I4`_~Wd~Ad~Adn~AdG~I$~Dt~Ate$5~Wb~J$~Wf~J$~Wf~J$R~Szw~G$Pu~WrT~I4~Wfm~AfI~Af~I$pe~StJ~G~O4~Wt{~AtW~AtI~At[~I, q ~b~A~I$PL~Wv~Avx~J,~Whv~AhO~I$~Wt{~AtK~J@~U$`~Wv~Avp~I`~@$pa~Sz{~AzK~F,~Wx~AxZ~I4n~D|F~A|M~A|M~A|F,`~Wvf~AvG~Av]~I4Pq~D|A~A|Q~A|Q~A|F,~Wvf~AvG~Av]~I$~Wz~AzY~I,~WxX~Ax[~Axf~J` 4~s$ W~Sxa~Ax[~F$!W~Sxa~Ax[~F,`!~Wh~Ah8~I$#X~Sx}~G$#X~Sx}~G$@$o~SvE~AvN~G4$@~Wp~Apz~Apa~Ap~I$'~Wt~AtG~I$(~Wxf~Ax[~I,`)~WrB~Arz~J@*~NP*8~w,*:~_X~AXs~I$-M~Sxr~G . ~K0.~N4@.~Dvb~AvI~AvD~AvF4/~Dvb~AvI~AvG~AvN~AvF$/v~Sxf~Axt~G$P0H~D||~A|F,0~WlH~AlU~I$ 3q~SxV~G,3~Wt~AtI~AtN~I,4S~Wlf~Al~AlW~I<5~Wnq~An~AnP~AnI~AnN~I,7N~WpF~Ap~I$:~Wl~Alk~I,<~Wrl~Arf~I4=K~Wjw~Aj*~AjR~Ajt~IPA~R$pAX~Sv}~G,AZ~WhZ~Ah~Ahq~I$0DO~D|C~A|F4D~Wvw~AvA~AvD~AvG~I$pEd~SrI~G$E~Wt~J,F ~Wh0~Ah~I$L?~D|s~A|FL9~x4 MI~WtL~At~AtR~AtO~I,pN~Wri~ArR~J,P!~Wd~~Ad~I@S~S~SS~T,T~Wr\~Ar1~IU~R,U~WrU~Ar~I,W ~WrX~Ar~I$ X~Wx~Axp~J,Y~Wl~Alj~Al[~I,Zd~Wl~Aln~Al[~I4[_~Wh~Ah~Ah_~I$P^~Sto~AtI~J$^~Wt{~At[~I,_&~Wr{~Ar~I$`P~Svu~G$0ah~SvM~G,a~D|w~A|r~A|Q~A|F<0b~Wl~Al~Alh~AlN~Al[~I$dF~Sxk~G$Pd~Wz~AzI~I,e~WrZ~Arj~If8~w$@f~Wr~Ark~I$gq~SvO~AvG~F$g|~SvF~Av[~F$h~SvL~Av[~I4hR~Wf~Af~AfK~Afz~I4lw~D|O~A|M~A|M~A|F$lz~Sz_~G$mg~Sz~~AzN~F$pm~Wp~J$Pn~Wp~J,`o~b}~AG~I$ q~Wv~J$q~Szi~AzL~I$rz~Svy~Avf~F,s~Sxd~AxX~Axp~I,s~bC~AC~IPu.~m$u~Wtk~AtT~I,0v~b~Ay~J w~Q@w~R,`w~b~Ay~J,`x~Wfw~AfS~I${~Wr~ArN~I,|~Wh~AhY~I,}~Wh~~AhR~I$~D|~A|J,0U~_P~APR~I$~Wf~AfG~I,PY~WdG~Ad~I,~Wd~Ad~I$`~~Wl\~J$~Wv~J<~Wve~Av|~AvZ~Ave~AvN~I,~xt~~AtL~I$Ќp~StU~G$@j~SvO~G,~Wr~ArG~I$x~Sv]~G4 ~SxU~AxI~AxI~AxG~I$T~Sxy~G~$~Dvm~Av$~Dvt~Av$p>~S|c~G~O$5~Wr~Arv~I,~Wxi~AxQ~I$\~SzA~G$@~SvU~Avc~J,~Wv~AvR~AvN~J, ~Wn~An~I,F~Wr~Ark~IN~M$`K~DzF~@$Y~Sx~~G,C~Wn~Ans~Anv~I4`~Dzf~AzR~AzR~AzD$~Wn~J$~Wvm~Av^~I$~Z^~A^W~J ~H4СZ~b{s~A{e~A{~I$0~Sxd~G$+~Dzf~@$P~Dvb~Avh~@$0L~Szq~G$~Wh~AhM~J$@~Wh~AhP~J$~Dp~ApM$Ч~Wtc~Ate~I,`~Wp~Ap~I$~WvQ~Avo~I$5~S|Z~GЪ~E$~Wx~I~Q$Ыt~SrY~G<Pg~Wl~AlQ~AlP~AlQ~AlM~Ala~I,~b~A[~I4>~Wp}~Apd~ApZ~Ap_~I$ V~DrQ~@$Q~DtL~@$$~Dz_~@$~Dp~@,~DlZ~Al~@$Z~DrU~@~M ~_0"~a$`G~Wr~Ar{~I$~Wvt~AvP~I$`g~SxM~F$еg~SxM~F$@g~SxM~F$g~SxM~F$ g~SxM~F$g~SxM~F$?~Sxe~F$@u~Dl~Al"~a~],~Wl~Al~I$R~Dvg~Ave~@$~StW~AtW~I$M~G^~A^$l~GZX~AZ $P?~Sxe~F$?~Sxe~F,u~Dl~Al~AlI~@,P~Wb~AbO~J,` ~Wx~AxV~I,p~_Vm~AV7~I$@0~Dxk~@pQ~P$(~Dzc~@$~Dn~~@$>~Sxd~F$~Dx~@,I~Wrk~Ar~I,~Wv~Av|~Av~I,x~Wd~AdD~I4p~Dx{~Ax^~AxO~Ax\~@$@v~Sx[~G$~Wr~ArG~I$~SxP~Ax\~I$pb~Szu~AzR~F4E~Wr~Arp~ArI~ArN~I$0Q~Sxv~G$Q~Sxv~G$~Sx~Axe~F4p~Wr~~Ar~Arl~Art~J$ ~Sxo~J$ ~_\~A\S~I$n~Sxf~Axm~F$0~_\~A\U~I$@<~Sza~G$h~SrM~G$~Wt~J$~Wx~J,p~Wj0~Aji~Aj~I~@$F~Sxk~G$F~Wr%~I$0(~Dzc~@,`{~Wt~Atj~I$o~SpT~G$P\~StA~G$~GX~AX^$D~GZ~AZ$ A~Dv|~@$p?~Sxe~F$?~Sxe~F$B~Sxh~F$@J~DtE~@$J~DtE~@)~Dxd,k~Wh~Ah~I,~WpF~Ap~I$0~Wr~J$~Wvc~Avk~I,~Wr~Ar~I,u~Wt~AtM~I$~Sxe~AxL~I$~Sxp~AxH~I,0i~Wp~Api~I$~Wx~JP~O,`~WxM~Ax~I,`~WxD~Ax~I$`w~Dj~Aj,p~Wr~Ar}~I$P ~Wxj~AxT~I$ ~Wxi~AxU~I$ ~Wxg~AxT~I,0 ~Wj~Aj~I~W,0\~Wn~Anh~I$~Dt~AtD, i~Wv~Av}~I,~Wj~Aj~I$`~Wx~Ax[~J,@ ~WtD~At~I$P~Dp=~Ap@$~StB~Atm~I,pH~Wp~Apt~I$~Wt~J$ ~Dxt~AxI$!+~Dzf~@,!~Wn~AnC~An[~I,P#~Wv;~AvQ~I%~T4 %~Wt~At]~AtN~Atl~IL 'q~WxG~Ax~Ax~Axl~Axl~Ax\~Axw~J$)c~Sx~~AxI~G,*~Wv~Avv~I$+~Wt~Atv~I,,~Wv~AvH~I,-~Wv~Av~ITp/ ~_Z~AZ~AZ~AZ~AZ8~AZ~AZ^~AZ~I4@9~Wx}~Axj~AxN~AxN~J$0:~WxT~Ax}~I,:X~Wr,~ArI~J,P<c~Wl~Al?~I$?~Svl~J$P@A~Szf~G,@~Wrs~Ar8~I$pB~Wx~Axi~I$@CN~Szl~AzG~F$CN~Szl~AzG~F$CP~Szn~AzG~F,0D~Wj~Aj~IGC~B$ H~Dr~Ar$JL~DvG~@$Ku~Sz}~Az]~F$K~Wv~Avp~I$LD~D`~A``$Nu~Sxh~Axr~F,PO~Dt\~At~At40R~Dl~AlJ~Alt~All~@$S~Dr~Are,T~Wxh~AxN~Axa~I,U?~Wt~Atp~I$V~Wpu~ApV~I$W~Dj~@,@X~Wd~Ad~I,P]~Wt~Atl~I,`~Wn~An~I$b~Wty~J$0d~DvV~Avid"~a$d~Dvd~Av{~@$ed~DxC~Ax[$f?~Sxe~FPfV~Uf ~J$f0~S|U~G$f0~S|U~G$ g0~S|U~G$Pg0~S|U~G4gM~b~~A~p~A~U~I$k~Dp]~Apr,pl~Wt`~Atr~AtN~J$@m~Wx~Axe~I,PnA~W`?~A`~I$vk~SzI~AzG~F,w~Wn~An~I,x~Wh~Ah~I${k~SzI~AzG~F<|~Wf~AfI~AfI~AfI~Af~I$~_\[~I,~Wp~ApG~I$~Wvw~AvG~I,`~WxF~Axb~Ax]~J4 ~_R ~AR_~AR~I$0i~SxN~G$i~SxN~G$~Wx~AxW~I$Д~SxU~Ax\~I$`~Wx~Ax\~I, [~Wr~Arb~ArG~I$~Sx_~Ax[~I$ h~SxM~G5~t4И/~Wp~Apx~ApI~ApJ~I4~b}~A}W~A}p~I, ~Wpm~Apc~ApW~J,J~Wp~Ap~ApQ~J4`~Wp~ApN~ApR~Ap[~I$Q~DxL~@~[$&~Dza~@0~E$@&~Dza~@p~E,~Dxc~Axe~AxN~@$ $~Dz_~@$PG~Wd%~J$s~D|Y~A|T ~S$@=~D|q~A|F ~L~\~M~MУ~[ ~I~M~X00~o`~R$i~Dz`~AzCE~D,@ ~Wj~Ajc~I,P~WnB~AnU~AnG~I,~Wnz~An[~AnG~I4~_T~ATf~AT~ATa~I$0f~Sxp~Ax[~F$~Wpk~ApV~IDPf~_N~AN~AN~AN~AN~AN~I~@,й-~Wr^~Ar~ArG~I,~Wf~AfB~I, ~Wf~AfB~I@T~S$C~Dv~~@$~Sx@~Axe~F$p?~Wn~Ana~I,{~Wn8~Ana~I0%~d,`~Wp~Ap~I,0:~Wf~Af~I,pr~_\:~A\N~I,~WrI~Arj~Iw~vP%~d6~u~Y,x~_ ~AE~I$`N~Svs~G$N~Svs~G$N~Svs~G,P~Wpo~ApX~I@ ~JP ~J`~Mp~[$0~Dxk~@ ~J~M ~J~M$0~Dxk~@$0~Wp~ApN~I$ i~Svm~Ava~F,~WxZ~Axa~I$pJ~Svo~G$J~Svo~G$E~Sxj~G$`N~Svs~G$<~Sza~G$i~Sxw~AxW~F$`J~Svo~G,n~Wl~Al~Al[~I$ A~Sxf~G4p~Wn~Ani~AnI~An[~I?~~@'~f4p~Wd~Ad~Ad~I,~Who~Ah!~J,F~Wf%~Af~I,~Wh~Ah~I$~Wx^~Ax~I$<~Sza~G$ ?~Wv~J$`0~Dxk~@$F~Sxk~G ~I$F~Sxk~G,@~Wr~Ar~I~\$0I~Sxn~G$J~Sxo~G$J~Sxo~G$ J~Sxo~G$pJ~Sxo~G$J~Sxo~G$J~Sxo~G$`J~Sxo~G$J~Sxo~G$J~Sxo~G$PJ~Sxo~G$J~Sxo~G$J~Sxo~G$@J~Sxo~G$J~Sxo~G$J~Sxo~G$07~Dxr~@$pM~Sxr~G$M~Sxr~G$M~Sxr~G$`M~Sxr~G~Q~Q$M~Sxr~G$@J~Sxo~G~P~Q$~Wxa~Ax~IL~Z^L~A^~A^@~A^L~A^~A^~A^N~I$P>~Szc~G,g~D|@~A|Z~A|F~@,v~Dr>~ArI~Arh~$0~Wvt~Av~I,0~Wnu~AnZ~I$0Y~Sxh~AxU~G4$~GPq~APu~APd~APO~@$~Wl~I$`~Dx[~@48~Wt~Ata~At{~AtG~I0~@$@~Wx~I$~Wx~I$~Wx~I$ U~Dxw~AxXL ~Dl~Alq~AlN~AlF~AlN~Al[~Alq~AlF$p"=~Dvx~@$"7~Dvr~@$"9~Dvt~@$0#X~DtS~@$#~Wp~Api~I$p$~Wr~J$0%l~Drk~Ar{%~P&@~$&q~Drl~@<'l~Wx~AxL~AxN~AxN~Axb~I$(C~D|w~A|F(1~p$)~Wt~At|~I4*~Wd~Ad~AdC~I$.~Svq~J.~Z,.[~Wj~Aj~I,1~Wt~At]~I$2~Wr~ArG~I,3-~Wl~AlG~I$4~Wp~ApG~I45~Z^~A^=~A^z~I49~Wh~Ah~Ah~I<)~h$<_~D|S~A|F$@=N~D|B~A|F,=[~_R+~AR~I<@s~_R~AR~ARW~AR~I$pI}~SxX~AxI~G$I~Wt~J$JL~Sxq~G$ K~Svg~JKh~g, LN~Wp~ApM~J,pMD~b|~A~IP#~b,PZ ~b~A ~IP^~E$`^~~Svx~Avk~FL^~Wv~~Av~Av\~AvI~AvI~AvI~AvI~Avv~I$p`~Wf~J$ b(~Dzc~@4Pb~_Z~AZF~AZg~AZp~I$dl~SpQ~G$`eo~SpT~G$er~SpW~G$Pfr~SpW~G,f)~Wr~ArQ~J$hg~SxH~AxD~F$ph~WpN~Apr~I$ i~Wn~Ank~I,j~WjB~Ajp~I,k~_Z~AZN~Im ~J$m~Wl~Alr~I$n~Wr~ArU~I,o~Wp~ApD~I,p!~Wn~AnZ~I,q~Wj~Aj[~AjG~I,r~Wp~ApR~ApR~J$si~SrN~G$sl~Srh~Ari~F`t!~ $uw~StE~AtV~Gv?~~$PvI~DtD~@v~R$v?~Sxe~F$wF~Sxk~GPw-~l$w2~Dzm~@w ~Jw ~Jw~]x ~Jx ~I$ x~Wl~AlU~Ix~,yK~_J~AJ_~I4z ~Wb~Ab]~Abw~Abg~I4}~Whn~Ah~Ah~ID~b~Ai~A~Aq~AN~I,~_B~AB~J ~J$f~SvK~G0C~B,+~W`~A`I~I$V~Sx{~G, ~b~~A~!~I$ ^~SvC~G$~StR~At[~J<~{P~O` ~J,p~Wr ~Arw~Ar~~ID ~_Vt~AV%~AV ~AVp~AVZ~AV~I,~SvI~Ave~AvG~I$h~SvM~G,~Wvl~Av[~AvG~I,~Wv|~Av^~AvG~I4~Wj~Ajd~Ajl~AjG~I$@q~SnV~G,~Wdc~AdD~I$~Wnc~Anv~J,P~Wtd~At~AtJ~I,p~Wp~Ap~Ap\~I$P^~D|R~A|F$~Sv]~Av[~I$P|~SxL~AxU~F,Щ~Wp"~Ap~J$Ы<~Sza~G$E~Sxj~G$`r~Sv{~Av\~F$\~SzA~G,@~Wh~Ah~I, ~WrZ~Ar~Ar~I$R~W`1~I,`~Wxj~Ax[~AxZ~J,pq~Wj:~AjU~I,;~Wh~Ahl~I$0<~Sza~Gp ~J~M ~J,~_N~AN~J4@7~Wn1~Anw~Anl~IL~Z^~A^~A^~A^~A^0~A^~A^x~I,p~Wvh~AvU~Avf~J$~Sxq~Ax|~J$~SxL~Axb~I$~Wvp~AvR~J4P~_\~A\;~A\b~I,<~Wn~An~I$ ~WvW~Avw~J$_~Szr~AzR~F,@~Wp~Ap~I4>~Wj~AjL~Aj\~AjG~I,~Wl~AlC~I$0u~D|b~A|M$E~D|y~A|F ~J$F~D|z~A|F<`~Wj~Ajc~AjM~AjQ~AjG~I, ~Wr~Ar[~ArG~I$^~SvC~G,~b~A~I,~x~d~A~G~I$09~Wn~An^~Ip ~J~M,~Wt ~Ath~I$0~Str~J$q~SpV~G$@~~Spc~G$~Wn~J$p~Spg~J$[~Sr@~G$`[~Sr@~G$[~Sr@~G$ ~Sx_~Ax[~I$~Wpa~Apy~I,~WlY~Al~I$[~Sr@~G$[~Sr@~G$@~Wn~J,P~Wb~Ab ~I$P[~Sr@~G$v~Sr[~G$0v~Sr[~G$~WrL~Art~I,`~Wl~Alb~I$[~Sr@~G$~Wl~J$~Wn~J$q~SpV~G,~WnZ~AnE~I$~Wv~J4m~_N~AN~ANo~I< .~b~ ~A~~A~~A~~I,P~WlB~Al~~I,@~b~(~A~n~I,~Z^^~A^~I$Pc~SrH~G$c~SrH~G,0~b:~A8~I$! ~Wb~J$"~Wf~AfG~I,#~WlE~Al~Al~J%@~,%~Wni~An~I,(~Wf~Afn~I+~+u~t, ,g~W`~A`~J,-!~Wn8~An~I$/~StL~Atb~I,P0~Wl~Alr~AlG~I,P1~Wvr~AvS~AvG~I2~$2>~Szc~G$2>~Szc~G403~Wfh~Af~AfR~Af~I$P6N~Svs~G<6|~Wh~AhN~Ah~AhY~Ah~I$ :N~Svs~G4p:a~Wj~Aj~Aj~I$=~Sv`~AvN~I$p>~Wt~AtQ~I@?~T$`?P~Svu~G?~Q$?~Sth~J$`@~Wr~Ar{~J,@A~WtT~Aty~At[~J,B~WtO~AtL~J,B9~Wro~Ar~ArH~I4D~b~~A~O~A~G~IK?~bT~A~A~AW~AW~Az~A~AW~AW~AW~AW~AT~A{~A~A^~AN~A[~A~AW~AW~AW~AW~AW~AW~Ad~Aa~A~AW~AW~AW~A~I@Z~R`Z ~KpZ~M<Z~D|~A|U~A|l~A|~A|X~A|M4P\Q~D|w~A|~A|R~A|e~A|[$]Z~Stx~AtG~F^ ~_$0^~Wt~I$_V~St{~G$`_?~Sxe~F$_?~Sxe~F$_A~Szf~G$0`A~Szf~G$`C~Svh~G$`d~StI~G$@a~SrR~ArU~I,a~WrV~ArM~I$b~Wt~I$pc?~Sxe~F,c.~WhX~Ah~I$f~Wv{~J$g?~Szd~G$g~SpU~Ap[~IPh7~v$h0~S|U~G$hD~Szi~G$i>~Szc~G$Pi>~Szc~G,i~Wx_~Ax{~I,j~WpI~Apo~J,pkv~Wp~Ap[~Il~T,mB~Wph~Ap~I$`nD~Sxi~G$nS~Svx~G$oH~Sxm~G$`oi~SrN~G$o~Wn~J$pk~SrP~G$ q.~Wl~AlR~I$PrD~Sxi~G$ru~Sxm~Axm~F$ si~StG~AtG~F,s~Wf,~AfH~I$0uV~St{~G$uV~St{~G$u;~Sz`~G$0vJ~Sxo~G$vO~Svt~G$vN~Svs~G, wo~_\>~A\G~I$y~Wrm~ArU~I,@z ~Wh~AhB~I$P|a~Svk~Av[~F$|M~Svr~G$}G~Sxl~G$`}>~S|\~A|G~F$}I~Svn~G$}~Wt~I$~?~Sxe~F$~Wr~I$\~Wn;~I$`\~Wn;~I$?~Sxe~F$~Wt~J$a~SxF~G$ X~St}~G$b~SrG~G$Y~St~~G,P~WrA~Arf~I$ ?~Sxe~F$`~Wd~AdG~I$ ~Wv^~Av~J ~,  ~|BzF|A~P0~@@=~|{~Dxv$f~S|I~Ip~@~$0~|R~@Ѝ~F~D~$Џ0~Dtk~@$~~StT~HtN$~~SlT~HlN$~[\u~K\Q$~^u~KQ$`~^~u~K~Q$~^}u~K}Q$~^{u~K{Q$p~twu~KwQ$@~tou~KoQ$~t_u~K_Q,~tu~KQ,~t~u~K~Q,~t}u~K}Q,P~t{u~K{Q, ~twu~KwQ,~tou~KoQ,~t_u~K_Q,~tu~KQ,`~t~u~K~Q,0~t}u~K}Q,~t{u~K{Q,П~twu~KwQ,~tou~KoQ,p~t_u~K_Q,@~tu~KQ,~t~u~K~Q ~K~@~\ 5~t`~$ ~Dx~@0~N@ ~IP~X$p&~Dza~@ ~_$C~Dt~~@~S0~UPE~D3~r4~s ~\@$~cp#~b$~cЭ>~=~]09~8p!~`!~`б~~W~W~ )~hP~Wpn~m~B~F ~H ~H  ~H0 ~H@1~0~~~`~Q ~H~V~V ~_~V ~_0!~``~D$p2~Dvm~@~U~UL~K$@~Dt~Atu~@0#~b`-~l$"~T|M~@?~Drz*~i0~^P!~`$@~Dx{~@6~u,3~D|AzAxJzA|A~`@.~m$p1~c|I~D ~K ~K~O~W~O$&~Dta~@@5~t~V-~l~Y$~~Stc~G$p~Stz~Atp~I$~~Stc~G7~v$~Stv~J,`~Wrc~Ar]~I$P~~Stc~G)~h$~Wt~J,#~Wr~Aro~I$~~Stc~Gp:~y$o~StT~G V~U$~Wt~J$P~Wt~Atn~I$0~Wv~J,h~Wr~Ar~I$P~Wt~J,~WtI~AtN~I$~~Stc~G$@|~Stw~Atj~F$~Wt~JpH~G$Y~St~~G$ X~St}~G$~~Stc~G<~{$@~~Stc~G$l~Stk~Atf~F$0~~Stc~G$~StC~Atp~I$P~~Stc~G$~StC~Atp~I$p~~Stc~G$~Stz~Atj~F$pu~StZ~G$~SrH~Arm~I,~StO~AtG~GtN$~~Stc~G$~StC~Atp~I$0Y~St~~G$X~St}~G$Y~St~~G$PX~St}~G$~Wt~J$~Wt~AtP~I$`Y~St~~G$X~St}~G$ Y~St~~G$X~St}~G$Y~St~~G@)~h$p~~Stc~G$~Stf~AtH~I$Y~St~~G$X~St}~G$@~~Stc~G$~Stz~Atj~F$@o~StT~G$~St]~AtN~J$@u~StZ~G$o~SvP~AvD~F$0p~StU~G$~Wr~ArN~J$`~~Stc~G:~y$ o~StT~GV~U$5~Wt~J,0~Wt~At~I,~StO~AtG~GtN$@~~Stc~G$~StC~Atp~I$`Y~St~~G$X~St}~G$ u~StZ~G$~~Sr@~Arc~F$ Y~St~~G$X~St}~G$~~Stc~G$`~St`~AtH~I$~~Stc~G$p~St]~AtH~F$~~Stc~G$p~WtW~Atr~I$ o~StT~G$~Wn~AnN~J$`u~StZ~G$~StE~Atn~I$p~StU~G$~Wr~ArN~J$n~StS~G$0~Wpy~ApN~J$o~StT~G$P~Wp~ApN~J$k~StP~G5~t$n~StS~G$0~Wpy~ApN~J$n~StS~G$P~Wpy~ApN~J$n~StS~G$p~Wpy~ApN~J$ n~StS~G$~Wpy~ApN~J$@n~StS~G$~Wpy~ApN~J$`Y~St~~G(~g$~~Stc~G$px~StY~AtD~F$~Wt~~J, M~Wt~At:~I$ ~~Stc~G` :~y$ Y~St~~G$X~St}~G$`~~Stc~G$x~StY~AtD~F$`Y~St~~G$X~St}~G$ Y~St~~G$X~St}~G$Y~St~~G$@X~St}~G$Y~St~~G+~j$0Y~St~~G)~h$Y~St~~G$ X~St}~G$Y~St~~G$X~St}~G$@~~Stc~G:~y$~Wt{~AtP~I+~j~@~R$~Wt~At`~I4~b ~Ao~A%~I,~Dxf~Axf~AxA4 J~b~A~AK~I4p"~Wpz~ApE~Apm~ApD~I$P#e~SrJ~G$#H~Sxm~G4$~bD~A~A~ID,.~Whz~Ah{~Ah~AhM~Ah{~AhZ~I,@.E~Wjb~Aj~Aj[~I4/~bt~A_~Ac~I$2~Wpn~Apt~J4P3~Wft~Af~Af~I478~Wt`~At\~Atz~At^~I4@8~Wrn~Ar~ArO~ArQ~J,P9~Wb~Ab ~J,p;~Wl~AlA~I,=~Wfd~AfD~I$`?~Wl|~Alf~J40@~_V~AV~AV~AVN~I,PC~_PH~APe~I$F>~Szc~G$0G8~Dzs~@$pG_~SrD~G$Gj~SxM~AxB~F$@H~Wv~AvS~I$ I~Wv~AvF~I$I~Wr~ArB~I,J~Wv`~Avi~AvW~I,K~_F~AF1~J$N5~_\ ~J<O~b~Ar~A~A ~I,PVM~Wt`~At@~At~I,Y ~WhY~Ah~AhG~I<Z~WvW~AvY~Av~Av*~Avk~I4] ~bb~A~A~I,d#~_L~ALo~IDh~_V~AV~AVN~AVu~AVU~AVU~I$0kN~Sps~G,ko~W`~A`~A`U~I$lf~DzE~Az[~@$`m~Wf~Afu~J,`n~_\~A\U~I,@p~_R~ARh~ARL~I,r~_Z-~AZ@~AZG~I$ptB~_Z~J4u~b~Ac~Au~I$y~Wh~J$`z~Wh~J$ {~Wh~JT{~b~A~Aa~A~A~A~A}~I,~WjO~Aj~AjK~I,~Wft~Afw~AfI~IDЅF~WpU~Apk~ApE~Apk~Apk~ApE~I$ ~Wh~J$~Wh~J$~Wf~AfB~I$~Wb~AbB~I,g~W`~A`~A`B~I$~Wj~AjB~I$@W~Sn|~G$~Wh~AhB~I,`~_Xb~AX]~I,{~Z^~A^~A^B~I,~_\~A\~A\B~I,P~_ZR~AZ]~I,Z~W`~A`Z~I$P~Wf~AfB~I,P{~Z^~A^~A^B~I,ИZ~W`~A`Z~I$0!~W`~A`B~I$`~Wj~AjB~I, A~Wr`~Ar~Arq~Ipb~ah~gPS~R,~Srk~ArG~JrN$P~Wt{~J$~Spt~ApB~I$~Wp~J,@~Wd~Ad^~J,`j~Dxn~Axo~AxF$Т5~b|~A|~A|~A|~A|~A|~A|~A|~A|~A|~A|~A|~A|~A|~A|~A|e~A| ~A|~A|~A|~A|~A|~A|~A|~A|~A|e~A|~A|y~A|w~A| ~I,~_B~ABk~I4 >~_H~AH~AHu~I,`;~_Df~AD~I,#~_L~ALO~I,f%~b~~A~b!~I,@u~Dxs~Axu~AxF4~Dh~Aho~Ahv~Ahk$~~Dl~Al|P^~bX~A~A~A~A~A*~A~A~A~A~Aa~Ab~I,!~Wt{~AtK~AtB~I$`"~SvK~Av^~I,"q~Wp ~ApD~I$p$s~Sv|~Av\~FD$~xwI~Aw;~Aw~Awl~AwG~I$*4~Wb~Abn~J$+<~Sva~G<0,~_R~AR~ARR~AR~ARL~I /P~Op/~\/Z~Y$/a~SvF~G,`0~Wt~At|~AtB~I$`1~Sts~AtB~I,2~WrK~ArN~ArL~I,39~WnK~AnN~An}~I,P4~WrK~Ar~ArB~I,P5~_V~AV0~AVN~I$@7Y~D|M~A|F,7'~W`a~A`~I$9v~Dzq~@$P:~Dx~@$0;U~Svz~G4;)~b%~A~A~I$Cy~Dld~AlO$@E~Dte~At@F~S$`F~Dx~@,G~Wlx~Ala~IDI,~_X~AX{~AXY~AX[~AX~AXc~J$0L~Wf~J4L~_T8~AT]~ATY~ATN~I,P~Z^~A^~J$R~Dv~@$ST~Svy~G$pS|~Sta~G,Sp~WbJ~AbD~I`U~$V~Wxc~AxW~J$Vk~SvP~G< W ~_\~A\~A\ ~A\~A\x~I<0\~Wj ~Aj~AjR~Aj_~Aj\~I$P^~Dh~Ahp~@$P_~Wj~J,`~Wp~Ap~Ap^~I,a)~Whz~Ah}~AhO~I,b~Wjt~Ajh~AjG~I,c~Wd~Adj~AdN~I| e~b~L~A~ ~A~~A~~A~T~A~L~A~Y~A~~A~~A~A~A~~I<y~b~A~A~Ae~I,}~Dzv~Az{~AzN,`~~Dzv~AzA~AzJt~ ~b~~A~~A~~A~M~A~~A~|~A~~A~~A~l~A~i~I<~_L}~ALj~AL~ALH~I4 ~_Dl~ADT~AD~J,~_Rl~AR~AR~I,~Srk~ArG~JrN$`~Str~J$~Wj~AjF~I$g~StL~G$`k~SpP~G,Ф~Srk~ArG~JrN,p~Wn}~AnG~JnU,0~Srk~ArG~JrN,Ц~Wpt~ApG~JpQ$~Wp~J,0~Wd~Ad^~J$P~Wp~J,~Wd~Ad^~J O~Np(~g,~Wrx~Ar@~Ard~I,`z~Wlx~Al~Alg~I$~Wrs~Ard~I,~Wj~Aj~Aj~I,~WhG~Ahg~I$p~WpX~Apz~J$0~Wpp~Ap]~J$~Wp]~Apz~J$d~StG~AtB~F$~Wp]~Apz~J$еd~StG~AtB~F$@:~Wj~Ajl~J$j~Szd~Azj~G$\~Szd~Az\~G,P~WnH~An`~J$ ~~Snc~G$~~Snc~G, ~Wjm~Aj`~J$~~Snc~G$~~Snc~G~Y402~WpJ~Ap~~Apk~Ap[~Ipo~n,W~Wp~Ap[~ApU~I$@~Wr~J$~Wl~Alz~JD~_P~AP|~AP~AP^~APD~APG~I,q~_Z~AZ~AZU~ILA~_F~AF~AF~AF/~AFL~AFJ~AFG~I,P~_Z~AZ~AZu~J,@~Wj^~Ajs~AjO~J,P.~Wt`~At~Atn~I$g~StL~G$k~SpP~G,`~_Vo~AVe~J<`u~b~Aj~Ak~A~I$~Wj~J$G~_Z~J$~Wf~J$~Wt~At{~J$X~St}~G<@~Dp~App~Apm~Apc~Ape$ ~Wn~AnF~I,~Wt~AtE~I1~p, 2~_H~AHL~I,`~_\~A\~J<0F~_J~AJN~AJ{~AJ~I,N~Z^~A^{~A^L~I$o~_TE~J$@~Wb~J$P~Wb~J4` ~Wp~Ap'~ApG~I$~~Snc~G$~Wr~ArF~I,~Wdh~Ad[~JJ~I'~f$@m~SpR~G4~Z^B~A^~A^~I$P~W|h~A|d~I,%~_R~AR~ARP~I$0~Wrb~Ara~J,]~Wf~Afm~J$@~Wf~J$0~Wd~J$0~Wf~J| i~b~5~A~~A~&~A~~A~~A~~A~L~A~~A~~A~5~A~x~A~U~I$h~Sxo~Ax^~FP~OP~S$pi~Dp*~Apy,Q~_ZU~AZ~J$@}~SvK~AvW~F$Q~Szt~AzB~F, ~Z^3~A^a~I$~Wl}~J4~Wd~Ad~AdV~J,"~Wf~Af~AfZ~I,%~Wf~Af~AfZ~I,'~_B~ABh~I+~U+~U++~j$,^~SvC~G,`,"~Wl~AlP~AlQ~I-~Y-~V->~}$.J~DzE~@`.G~F. ~J4.~Wl`~AlJ~Al~I$p3~Wt~J,044~Wf ~AfH~I,p5~Sri~ArG~JrN,6|~SvK~AvG~GvN$6~Wv~J,p7~_R=~AR]~I$:~Wv~J,:~_Z~AZS~I$<~Svi~J,@=-~Wb~AbI~I$p>~Wt~J,@?~Wf~~AfW~I$A~Str~J$A~Wj~AjI~I4BV~Wfw~Af+~Af~AfQ~IE'~f$ Fh~S|]~A|o~GF~ZF~M$Fk~StP~G$0Gs~SpX~GGT~S$H~Stb~AtQ~I$H\~SvA~GI~W0I~\PI~ZpI~\$Iu~S|]~A||~GJs~r\K~DrG~Ar~Arc~ArD~ArC~ArA~ArC~Ar~~ArD~Ari\N~DrG~Ar~Arc~ArD~ArC~ArA~ArC~Ar~~ArD~Ari<pQ~Z^X~A^P~A^p~A^L~A^C~I<Tj~WbU~AbJ~AbZ~AbI~AbC~IpV~< W~DzR~Azr~Az~Az~AzZ$Y\~Dh4~Ahb$ \F~Dj~Ajbp^~V^<~{4^~Wl~AlQ~Al~Al~IpfI~H4f.~Dp}~Ap~Apk~ApMTga~Wfu~Af~AfK~Afy~Af~AfR~Afk~Aff~IT`k~_Rk~AR~AR~ARu~AR~ARY~AR~AR~ITs~_Ft~AF~AF~AFu~AF~AF|~AF~AF~I,y~_X~AXn~ID4~Dv~~Av]~Av~Av^~Av]~AvK~AvwDP0~Dx~~Ax]~Ax~Ax]~Ax^~AxK~AxwL}~b}~A} ~A}E~A}~A}~A}O~ILu~b}~A}~A}F~A}~A}~A}O~I,~_\~A\~J,P~_H~AHy~I$p~Wv~Avs~I$~Wv~Avs~I4 ~_H~AH~AHo~IL~b~AQ~AT~AU~A~A ~I,~_\c~A\b~I4` ~b~Z~A~k~A~~I$ ~Dt~AtF$~Dz~AzJ,p~Wf~AfN~I40~_Z~AZ~AZp~I4~DtT~At~Atm~AtM, c~_F~AFq~I$#~Wtl~At~I4=~D|h~A|~A|E~A|p~A|V,~Wta~Atf~AtZ~I$~Sza~AzF~J4`X~Dta~At~Atf~AtM,~Wh{~AhD~AhN~I,pK~Wd~AdR~I,~Dr~Ar~Ard,P~Z^g~A^~A^[~I$H~DbC~@4PO~_X~AXu~AXY~AX~I,~Whe~AhN~I$@~Wn~AnN~ID`l~b~A~A~A{~A~I4~Wh~Ah~Ahl~AhQ~ID ~b~A~Aq~A=~A~I4~Dpq~Ap~Apa~Apw~ApS$x~_ZN~J$P~Wb~JT@ ~b~~~A~f~A~^~A~~A~:~A~~A~~I,*~b}~A}~IL0 ~b~A~A1~A~A~AP~IT l~b|C~A|~A|~A||~A|u~A|~A|[~I,P } ~_R;~AR~I, ~_P~AP6~I, ~_X~AX~I 0~o 0~o, _~_Z~AZ~AZE~I,P" ~_Z~AZ~AZJ~I$# u~SpZ~G$`$ ~Dr~ArL4 % }~b~A~A~I$- s~_\I~J$ / ~Wh~J,0 1~_ZT~AZ~I,P6 ~Wj*~Aj~ID08 ~b~~A~k~A~~A~~A~~I$@O ~Sng~J$O ~Wd~J$P ~Sng~J$@Q ~Wd~J$ R v~Sr[~G$R ~Wh~J$pS ~Wh~J<@T a~Wl~Alb~Alf~Aln~AlG~I$U ~Dt~AtF$pV ~Dt~AtFd0W ~bP~Ax~AW~AT~A~Ap~A~A~AO~I,] ~Wlj~Al~AlI~I,^ ~Wt`~At~Atn~I$ _ ~Wv~J,_ ~_Z~AZS~I$a g~StL~G$@b k~SpP~G$b g~StL~G$ c k~SpP~G$c ~Str~J$ d ~Wj~AjD~I$e ~Wp~J$e ~Dvq~Av_~@$Pf ~Wp~J$g ~Dvr~Av_~@$g ~Wp~J,`h S~Wd~~Ad~J$i ~Wp~J,j ~Dvw~Avw~@$k ~Wp~J,@l ~Dvw~Avw~@$@m ~Wp~~ApF~J$m ~Wd~Adr~J,n ~WtE~At[~AtF~J<o I~Dj~AjI~Ajb~Aj~AjD~Aj[<r /~Dh~AhC~Ahe~Ah~AhC~Ah[4@t ~Z^~A^~A^X~A^U~I4v >~_V7~AV~AV[~AV\~I4@x ~Dnp~An~AnS~AnE~AnM$y |~Sna~G$Pz ~StM~Atl~J$z ~StM~Atl~JD{ ~Wnp~Any~An ~Ano~Ana~An^~I4} ~b|l~A|x~A|~I,@ ~bW~A~Il` M ~b~Ah~Ay~A~A~A ~A~A~A~Ar~I ~\ ~[$ ^~StC~GP ~X$p ~Srz~J, ~WlQ~Al~J$  ~Wt~AtY~J, ~WnV~Any~AnP~I, ~_D~AD~ADO~I, ~b~A~I," ~Whq~Ahw~AhG~I$# ~Wl~AlG~I$$ P~Svu~G$$ o~SrT~G$`% \~StA~G$% \~StA~G\ & ~Wtv~AtS~Atc~At_~Atc~Atc~Atm~Atc~Atj~Atc~AtB~I,( ~Wl~Al]~AlG~I) ~X, ) B~Wdb~Ad~Ip* ~Y* ~Y* ~\* ~Y* ~S<+  ~bn~Al~A~A~I, 3 ~Wf^~Afe~Af~J44  ~b~~A~I~A~~ID > 9~bh~A~A]~Ay~AG~I,`B ~WnH~Ano~An[~J,`C D~WfH~Af~Afi~I$D ~StS~At^~I$@E ~StU~At^~IDE t~_T~ATY~ATf~AT_~ATY~ATc~I$`H D~_@~A@^~I,I d~b~A^~I, K ~b~A^~I, M ~b~A^~I$O ~Wf~Afe~I$P ~Wn~~An^~I$P ~StS~At^~I$`Q ~SrX~Ar^~I$R ~StS~At^~I$R ~Why~Ah^~I$PS ~Wf~Afe~I$PT ~Wh~AhB~I,@U E~Wh~AhL~IV ~X4V :~WhN~Ahh~Ahh~Ahw~J4W f~_XR~AX]~AX~I$`Z 5~Dzp~@<Z S~_~Aq~AO~AG~I,] "~_R>~AR~I$0` ~b~J40c |~b~~A~~A~^~I<q 4~b~~A~~A~b~A~L~I$u ~Snl~JDv ~bu~A~AX~A~A~I$} ~Dn~@,P~  ~Wr~Ar_~I,` ~Wrl~Ard~I,` ~Wrh~ArA~I0 :~y\p  ~bU~A~~A~A~~A~A~AW~A\~I4` .~Wfn~Afe~Afu~AfB~I4 G~W`|~A`~A`~A`E~I ~b~F~A~\~A~k~A~L~A~~A~~A~h~A~M~A~0~A~W~A~[~A~~A~[~A~v~A~~A~|~A~#~A~c~A~~A~E~A~r~A~\~A~S~I$ ^~StC~G, ~bw~AU~IL ~b~ ~A~m~A~~A~ ~A~Z~A~D~I,и ^~b~ ~A~~I$0 l~DzK~Az[~@4 _~b~~A~ ~A~~I ~Y, ~_Z~AZ~I, ~W`g~A`~A`~I ~W,0 ~Wvk~AvS~Av`~I, "~Wh9~Ah~I,0 |~W` ~A`L~J, ~Z^~A^~J$` ~Wf~Af^~J$0 ~Wl~Alq~I,@ ~_R~AR~I$ X~Sx}~G$0 ~Wp~Ap^~I$ ~Wp~Ap^~I ~U,0 ~b~A~I, >~Wjl~Aj~I,@ *~b~Ac~JX,p ]~Wnm~Ano~An~I< 6~bj~A~A_~A~I, ~_T/~AT~I, =~WnX~And~An~I<P ~bl~A^~A~A~ID` ~Wll~Alc~Al~Alb~Alb~Alv~I$0 ~Wt~Atp~I$ ~Slj~J4 ~_Z~AZ_~AZe~AZX~I4 ~Wl`~Al{~Ali~Al~I` ~T$ T~Svy~GD [~W`o~A`c~A`~A`i~A`i~A`v~I4@ ~_B~AB~AB_~ABU~I,@ ~b~A\~I,  ~Wr~~Arf~Ar~I$  h~StM~G< ?~Wd~AdJ~AdX~Ad~AdC~I$ ~Wn~Ann~I$ ~Wn~Ann~I$ ~Svc~AvP~I4p a~_~AJ~A~I,% ~Z^r~A^w~A^~J4' 6~_T~AT~AT~AT|~ID* ~Wll~Alb~Alb~Al~Alb~Alb~Alv~I, "~a,, ~Wf~AfG~J4. ~W`=~A`e~A`A~I, 0 c~Wh~AhA~I41  ~b~A~A~I6 C~b~Al~Ah~AT~A~Au~A`~A]~Aq~Al~Ah~Ad~Al~Al~Ah~A ~Ah~A~Ah~AT~I,> ~Wb.~Abz~I,@ p~Wf$~Afj~I,0B ~Wf6~Afu~I$C @~Wd~J$E M~Wd+~J$PF M~Wd+~J$G ~Wf~J$H ~Wf~J$I ~Wf~J$J 0~Wf~Af[~I$K ~Wf~J$L +~Wf~Af^~I$ N ~Wf~J$ O  ~Wb~J$@P "~Wd~J$pQ "~Wd~J$R P~W`.~J$S ~~_ZT~J$pU P~W`.~J$V ~~_ZT~J,@X e~WfA~AfB~I,Y `~_\~A\~I,\ ~_V~AV~J$ ^ |~SxH~AxY~F$^ B~Sxh~F$^ h~Sxo~Ax^~F$`_ ,~Wn~Anq~I,` ]~Wl ~Alq~I$a ~Dr~ArP$b ~Dr~ArP$c ~Dr~ArP$Pd ~Dr~ArP, e w~Wh7~Ah^~I$f ~Snu~AnB~I,@g f~_@~A@~I$j r~StW~G,0k ~Wp`~Ap~Apz~I$Pl L~Mxo~AxN,l ~Srk~ArG~JrN,@m ~Srk~ArG~JrN$m ~Wt{~Jn \~[,n ~Sre~ArG~JrN,o ~Sre~ArG~JrN, p ~Sre~ArG~JrN,p ~Sre~ArG~JrN,`q ~Wn}~AnG~JnU$ r ~Wt~J,s ~_ZC~AZa~I$u ~Str~J$ v ~Wj~AjD~Iv ~Yw #~b@w ~Y`w ~Yw ~Yw ~Yw ~Yw ~Yx ~Y x 0~oPx 5~tx #~bx #~bx ~Yy ~U0y #~b`y 9~xy 9~xy A~@0z A~@z #~bz #~bz ~Y{ ~Y { ~Y@{ ~Y`{ #~b{ ~U{ ~U{ ~U{ ~U| ~Y0| #~b`| ~Y| ~Y| ~Y| ~Y| ~Y} ~Y } ~Y@} 0~op} 5~t} #~b} #~b~ ~Y0~ ~UP~ #~b~ 9~x~ 9~x A~@P A~@ #~b #~b ~Y ~Y@ ~Y` ~Y #~b ~UЀ ~U ~U ~U0 ~YP #~b ~Y ~Y ~Y ~Y ~Y ~Y@ ~Y` 0~o 5~tЂ #~b #~b0 ~YP ~Up #~b #~bЃ #~b ~Y ~Y@ ~Y` ~Y #~b ~UЄ ~U ~U ~U$0 g~StL~G$ k~SpP~G ~Y0 #~b` ~Y ~Y ~Y ~Y ~Y ~Y ~Y@ 0~op 5~t #~b #~b ~Y0 ~UP #~b 9~x 9~x A~@P A~@ #~bЉ #~b ~Y ~Y@ ~Y` ~Y #~b ~UЊ ~U ~U ~U$0 ~Str~J$  ~Wl~AlF~IЌ ~Y #~b ~Y@ ~Y` ~Y ~Y ~Y ~Y ~Y 0~o0 5~tp #~b #~bЎ ~Y ~U #~b@ 9~x 9~x A~@ A~@` #~b #~b ~Y ~Y ~Y ~Y@ #~bp ~U ~U ~UБ ~U$ ~Str~J$  ~Wl~AlF~I ~Y #~b ~Y ~Y ~Y@ ~Y` ~Y ~Y ~Y 0~o 5~t0 #~b` #~b ~Y ~UЕ #~b 9~x@ 9~x A~@Ж A~@ #~bP #~b ~Y ~Y ~Y ~Y #~b0 ~UP ~Up ~U ~U$ ~Str~J$@  ~Wl~AlF~IP ~Yp #~b ~Y ~Y ~Y ~Y ~Y@ ~Y` ~Y 0~o 5~t #~b #~bP ~Yp ~U #~b 9~x 9~x@ A~@ A~@ #~b #~b@ ~Y` ~Y ~Y ~Y #~b ~U ~U0 ~UP ~U$p ~Str~J$  ~Wl~AlF~I ~Y0 #~b` ~Y ~Y ~Y ~Y ~Y ~Y ~Y@ 0~op 5~t #~b #~b ~Y0 ~UP #~b 9~x 9~x A~@P A~@ #~bФ #~b ~Y ~Y@ ~Y` ~Y #~b ~UХ ~U ~U ~U$0 ~Str~J$  ~Wl~AlF~IЧ ~Y #~b ~Y@ ~Y` ~Y ~Y ~Y ~Y ~Y 0~o0 5~tp #~b #~bЩ ~Y ~U #~b@ 9~x 9~x A~@ A~@` #~b #~b ~Y ~Y ~Y ~Y@ #~bp ~U ~U ~UЬ ~U$ ~Str~J$  ~Wl~AlF~I ~Y #~b ~Y ~Y ~Y@ ~Y` ~Y ~Y ~Y 0~o 5~t0 #~b` #~b ~Y ~Uа #~b 9~x@ 9~x A~@б A~@ #~bP #~b ~Y ~Y ~Y ~Y #~b0 ~UP ~Up ~U ~U ~Yг #~b ~Y ~Y@ ~Y` ~Y ~Y ~Y #~b #~b ~Y@ ~U` #~b 9~xе 9~x A~@` A~@ #~b #~b ~Y0 ~YP ~Yp ~Y #~b ~U ~U ~U ~U@ ~Y` #~b ~Y ~Yи ~Y ~Y ~Y0 ~YP ~Yp 0~o 5~t #~b #~b@ ~Y` ~U #~b 9~x 9~x0 A~@ A~@л #~b #~b0 ~YP ~Yp ~Y ~Y #~b ~U ~U ~U@ ~U` ~Y #~b ~Yн ~Y ~Y ~Y0 ~YP ~Yp ~Y 0~o 5~t #~b0 #~b` ~Y ~U #~bп 9~x 9~xP A~@ A~@ #~b #~bP ~Yp ~Y ~Y ~Y #~b ~U ~U@ ~U` ~U ~Y #~b ~Y ~Y ~Y0 ~YP ~Yp ~Y ~Y 0~o 5~t #~bP #~b ~Y ~U #~b 9~x0 9~xp A~@ A~@ #~b@ #~bp ~Y ~Y ~Y ~Y #~b ~U@ ~U` ~U ~U$ g~StL~G =~|$P ~Str~J$ ~Wj~AjD~I$ ~Wp~J,p ~Wd~Ad^~J$ ~Str~J$ ~Wl~AlF~I ~W$ i~Sx~~AxP~F4p ~~bn~A~Ax~I, ~Wpl~Ap~ApP~I, [~Wrb~Ar~ArF~I$ ~SvC~Ave~I,p ~bL~Ae~I4P  ~b~A0~A~I,0 ~Z^+~A^n~A^I~I$ ~Srk~J4 M~_V~AV~AV@~I$ ~Sld~G$` ~Sle~G4 ~_N~AN~AN~I, I~_\~A\L~I, ~_Z~AZz~ID  ~b~Am~AK~A~A~I, ~_\P~A\\~I,P ~_\P~A\\~I, ~WfB~Af~I, ~_Ho~AHc~AHb~I$ ~Wn~An\~I, (~Wr~ArG~I$ N~DzI~@$p N~DzI~@D ~DzB~Azj~Az_~Azj~Azo~Azb~AzD$ ~Wr}~J$ H~Wf&~J$ ?~_\~J$ ~Wj~J$ ~Wf~J$ .~Wf ~J$ .~Wf ~J$@ ~W`~J,` {~Wd~AdD~I ~]4 ~WtS~At~At]~AtV~I$ ?~Wh~Ahn~J,  ~Z^~A^U~I$ ~SvC~Avc~I$ ~Wn~J,0 g~WnX~An~I,! ~Wpk~Ap(~I,`# ~Wn+~AnE~I,% ~Wpm~ApH~I4& L~b~A~A~I,0- ~Wb~Ab~~J40 ~W` ~A`N~A`a~Id`3 ~_BD~ABJ~ABU~AB}~ABU~AB_~AB~ABU~AB7~ABU~ABC~IL : ~bL~A~A~A;~AG ~Au~I\L ~b}C~A}c~A}~A}:~A}~A}~A}F~I,k ~Z^,~A^W~I<m m~_Vt~AV*~AVK~AVP~AVG~I4 p I~Z^|~A^:~A^Z~A^R~I$pr ~Svu~J$s ~Svu~J,s R~b~~A~p~I$ ~_V~J$ Z~Z^5~J$` k~SvP~G,Ј 8~Wt`~At~Atn~I$ ~Wt{~J$ ~Wl~AlD~I$ ~Wp~J$` ~Wj~J, l~WlC~Al~AlI~I$ j~WdH~J,` g~Wr<~ArI~I,Б -~b~A~I, ~W`w~A`Z~A`B~I$ ~Sny~J$ s~Dtn~@$ +~Wb ~J$P /~Dzj~@$ ~Wn~AnK~I$P 3~Wt~Atq~I$ ~~Snc~G$ ~~Snc~G$ ~Wl~J, H~WnC~An~AnF~I$ \~Wd:~J$@ "~Wt~AtI~I,p w~b~A~I, ~W`w~A`;~A`B~I$б h~S|]~A|o~G,@ ~Sre~ArG~JrN, ~Sns~AnG~JnQ, ~Sra~ArG~JrN0 "~a$` ~Wh~J$@ p~SrU~G  ~J #~b$ ~Wb~J$ q~SrV~G$p ~Wb~J$p z~Sp_~G #~b$ ~Wb~J$ z~Sp_~G$ ~Wb~J$ z~Sp_~G$ w~SxL~AxP~F$ ~Sx]~AxP~I0 +~j$` ~Wd~J$P ~Slo~J #~b$ ~Wf~J$ q~SrV~G,p ~b~AU~I W~V$ ~Z^~JD ~_LD~ALD~ALx~ALc~AL[~ALo~I4 Y~_Ld~AL~AL~I$ ~Wrw~ArP~I$ >~Szc~G, ~_P~AP4~I$0 ~Wl~J$ ~Wl~J$ ~Sll~J$0 ~Wl~J$ ~Wl~J$ ~Slm~J$0 ~Wl~J$ ~Wl~J$ ~Slm~J$0 ~Wl~J$ ~Wj~J$ ~Wj~J$p ~Wl~J$ ~Wl~J$ ~Slm~J,p ~b%~A~I,P ~_R~ARE~I$@ `~Szu~AzP~F %~b}|~A}u~A}0~A}~A}~A}~A}~A}~A}~A}~A}~A}~I, ~Wb&~Aby~Abm~I ~T$ ~Wj~AjG~I$ P~Svu~G$ f~Sxt~AxW~F$P 7~S|\~G, ~Wr~ArM~I,  d~_X ~AXZ~I,  ~b~a~A~=~I,` ^~Wt`~At~Atx~I$ @~Sxe~G$ ~Wv~J, ~_R@~AR]~I$p ~Wp~J,  ~Wf~AfL~J$0 ~Wp~J, ~Wf~AfL~J$ ~Dt~AtF, ~Wh~Ah^~AhG~I$ C~Dz~~@ 9~x,0 ~Dv~AvY~AvF< ~b~A~A`~Az~I, (~_R~AR@~I," ~_T~AT@~I4$ ~bA~A@~AP~I$* ~Wj~AjO~J4+ ~_T~AT~~ATb~ATg~I$. ~Wn~Anj~I,/ ~Wb~Ab3~Abx~I41 ~_T~ATO~ATn~ATN~I4P4 ~_X~AX~AX ~AXN~I$07 ~Wv~Avg~I$ 8 ~W`~A`I~I 9 (~gP9 = ~bM~Az~A~A]~Ay~A~A~A~A&~A[~Aq~Az~A~Al~AY~I$C  ~Dl~AlF$D z~DxG~Axm~@$0E 5~Dzp~@,pE :~_V~AV]~AVI~I4G ~_Z~AZ~AZ~AZN~I4PJ ~_V~AV~AVG~I$L ~Wv~AvP~I$M ~Wlq~AlZ~I,`N ~Wt`~At~~AtW~I,@O ~_X)~AXN~I$R  ~Dl~AlF$T ~Dl~AlF,0U T~Wd`~Adi~Adh~I$V g~SrL~G\W S~_HY~AHm~AH~AH]~AH{~AH~AHm~AH@~AHt~I<`\ ~W`l~A`~A`O~A`t~A`W~J,^ ~Dvg~Avf~AvF< _ K~_Hv~AH~AH~AH1~I$pc ~Wd~JLPd ~b~{~A~J~A~~A~~A~F~A~C~I$Pm ~Wh~AhM~I,0n ~Wlp~AlA~AlG~I,o ~W`<~A`h~I$p ~Wj~J,`q F~Wd~AdW~J,r (~Wd~Ad^~AdG~I$s ~Sng~Jpt (~gt s ~bM~Am~A~A]~A{~A~Ac~A~A~A[~Av~AR~A~An~A^~I, ~ ~Wl~AlH~AlI~I$  w~S|]~A|~~G$ w~S|]~A|~~G, ~WpN~ApG~J$ 0~S|U~G$ ~Shi~J$ m~S|]~A|t~G$ ~Wpi~Ap~I, ~W`~A`B~I$Є -~Wp~ApR~I, ~Wvz~AvV~AvG~I, ~Wj~AjQ~J 0~o 0~o$ ~Dp~@< ~WvG~Ave~Avd~Avd~AvW~J< N~b~A~A~AJ~I, \~Wj~Ajc~I$p ~Wv~J,P ~Z^~A^\~A^G~I,P ~Wvq~AvD~AvG~I$ ~Wvp~Avs~J, k~D|n~A|p~A|F,0 k~D|n~A|p~A|F, ~b~~A~~I,@ l~_N~ANf~I, c~_L~ALU~J4 z~bK~AG~A~I$  ~b~ ~J, w~_\n~A\~A\Z~J,0 ~W`~A`p~I,0 {~_N ~ANF~I, Z~_V)~AVG~I4 ~ ~b~ ~A~@~A~t~I$ v~bI~J$ ~Wd~J4 ~bb~AU~A|~I, ~b~h~A~\~I< C~_F~AF~AFZ~AF^~AFG~I,` ~b1~A~I,p v~b#~Af~I, ~b~AN~I4 ~DzE~Az]~Az~~Azm~AzkD ~b~A~Ad~A_~Ae~I,~b~A~I, ~Wdx~AdO~AdO~J,~_Be~ABU~I, ~_XI~AXS~I 2~q,`~Wv~AvO~AvB~I, l~Wf~AfO~Af~I$~WvX~Avd~I,0;~_X~AXj~AXG~I$p~Wj~J$0~Svg~AvO~J,~b~Ae~I,w~Wj"~Aj_~AjS~I,p~_B~AB~J$pK~Wr~Arz~I, ~Wtv~AtX~J,!~Wtk~At[~J,"w~Wv~AvF~I<0$T~b~AJ~A~A9~I,,v~bA~A~J,3= ~b~~A~p~I$P<~_H^~JL@~b~H~A~~A~~A~q~A~~A~g~I,I~b~ ~A~~I4PX~_Hm~AHv~AH~AHG~I$p[~Wvc~AvY~I$\U~Sxx~AxB~F,p\~bm~A~I$0bQ~Sxv~G$b~SvX~AvO~J, c ~_~AU~I$0fQ~Sxv~G$f4~_X ~J$g^~SrC~G,0h~_Di~ADa~I,j} ~b~~A~~I,pv~_@d~A@X~I$`{N~Sxs~G${Y~_X/~J$}u~_ZL~I4~ ~Wl`~Al~Al6~I #~bP#~b$~Wb~J,~Wj~AjG~JjU$`~Wt{~J$~Wr~ArD~I,A~Wb~AbG~JbU$~Wp~J,~Wf~AfL~J$~Wp~J,p~Wf~AfL~J$~Str~J$~Wl~AlF~I,|~Dz\~AzS~AzF$`~Dz~AzF4~Wrm~Ar[~Ar~Ar^~I$ ~Wp~J$ ~Wtl~AtP~I^~b~~A~S~A~~~A~~A~~A~~A~~~A~_~A~X~A~X~A~o~A~X~A~a~A~x~A~~A~~A~~A~s~A~~A~u~A~F~I, ~_X~AX~I$p~StU~G$8~Dzs~@$~Wt~AtI~I,~WrA~Ar]~J46~Wnv~Anc~An~AnG~I$~Wn~An`~I$~Wr~Ar`~I$~Spx~J$~Wt~AtG~I,@~WfZ~Af~I$в~Z^~J'~f, ~Wv~AvC~I$0~Wx]~Ax`~I<е~_V~AV~AV~AVJ~I<м6~_HJ~AH~AH~AHt~AH{~I$~Wn~AnU~I$ ~Wvs~Avw~J$u~StZ~G$p~Srt~JLW ~b8~Ai~A~A~A ~A~I<p~W`T~A`D~A` ~A`Q~A`V~I,`\~_\~A\|~A\Z~I,~_X~AX~AXf~I<pO~_@T~A@*~A@:~A@k~I4i~be~A~A~I40S~b~~A~~A~~I,~Dz~Az~~AzL4C~_~AC~A|~I4~Dxu~Axb~AxN~AxW~AxH,~_Z~AZ~AZY~I,~_F5~AF`~I !~b}~A}g~A}~A}~A}~A}M~A}=~A}0~A}~A}~A}X~A}~A}~A}~A}~A}s~A}~IT`-~W`\~A`#~A`R~A`u~A`R~A`~A`I~A`q~IlP1 ~bc~A~A~AI~A~A~A~A<~AY~I,0<6~Wfi~Af~AfF~J4p=~DjG~Aj~Aj:~Aj$P@~Dz_~AzwD@~Dr|~Ar~Arp~ArR~Ar_~ArV~ArO$B~Std~AtU~I,@CR~b~Aw~I4HE~Wb!~Abj~Abx~Ab^~I<L~_Zs~AZo~AZ~AZ~IQ ~b~AD~A~A_~A~AE~AC~AR~AC~AJ~AC~A3~AM~Ae~A~A~Ao~I<_~_@A~A@t~A@,~A@G~I4c~_Nr~AN~AN#~ANU~IDpf-~b~A~Aa~A~A]~I,kx~Wd~AdT~I< o$~Wn~An~An~An[~AnW~I\Pq ~b~A~A~A~A~A ~Ar~A^~Id`~~b~~A~/~A~f~A~~A~E~A~~A~[~A~O~I,~_T~AT~ATq~I,[~Wb~Ab}~J4P~_R~AR~AR^~I4p5~Z^~A^~A^~A^O~I,b~Wf9~AfG~I, b~Wf9~AfG~I,-~Wb~AbI~I$~b~J,~b~AB~I,Ю~_Z(~AZi~I$@~Dr~Ar$вF~DzA~@$ ~Dfx~AfX,~Wj~Aj~AjG~I,8~Wby~Ab~AbI~IC~B_~^,p~DzN~Az|~AzF,I~Wt~At~I`W~V$~Wp~ApW~I$~Dz~AzM$L~DzE~AzA,н~Z^~A^~A^e~I,~Dx~AxV~AxZ$^~StC~GLr~Z^~A^_~A^r~A^y~A^X~A^~A^z~A^h~I$~Wp~ApW~I$p~_\~J,~bK~AN~I$t~SpY~G,~b}~A}~I|P~bs~Ar~A~AA~AM~AI~Ap~A~A"~A&~Ax~Ae~I,$~b{~A|~I$0~Wp~ApW~I4 G~Wd~AdZ~Ad<~I,p(~Wd~AdE~I$~Wf~J,o~Wd.~Ad_~I \~b~~A~~A~c~A~~A~~A~l~A~~A~/~A~~A~s~A~~A~o~A~U~I<~Whv~AhH~Ah~Ah~Ahb~I4'~bl~Az$~A~I,:~Wpt~ApG~JpQ$P;~Svi~J,;?~Wb~AbI~I, =~Srj~ArG~JrN,=~Sra~ArG~JrN,`>~SvS~AvG~GvN,>~SvO~AvG~GvN$p?~Wp~J, @~Wd~Ad^~J,@A~Wtn~AtR~AtG~I$A~Wt~At|~J$C9~Dzt~@,PC.~_H~AHK~I,G~Dpg~Ap}~ApQ4H$~_\X~A\~A\~A\L~IDJ ~b~A~Al~A~A~ILV~_Tz~ATo~AT~AT~AT~AT~ATA~I$[~Wv~AvP~I$@\~Wv|~AvP~I$\~Wv~AvP~I,]/~bZ~A~I$b~Dl~AlM,c~W`~A`~I4e~bL~A~A~I$m@~_N~J,o+ ~b ~AH~I< zX ~_FH~AF~AFg~AF~Il ~bL~Av~A~Aq~A~A~A\~AL~Aq~A~I$P~_V~J<ps~_P~AP~AP~AP~AP~I<^~Z^~A^~A^~A^V~I4P~Wta~Atg~AtQ~AtG~I$ L~DzE~AzAp#~b$h~Dz\~AzF~\,0~Dzv~Az~~AzN$m~Stz~AtX~F,p~Dxm~Axr~AxM,0~Wbf~Abz~I4~_Lq~AL~AL`~ALe~I,Ф(~_B~ABU~I, ~b~~A~R~I$/~Dzj~@$@`~D|P~A|J$~Dz~AzP4@G~bW~AE~A}~IL~_VO~AV[~AVW~AV~AVm~AVn~AV^~I+~j$@~Wd~J<@~b~A,~A~A?~I,~Wl~Aly~Al^~I,a~Wd~Ad~I4`~Wf~Af~Af_~AfN~I` ~J$p~Sln~J$~Wl~AlG~I,~Wb~Abj~I4~Wb~Ab~Abb~AbN~IP ~J$`~Wf~J$~Wf~AfG~I,7~_\~A\j~I4@~Wb~AbD~Abz~AbE~I ~J ~J~R ~J$ ~Sht~J$~Dh~AhF$~Wxc~Ax~~I4Z~_R~AR3~AR<~I47$~b}~A}~A}!~I$@~S|]~A|W~J#~b$~Wt{~J_~^$~Wt{~J=~|$~Wt~J$~Wl~AlF~I,~Sre~ArG~JrN,P~Sns~AnG~JnQ,~Sra~ArG~JrN$o~D|X~A|Q$m~D|S~A|T$~D|~A|U$0~D|~A|b$C~D|~A|d$@Z~D|~A|~(~g(~g$o~D|X~A|Q$pm~D|S~A|T$~D|~A|U$~D|~A|b$PC~D|~A|d$ Z~D|~A|~ (~g0 (~g,` ~Wt`~Aty~AtW~I,@ ~Srg~ArG~JrN, ~St[~AtG~GtN,p ~Sre~ArG~JrN,~StY~AtG~GtN,~Sri~ArG~JrN,@~St[~AtG~GtN,~Stc~AtG~JtN,p~Stc~AtG~JtN,~Srg~ArG~JrN,~St[~AtG~GtN,@~Sre~ArG~JrN,~StY~AtG~GtN,p~Sri~ArG~JrN,~St[~AtG~GtN,~Stc~AtG~JtN,@~Stc~AtG~JtN,~DzS~Azn~Az`~@$>~Szc~G,~Wt`~At~Atb~I4A~W`~A`+~A`M~I$g~SrL~GDP~bl~A|~A[~A_~As~I$ C~Dz~~@p ~Y4 ~b~A~A_~I4 &R~b~Ay~A_~ID*x~b~A~Aw~A~Ah~I,0 ~Wt`~At~At~I,4~_\~A\~I$5~Wz~J,6~WpV~Apz~I,P8~_\~A\v~I$9~Wh~AhG~I4:~Wj|~Aj~Ajz~Ajl~I,<~b~Aq~I,D ~_@~A@\~I$J~Sjx~J,Jx~Z^H~A^K~I$0Lk~Dzt~Azq,L~Wp~Apf~I,M~_ZI~AZ~I,O~_\~A\k~A\~I$Ql~SrQ~G,R~Wp;~ApS~ApO~J<S~_~A~AU~Ac~I$`[~Wf~J$0\m~S|]~A|t~G$\g~StL~G$]k~SpP~G]<~{,]O~b~AX~I,e~Wd~Adj~AdG~I4f~bt~A~A}~I,l~_Dc~AD~I,`q~Wr~Ar`~J$r~D|~A|N, s~Dpe~Ap2~Apc,tL~Dj~Ajz~AjTDv~b~A,~A~A ~Ah~I,|~Wd~Ad}~IL~~b~~A~v~A~0 ~A~~A~~A~k~I,~_Za~AZL~I,0^~Wd ~Ads~I,~Whk~Ah~Aha~I4  ~Wf~Af)~Afh~AfG~I40~b~A~At~I,~Wh~Ah~I4~WvY~Ava~Avk~AvB~J,p3~Wj~Ajh~AjZ~I$ ~Wb~J$~Wb~J$Ъn~SrS~G,@{~Wj~AjB~I$~Dx~Ax[$~Dxx~Axj~Y$;~Wh~Ahj~I4 ~bm~Ah~A~I$~Z^~J\@~b~AA~AT~A~A`~A5~AA~Af~I$~Wxy~AxB~I$~Dv~AvF,0~_V~AV~I$~Wx~Axg~I,0~Wfw~AfX~AfN~I,~Wjh~Aj~AjP~I,~_Xw~AX~AX@~I4p/~Wfh~Afi~Afj~AfP~I,~b~A~I,0K~Wb~AbP~I$~Wn~J,`~Dx\~AxY~AxW~@,~_Xw~AX~AX@~I4~W`k~A`~A`~I,~Wth~At~AtB~I,~Sth~AtE~AtB~I<k~bw~Ad~A~A~I4~_@w~A@ ~A@~A@M~I,`E~b~AB~I,e~_\w~A\~A\q~I$ ~Wp~Ap^~ID  ~bw~A~A~A~A`~I$~Dn~AnM  ~_$ T~DzO~@$0 /~Wh~Ahg~I,` ~Wl~AlG~I$0 !~Wh~AhG~I$`~Dh ~AhF, ~b|~A|K~I,m~_B.~ABU~I4~b~A~A~I$"~Sva~AvP~I$@#/~Dzj~@$p#k~D|[~A|J$#~Dz~AzP$$~Sva~AvP~I$@%/~Dzj~@,p%~D|~A|Q~A|\$&~Dz~AzP$`'e~SvJ~G$'~Sno~J`(~P(~\(~P(~U(~X$)@~D|t~A|F4@)~D|D~A|z~A|j~A|T,*~Wx`~Ax~Axn~I,+~Sre~ArG~JrN,+~Sns~AnG~JnQ,`,~Sra~ArG~JrN,-~Sre~ArG~JrN,-~Sns~AnG~JnQ,P.~Sra~ArG~JrN,.~Wpt~ApG~JpQ$/~Wt{~J@0=~|$0h~S|]~A|o~G,0~WxK~Ax~I,1_~Wjx~Aju~AjN~JP3"~a$3~WxS~Axy~I,04?~_\}~A\b~A\u~I$p6q~SvV~G$6~Dr~ArF$7~Dn~@,8X~Wl(~AlN~I,: ~Wh|~AhS~AhW~I$ =x~Sn]~G,=~Wx`~Ax`~AxW~I`>~, @4~_Vx~AV~J,`BT~_J~AJf~I4C~_N~ANX~AN~J<FM~b ~A~A~A~ITK ~b~A~A~A~A~A~AR~IDpV1~_Tw~AT~~AT~AT~AT~ATE~I,Z=~Wt`~At~Atn~I,[.~Wt`~At~Atn~I, ]~Z^~A^R~J4^ ~b8~A[~AK~J,c~Wb)~Aba~AbZ~I$d~S|]~A|R~J eE~b~~~A~G~A~p~A~~A~~A~O~A~~A~!~A~~A~~A~~A~~A~x~A~i~A~~I4p{ ~b~A~A~I,0a~W`s~A` ~I$>~Szc~G$~Wr~ArO~J+~j4Њ~b~A~Ae~I$/~Dzj~@$n~D|b~A|F$ Q~Wr~Arq~I, ~Z^w~A^S~A^[~I4:~b~g ~A~K~A~Z~I$Ф5~Dzp~@,`~Wn ~Anq~I,p~_\r~A\M~A\K~I4p~b~~A~Y~A~q~I$ ~Snd~G$t~SlY~G4 .~xn~An)~An~I$ o~SnT~G$~Wh~J$@J~Sxo~G, ~Wdw~Ads~J,g~_R~AR~I,t~_P<~APN~I$/~Dzj~@$~Wn~AnG~I,p~Wh~Aha~Ahc~J,@4~_@~A~I,~Wv~AvO~AvO~J$Po~SnT~G$o~SnT~G,0. ~b~ ~A~B~I,`g ~b~ ~A~U~I$0~S|U~G ~_, m~_Z~AZ~I$ ~Wj~AjF~I$p )~Wn~J$  ~Wp~ApB~I$ R~Wn0~J$ ~Wt~J$~Wn~J<`~b~~A~Z~A~ ~A~>~I,@!~_L~AL~IL&~b~A~Al~A~A~AK~I,-~b:~Af~I$P65~_\~A\P~I,7~b~\~A~~~I,`@~_Z9~AZ~I,pB~Z^U~A^~I$pDf~SxK~G$Db~SxG~G4PE~b~~A~ ~A~U~I$PLf~Sv_~Avk~G$LZ~St~G$ Mf~Sv_~Avk~G4M~b~~A~ ~A~U~I,T~_Z~AZ\~I$`V~W`~J$pWS~DxN~@,W#~b~Aq~I,]N ~b}~A}c~I,PfY~WrE~Arx~Ar~J$g~b~J$j~Wr~ArK~I$pk~Dzp~AzJ$k~Dzp~AzJ$plm~Dxa~AxF$lz~_DP~J,`n~Z^~A^m~A^q~I$ q~Sjv~AjB~I,qo~Wt`~At~Atn~I$0s~Sjq~J$s~Wt~J,th~Wb8~AbN~I,u~Sre~ArG~JrN,v~Wh~AhG~JhU,w~Sre~ArG~JrN, x~Wh~AhG~JhU,y~Sra~ArG~JrN,y~Sns~AnG~JnQ$`z~Wp~J,{~Wf~AfL~J$ |~Wp~J,|~_\~A\\~J$~Wt{~J}~|4 ~Wj!~AjT~Aj~~I$@v~Sp[~G$0~S|U~G$v~Sp[~G$p~Wj~J0+~j$`r~S|]~A|y~G,<~Wd~AdG~JdU, ~Wpw~ApG~JpQ,b~S|q~A|G~G|N,P~Wpw~ApG~JpQ,~Wj~AjG~JjU,~Stc~AtG~JtN$ ~Wn~An`~I$~Wp~ApB~Ip~P$h~S|]~A|o~G$~Str~J$0~Wl~AlO~I$h~S|]~A|o~G,0~_\F~A\w~I$ h~S|]~A|o~G$~Wvf~AvW~I,0~W`f~A`j~I,y~Wp~ApH~J$p~Wvn~AvO~J$~S|]~A|M~J,~_DV~ADh~I,P~_Dm~ADh~I,~_D~ADh~I$|~S|]~A|C~G$ps~Sxz~Ax^~F$~W`~J$~S|]~A|H~JHkm (  $i$$ GLP3{P3/bP3bp;=er|=r|PC/PCwPC3LwPCf@H#OZO_ 1xOO_ %x]}!&]dxd#7Yds7Yd5Y hy @pk&{ux{Nf{{vf{{ C ТnF335Т 2 F335Т 33Т 33Zt{ u-4`T%*1`%%\%[`eG%N%_ 9%@%{8  * blx8 %%hiiw~P FTPM ?P*1P> #*0,;yiC2ryCQryG*cS[bd W W W0\80\:c9gu eYa e e> eo  e' A  ek z} e z} e=a}~~ ~g mvKP d+ *`*KYp*IPocjl6=Ba07P`4j_fudk 30u)5<GI.5G  49iT1 O qIb . b . 1b r 1[  1[ X 13'')B0BGKNY*%9\YIz%9\Y%c%9NY%9GY!#%9@ \!#F \@{qv#F \Zv#8 \#1 \#*fD .fh  .`kW,Os!|s }yo y< nifa[L lpS0m O010[  q6D JQt/6`BJX``JX`` /6`/6` (/`7^`Vn4Fb)` u yn u rn u $g n   K ` K ` @ @[- h @y B 0 5 iMb ]vMbP (fe l   Pi r"i w`i % 9\ % G\ % 9 % $2 % $ % $0 '0 ` '08 Au@T <=?APWU EpV E0W 6o *;Io ];Io J-;r +!/r ^!/r 5!v [[&4@x ^PWhz@x 4z{     Gc+ .+ '.+ #;4 rw > z > (/ > (/Z af"BI] {^c0` YM0c wD]r0c #4]r0c Fy/]r0c /]r0c  ?  /]rq R#*q 4NR#*v {v v p  p  p + p p m p  # p #t y V      inw tZ G0XZ u| 0XZ 0XU 2x 1_x sUx  sUx % \ 7  S 7   ; и 1Mи  ! * c c   O \av0 O0 nsO FxP vP P  NM^@ .L@ .\p nN"Wp @Wp P"@' ",@g r;\p hfmp "P Q # P K 0 S0 f ( < = M  `# 37COk0 )fp0 Pdpuw0 P%pu : x} : zL pL L L L X>CLL Y& L $ L   L }k I %k %z|~m ,\cs f Hs ] b  Hs 3q,:s 9  z P` D /Q[HObБ  >y D /Q['.>p m(- >yp p X O 3Hp   jP |  WY sx. 0  $ <d$ S$ Q+ eP9 n , P9 i(  P9 W< P9 :  P9  C & G @O {@O  Oh{R & T &0U <CJW =;BW j4^  _  Y ,APd !Pd 4o nur -r Ht 8 b t 5F M t 8 ? t :1 8 t I *  !mqs ::D Z:?P iP P < E` [ W    0 /+q 4 X t   X t    X t  K_ y  X t  ] y  X f 'I\  [ &629 829` p F { \&+> LQ E^2 J |+2upJ.A3M 3 3Ou3y3P<nI/iI( &IW p\NzBGp`jnmX/=2/=2/=`(/p@ QXJQ0 I0DPp I0pP 4B0^ c -0&0A J0q N n  $ J020'*0P*0 0ot000sPnG9.$+`"{8U Zls!!  4 m!{! p8_!m!  !_! '!HQ4HeQ"P Q G knPq Pq U`~xsx:)Z`~DESrfhrP`9P+7E QX E QXMu#tOiu#}B"[BЮdЮvDe:ah<'@ESaf'ES'ES2^n|n-A^n|P P9Y l   7 F p jKR KR -KR DK =D %2  <PCaPC[J J 7 > V;bc6eoI ! oy ! oT zh G N z - Ф/ 8c@-@6= ZhXzZh@s]sT(HVZLo}.gwZ_#&$S ## j## ~##j0##%~##GT#~#5.op#w#aT#[#\""### w &OV[:H* W+bgn6:86<N<th<%DaDDDqD+YO7(8SST,bS]v">]?0>]?v"0eKf#0vfB"'0vls`olhs1Vo} sSestV7>~IY 8V~V%)kr~~ n dk~  ) dk~v\V] ||@!%/q t  r )t2    - n @=o@k ov@gLS@W7><2DJL2qx cjU\G\sG, $2$2DJL)%MZaMSZgz`J4;`Z-4`Z-`a-W*[!A*[)?F *1 Zq x   $ c ,$ c +` }30 ]`#U 2   W I]z o $ 6>Nc9NcU\Rmt04ri 66+8W,@N8t@N8@G^P^cM7AYc} e4; eB eB e e e! %  e! >  eFfp{z/ p{^ p{c | )0,Zpdpr5 I.. W'.. !8.. f 8..]=V]@mgu@ gu0u   0#3 M u   ` O V `IY s O V ,35L X  @ AH&G-cu- FO7\aoPEJMJ]l! D ],l! D ]A])q] glxfvP}JTZtesting/internal/testdeps.ImportPathZruntime.writeBarrierZgo.itab.testing/internal/testdeps.TestDeps,testing.testDepsZruntime.zerobase[main.tests6[main.benchmarksV[main.examplest[main.initdone·[main.statictmp_0[main.statictmp_1[main.statictmp_2[runtime.algarray\runtime.support_aes<\runtime.support_ssse3b\runtime.support_sse41\runtime.useAeshash\runtime.aeskeysched\runtime.hashkey\runtime.iscgo ]runtime.framepointer_enabled:]runtime.main_init_donea]runtime.extraMWaiters]runtime.debug]runtime.mheap_]runtime.statictmp_0]runtime.blockprofilerate^runtime.statictmp_25^runtime.statictmp_1Y^runtime.statictmp_4}^runtime.statictmp_3^$f64.3ff0000000000000^runtime.inf^runtime.processorVersionInfo_runtime.isIntel0_runtime.support_avxT_runtime.useAVXmemmovez_runtime.cpuprof_runtime.prof_runtime.sched_runtime.gomaxprocs_runtime.newprocs`runtime.ncpu6`runtime.allmS`runtime._cgo_setenvw`runtime._cgo_unsetenv`runtime.statictmp_6`runtime.statictmp_7`runtime.statictmp_8 aruntime.fastlog2Table/a$f64.3eb0000000000000Uaruntime.zeroValuaruntime.statictmp_9a$f32.40d00000aruntime.statictmp_10aruntime.statictmp_11bruntime.statictmp_12&bruntime.allglenFbruntime.allgsdbruntime.firstmoduledatabruntime.memstatsbruntime.ifaceLockbruntime.hashbruntime.cgo_yieldcruntime.class_to_size4cruntime.physPageSizeYcruntime.statictmp_13~cruntime.gcphasecruntime.gcBlackenEnabledcruntime.MemProfileRatecruntime.deferTypedruntime.size_to_class87druntime.size_to_class128`druntime.statictmp_14d$f64.403a000000000000d$f64.bfe62e42fefa39efdruntime.globalAllocdruntime.oneBitCounteruntime.emptymspanunicode.ZlYunicode.Zptunicode.Zsunicode.Categoriesunicode.Adlamunicode.Ahomunicode.Anatolian_Hieroglyphsunicode.Arabic:unicode.Armenian[unicode.Avestan{unicode.Balineseunicode.Bamumunicode.Bassa_Vahunicode.Batakunicode.Bengaliunicode.Bhaiksuki<unicode.Bopomofo]unicode.Brahmi|unicode.Brailleunicode.Bugineseunicode.Buhidunicode.Canadian_Aboriginalunicode.Carian&unicode.Caucasian_AlbanianQunicode.Chakmapunicode.Chamunicode.Cherokeeunicode.Commonunicode.Copticunicode.Cuneiformunicode.Cypriot.unicode.CyrillicOunicode.Deseretounicode.Devanagariunicode.Duployanunicode.Egyptian_Hieroglyphsunicode.Elbasanunicode.Ethiopic!unicode.GeorgianBunicode.Glagoliticeunicode.Gothicunicode.Granthaunicode.Greekunicode.Gujaratiunicode.Gurmukhiunicode.Han unicode.Hangul?unicode.Hanunoo_unicode.Hatran~unicode.Hebrewunicode.Hiraganaunicode.Imperial_Aramaicunicode.Inherited unicode.Inscriptional_Pahlavi7unicode.Inscriptional_Parthianfunicode.Javaneseunicode.Kaithiunicode.Kannadaunicode.Katakanaunicode.Kayah_Liunicode.Kharoshthi+unicode.KhmerIunicode.Khojkihunicode.Khudawadiunicode.Laounicode.Latinunicode.Lepchaunicode.Limbuunicode.Linear_A"unicode.Linear_BCunicode.Lisu`unicode.Lycianunicode.Lydianunicode.Mahajaniunicode.Malayalamunicode.Mandaicunicode.Manichaean$unicode.MarchenDunicode.Meetei_Mayekiunicode.Mende_Kikakuiunicode.Meroitic_Cursiveunicode.Meroitic_Hieroglyphsunicode.Miaounicode.Modiunicode.MongolianAunicode.Mro]unicode.Multani}unicode.Myanmarunicode.Nabataeanunicode.New_Tai_Lueunicode.Newaunicode.Nkounicode.Ogham:unicode.Ol_Chiki[unicode.Old_Hungarianunicode.Old_Italicunicode.Old_North_Arabianunicode.Old_Permicunicode.Old_Persianunicode.Old_South_Arabian?unicode.Old_Turkicbunicode.Oriyaunicode.Osageunicode.Osmanyaunicode.Pahawh_Hmongunicode.Palmyreneunicode.Pau_Cin_Hau)unicode.Phags_PaJunicode.Phoenicianmunicode.Psalter_Pahlaviunicode.Rejangunicode.Runicunicode.Samaritanunicode.Saurashtraunicode.Sharada7unicode.ShavianWunicode.Siddhamwunicode.SignWritingunicode.Sinhalaunicode.Sora_Sompengunicode.Sundaneseunicode.Syloti_Nagri'unicode.SyriacFunicode.Tagalogfunicode.Tagbanwaunicode.Tai_Leunicode.Tai_Thamunicode.Tai_Vietunicode.Takriunicode.Tamil$unicode.TangutCunicode.Telugubunicode.Thaanaunicode.Thaiunicode.Tibetanunicode.Tifinaghunicode.Tirhutaunicode.Ugaritic unicode.Vai<unicode.Warang_Citi`unicode.Yi{unicode.Scriptsunicode.ASCII_Hex_Digitunicode.Bidi_Controlunicode.Dashunicode.Deprecated(unicode.DiacriticJunicode.Extenderkunicode.Hex_Digitunicode.Hyphenunicode.IDS_Binary_Operatorunicode.IDS_Trinary_Operatorunicode.Ideographic)unicode.Join_ControlNunicode.Logical_Order_Exception~unicode.Noncharacter_Code_Pointunicode.Other_Alphabeticunicode.Other_Default_Ignorable_Code_Pointunicode.Other_Grapheme_Extend@unicode.Other_ID_Continuejunicode.Other_ID_Startunicode.Other_Lowercaseunicode.Other_Mathunicode.Other_Uppercaseunicode.Pattern_Syntax+unicode.Pattern_White_SpaceWunicode.Prepended_Concatenation_Markunicode.Quotation_Markunicode.Radicalunicode.Sentence_Terminalunicode.Soft_Dotted!unicode.Terminal_PunctuationNunicode.Unified_Ideographxunicode.Variation_Selectorunicode.Propertiesunicode.foldLunicode.foldLlunicode.foldLt"unicode.foldLuAunicode.foldM_unicode.foldMn~unicode.FoldCategoryunicode.foldCommonunicode.foldGreekunicode.foldInheritedunicode.FoldScript1unicode.statictmp_19Vunicode.statictmp_20{unicode.statictmp_23unicode.statictmp_25unicode.statictmp_28unicode.statictmp_31unicode.statictmp_13unicode.statictmp_33Xunicode.statictmp_36}unicode.statictmp_39unicode.statictmp_42unicode.statictmp_44unicode.statictmp_4unicode.statictmp_475unicode.statictmp_50Zunicode.statictmp_52unicode.statictmp_7unicode.statictmp_55unicode.statictmp_58unicode.statictmp_61unicode.statictmp_107unicode.statictmp_64\unicode.statictmp_66unicode.statictmp_68unicode.statictmp_70unicode.statictmp_72unicode.statictmp_74unicode.statictmp_77:unicode.statictmp_13_unicode.statictmp_79unicode.statictmp_81unicode.statictmp_84unicode.statictmp_87unicode.statictmp_90unicode.statictmp_92=unicode.statictmp_94bunicode.statictmp_16unicode.statictmp_96unicode.statictmp_99unicode.statictmp_102unicode.statictmp_105unicode.statictmp_108Cunicode.statictmp_110iunicode.statictmp_113unicode.statictmp_115unicode.statictmp_118unicode.statictmp_121unicode.statictmp_123'unicode.statictmp_125Municode.statictmp_128sunicode.statictmp_130unicode.statictmp_133unicode.statictmp_135unicode.statictmp_137 unicode.statictmp_1391unicode.statictmp_141Wunicode.statictmp_144}unicode.statictmp_147unicode.statictmp_150unicode.statictmp_152unicode.statictmp_154unicode.statictmp_157;unicode.statictmp_159aunicode.statictmp_162unicode.statictmp_165unicode.statictmp_167unicode.statictmp_170unicode.statictmp_172unicode.statictmp_175Eunicode.statictmp_178kunicode.statictmp_181unicode.statictmp_183unicode.statictmp_185unicode.statictmp_188unicode.statictmp_191)unicode.statictmp_194Ounicode.statictmp_197uunicode.statictmp_199unicode.statictmp_201unicode.statictmp_204unicode.statictmp_206 unicode.statictmp_2083unicode.statictmp_211Yunicode.statictmp_213unicode.statictmp_216unicode.statictmp_219unicode.statictmp_222unicode.statictmp_225unicode.statictmp_228=unicode.statictmp_230cunicode.statictmp_233unicode.statictmp_235unicode.statictmp_238unicode.statictmp_240unicode.statictmp_243!unicode.statictmp_245Gunicode.statictmp_248municode.statictmp_251unicode.statictmp_253unicode.statictmp_255unicode.statictmp_257unicode.statictmp_259+unicode.statictmp_262Qunicode.statictmp_265wunicode.statictmp_267unicode.statictmp_270unicode.statictmp_273unicode.statictmp_276unicode.statictmp_2785unicode.statictmp_280[unicode.statictmp_283unicode.statictmp_286unicode.statictmp_288unicode.statictmp_291unicode.statictmp_294unicode.statictmp_297?unicode.statictmp_300eunicode.statictmp_303unicode.statictmp_306unicode.statictmp_309unicode.statictmp_312unicode.statictmp_314#unicode.statictmp_317Iunicode.statictmp_319ounicode.statictmp_322unicode.statictmp_324unicode.statictmp_326unicode.statictmp_328unicode.statictmp_331-unicode.statictmp_334Sunicode.statictmp_337yunicode.statictmp_340unicode.statictmp_343unicode.statictmp_346unicode.statictmp_349unicode.statictmp_3517unicode.statictmp_354]unicode.statictmp_357unicode.statictmp_360unicode.statictmp_363unicode.statictmp_366unicode.statictmp_368unicode.statictmp_371Aunicode.statictmp_374gunicode.statictmp_376unicode.statictmp_378unicode.statictmp_380unicode.statictmp_382unicode.statictmp_385%unicode.statictmp_388Kunicode.statictmp_391qunicode.statictmp_394unicode.statictmp_397unicode.statictmp_400unicode.statictmp_402 unicode.statictmp_404/unicode.statictmp_406Uunicode.statictmp_408{unicode.statictmp_410unicode.statictmp_412unicode.statictmp_414unicode.statictmp_416unicode.statictmp_4199unicode.statictmp_421_unicode.statictmp_424unicode.statictmp_426unicode.statictmp_428unicode.statictmp_430unicode.statictmp_432unicode.statictmp_434Cunicode.statictmp_437iunicode.statictmp_440unicode.statictmp_442unicode.statictmp_445unicode.statictmp_447unicode.statictmp_449'unicode.statictmp_451Municode.statictmp_453sunicode.statictmp_456unicode.statictmp_459unicode.statictmp_462unicode.statictmp_464 unicode.statictmp_4661unicode.statictmp_468Wunicode.statictmp_470}unicode.statictmp_473unicode.statictmp_475unicode.statictmp_477unicode.statictmp_480unicode.statictmp_483;unicode.statictmp_486aunicode.statictmp_489unicode.statictmp_491unicode.statictmp_493unicode.statictmp_495unicode.statictmp_498unicode.statictmp_501Eunicode.statictmp_503kunicode.statictmp_505unicode.statictmp_508unicode.statictmp_510unicode.statictmp_512unicode.statictmp_515)unicode.statictmp_518Ounicode.statictmp_521uunicode.statictmp_524unicode.statictmp_527unicode.statictmp_529unicode.statictmp_530 unicode.statictmp_5313unicode.statictmp_533Yunicode.statictmp_536unicode.statictmp_538unicode.statictmp_541unicode.statictmp_543unicode.statictmp_545unicode.statictmp_547=unicode.statictmp_549cunicode.statictmp_2unicode.statictmp_3unicode.statictmp_5unicode.statictmp_6unicode.statictmp_8unicode.statictmp_9;unicode.statictmp_11`unicode.statictmp_12unicode.statictmp_14unicode.statictmp_15unicode.statictmp_17unicode.statictmp_21unicode.statictmp_22>unicode.statictmp_24cunicode.statictmp_26unicode.statictmp_27unicode.statictmp_29unicode.statictmp_30unicode.statictmp_32unicode.statictmp_34Aunicode.statictmp_35funicode.statictmp_37unicode.statictmp_38unicode.statictmp_40unicode.statictmp_41unicode.statictmp_43unicode.statictmp_45Dunicode.statictmp_46iunicode.statictmp_48unicode.statictmp_49unicode.statictmp_51unicode.statictmp_53unicode.statictmp_54"unicode.statictmp_56Gunicode.statictmp_57lunicode.statictmp_59unicode.statictmp_60unicode.statictmp_62unicode.statictmp_63unicode.statictmp_65%unicode.statictmp_67Junicode.statictmp_69ounicode.statictmp_71unicode.statictmp_73unicode.statictmp_75unicode.statictmp_76unicode.statictmp_78(unicode.statictmp_80Municode.statictmp_82runicode.statictmp_83unicode.statictmp_85unicode.statictmp_86unicode.statictmp_88unicode.statictmp_89+unicode.statictmp_91Punicode.statictmp_93uunicode.statictmp_95unicode.statictmp_97unicode.statictmp_98unicode.statictmp_100 unicode.statictmp_1010unicode.statictmp_103Vunicode.statictmp_104|unicode.statictmp_106unicode.statictmp_107unicode.statictmp_109unicode.statictmp_111unicode.statictmp_112:unicode.statictmp_114`unicode.statictmp_116unicode.statictmp_117unicode.statictmp_119unicode.statictmp_120unicode.statictmp_122unicode.statictmp_124Dunicode.statictmp_126junicode.statictmp_127unicode.statictmp_129unicode.statictmp_131unicode.statictmp_132 unicode.statictmp_134( unicode.statictmp_136N unicode.statictmp_138t unicode.statictmp_140 unicode.statictmp_142 unicode.statictmp_143 unicode.statictmp_145 unicode.statictmp_1462 unicode.statictmp_148X unicode.statictmp_149~ unicode.statictmp_151 unicode.statictmp_153 unicode.statictmp_155 unicode.statictmp_156 unicode.statictmp_158< unicode.statictmp_160b unicode.statictmp_161 unicode.statictmp_163 unicode.statictmp_164 unicode.statictmp_166 unicode.statictmp_168 unicode.statictmp_169F unicode.statictmp_171l unicode.statictmp_173 unicode.statictmp_174 unicode.statictmp_176 unicode.statictmp_177 unicode.statictmp_179* unicode.statictmp_180P unicode.statictmp_182v unicode.statictmp_184 unicode.statictmp_186 unicode.statictmp_187 unicode.statictmp_189unicode.statictmp_1904unicode.statictmp_192Zunicode.statictmp_193unicode.statictmp_195unicode.statictmp_196unicode.statictmp_198unicode.statictmp_200unicode.statictmp_202>unicode.statictmp_203dunicode.statictmp_205unicode.statictmp_207unicode.statictmp_209unicode.statictmp_210unicode.statictmp_212"unicode.statictmp_214Hunicode.statictmp_215nunicode.statictmp_217unicode.statictmp_218unicode.statictmp_220unicode.statictmp_221unicode.statictmp_223,unicode.statictmp_224Runicode.statictmp_226xunicode.statictmp_227unicode.statictmp_229unicode.statictmp_231unicode.statictmp_232unicode.statictmp_2346unicode.statictmp_236\unicode.statictmp_237unicode.statictmp_239unicode.statictmp_241unicode.statictmp_242unicode.statictmp_244unicode.statictmp_246@unicode.statictmp_247funicode.statictmp_249unicode.statictmp_250unicode.statictmp_252unicode.statictmp_254unicode.statictmp_256$unicode.statictmp_258Junicode.statictmp_260punicode.statictmp_261unicode.statictmp_263unicode.statictmp_264unicode.statictmp_266unicode.statictmp_268.unicode.statictmp_269Tunicode.statictmp_271zunicode.statictmp_272unicode.statictmp_274unicode.statictmp_275unicode.statictmp_277unicode.statictmp_2798unicode.statictmp_281^unicode.statictmp_282unicode.statictmp_284unicode.statictmp_285unicode.statictmp_287unicode.statictmp_289unicode.statictmp_290Bunicode.statictmp_292hunicode.statictmp_293unicode.statictmp_295unicode.statictmp_296unicode.statictmp_298unicode.statictmp_299&unicode.statictmp_301Lunicode.statictmp_302runicode.statictmp_304unicode.statictmp_305unicode.statictmp_307unicode.statictmp_308 unicode.statictmp_3100unicode.statictmp_311Vunicode.statictmp_313|unicode.statictmp_315unicode.statictmp_316unicode.statictmp_318unicode.statictmp_320unicode.statictmp_321:unicode.statictmp_323`unicode.statictmp_325unicode.statictmp_327unicode.statictmp_329unicode.statictmp_330unicode.statictmp_332unicode.statictmp_333Dunicode.statictmp_335junicode.statictmp_336unicode.statictmp_338unicode.statictmp_339unicode.statictmp_341unicode.statictmp_342(unicode.statictmp_344Nunicode.statictmp_345tunicode.statictmp_347unicode.statictmp_348unicode.statictmp_350unicode.statictmp_352 unicode.statictmp_3532unicode.statictmp_355Xunicode.statictmp_356~unicode.statictmp_358unicode.statictmp_359unicode.statictmp_361unicode.statictmp_362unicode.statictmp_364<unicode.statictmp_365bunicode.statictmp_367unicode.statictmp_369unicode.statictmp_370unicode.statictmp_372unicode.statictmp_373 unicode.statictmp_375Funicode.statictmp_377lunicode.statictmp_379unicode.statictmp_381unicode.statictmp_383unicode.statictmp_384 unicode.statictmp_386* unicode.statictmp_387P unicode.statictmp_389v unicode.statictmp_390 unicode.statictmp_392 unicode.statictmp_393 unicode.statictmp_395!unicode.statictmp_3964!unicode.statictmp_398Z!unicode.statictmp_399!unicode.statictmp_401!unicode.statictmp_403!unicode.statictmp_405!unicode.statictmp_407"unicode.statictmp_409>"unicode.statictmp_411d"unicode.statictmp_413"unicode.statictmp_415"unicode.statictmp_417"unicode.statictmp_418"unicode.statictmp_420"#unicode.statictmp_422H#unicode.statictmp_423n#unicode.statictmp_425#unicode.statictmp_427#unicode.statictmp_429#unicode.statictmp_431$unicode.statictmp_433,$unicode.statictmp_435R$unicode.statictmp_436x$unicode.statictmp_438$unicode.statictmp_439$unicode.statictmp_441$unicode.statictmp_443%unicode.statictmp_4446%unicode.statictmp_446\%unicode.statictmp_448%unicode.statictmp_450%unicode.statictmp_452%unicode.statictmp_454%unicode.statictmp_455&unicode.statictmp_457@&unicode.statictmp_458f&unicode.statictmp_460&unicode.statictmp_461&unicode.statictmp_463&unicode.statictmp_465&unicode.statictmp_467$'unicode.statictmp_469J'unicode.statictmp_471p'unicode.statictmp_472'unicode.statictmp_474'unicode.statictmp_476'unicode.statictmp_478(unicode.statictmp_479.(unicode.statictmp_481T(unicode.statictmp_482z(unicode.statictmp_484(unicode.statictmp_485(unicode.statictmp_487(unicode.statictmp_488)unicode.statictmp_4908)unicode.statictmp_492^)unicode.statictmp_494)unicode.statictmp_496)unicode.statictmp_497)unicode.statictmp_499)unicode.statictmp_500*unicode.statictmp_502B*unicode.statictmp_504h*unicode.statictmp_506*unicode.statictmp_507*unicode.statictmp_509*unicode.statictmp_511+unicode.statictmp_513&+unicode.statictmp_514L+unicode.statictmp_516r+unicode.statictmp_517+unicode.statictmp_519+unicode.statictmp_520+unicode.statictmp_522 ,unicode.statictmp_5230,unicode.statictmp_525V,unicode.statictmp_526|,unicode.statictmp_528,unicode.statictmp_532,unicode.statictmp_534,unicode.statictmp_535-unicode.statictmp_537:-unicode.statictmp_539`-unicode.statictmp_540-unicode.statictmp_542-unicode.statictmp_544-unicode.statictmp_546-unicode.statictmp_548.unicode.statictmp_550D.internal/cpu.initdone·l.internal/cpu.cpuid.args_stackmap.internal/cpu.xgetbv.args_stackmap.regexp/syntax.anyRuneNotNL.regexp/syntax.anyRune /regexp/syntax.statictmp_0J/go.itab.*regexp/syntax.Error,error}/regexp/syntax.perlGroup/regexp/syntax.posixGroup/regexp/syntax.anyTable/go.itab.regexp/syntax.ranges,sort.Interface10regexp/syntax.instOpNames[0regexp/syntax.statictmp_20regexp/syntax.statictmp_30regexp/syntax.statictmp_40regexp/syntax.statictmp_51regexp/syntax.statictmp_6-1regexp/syntax.statictmp_7W1regexp/syntax.statictmp_81regexp/syntax.statictmp_91regexp/syntax.statictmp_101regexp/syntax.statictmp_122regexp/syntax.statictmp_13,2regexp/syntax.statictmp_14W2regexp/syntax.statictmp_112regexp/syntax.statictmp_152regexp/syntax.statictmp_162regexp/syntax.statictmp_173regexp/syntax.initdone·,3regexp/syntax.code1P3regexp/syntax.code2t3regexp/syntax.code33regexp/syntax.code43regexp/syntax.code53regexp/syntax.code64regexp/syntax.code7(4regexp/syntax.code8L4regexp/syntax.code9p4regexp/syntax.code104regexp/syntax.code114regexp/syntax.code124regexp/syntax.code135regexp/syntax.code14)5regexp/syntax.code15N5regexp/syntax.code16s5regexp/syntax.code175regexp/syntax.statictmp_185regexp/syntax.statictmp_195regexp/syntax.statictmp_206regexp/syntax.statictmp_23D6regexp/syntax.statictmp_24o6regexp/syntax.statictmp_256regexp/syntax.statictmp_266regexp/syntax.statictmp_276regexp/syntax.statictmp_287regexp/syntax.statictmp_29F7regexp/syntax.statictmp_30q7regexp/syntax.statictmp_317regexp/syntax.statictmp_327regexp/syntax.statictmp_337regexp/syntax.statictmp_348regexp/syntax.statictmp_35H8regexp/syntax.statictmp_36s8regexp/syntax.statictmp_378regexp/syntax.statictmp_388regexp/syntax.statictmp_398regexp/syntax.statictmp_409regexp/syntax.statictmp_21J9regexp/syntax.statictmp_22u9encoding/binary.overflow9encoding/binary.initdone·9context.background9context.todo :context.closedchan,:context.CanceledM:context.initdone·p:bufio.errNegativeRead:bufio.ErrNegativeCount:bufio.ErrBufferFull:bufio.ErrInvalidUnreadByte ;bufio.ErrInvalidUnreadRune7;bufio.errNegativeWrite^;bufio.ErrFinalToken;bufio.ErrTooLong;bufio.ErrNegativeAdvance;bufio.ErrAdvanceTooFar;bufio.initdone·<text/tabwriter.statictmp_0?<text/tabwriter.tabsc<text/tabwriter.statictmp_1<text/tabwriter.vbar<text/tabwriter.newline<text/tabwriter.hbar<text/tabwriter.initdone·'=text/tabwriter..gobytes.1Q=text/tabwriter..gobytes.2{=text/tabwriter.statictmp_2=text/tabwriter.statictmp_3=compress/gzip.ErrHeader=hash/crc32.IEEETable>compress/gzip.ErrChecksumH>compress/gzip.statictmp_0r>compress/gzip.initdone·>io/ioutil.initdone·>github.com/VividCortex/gohistogram.initdone·>github.com/go-kit/kit/metrics/internal/lv.initdone·C?compress/flate.statictmp_0n?compress/flate.statictmp_2?compress/flate.statictmp_1?compress/flate.levels?go.itab.*compress/flate.dictWriter,io.Writer'@go.itab.compress/flate.InternalError,errorb@compress/flate.statictmp_3@compress/flate.codegenOrder@compress/flate.fixedLiteralEncoding@compress/flate.fixedOffsetEncoding Acompress/flate.lengthExtraBitsOAcompress/flate.offsetExtraBits~Acompress/flate.lengthBaseAcompress/flate.offsetBaseAcompress/flate.huffOffsetAcompress/flate.statictmp_5'Bcompress/flate.statictmp_4RBgo.itab.*compress/flate.byLiteral,sort.InterfaceBgo.itab.*compress/flate.byFreq,sort.InterfaceBcompress/flate.lengthCodesBcompress/flate.offsetCodes'Ccompress/flate.initdone·QCcompress/flate.statictmp_12}Ccompress/flate.statictmp_13Ccompress/flate.statictmp_14Ccompress/flate.statictmp_15Dcompress/flate.statictmp_16-Dcompress/flate.statictmp_17YDhash/crc32.castagnoliTableDhash/crc32.updateCastagnoliDhash/crc32.ieeeArchImplDhash/crc32.updateIEEEDhash/crc32.ieeeTable8$Ehash/crc32.ieeeOnceHEhash/crc32.archIeeeTable8rEhash/crc32.statictmp_2Ehash/crc32.statictmp_3Ehash/crc32.initdone·Ehash/crc32.ieeeCLMUL.args_stackmapmFpath/filepath.ErrBadPatternFpath/filepath.SkipDirFpath/filepath.initdone·Fmath/bits.rev8tab Ghash.initdone·*Gruntime.pclntabJGruntime.findfunctabnGruntime.typelinkGruntime.itablinkGruntime.eitablinkGruntime.rodataGruntime.erodataHruntime.types/Hruntime.etypesNHruntime.noptrdatapHruntime.enoptrdataHruntime.dataHruntime.edataHruntime.bssHruntime.ebssIruntime.noptrbss(Iruntime.enoptrbssJIruntime.endfIruntime.epclntabIruntime.esymtabIruntime.gcdataIruntime.egcdataIruntime.gcbssJruntime.egcbss#Jtype.*:Jgo.func.*TJruntime.symtabsJruntime.textsectionmapJʶٶvoid߶unsafe.Pointeruintptrruntime._typeruntime._typeʷuint32շruntime.tflaguint8*runtime.typeAlgruntime.typeAlg9runtime.typeAlgNfunc(unsafe.Pointer, uintptr) uintptrfunc(unsafe.Pointer, uintptr) uintptr*uintptrfunc(unsafe.Pointer, unsafe.Pointer) boolfunc(unsafe.Pointer, unsafe.Pointer) bool+bool4*bool@*uint8Mruntime.nameOffaruntime.typeOffuruntime.arraytype¹runtime.arraytypeٹ*runtime._typeruntime.chantype+runtime.chantypeAruntime.functyperuntime.functypeuint16runtime.maptyperuntime.maptyperuntime.ptrtypeֻruntime.ptrtyperuntime.slicetyperuntime.slicetype3runtime.structtypexruntime.structtyperuntime.nameruntime.name¼[]runtime.structfield runtime.structfieldPruntime.structfieldiruntime.interfacetyperuntime.interfacetypeʽ[]runtime.imethod runtime.imethod=runtime.imethodRruntime.itab׾runtime.itab*runtime.interfacetype*runtime.itab[2]uint81[1]uintptrJstringostruct { runtime.enabled bool; runtime.pad [3]uint8; runtime.needed bool; runtime.cgo bool; runtime.alignme uint64 }4[3]uint8Kuint64V[]testing.InternalTesttesting.InternalTesttesting.InternalTestfunc(*testing.T)func(*testing.T)*testing.T*testing.Tptesting.Ttesting.commontesting.commonsync.RWMutex^sync.RWMutexpsync.Mutexsync.Mutexint32[]uint8io.Writerio.Writerruntime.iface<runtime.ifaceOmap[string]struct {}rstruct {}int*testing.commontime.Timetime.Timeint64*time.Locationtime.Locationutime.Location[]time.zonetime.zonetime.zone[]time.zoneTransQtime.zoneTranstime.zoneTrans*time.zonetime.Durationchan bool[]*testing.T(*testing.testContextCtesting.testContexttesting.testContext*testing.matchertesting.matcherLtesting.matchera[]stringfunc(string, string) (bool, error)func(string, string) (bool, error)error error*error"map[string]int64A[]testing.InternalBenchmarktesting.InternalBenchmarktesting.InternalBenchmarkfunc(*testing.B)func(*testing.B)*testing.B$testing.Btesting.B*testing.benchContexttesting.benchContext testing.benchContext&testing.BenchmarkResulttesting.BenchmarkResult[]testing.InternalExampletesting.InternalExampleLtesting.InternalExampleifunc()sfunc()[3]testing.InternalTest[0]testing.InternalBenchmark[0]testing.InternalExample[14]runtime.typeAlg[128]uint87[4]uintptrPstruct { runtime.allocfreetrace int32; runtime.cgocheck int32; runtime.efence int32; runtime.gccheckmark int32; runtime.gcpacertrace int32; runtime.gcshrinkstackoff int32; runtime.gcrescanstacks int32; runtime.gcstoptheworld int32; runtime.gctrace int32; runtime.invalidptr int32; runtime.sbrk int32; runtime.scavenge int32; runtime.scheddetail int32; runtime.schedtrace int32 }runtime.mheapruntime.mheapruntime.mutex/runtime.mutexB[128]runtime.mSpanListiruntime.mSpanListruntime.mSpanList*runtime.mspanruntime.mspanruntime.mspan*runtime.mSpanListruntime.gclinkptr*runtime.gcBitsruntime.gcBits/runtime.spanClassEruntime.mSpanState\*runtime.specialsruntime.specialruntime.specialruntime.mTreapruntime.mTreap*runtime.treapNoderuntime.treapNoderuntime.treapNode[]*runtime.mspan[2]runtime.gcSweepBuf runtime.gcSweepBufyruntime.gcSweepBuffloat64[67]uint64[134]struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }uruntime.mcentralruntime.mcentral[8]uint8 runtime.fixallocruntime.fixallocfunc(unsafe.Pointer, unsafe.Pointer)func(unsafe.Pointer, unsafe.Pointer)*runtime.mlink(runtime.mlinkHruntime.mlink[*uint64iruntime.plainErrorruntime.cpuProfileruntime.cpuProfile'*runtime.profBuf>runtime.profBufruntime.profBufruntime.profAtomic*[]uint64d[]unsafe.Pointerruntime.profIndexruntime.noteruntime.note[1000]uintptr struct { runtime.signalLock uint32; runtime.hz int32 }eruntime.schedtruntime.schedtruntime.muintptr)runtime.puintptr>runtime.guintptrS*runtime.gdruntime.gruntime.gruntime.stackruntime.stack*runtime._panicruntime._panicMruntime._panicainterface {}uinterface {}runtime.efaceruntime.eface*runtime._deferruntime._deferRruntime._deferf*runtime.funcval}runtime.funcvalruntime.funcval*runtime.mruntime.mruntime.mruntime.gobufjruntime.gobuf}runtime/internal/sys.Uintregruntime.sigset[6]uintptrint8*runtime.cgoCallersruntime.cgoCallersruntime.cgoCallers'*runtime.mcache=runtime.mcacheBruntime.mcacheV[134]*runtime.mspanz[4]runtime.stackfreelistruntime.stackfreelistruntime.stackfreelist[67]uintptr [32]uintptr([16]uint32Aruntime.libcallruntime.libcallruntime.mOSruntime.mOS*runtime.sudogruntime.sudogruntime.sudog*uint32*runtime.hchanruntime.hchanruntime.hchanuintruntime.waitq"runtime.waitq5[]uintptrp*runtime.timerruntime.timerruntime.timerfunc(interface {}, uintptr)!func(interface {}, uintptr)B[5]*runtime._defercfunc(*runtime.p)|func(*runtime.p)*runtime.pruntime.p runtime.p/runtime.sysmontickruntime.sysmontick[5][]*runtime._defer[]*runtime._defer[5][32]*runtime._defer:[32]*runtime._defer][256]runtime.guintptr[]*runtime.sudog[128]*runtime.sudogruntime.traceBufPtrruntime.persistentAlloc8runtime.persistentAllocUruntime.gcMarkWorkerModerruntime.gcWorkruntime.gcWork*runtime.workbufruntime.workbuf+runtime.workbuf@runtime.workbufhdrsruntime.workbufhdrruntime.lfnoderuntime.lfnode[253]uintptr[64]uint8[6]string[9]string7[33]float64R[1024]uint8n[]*runtime.gruntime.moduledata runtime.moduledata$[]runtime.functabgruntime.functabruntime.functab[]uint32[]runtime.textsect.runtime.textsecttruntime.textsect[]int32[]*runtime.itab[]runtime.ptabEntryIruntime.ptabEntryzruntime.ptabEntry[]runtime.modulehashruntime.modulehash-runtime.modulehashE*stringSruntime.bitvectorruntime.bitvectormap[runtime.typeOff]*runtime._type*runtime.moduledataruntime.mstats runtime.mstats [256]uint64<[67]struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }[1009]*runtime.itab?*unsafe.PointerU[67]uint16o[129]uint8[249]uint8struct { runtime.mutex; runtime.persistentAlloc }[256]uint8[67]uint86struct { runtime.lock runtime.mutex; runtime.lockOwner *runtime.g; runtime.enabled bool; runtime.shutdown bool; runtime.headerWritten bool; runtime.footerWritten bool; runtime.shutdownSema uint32; runtime.seqStart uint64; runtime.ticksStart int64; runtime.ticksEnd int64; runtime.timeStart int64; runtime.timeEnd int64; runtime.seqGC uint64; runtime.reading runtime.traceBufPtr; runtime.empty runtime.traceBufPtr; runtime.fullHead runtime.traceBufPtr; runtime.fullTail runtime.traceBufPtr; runtime.reader runtime.guintptr; runtime.stackTab runtime.traceStackTable; runtime.strings map[string]uint64; runtime.stringSeq uint64; runtime.markWorkerLabels [3]uint64; runtime.bufLock runtime.mutex; runtime.buf runtime.traceBufPtr } runtime.traceStackTable% runtime.traceStackTableB runtime.traceAlloct runtime.traceAlloc runtime.traceAllocBlockPtr [8192]runtime.traceStackPtr runtime.traceStackPtr map[string]uint64 [3]uint64* runtime.gcControllerState runtime.gcControllerState *runtime.finblock runtime.finblock5runtime.finblockK[101]runtime.finalizerqruntime.finalizerruntime.finalizer*runtime.ptrtype[5]uint8 struct { runtime.full runtime.lfstack; runtime.empty runtime.lfstack; runtime.pad0 [64]uint8; runtime.wbufSpans struct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }; _ uint32; runtime.bytesMarked uint64; runtime.markrootNext uint32; runtime.markrootJobs uint32; runtime.nproc uint32; runtime.tstart int64; runtime.nwait uint32; runtime.ndone uint32; runtime.alldone runtime.note; runtime.helperDrainBlock bool; runtime.nFlushCacheRoots int; runtime.nDataRoots int; runtime.nBSSRoots int; runtime.nSpanRoots int; runtime.nStackRoots int; runtime.markrootDone bool; runtime.startSema uint32; runtime.markDoneSema uint32; runtime.bgMarkReady runtime.note; runtime.bgMarkDone uint32; runtime.mode runtime.gcMode; runtime.userForced bool; runtime.totaltime int64; runtime.initialHeapLive uint64; runtime.assistQueue struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }; runtime.sweepWaiters struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }; runtime.cycles uint32; runtime.stwprocs int32; runtime.maxprocs int32; runtime.tSweepTerm int64; runtime.tMark int64; runtime.tMarkTerm int64; runtime.tEnd int64; runtime.pauseNS int64; runtime.pauseStart int64; runtime.heap0 uint64; runtime.heap1 uint64; runtime.heap2 uint64; runtime.heapGoal uint64 }runtime.lfstackstruct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }Eruntime.gcModeXstruct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }O[1025]*runtime.ppruntime.sweepdataruntime.sweepdata[1]uint8[67]runtime.divMagic9runtime.divMagicruntime.divMagicstruct { runtime.lock runtime.mutex; runtime.free *runtime.gcBitsArena; runtime.next *runtime.gcBitsArena; runtime.current *runtime.gcBitsArena; runtime.previous *runtime.gcBitsArena }*runtime.gcBitsArenaruntime.gcBitsArena runtime.gcBitsArena$[65520]runtime.gcBitsL*[179999]*runtime.bucketk[179999]*runtime.bucket*runtime.bucketruntime.bucketruntime.bucket(runtime.bucketType?struct { runtime.cycle uint32; runtime.flushed bool }runtime.pollCacheruntime.pollCache*runtime.pollDescruntime.pollDescruntime.pollDescruntime.machndrnruntime.machndr[512]uint8runtime.forcegcstateruntime.forcegcstateruntime.rwmutex runtime.rwmutex runtime.randomOrder runtime.randomOrder [1]unsafe.Pointer!struct { runtime.lock runtime.mutex; runtime.pad uint32; runtime.val uint64 }!**uint8![]runtime.dbgVar!runtime.dbgVar "runtime.dbgVar"*int32*"struct { runtime.lock runtime.mutex; runtime.next int32; runtime.m map[int32]unsafe.Pointer; runtime.minv map[unsafe.Pointer]int32 }"map[int32]unsafe.Pointer#map[unsafe.Pointer]int326#[251]struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }#struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }#runtime.semaRoot+$runtime.semaRootA$[40]uint8Y$[32]runtime.sigTabT|$runtime.sigTabT$runtime.sigTabT$[32]uint32$struct { runtime.note runtime.note; runtime.mask [1]uint32; runtime.wanted [1]uint32; runtime.ignored [1]uint32; runtime.recv [1]uint32; runtime.state uint32; runtime.inuse bool }%[1]uint32&[33]uintptr0&runtime.errorStringb&[4]runtime.mSpanList&struct { runtime.lock runtime.mutex; runtime.free [26]runtime.mSpanList }&[26]runtime.mSpanList'runtime.Frame~'runtime.Frame'*runtime.Func'runtime.Func'runtime.Func'struct { runtime.lock runtime.mutex; runtime.gp *runtime.g; runtime.created bool; runtime.sleeping bool; runtime.rescheduling bool; runtime.sleepUntil int64; runtime.waitnote runtime.note; runtime.t []*runtime.timer }:)[]*runtime.timer|)[3]string)[1]uint64)[]map[runtime.typeOff]*runtime._type*[4]string*[14]runtime.dbgVar<*[7]stringT*syscall.Errnof*func(error) bool*func(error) bool*struct { sync.Mutex; os.dir string }**os.File*os.File+os.File+*os.file$+os.filen+os.file{+internal/poll.FD,internal/poll.FD,internal/poll.fdMutex_,internal/poll.fdMutexz,internal/poll.pollDesc,internal/poll.pollDesc,*[]syscall.Iovec,[]syscall.Iovec-syscall.IovecJ-syscall.Iovec]-*os.dirInfoo-os.dirInfo-os.dirInfo-runtime.MemStats#0runtime.MemStats90[61]struct { Size uint32; Mallocs uint64; Frees uint64 }0struct { Size uint32; Mallocs uint64; Frees uint64 }0sync.Once1sync.Once1[]intU1*time.Durationj1testing.Cover1testing.Cover1map[string][]uint321map[string][]testing.CoverBlock(2[]testing.CoverBlockn2testing.CoverBlock2testing.CoverBlock2*int2*time.Timer3time.Timer(3time.Timer83<-chan time.TimeS3time.runtimeTimer3time.runtimeTimer3*uint3*regexp.Regexp3regexp.Regexp34regexp.RegexpF4regexp.regexpRO35regexp.regexpROH5*regexp/syntax.Progb5regexp/syntax.Prog5regexp/syntax.Prog5[]regexp/syntax.Inst6regexp/syntax.InstO6regexp/syntax.Instg6regexp/syntax.InstOp6*regexp.onePassProg6regexp.onePassProg6regexp.onePassProg6[]regexp.onePassInst<7regexp.onePassInsto7regexp.onePassInst7regexp/syntax.EmptyOp7[]*regexp.machine7*regexp.machine7regexp.machine8regexp.machine8*regexp.bitState 9regexp.bitStateg9regexp.bitState|9[]regexp.job9regexp.job9regexp.job9regexp.queue/:regexp.queueA:[]regexp.entry:regexp.entry:regexp.entry:*regexp.thread:regexp.thread:regexp.thread;*regexp/syntax.Inst*;[]*regexp.threadl;regexp.inputBytes;regexp.inputBytes;regexp.inputString;regexp.inputString;regexp.inputReader <regexp.inputReader8<io.RuneReaderM<io.RuneReader`<map[string]int}<syscall.attrList =syscall.attrList"=[106]string==syscall.mmapper=syscall.mmapper=map[*uint8][]uint8=func(uintptr, uintptr, int, int, int, int64) (uintptr, error)->func(uintptr, uintptr, int, int, int, int64) (uintptr, error)p>func(uintptr, uintptr) error>func(uintptr, uintptr) error>[]*sync.Pool>*sync.Pool?sync.Pool]?sync.Pooll?sync.noCopy|?sync.noCopy?func() interface {}?func() interface {}?*interface {}?[6]int?[12]string@[13]int32@func(int) error:@func(int) errorO@internal/poll.TimeoutErrorn@internal/poll.TimeoutError@*flag.FlagSet@flag.FlagSet5Aflag.FlagSetGAmap[string]*flag.FlagkA*flag.Flag|Aflag.FlagAflag.FlagAflag.ValueAflag.ValueAflag.ErrorHandlingBinternal/cpu.x865Cinternal/cpu.x86KCstrconv.floatInfoCstrconv.floatInfoC[]float64C[]float32Dfloat32+D[]strconv.leftCheatpDstrconv.leftCheatDstrconv.leftCheatD[20]uint64D[87]strconv.extFloatDstrconv.extFloat7Estrconv.extFloatME[8]strconv.extFloatpE[37]uintE[]uint16E[9]intE[23]float64E[11]float32 F[61]strconv.leftCheat1F[462]uint16MF[139]uint16iF[378]uint32F[82]uint16F[16]uint16F[0]intF[16]uint8F[0]int32F[4]int32G[2]int32*Gstruct { runtime/pprof.mu sync.Mutex; runtime/pprof.m map[string]*runtime/pprof.Profile }Gmap[string]*runtime/pprof.ProfileG*runtime/pprof.ProfileGruntime/pprof.ProfileIHruntime/pprof.ProfiledHmap[interface {}][]uintptrHfunc() intHfunc() intHfunc(io.Writer, int) errorHfunc(io.Writer, int) errorH[1]int64Istruct { sync.Mutex; runtime/pprof.profiling bool; runtime/pprof.done chan bool }I[1]stringI[2]int64I[4]int64Isync.Map&Jsync.Map4Jsync/atomic.ValueeJsync/atomic.Value|Jsync/atomic.noCopyJsync/atomic.noCopyJmap[interface {}]*sync.entryJ*sync.entryJsync.entryKsync.entryKreflect.MethodoKreflect.MethodKreflect.TypeKreflect.TypeKreflect.ValueKreflect.ValueK*reflect.rtype Lreflect.rtypeLreflect.rtypeLreflect.tflagL*reflect.typeAlgMreflect.typeAlg4Mreflect.typeAlgIMreflect.nameOff]Mreflect.typeOffqMreflect.flagMreflect.StructFieldNreflect.StructFieldNreflect.StructTagONstruct { sync.Mutex; reflect.m sync.Map }Nreflect.layoutTypeNreflect.layoutTypeO*reflect.bitVector0Oreflect.bitVector_Oreflect.bitVectorvOstruct { reflect.b bool; reflect.x interface {} }O[27]stringO[5]unicode/utf8.acceptRangePunicode/utf8.acceptRange;Punicode/utf8.acceptRangeYP[]*unicode.RangeTableP*unicode.RangeTablePunicode.RangeTableQunicode.RangeTableQ[]unicode.Range16[Qunicode.Range16Qunicode.Range16Q[]unicode.Range32Qunicode.Range32+Runicode.Range32@R[]unicode.CaseRangeRunicode.CaseRangeRunicode.CaseRangeRunicode.dRunicode.dS[128]uint16S[]unicode.foldPair`Sunicode.foldPairSunicode.foldPairSmap[string]*unicode.RangeTableS[5]*unicode.RangeTableS[304]unicode.CaseRangeT[88]unicode.foldPairBT[357]unicode.Range16gT[179]unicode.Range32T[176]unicode.Range16T[66]unicode.Range32T[66]unicode.Range16T[47]unicode.Range32U[112]unicode.Range16>U[35]unicode.Range32aU[127]unicode.Range16U[62]unicode.Range32U[5]unicode.Range16U[14]unicode.Range16U[7]unicode.Range32 V[2]unicode.Range16-V[11]unicode.Range16OV[5]unicode.Range32pV[1]unicode.Range16V[2]unicode.Range32V[117]unicode.Range16V[33]unicode.Range32V[40]unicode.Range16W[4]unicode.Range32=W[280]unicode.Range16bW[140]unicode.Range32W[7]unicode.Range16W[103]unicode.Range16W[96]unicode.Range16W[40]unicode.Range32X[173]unicode.Range167X[77]unicode.Range32ZX[37]unicode.Range16}X[17]unicode.Range32X[28]unicode.Range16X[31]unicode.Range32X[22]unicode.Range16 Y[6]unicode.Range16*Y[109]unicode.Range16NY[36]unicode.Range32qY[25]unicode.Range16Y[12]unicode.Range16Y[23]unicode.Range16Y[43]unicode.Range16Y[6]unicode.Range32Z[101]unicode.Range16AZ[58]unicode.Range32dZ[0]unicode.Range16Z[3]unicode.Range32Z[1]unicode.Range32Z[21]unicode.Range16Z[3]unicode.Range16 [[4]unicode.Range16+[[93]unicode.Range16N[[72]unicode.Range32q[[8]unicode.Range16[[32]unicode.Range16[[15]unicode.Range32[[33]unicode.Range16[[16]unicode.Range16\[9]unicode.Range16>\[20]unicode.Range16`\[8]unicode.Range32\[18]unicode.Range16\[31]unicode.Range16\[13]unicode.Range16\[121]unicode.Range16 ][10]unicode.Range16.][16]unicode.Range32Q][146]unicode.Range16v][48]unicode.Range32][15]unicode.Range16][70]unicode.Range16][64]unicode.Range32^[44]unicode.Range16$^[22]unicode.Range32G^[13]unicode.Range32j^[63]unicode.Range16^[102]unicode.Range16^map[string]regexp/syntax.charGroup^regexp/syntax.charGroup_regexp/syntax.charGroup8_[2]stringP_[6]int32g_[8]int32~_[11]string_*context.emptyCtx_context.emptyCtx_chan struct {}_*hash/crc32.Table_hash/crc32.Table`hash/crc32.Table-`[10]uint8E`[]compress/flate.compressionLevel`compress/flate.compressionLevelacompress/flate.compressionLevelBacompress/flate.InternalError}a*compress/flate.huffmanEncoderacompress/flate.huffmanEncoderbcompress/flate.huffmanEncoder7b[]compress/flate.hcodebcompress/flate.hcodebcompress/flate.hcodeb[]compress/flate.literalNodeccompress/flate.literalNodeYccompress/flate.literalNodeyc[17]int32ccompress/flate.byLiteralccompress/flate.byLiteralccompress/flate.byFreq@dcompress/flate.byFreq[d[]int8d[256]uint32d[10]compress/flate.compressionLeveld[29]int8d[29]uint32e[44]int8)e[44]uint32Ce[19]uint32\efunc(uint32, []uint8) uint32efunc(uint32, []uint8) uint32e*hash/crc32.slicing8Tableehash/crc32.slicing8Tableehash/crc32.slicing8Tablef*sync/atomic.Value,f*sync/atomic.ifaceWordsJfsync/atomic.ifaceWordsfsync/atomic.ifaceWordsf*[]uintptrf**runtime.moduledatafstruct { F uintptr; runtime.src uintptr; runtime.dst *uintptr }2gruntime.slicemgruntime.slicegstruct { F uintptr; runtime.typ *runtime._type; runtime.src unsafe.Pointer; runtime.off uintptr; runtime.size uintptr }=h*runtime.structfieldXh*runtime.chantypephstruct { F uintptr; runtime.c *runtime.hchan }h*runtime.mutexh**runtime.hchanh**runtime.sudogh**uint32 i*runtime.waitqi*runtime.cpuProfile9i[2]uintptrRi*runtime.timevaliiruntime.timevaliruntime.timevali[4]uint8i*runtime.TypeAssertionErroriruntime.TypeAssertionError~jruntime.TypeAssertionErrorjint16j[32]uint8jruntime.stackExpanderkruntime.stackExpander)kruntime.pcExpanderkruntime.pcExpanderk[]runtime.Framelruntime.funcInfoGlruntime.funcInfo]l*runtime._funcrlruntime._func mruntime._func m*[1048576]runtime.inlinedCallDm[1048576]runtime.inlinedCalltmruntime.inlinedCallmruntime.inlinedCallm[3]uintptrm*runtime.bmap nruntime.bmap/nruntime.bmapAn*runtime.maptypeXn*runtime.hmaplnruntime.hmaporuntime.hmap!o*runtime.mapextra9oruntime.mapextravoruntime.mapextrao[2]*[]*runtime.bmapo*[]*runtime.bmapo[]*runtime.bmapp**runtime.bmapp**runtime.mapextra4p*runtime.hiterIpruntime.hiter/qruntime.hiterBq**runtime.hmapWq**runtime.maptypeoq**[]*runtime.bmapq*runtime.stringStructqruntime.stringStructqruntime.stringStructq**runtime._typer*runtime.imethodr**runtime.itab2r*runtime.uncommontypeNrruntime.uncommontyperruntime.uncommontyper*runtime.ifacer*runtime.lfstackr*runtime.lfnodes*runtime.notes*runtime.mheap1sstruct { F uintptr; runtime.c *runtime.mcache; runtime.spc runtime.spanClass }sstruct { F uintptr; runtime.s **runtime.mspan; runtime.size *uintptr; runtime.needzero bool; runtime.noscan bool }ft**runtime.mspan|tstruct { F uintptr; runtime.p *unsafe.Pointer; runtime.size uintptr; runtime.align uintptr; runtime.sysStat *uint64 };u*runtime.persistentAllocZustruct { F uintptr; runtime.mp *runtime.m; runtime.src uintptr; runtime.dst *uintptr }ustruct { F uintptr; runtime.dst *uintptr; runtime.src uintptr }Qvstruct { F uintptr; runtime.srcp *unsafe.Pointer; runtime.dstp *unsafe.Pointer; runtime.n int; runtime.typ **runtime._type }wruntime.markBitsSwruntime.markBitsiw*runtime.markBitswruntime.heapBitswruntime.heapBitsw*runtime.gclinkwruntime.gclinkxruntime.gclinkxstruct { F uintptr; runtime.c *runtime.mcache }_x*runtime.mcentralwx**runtime.ptrtypexstruct { F uintptr; runtime.e *runtime.eface; runtime.f *runtime.eface; runtime.nret uintptr; runtime.fint *runtime._type; runtime.ot *runtime.ptrtype }vy*runtime.efaceystruct { F uintptr; runtime.e *runtime.eface }y*runtime.fixallocychan intz*runtime.gcControllerState!zruntime.gcTrigger]zruntime.gcTriggertzruntime.gcTriggerKindzstruct { F uintptr; runtime.startTime *int64 }z*int64z[5]int64{[3]int64{[24]uint83{**runtime.pE{struct { F uintptr; runtime.gp *runtime.g; runtime._p_ *runtime.p }{*runtime.puintptr{*runtime.guintptr{*runtime.parkInfo·2{runtime.parkInfo·20|runtime.parkInfo·2I|*runtime.gcWork_|**runtime._deferv|*runtime.mTreap|**runtime.treapNode|struct { F uintptr; runtime.gp *runtime.g; runtime.gcw *runtime.gcWork }}struct { F uintptr; runtime.gp *runtime.g; runtime.scanWork int64 }}struct { F uintptr; runtime.cache *runtime.pcvalueCache; runtime.gcw *runtime.gcWork } ~*runtime.pcvalueCache)~runtime.pcvalueCacheT~runtime.pcvalueCachen~[16]runtime.pcvalueCacheEnt~runtime.pcvalueCacheEnt~runtime.pcvalueCacheEnt~runtime.hex*runtime.stkframe&runtime.stkframeruntime.stkframe*runtime.bitvectorruntime.gcDrainFlags struct { F uintptr; runtime.ret *uintptr }U**runtime.specialm*runtime.gcSweepBufstruct { F uintptr; runtime.s **runtime.mspan }Ҁstruct { F uintptr; runtime.preemptible bool }&*[]*runtime.mspan>struct { F uintptr; runtime.s **runtime.mspan; runtime.h *runtime.mheap; runtime.npage uintptr; runtime.spanclass runtime.spanClass; runtime.large bool }/struct { F uintptr; runtime.h *runtime.mheap; runtime.s *runtime.mspan; runtime.acct int32 }**runtime.funcval؂*runtime.memRecordCycleruntime.memRecordCycleYruntime.memRecordCycleu*runtime.memRecordruntime.memRecordŃruntime.memRecord܃[3]runtime.memRecordCycle*runtime.blockRecordruntime.blockRecordVruntime.blockRecordostruct { F uintptr; runtime.p unsafe.Pointer; runtime.b *runtime.bucket }߄*runtime.StackRecordruntime.StackRecord#runtime.StackRecord<*runtime.MemProfileRecord\runtime.MemProfileRecord܅runtime.MemProfileRecord*[32]uintptr []runtime.MemProfileRecordY[]runtime.BlockProfileRecordruntime.BlockProfileRecordruntime.BlockProfileRecord*runtime.BlockProfileRecord=[]runtime.StackRecordstruct { F uintptr; runtime.pc uintptr; runtime.sp uintptr; runtime.gp *runtime.g; runtime.r *[]runtime.StackRecord }9*[]runtime.StackRecordVstruct { F uintptr; runtime.gp *runtime.g }**runtime.gstruct { F uintptr; runtime.buf *[]uint8; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr; runtime.all bool; runtime.n *int }*[]uint8struct { F uintptr; runtime.pc uintptr; runtime.sp uintptr; runtime.gp *runtime.g },*runtime.MemStatsDstruct { F uintptr; runtime.m *runtime.MemStats }*runtime.pollCache*func(interface {}, uintptr)͊[2]runtime.keventtruntime.keventt]runtime.keventtr[64]runtime.keventt*runtime.timespecruntime.timespecruntime.timespecstruct { F uintptr; runtime.mp *runtime.m }A[2]uint32Y*runtime.machheadersruntime.machheader runtime.machheader#struct { F uintptr; runtime.r *int32; runtime.ns int64 }struct { F uintptr; runtime.r int32 }čruntime.sigactiont'runtime.sigactiont?runtime.usigactiontruntime.usigactiont*runtime.stacktruntime.stacktruntime.stackt,*runtime.sigsetB[5]int32Ystruct { F uintptr; runtime.pp *runtime.p; runtime.sc uintptr }struct { F uintptr; runtime.siz int32; runtime.d **runtime._defer }-*[]*runtime._deferF**runtime._panic]struct { F uintptr; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr }[14]uint8complex128 [100]uint8%func(*runtime.g, unsafe.Pointer) bool]func(*runtime.g, unsafe.Pointer) boolstruct { F uintptr; runtime.gp *runtime.g; runtime.traceskip int }*[]*runtime.sudogfunc(*runtime.g)+func(*runtime.g)Astruct { F uintptr; runtime.oldval uint32; runtime.newval uint32 }**runtime.mƒruntime.cgothreadstartruntime.cgothreadstart!runtime.randomEnumlruntime.randomEnum**runtime.timerstruct { F uintptr; runtime._g_ *runtime.g }struct { F uintptr; runtime.sp1 uintptr; runtime.sp2 uintptr; runtime.sp3 uintptr; runtime._g_ *runtime.g }struct { F uintptr; runtime.sp uintptr; runtime._g_ *runtime.g }struct { F uintptr; runtime.ok *bool; runtime.oldp *runtime.p; runtime._g_ *runtime.g }struct { F uintptr; runtime.newg *runtime.g; runtime.stacksize int32 }struct { F uintptr; runtime.fn **runtime.funcval; runtime.argp unsafe.Pointer; runtime.siz *int32; runtime.pc uintptr }*runtime.gobufՖ[64]uintptr*runtime.muintptr[129]*runtime.g(*[256]runtime.guintptrE*runtime.randomOrder`*[]uint32p*runtime.randomEnum*runtime.profAtomicruntime.profBufReadMode*runtime.dbgVar֗[][]int32*[1]unsafe.Pointer**[1][]int32<[1][]int32U*[]int32d*runtime.rwmutex{struct { F uintptr; runtime.rw *runtime.rwmutex }ɘruntime.semaProfileFlags*runtime.semaRoot*runtime.sigctxtruntime.sigctxtEruntime.sigctxtZ*runtime.siginfoqruntime.siginfo0runtime.siginfoE[7]uint64]*runtime.regs64sruntime.regs64runtime.regs64runtime.itimervalruntime.itimervalruntime.gsignalStackgruntime.gsignalStack*runtime.gsignalStack*runtime.stack*runtime.adjustinfo̜runtime.adjustinforuntime.adjustinfo6runtime.gobitvectorkruntime.gobitvector*runtime.gobitvector*runtime.tmpBufruntime.tmpBufҝruntime.tmpBuf[5]string*[32]int32[32]int32(*[4]uint88*runtime.FramesNruntime.Framesruntime.Frames*runtime.stackExpander*runtime.pcExpander՞runtime.cgoSymbolizerArgYruntime.cgoSymbolizerArgw*runtime.Frame[]*runtime.moduledataӟ*[]*runtime.moduledata*runtime.modulehash *runtime.stackmap"runtime.stackmapbruntime.stackmapx*runtime.traceBufruntime.traceBuf͠runtime.traceBufruntime.traceBufHeader:runtime.traceBufHeaderV[128]uintptrs[64488]uint8*runtime.traceBufPtr*runtime.traceStackǡruntime.traceStackruntime.traceStack6[0]uintptrO*runtime.traceStackTablen*runtime.traceStackPtr[5140]uint8runtime.traceFrameruntime.traceFrame*runtime.traceAllocBlock#runtime.traceAllocBlock]runtime.traceAllocBlockz[65528]uint8*runtime.traceAllocBlockPtr*runtime.traceAllocգ[2]uint64func(*runtime.stkframe, unsafe.Pointer) bool,func(*runtime.stkframe, unsafe.Pointer) bool^struct { F uintptr; runtime.n *int; runtime.pc uintptr; runtime.sp uintptr; runtime.gp *runtime.g; runtime.skip *int; runtime.pcbuf []uintptr }J*runtime.cgoSymbolizerArgjfunc(unsafe.Pointer, unsafe.Pointer) int32func(unsafe.Pointer, unsafe.Pointer) int32ץruntime.cgoTracebackArg2runtime.cgoTracebackArgOruntime.textOffc*runtime.functype{[]*runtime._typenoalg.map.bucket[uint32][]*runtime._type-noalg.map.bucket[uint32][]*runtime._type[noalg.[8]uint32ynoalg.[8]uint32noalg.[8][]*runtime._typenoalg.[8][]*runtime._type֧*map.bucket[uint32][]*runtime._typenoalg.map.hdr[uint32][]*runtime._typenoalg.map.hdr[uint32][]*runtime._type*map[runtime.typeOff]*runtime._typemap[uint32][]*runtime._type>map[runtime._typePair]struct {}lruntime._typePairruntime._typePair*struct { Size uint32; Mallocs uint64; Frees uint64 }*[61]struct { Size uint32; Mallocs uint64; Frees uint64 }-*runtime.sysmontickG*runtime.errorStringb*runtime.forcegcstate~*runtime.gcTrigger*runtime.heapBits*[2]runtime.gcSweepBuf̪*struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }*[134]struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }e*struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }*[67]struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }*runtime.mstats'*runtime.plainErrorA*runtime.sigTabTX*runtime.sweepdataq*[14]runtime.dbgVar*struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }Ҭ*[251]struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }*[2]string/*[32]runtime.sigTabTJ*[33]float64]*[3]stringn*[4]string*[5]string*[6]string*[9]string*struct { runtime.cycle uint32; runtime.flushed bool }*struct { runtime.enabled bool; runtime.pad [3]uint8; runtime.needed bool; runtime.cgo bool; runtime.alignme uint64 }k*struct { runtime.full runtime.lfstack; runtime.empty runtime.lfstack; runtime.pad0 [64]uint8; runtime.wbufSpans struct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }; _ uint32; runtime.bytesMarked uint64; runtime.markrootNext uint32; runtime.markrootJobs uint32; runtime.nproc uint32; runtime.tstart int64; runtime.nwait uint32; runtime.ndone uint32; runtime.alldone runtime.note; runtime.helperDrainBlock bool; runtime.nFlushCacheRoots int; runtime.nDataRoots int; runtime.nBSSRoots int; runtime.nSpanRoots int; runtime.nStackRoots int; runtime.markrootDone bool; runtime.startSema uint32; runtime.markDoneSema uint32; runtime.bgMarkReady runtime.note; runtime.bgMarkDone uint32; runtime.mode runtime.gcMode; runtime.userForced bool; runtime.totaltime int64; runtime.initialHeapLive uint64; runtime.assistQueue struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }; runtime.sweepWaiters struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }; runtime.cycles uint32; runtime.stwprocs int32; runtime.maxprocs int32; runtime.tSweepTerm int64; runtime.tMark int64; runtime.tMarkTerm int64; runtime.tEnd int64; runtime.pauseNS int64; runtime.pauseStart int64; runtime.heap0 uint64; runtime.heap1 uint64; runtime.heap2 uint64; runtime.heapGoal uint64 }*struct { runtime.lock runtime.mutex; runtime.pad uint32; runtime.val uint64 }*struct { runtime.note runtime.note; runtime.mask [1]uint32; runtime.wanted [1]uint32; runtime.ignored [1]uint32; runtime.recv [1]uint32; runtime.state uint32; runtime.inuse bool }δ*struct { F uintptr; runtime.buf *[]uint8; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr; runtime.all bool; runtime.n *int }a*struct { F uintptr; runtime.c *runtime.mcache; runtime.spc runtime.spanClass }*struct { F uintptr; runtime.h *runtime.mheap; runtime.s *runtime.mspan; runtime.acct int32 }*struct { F uintptr; runtime.newg *runtime.g; runtime.stacksize int32 }i*struct { F uintptr; runtime.preemptible bool }*struct { F uintptr; runtime.r int32 }̶*struct { F uintptr; runtime.s **runtime.mspan; runtime.h *runtime.mheap; runtime.npage uintptr; runtime.spanclass runtime.spanClass; runtime.large bool }m*struct { F uintptr; runtime.s **runtime.mspan; runtime.size *uintptr; runtime.needzero bool; runtime.noscan bool }*struct { F uintptr; runtime.siz int32; runtime.d **runtime._defer }2*errors.errorStringLerrors.errorStringnerrors.errorString*sync.Mapsync.readOnlyĸsync.readOnly׸**sync.entrynoalg.map.iter[interface {}]*sync.entryԹnoalg.map.iter[interface {}]*sync.entry*map.hdr[interface {}]*sync.entry)noalg.map.hdr[interface {}]*sync.entrynoalg.map.hdr[interface {}]*sync.entry*map.bucket[interface {}]*sync.entry@noalg.map.bucket[interface {}]*sync.entrynoalg.map.bucket[interface {}]*sync.entrynoalg.[8]interface {}noalg.[8]interface {}!noalg.[8]*sync.entryDnoalg.[8]*sync.entry^*sync.Mutexp*sync.Once*sync.poolLocalsync.poolLocalӼsync.poolLocalsync.poolLocalInternal2sync.poolLocalInternalN[]interface {}[80]uint8*[]interface {}[]sync.poolLocal**sync.Pool*[0]*sync.Pool%[0]*sync.PoolAsync.notifyListsync.notifyList*sync.RWMutexƾio.stringWriterݾio.stringWriterio.Readerio.Readerio.WriterTo%io.WriterTo6io.ReaderFromKio.ReaderFrom^[][]uint8*syscall.attrList*syscall.Stat_tǿsyscall.Stat_t syscall.Stat_tsyscall.TimespecMsyscall.Timespecc*syscall.Errnox*[106]string[20]uint8[9]uint8time.Monthtime.Weekdaytime.fileSizeError [4096]uint8'*time.Time8*time.zoneTransN*time.data_time.datatime.data[22]uint8*time.Month*time.Weekday*time.fileSizeError*[12]string*[7]string*internal/poll.TimeoutError3*internal/poll.fdMutexP*internal/poll.FDh*internal/poll.pollDesc*os.PathErroros.PathErroros.PathError*os.SyscallErroros.SyscallError-os.SyscallErrorB*os.LinkErrorVos.LinkErroros.LinkErroros.FileModefunc(*os.file) errorfunc(*os.file) erroros.FileInfo os.FileInfo[2]int1*os.fileStatDos.fileStatos.fileStat*os.FileMode*struct { sync.Mutex; os.dir string }*internal/cpu.x86*strconv.NumErrorstrconv.NumErrorZstrconv.NumErrorp*strconv.decimalstrconv.decimalstrconv.decimal[800]uint8*strconv.floatInfo(*strconv.extFloat@*strconv.decimalSlice\strconv.decimalSlicestrconv.decimalSlice[65]uint8*[800]uint8*strconv.leftCheat*[11]float32*[23]float64(*[61]strconv.leftCheatE*[87]strconv.extFloata*[8]strconv.extFloat|**unicode.RangeTable*unicode.Range16*unicode.Range32*reflect.methodValuereflect.methodValue1reflect.methodValueJreflect.Kind[func(int, int)wfunc(int, int)[]int16[]int64*reflect.ValueErrorreflect.ValueErrorLreflect.ValueErrord*struct { F uintptr; reflect.ps []unsafe.Pointer }struct { F uintptr; reflect.ps []unsafe.Pointer }*struct { F uintptr; reflect.ss []string }struct { F uintptr; reflect.ss []string }b*struct { F uintptr; reflect.is []int64 }struct { F uintptr; reflect.is []int64 }*struct { F uintptr; reflect.is []int32 }struct { F uintptr; reflect.is []int32 }L*struct { F uintptr; reflect.is []int16 }|struct { F uintptr; reflect.is []int16 }*struct { F uintptr; reflect.is []int8 }struct { F uintptr; reflect.is []int8 }4*struct { F uintptr; reflect.s *reflect.sliceHeader; reflect.size uintptr; reflect.typ *reflect.rtype; reflect.tmp unsafe.Pointer }struct { F uintptr; reflect.s *reflect.sliceHeader; reflect.size uintptr; reflect.typ *reflect.rtype; reflect.tmp unsafe.Pointer }*reflect.sliceHeaderreflect.sliceHeaderreflect.sliceHeader*reflect.structFieldreflect.structFieldZreflect.structFieldsreflect.namereflect.name*reflect.stringHeaderreflect.stringHeaderreflect.stringHeader*reflect.uncommonType+reflect.uncommonTypereflect.uncommonType[]reflect.methodreflect.method.reflect.methodBreflect.textOffV*reflect.methodl*reflect.interfaceTypereflect.interfaceTypereflect.interfaceType[]reflect.imethod2reflect.imethodareflect.imethodv[]*reflect.rtype[]reflect.Type**reflect.rtype*reflect.Method$*reflect.funcType<reflect.funcTypereflect.funcTypereflect.ChanDir*reflect.chanTypereflect.chanTypereflect.chanType*reflect.sliceType3reflect.sliceTypefreflect.sliceType}*reflect.arrayTypereflect.arrayTypereflect.arrayType*reflect.mapTypereflect.mapTypereflect.mapType*reflect.ptrType,reflect.ptrType]reflect.ptrTyper*reflect.structTypereflect.structTypereflect.structType[]reflect.structField2func(string) boolQfunc(string) boolh*reflect.imethod*[1]int[1]int[1]reflect.fieldScanreflect.fieldScanreflect.fieldScan[]reflect.fieldScanS*[0]reflect.fieldScano[0]reflect.fieldScan*[1]reflect.fieldScan*reflect.fieldScan*[]intmap[*reflect.structType]intmap[*reflect.structType]bool)struct { F uintptr; reflect.name string }q*struct { F uintptr; reflect.name string }reflect.emptyInterfacereflect.emptyInterface*[1]uint8func(reflect.Value, reflect.Type) reflect.ValueFfunc(reflect.Value, reflect.Type) reflect.Value{*reflect.Value*reflect.Type*struct { F uintptr; reflect.hash uint32 }struct { F uintptr; reflect.hash uint32 }func(*reflect.rtype) reflect.TypeLfunc(*reflect.rtype) reflect.Types*reflect.funcTypeFixed32reflect.funcTypeFixed32reflect.funcTypeFixed32[32]*reflect.rtype*reflect.funcTypeFixed128.reflect.funcTypeFixed128lreflect.funcTypeFixed128[128]*reflect.rtype*reflect.funcTypeFixed4reflect.funcTypeFixed4reflect.funcTypeFixed4#[4]*reflect.rtypeC*reflect.funcTypeFixed8areflect.funcTypeFixed8reflect.funcTypeFixed8[8]*reflect.rtype*reflect.funcTypeFixed16reflect.funcTypeFixed164reflect.funcTypeFixed16Q[16]*reflect.rtypes*reflect.funcTypeFixed64reflect.funcTypeFixed64reflect.funcTypeFixed64[64]*reflect.rtypereflect.layoutKey=reflect.layoutKeyT*struct { F uintptr; reflect.x *reflect.rtype }struct { F uintptr; reflect.x *reflect.rtype }*func() interface {}*reflect.emptyInterface *reflect.nonEmptyInterface.reflect.nonEmptyInterfacehreflect.nonEmptyInterface*struct { reflect.ityp *reflect.rtype; reflect.typ *reflect.rtype; reflect.link unsafe.Pointer; reflect.bad int32; reflect.unused int32; reflect.fun [100000]unsafe.Pointer };struct { reflect.ityp *reflect.rtype; reflect.typ *reflect.rtype; reflect.link unsafe.Pointer; reflect.bad int32; reflect.unused int32; reflect.fun [100000]unsafe.Pointer }A[100000]unsafe.Pointerjinterface { M() }interface { M() }[]reflect.Value*[]unsafe.Pointer*uint16*float32*float64*complex640complex64>*complex128P*[]string`*[]int64o*[]int16~*[]int8*reflect.ChanDir*reflect.Kind*[128]*reflect.rtype*[16]*reflect.rtype*[32]*reflect.rtype*[4]*reflect.rtype*[64]*reflect.rtype9*[8]*reflect.rtypeR*[27]stringd*struct { reflect.b bool; reflect.x interface {} }*fmt.fmtfmt.fmtfmt.fmt*fmt.buffer!fmt.buffer]fmt.buffermfmt.fmtFlagsfmt.fmtFlags![68]uint89*fmt.ppGfmt.ppfmt.ppfmt.GoStringerfmt.GoStringerfmt.Formatter$fmt.Formatter7fmt.StringerKfmt.Stringer]*fmt.fmtFlagsqfunc(int) boolfunc(int) boolsort.Interfacesort.Interfacefunc(int, int) boolfunc(int, int) bool sort.lessSwap8sort.lessSwapKsort.StringSlicesort.StringSlice*sort.StringSlice*flag.boolValueflag.boolValue*flag.intValueflag.intValue *flag.int64Value"flag.int64Value6*flag.uintValueLflag.uintValue_*flag.uint64Valuewflag.uint64Value*flag.stringValueflag.stringValue*flag.float64Valueflag.float64Value*flag.durationValueflag.durationValue3[]*flag.Flagqnoalg.map.iter[string]*flag.FlagTnoalg.map.iter[string]*flag.Flagz**flag.Flag*map.hdr[string]*flag.Flagnoalg.map.hdr[string]*flag.Flagfnoalg.map.hdr[string]*flag.Flag*map.bucket[string]*flag.Flagnoalg.map.bucket[string]*flag.Flagnoalg.map.bucket[string]*flag.FlagBnoalg.[8]stringanoalg.[8]stringvnoalg.[8]*flag.Flagnoalg.[8]*flag.Flagfunc(*flag.Flag)func(*flag.Flag)struct { F uintptr; flag.f *flag.FlagSet }&*struct { F uintptr; flag.f *flag.FlagSet }X[1]interface {}v*[1]interface {}[2]interface {}*[2]interface {}[3]interface {}flag.boolFlagflag.boolFlag*[3]interface {}*struct { F uintptr; R *flag.FlagSet }Lstruct { F uintptr; R *flag.FlagSet }*bytes.Bufferbytes.Bufferbytes.Bufferbytes.readOp*bytes.Reader'bytes.Reader`bytes.Readerrfunc(int32) boolfunc(int32) boolstruct { F uintptr; testing.b *testing.B }*struct { F uintptr; testing.b *testing.B }*testing.InternalBenchmark?*struct { F uintptr; testing.bs []testing.InternalBenchmark }struct { F uintptr; testing.bs []testing.InternalBenchmark }*func(*testing.B)*testing.BenchmarkResult[7]interface {}1noalg.map.iter[string][]uint32noalg.map.iter[string][]uint326*map.hdr[string][]uint32Unoalg.map.hdr[string][]uint32 noalg.map.hdr[string][]uint32/*map.bucket[string][]uint32Qnoalg.map.bucket[string][]uint32noalg.map.bucket[string][]uint32noalg.[8][]uint32noalg.[8][]uint32*[7]interface {}/*testing.InternalExampleNchan stringd[4]interface {}*[4]interface {}*[0]uint8[0]uint8*[50]uintptr[50]uintptrtesting.indentertesting.indenter$*[2]uintptr6testing.testDepsNtesting.testDepsd*testing.Mutesting.Mtesting.Mstruct { F uintptr; R testing.testDeps }*struct { F uintptr; R testing.testDeps }H*testing.InternalTestdstruct { F uintptr; testing.tests []testing.InternalTest }*struct { F uintptr; testing.tests []testing.InternalTest }*[]testing.InternalBenchmark#**testing.T5*[]testing.InternalTestS*testing.CoverBlockm*testing.indenterregexp/syntax.patchList*regexp/syntax.Regexpregexp/syntax.Regexp^regexp/syntax.Regexpxregexp/syntax.Opregexp/syntax.Flags[]*regexp/syntax.Regexp[1]*regexp/syntax.Regexpregexp/syntax.compiler;regexp/syntax.compilerWregexp/syntax.fragregexp/syntax.frag*regexp/syntax.compiler**regexp/syntax.Regexp*regexp/syntax.Errorregexp/syntax.Error(regexp/syntax.ErrorAregexp/syntax.ErrorCodew*regexp/syntax.parserregexp/syntax.parserregexp/syntax.parser)*[]*regexp/syntax.RegexpHregexp/syntax.rangeslregexp/syntax.ranges*[1]string*[1]*regexp/syntax.Regexp*regexp/syntax.charGroup*regexp/syntax.ErrorCode*regexp/syntax.InstOp*regexp/syntax.ranges-*[11]string?*[]regexp.jobS*regexp.joberegexp.inputyregexp.input*regexp.inputBytes*regexp.inputString*regexp.inputReader**regexp.thread*regexp.queue*[]*regexp.thread*regexp.entry.*regexp.onePassInstH*regexp.queueOnePasscregexp.queueOnePassregexp.queueOnePassstruct { F uintptr; regexp.ix *int; regexp.merged *[]int32; regexp.next *[]uint32 }b*struct { F uintptr; regexp.ix *int; regexp.merged *[]int32; regexp.next *[]uint32 }func(*int, *[]int32, uint32) boolfunc(*int, *[]int32, uint32) boolregexp.runeSlice_regexp.runeSliceustruct { F uintptr; regexp.p **regexp.onePassProg; regexp.visitQueue *regexp.queueOnePass; regexp.check *func(uint32, []bool) bool; regexp.onePassRunes [][]int32; regexp.instQueue *regexp.queueOnePass }**regexp.onePassProg*func(uint32, []bool) boolfunc(uint32, []bool) boolfunc(uint32, []bool) bool.[]boolf*struct { F uintptr; regexp.p **regexp.onePassProg; regexp.visitQueue *regexp.queueOnePass; regexp.check *func(uint32, []bool) bool; regexp.onePassRunes [][]int32; regexp.instQueue *regexp.queueOnePass }8*[]*regexp.machineQ**regexp.machineh*[][]int32y*[0]int32*[1]uint32*regexp.runeSlice*encoding/binary.bigEndianencoding/binary.bigEndianencoding/binary.bigEndian*encoding/binary.littleEndian4encoding/binary.littleEndianUencoding/binary.littleEndianw*bufio.Writerbufio.Writerbufio.Writer*text/tabwriter.Writertext/tabwriter.Writertext/tabwriter.Writertext/tabwriter.cell8text/tabwriter.cellQ[][]text/tabwriter.cell[]text/tabwriter.cell*[0]text/tabwriter.cell[0]text/tabwriter.cell$*[][]text/tabwriter.cellC*[]text/tabwriter.cell`text/tabwriter.osErrortext/tabwriter.osError*text/tabwriter.cell*compress/flate.compressorcompress/flate.compressor compress/flate.compressor *compress/flate.huffmanBitWriter compress/flate.huffmanBitWriter compress/flate.huffmanBitWriter; [248]uint8V [19]int32n func([]uint8, []uint32) func([]uint8, []uint32) func(*compress/flate.compressor, []uint8) int func(*compress/flate.compressor, []uint8) int# func(*compress/flate.compressor)L func(*compress/flate.compressor)r *compress/flate.deflateFast compress/flate.deflateFast compress/flate.deflateFast [16384]compress/flate.tableEntry6 compress/flate.tableEntryq compress/flate.tableEntry [131072]uint32 [32768]uint32 []compress/flate.tokencompress/flate.token2[257]uint32N*[]compress/flate.tokenl*compress/flate.token*compress/flate.Writercompress/flate.Writercompress/flate.Writer*compress/flate.dictWritercompress/flate.dictWriterAcompress/flate.dictWriter`*compress/flate.hcode|*[16]int32[16]int32*compress/flate.levelInfocompress/flate.levelInfo?compress/flate.levelInfo][16][16]int32z[16]compress/flate.levelInfo*compress/flate.literalNode*compress/flate.byLiteral*compress/flate.byFreq*compress/flate.InternalError)*compress/gzip.WriterEcompress/gzip.Writercompress/gzip.Writercompress/gzip.Header}compress/gzip.Headerencoding/binary.ByteOrderencoding/binary.ByteOrder*runtime/pprof.profMapruntime/pprof.profMapVruntime/pprof.profMapqmap[uintptr]*runtime/pprof.profMapEntry*runtime/pprof.profMapEntryruntime/pprof.profMapEntry4runtime/pprof.profMapEntryT[]runtime/pprof.profMapEntry**runtime/pprof.profMapEntry**runtime/pprof.Profilenoalg.map.iter[interface {}][]uintptrnoalg.map.iter[interface {}][]uintptr*map.hdr[interface {}][]uintptrnoalg.map.hdr[interface {}][]uintptrnoalg.map.hdr[interface {}][]uintptr*map.bucket[interface {}][]uintptr-noalg.map.bucket[interface {}][]uintptrnoalg.map.bucket[interface {}][]uintptrnoalg.[8][]uintptrnoalg.[8][]uintptrruntime/pprof.stackProfilePruntime/pprof.stackProfilep[][]uintptrruntime/pprof.countProfileruntime/pprof.countProfile*runtime/pprof.keysByCountruntime/pprof.keysByCountKruntime/pprof.keysByCountj*struct { F uintptr; runtime/pprof.buf *bytes.Buffer }struct { F uintptr; runtime/pprof.buf *bytes.Buffer }*[1]int64 *runtime/pprof.profileBuilder.runtime/pprof.profileBuilderruntime/pprof.profileBuilder6runtime/pprof.protobufzruntime/pprof.protobufmap[uintptr]int[]runtime/pprof.memMapruntime/pprof.memMap1runtime/pprof.memMapKfunc([]uintptr) stringofunc([]uintptr) string[5]interface {}*[5]interface {}struct { F uintptr; runtime/pprof.p []runtime.MemProfileRecord }*struct { F uintptr; runtime/pprof.p []runtime.MemProfileRecord }dfunc([]runtime.StackRecord) (int, bool)func([]runtime.StackRecord) (int, bool)runtime/pprof.runtimeProfileruntime/pprof.runtimeProfile;struct { F uintptr; runtime/pprof.p []runtime.BlockProfileRecord }*struct { F uintptr; runtime/pprof.p []runtime.BlockProfileRecord }runtime/pprof.msgOffset[8]runtime/pprof.newFunc·1*runtime/pprof.newFunc·1oruntime/pprof.newFunc·1struct { F uintptr; runtime/pprof.b *runtime/pprof.profileBuilder; runtime/pprof.addr uintptr } []runtime/pprof.newFunc·1b *[1]uintptrt *struct { F uintptr; runtime/pprof.b *runtime/pprof.profileBuilder; runtime/pprof.addr uintptr } *runtime/pprof.newFunc·1 *[1]uint64 !struct { F uintptr; runtime/pprof.e **runtime/pprof.profMapEntry; runtime/pprof.b *runtime/pprof.profileBuilder }!*runtime/pprof.protobuf!*[2]int64!*struct { F uintptr; runtime/pprof.e **runtime/pprof.profMapEntry; runtime/pprof.b *runtime/pprof.profileBuilder }K"struct { F uintptr; R *runtime/pprof.profileBuilder }"*struct { F uintptr; R *runtime/pprof.profileBuilder }"func(uint64, uint64, uint64, string, string)!#func(uint64, uint64, uint64, string, string)S#struct { F uintptr; runtime/pprof.line *[]uint8 }#*struct { F uintptr; runtime/pprof.line *[]uint8 }#func() []uint8#func() []uint8$*runtime/pprof.memMap#$*[]runtime/pprof.memMapA$struct { F uintptr; runtime/pprof.blockSize int64; runtime/pprof.b *runtime/pprof.profileBuilder }$*[4]int64$*struct { F uintptr; runtime/pprof.blockSize int64; runtime/pprof.b *runtime/pprof.profileBuilder }L%*[]runtime.MemProfileRecordn%*[]runtime.BlockProfileRecord%noalg.map.iter[string]stringq&noalg.map.iter[string]string&*map.hdr[string]string&noalg.map.hdr[string]stringe'noalg.map.hdr[string]string'*map.bucket[string]string'noalg.map.bucket[string]string (noalg.map.bucket[string]string1(runtime/pprof.labelMapV(*runtime/pprof.runtimeProfilez(*runtime/pprof.stackProfile(*[8]runtime/pprof.newFunc·1(*struct { sync.Mutex; runtime/pprof.profiling bool; runtime/pprof.done chan bool })*testing/internal/testdeps.TestDepsB)testing/internal/testdeps.TestDepsi)testing/internal/testdeps.TestDeps)github.com/go-kit/kit/metrics.Histogram)github.com/go-kit/kit/metrics.Histogram)*github.com/go-kit/kit/metrics.Timer*github.com/go-kit/kit/metrics.Timera*github.com/go-kit/kit/metrics.Timer*github.com/go-kit/kit/metrics/internal/lv.LabelValues*github.com/go-kit/kit/metrics/internal/lv.LabelValues,+*github.com/go-kit/kit/metrics/generic.SimpleHistogrami+github.com/go-kit/kit/metrics/generic.SimpleHistogram+github.com/go-kit/kit/metrics/generic.SimpleHistogram,runtime.stringStructDWARFH,runtime.stringStructDWARFg,*int16t,*int8,*compress/flate.compressionLevel,*unicode.foldPair,*unicode.CaseRange,*syscall.Iovec,*runtime.ptabEntry-*runtime.textsect-*runtime.functab5-[]keyR-[]valo-bucket-*bucket-hash.*hash.[]key.[]val.bucket@/*bucket[/hash0*hash0[]val<*runtime/pprof.profMapEntry>M0bucket0*bucket0hash1*hash1[]key<*reflect.structType> 2[]val'2bucket<*reflect.structType,bool>2*bucket<*reflect.structType,bool>2hash<*reflect.structType,bool>j3*hash<*reflect.structType,bool>3bucket<*reflect.structType,int>3*bucket<*reflect.structType,int>4hash<*reflect.structType,int>4*hash<*reflect.structType,int>4[]key5[]val>5bucket5*bucket5hash6*hash6[]key6[]val<[]*runtime._type>6bucket`7*bucket7hash;8*hash`8[]val8bucket8*bucket+9hash9*hash:[]val<*unicode.RangeTable>;:bucket:*bucket:hash;*hash;[]key;[]val<*sync.entry>;bucket\<*bucket<hash9=*hash_=[]val<[]uintptr>=bucket=*bucket >hash>*hash>[]val<*runtime/pprof.Profile>?bucket}?*bucket?hashd@*hash@[]val<*flag.Flag>@bucketA*bucket2AhashA*hashA[]key<*uint8>B[]val<[]uint8>9Bbucket<*uint8,[]uint8>B*bucket<*uint8,[]uint8>Bhash<*uint8,[]uint8>`C*hash<*uint8,[]uint8>|CbucketC*bucketChashD*hashD[]val<[]testing.CoverBlock>DbucketGE*bucketrEhash*F*hashSF[]val<[]uint32>rFbucketF*bucketFhashG*hashG[]keyG[]valGbucket[H*bucketHhash0I*hashRI[]keymI[]valIbucketI*bucketJhashJ*hashJ[]valKbucketdK*bucketKhash+L*hashFL[]keykL[]val<*runtime._type>LbucketL*bucket)MhashM*hashN[]val+NbucketN*bucketNhashMO*hashgObucketO*bucketOhashP*hashPsudogQwaitqQ*sudogQhchanR*hchanRsudogpSwaitqS*sudogShchanjT*hchan|TsudogSUwaitqU*sudogUhchan_V*hchanwVsudogNWwaitqW*sudogWhchanZX*hchanrXsudogDYwaitqqY*sudogYhchanAZ*hchan,e/usr/local/Cellar/go/1.9/libexec/src/runtime/runtime-gdb.pyJgoe/Users/lorenzocanese/Projects/subito-envs/src/github.com/go-kit/kit/metricsGo cmd/compile go1.9sync/atomic.(*Value).LoadxpP",fvpX",ftyp`"߶datah"߶vfx"usync/atomic.(*Value).Storexp@",fvpH",fvfx"utypP"߶sync/atomic.CompareAndSwapUintptrsync/atomic.CompareAndSwapUint64sync/atomic.StoreUint32sync/atomic.StoreUint64sync/atomic.StoreUintptrtype..hash.sync/atomic.Value pfh"~r2"type..eq.sync/atomic.ValueUpfq"f~r2"+runtime.memhash0`kp߶h"~r2"runtime.memhash8pp߶h"~r2"runtime.memhash16)p߶h"~r2"runtime.memhash320p߶h"~r2"runtime.memhash64p߶h"~r2"runtime.memhash128Ip߶h"~r2"runtime.strhashPa߶h"~r2"runtime.f32hashp߶h"~r2"runtime.f64hashpp߶h"~r2"runtime.c64hashpp߶h"~r2"runtime.c128hashNp߶h"~r2"runtime.interhashPfnX"p߶h"~r2"runtime.nilinterhashfnX"p߶h"~r2"runtime.memequal0p߶q"߶~r2"+runtime.memequal8p߶q"߶~r2"+runtime.memequal16p߶q"߶~r2"+runtime.memequal32p߶q"߶~r2"+runtime.memequal64+p߶q"߶~r2"+runtime.memequal1280\p߶q"߶~r2"+runtime.f32equal`p߶q"߶~r2"+runtime.f64equalp߶q"߶~r2"+runtime.c64equalp߶q"߶~r2"+runtime.c128equal;p߶q"߶~r2"+runtime.strequal@p߶q"߶~r2"+runtime.interequalp߶q"߶~r2"+runtime.nilinterequal p߶q"߶~r2"+runtime.efaceeq !eqP"tٹx"߶y"߶~r3"+runtime.ifaceeq!"eqP"tabx"߶y"߶~r3"+runtime.alginit"$runtime.atomicstorep $n$ptr߶new"߶runtime.caspp$$ptr?old"߶new"߶~r3"+sync/atomic.StorePointer$;%ptr?new"߶sync/atomic.CompareAndSwapPointer@%%ptr?old"߶new"߶~r3"+runtime.cgocall%&errnod"mph"fn߶arg"߶~r2"runtime.endcgo&&mpruntime.cgocallbackg& (savedpc"syscall"savedsp`"߶gph"Sctxtruntime.cgocallbackg1(*restoreG"+s.lenH"s.capP"gp`"Sctxtruntime.unwindm*+mph"restore4runtime.cgoIsGoPointer +A,datap`"p߶~r1"+runtime.cgoInRangeP,s,p߶start"end"~r3"+runtime.cgoCheckWriteBarrier,K-dstsrc"runtime.cgoCheckMemmoveP--typٹdst"߶src"߶off"size "runtime.cgoCheckSliceCopy-.i`"ph"߶typٹdst"mgsrc "mgn8"runtime.cgoCheckTypedBlock.3hbits.shift"ʷi"hbits.bitp"@datap"typٹsrc"߶off"size"runtime.cgoCheckBits 34bitsH"ʷiP"ptrmask`"@src߶gcbits"@off"size"runtime.cgoCheckUsingType437skipped"skipped@"iH"f.typ`"ٹtypٹsrc"߶off"size"runtime.makechan@79elemX"ٹc`"tXhsize"~r2"runtime.chanbuf9,:ci"~r2"߶runtime.chansend10:}:celem"߶runtime.chansend:@t0"mysg"gp"Scep"߶block"+callerpc"~r4 "+runtime.send@ Bgp`"Scsg"ep"߶unlockf"sskip "runtime.sendDirectBBdsth"߶tٹsg"src"߶runtime.recvDirectB/Csrch"߶tٹsg"dst"߶runtime.closechan0CJFsg"sg@"gpH"SgpP"SgpX"Sglist`"Scruntime.chanrecv1PFFcelem"߶runtime.chanrecvFMt0"qp"߶mysg"gp"Scep"߶block"+selected"+received"+runtime.recvMNqp`"߶gph"Scsg"ep"߶unlockf"sskip "reflect.chanlenN Oc~r1"runtime.(*waitq).enqueueOgPq isgp"runtime.(*waitq).dequeuepPQyX"sgp`"q i~r0"runtime.init.0QARruntime.SetCPUProfileRatePR=Thdrh")hzruntime.(*cpuProfile).add@TbUhdrh")pigp"Sstk"5runtime.(*cpuProfile).addNonGopUVpistk"5runtime.(*cpuProfile).addExtraVXi@"hdrH")hdrP")lostStk`"9ipiruntime/pprof.runtime_cyclesPerSecondX Y~r0runtime/pprof.readProfileYZeof"+tags.len"tags.cap@"data.lenH"data.capP"tags.ptrX"?log`"'data.ptrh"[~r0*~r1"d~r20"+runtime.GOMAXPROCSZs[n~r1"runtime.NumGoroutine[[~r0runtime.(*timeval).set_usec[[tvRix"runtime.gogetenv[]s.lenH"env.lenP"s.ptr`"@keyJ~r1"Jruntime.(*TypeAssertionError).Error ]_ei~r0"Jruntime.errorString.Error_`e0&~r0"Jruntime.plainError.Error `5`ei~r0"Jruntime.typestring@``xu~r1"Jruntime.printany`0jv~"+v~"v~"v~"v~"jv.real~"Dv.imag~"Dv"ʷv"v.real"v.len"v.imag"v"v"v"Kv@"vH"v.ptr`"@iuruntime.panicwrap0j=opkg.len|"pc.len|"pc.cap|"name.len|"typ.ptr}"@pkg.ptr}"@pc.ptr}"frame}"~'runtime.Caller@oqrpc}"mframe~"~'stackExpander"kskippc"file"Jline "ok("+runtime.Callersr|rskippc"5~r2 "runtime.GOROOTrr~r0Jruntime.fastlog2ssx~r1"runtime.float64bitst tf~r1"Kruntime.float64frombitsttbK~r1"runtime.memhash tzv4"Kv3"Kv2"Kv1"Kp߶seed"s"~r3"runtime.rotl_31zzxK~r1"Kruntime.evacuatedzzbm~r1"+runtime.(*bmap).overflowz;{bmt"An~r1"mruntime.(*bmap).setoverflow@{{bmt"Anovf"mruntime.(*hmap).incrnoverflow{J|hXnruntime.(*hmap).newoverflowP|~ovfP"mhXnt"Anb"m~r2"mruntime.(*hmap).createOverflow~hXnruntime.makemapBG"nextOverflowP"mextraX"!obuckets`"߶tAnhint"h"Xnbucket"߶~r4 "Xnruntime.mapaccess2top"i"cH"߶bP"malgX"tAnh"Xnkey"߶~r3"߶~r4 "+runtime.mapaccessK׊top"i"hash"k@"߶cH"߶bP"malgX"tAnh"Xnkey"߶~r3"߶~r4 "߶runtime.mapassigntop~"i"hash"bucket"val"߶newb"mkmem"߶k"߶insertk"߶inserti@"@bH"malgP"tAnh"Xnkey"߶~r3"߶runtime.mapiterinitڕtAnh"Xnit"4pruntime.mapiternext i~"checkBucket"bucket"v"߶t"Anrv"߶k2@"߶k2H"߶hP"XnbX"malg`"it4pruntime.makeBucketArrayszH"nbucketsP"tAnb"buckets"߶nextOverflow"mruntime.hashGrow3oldbucketsH"߶nextOverflowP"mnewbucketsX"߶tAnh"Xnruntime.overLoadFactor@countB"~r2"+runtime.tooManyOverflowBucketsnoverflowB"~r2"+runtime.(*hmap).growinghXn~r0"+runtime.(*hmap).sameSizeGrow#hXn~r0"+runtime.(*hmap).noldbuckets0oldBo"hXn~r0"runtime.(*hmap).oldbucketmaskhXn~r0"runtime.growWorktAnh"Xnbucket"runtime.bucketEvacuatedtAnh"Xnbucket"~r3"+runtime.evacuate top~"yi~"xi~"stop~"i~"hash~"yv~"߶yk~"߶y~"mxv"߶xk"߶x"mv"߶newy"mnewx"mk2"߶k"߶b@"malgH"tAnh"Xnoldbucket"runtime.ismapkeytٹ~r1"+reflect.mapaccess tAnh"Xnkey"߶~r3"߶reflect.mapiterinitith"4ptAnh"Xn~r2"4preflect.mapiternext<it4preflect.mapiterkey@Nit4p~r1"߶reflect.maplenPmhXn~r1"runtime.mapaccess1_fast32pm"i@"hashH"cP"߶bX"mtAnh"Xnkey"ʷ~r3"߶runtime.mapaccess2_fast32 ٹm"i@"hashH"cP"߶bX"mtAnh"Xnkey"ʷ~r3"߶~r4 "+runtime.mapaccess1_fast64m"i@"hashH"cP"߶bX"mtAnh"Xnkey"K~r3"߶runtime.mapaccess2_fast64Lm"i@"hashH"cP"߶bX"mtAnh"Xnkey"K~r3"߶~r4 "+runtime.mapaccess1_faststrP7top"m"keymaybe"i"i"i"hash"key"qc@"߶bH"mtAnh"Xnky"J~r3 "߶runtime.mapaccess2_faststr@gtop"m"keymaybe"i"i"i"hash"key"qc@"߶bH"mtAnh"Xnky"J~r3 "߶~r4("+runtime.mapassign_fast32ptop"i"hash"bucket"val"߶newb@"minsertkH"߶insertiP"@bX"mtAnh"Xnkey"ʷ~r3"߶runtime.mapassign_fast64htop"i"hash"bucket"val"߶newb@"minsertkH"߶insertiP"@bX"mtAnh"Xnkey"K~r3"߶runtime.mapassign_faststrptop"i"hash"bucket"val"߶newb"mkey"qinsertk@"߶insertiH"@bP"mtAnh"Xnky"J~r3 "߶runtime.itabhashintertyp"ٹ~r2"ʷruntime.getitab$locked"name.bytes"@m"intertyp"ٹcanfail"+~r3"runtime.additab0pkgPath.len~"k~"j~"ipkg.len~"iname.len~"x~"2rtyp~"ٹtname.bytes"@pkgPath.ptr"@name.bytes"@itype"ٹipkg.ptr"@inter"iname.ptr"@ifn"߶mlocked"+canfail "+runtime.itabsinitruntime.panicdottypeEhaveString.len"haveString.ptrP"@haveٹwant"ٹiface"ٹruntime.panicdottypeI-havewant"ٹiface"ٹruntime.convT2E0xh"߶tٹelem"߶e"runtime.convT2E16?tٹelem"߶e"runtime.convT2E32@tٹelem"߶e"runtime.convT2E64?tٹelem"߶e"runtime.convT2Estring@xh"߶tٹelem"߶e"runtime.convT2Eslicexh"߶tٹelem"߶e"runtime.convT2EnoptrOxh"߶tٹelem"߶e"runtime.convT2I64Ptabelem"߶i"<runtime.convT2Istringxh"߶tabelem"߶i"<runtime.convT2Islice]xh"߶tabelem"߶i"<runtime.assertI2I2`#interi"<r"<b("+runtime.assertE2I0cintere"r"<runtime.assertE2I2p'intere"r"<b("+reflect.ifaceE2I0intere"dst"rruntime.(*lfstack).push^newX"Knode1h"rheadrnode"rruntime.(*lfstack).pop`oldh"Kheadr~r0"߶runtime.(*lfstack).emptyheadr~r0"+runtime.lfstackPack.nodercnt"~r2"Kruntime.lfstackUnpack0CvalK~r1"rruntime.lockP$spinX"i`"gph"Slhruntime.unlock0gph"Slhruntime.noteclear -nsruntime.notewakeup0nsruntime.notesleepgp`"Snsruntime.notetsleep_internal{nsns"gp"Sdeadline"~r4 "+runtime.notetsleep-nsns"~r2"+runtime.notetsleepg0oko"+nsns"~r2"+runtime.mallocinitreserved~"+spansSize~"procBrk~"pSize"p"i"bitmapSize"arenaSize"_g_`"Sruntime.(*mheap).sysAlloc reservedW"+statX"Kp_size`"hsn"~r1"߶runtime.nextFreeFast | resulth"s~r1"runtime.(*mcache).nextFree freeIndex"c'spc"/v"s"shouldhelpgc "+runtime.mallocgc spc"/shouldhelpgc"+noscan"+scanSize"dataSize"x"߶span"s"mp"mp"c@"'assistGH"Ssizetyp"ٹneedzero"+~r3"߶runtime.largeAllocnpages`"sh"sizeneedzero"+noscan "+~r3"runtime.newobjectctypٹ~r1"߶reflect.unsafe_Newptypٹ~r1"߶runtime.newarrayftypٹn"~r2"߶runtime.profileallocpmpx"߶size"runtime.nextSampleperiodh"~r0runtime.persistentallocWp@"߶sizealign"sysStat"[~r3"߶runtime.persistentalloc1``persistentP";upX"߶mp`"sizealign"sysStat"[~r3"߶runtime.gcmarkwb_m`slotptr"runtime.writebarrierptr_prewrite1mpH"dstsrc"runtime.writebarrierptrX dstsrc"runtime.writebarrierptr_prewrite`  dstsrc"runtime.typedmemmove !typٹdst"߶src"߶reflect.typedmemmove!"typٹdst"߶src"߶reflect.typedmemmovepartial"x#frag`"adsth"߶typٹdst"߶src"߶off"size "runtime.reflectcallmove#$typٹdst"߶src"߶size"runtime.typedslicecopy $%n"srcp"߶dstp@"߶typٹdst"mgsrc "mg~r38"runtime.typedmemclr%U&typٹptr"߶runtime.memclrHasPointers`&&ptr߶n"runtime.addb&&p@n"~r2"@runtime.subtractb&&p@n"~r2"@runtime.add1''p@~r1"@runtime.subtract1''p@~r1"@runtime.(*mheap).mapBits ''nh"hsarena_used"runtime.(*mspan).allocBitsForIndex(Q(sallocBitIndex"~r1"Swruntime.(*mspan).refillAllocCache`((swhichByte"runtime.(*mspan).nextFreeIndex(4*snelemsX"sfreeindex`"resulth"s~r0"runtime.(*mspan).isFree@**sindex"~r1"+runtime.(*mspan).objIndex*+sp"~r1"runtime.markBitsForAddr+!,sh"p~r1"Swruntime.(*mspan).markBitsForIndex0,,sobjIndex"~r1"Swruntime.(*mspan).markBitsForBase,,s~r0"Swruntime.markBits.isMarked,,mSw~r0"+runtime.markBits.setMarked,,mSwruntime.markBits.setMarkedNonAtomic,-mSwruntime.(*markBits).advance--miwruntime.heapBitsForAddr--addr~r1"wruntime.heapBitsForSpan-/basehbits"wruntime.heapBitsForObject/G4prefBase"refOff"base"hbits "ws0"objIndex8"runtime.heapBits.nextP44hw~r0"wruntime.heapBits.forward45hwn"~r1"wruntime.heapBits.bits 535hw~r0"ʷruntime.heapBits.isPointer@5}5hw~r0"+runtime.heapBits.isCheckmarked55hwsize"~r1"+runtime.heapBits.setCheckmarked56hwsize"runtime.bulkBarrierPreWrite 6 9h.shiftT"ʷiX"i`"h.bitph"@dstsrc"size"runtime.bulkBarrierBitmap91:mask^"i`"dstsrc"size"maskOffset"bits "@runtime.typeBitsBulkBarrier@:<bits@"ʷiH"ptrmask`"@typٹdst"src"size"runtime.heapBits.initSpan<L>totalX"size`"hws"runtime.heapBits.initCheckmarkSpanP>7?i`"ih"hwsize"n"total "runtime.heapBits.clearCheckmarkSpan@??ih"hwsize"n"total "runtime.(*mspan).countAlloc?@iP"countX"bitsInLastByte`"s~r0"runtime.heapBitsSetType@.Jh.shift~"ʷw~"pbits~"nw~"nb~"n~"i~"endnb"b"p@"@hbitpH"@h.bitpP"@endpX"@xsize"dataSize"typ"ٹruntime.heapBitsSetTypeGCProg0JNtrailer"A$hwprogSize"elemSize"dataSize "allocSize("prog0"@runtime.progToPointerMask N=Oprog@size"~r2"runtime.runGCProg@OB\totalBits}"pattern}"off}"off~"off~"npattern~"nbits~"n~"i~"i~"i~"frag~"frag~"c~"bits~"src@"@pH"@prog@trailer"@dst"@size"~r4 "runtime.gclinkptr.ptrP\[\p~r0"wruntime.allocmcache`\]~r0'runtime.freemcache]b]c'runtime.(*mcache).refillp]^_g_h"Sc'spc"/~r1"runtime.(*mcache).releaseAll^_ih"c'runtime.(*mcentral).init__c_xspc"/runtime.(*mcentral).cacheSpan_%dsgT"ʷs`"c_x~r0"runtime.(*mcentral).uncacheSpan0dKenl"c_xs"runtime.(*mcentral).freeSpanPefc_xs"preserve"+wasempty"+~r3"+runtime.(*mcentral).growfuhnP"sh"c_x~r0"runtime.sysAllochivh"߶nsysStat"[~r2"߶runtime.sysUnused iniv߶n"runtime.sysUsedpiqiv߶n"runtime.sysFreeiiv߶n"sysStat"[runtime.sysFaulti/jv߶n"runtime.sysReserve0jjv߶n"reserved"4~r3"߶runtime.sysMapjkv߶n"reserved"+sysStat"[runtime.queuefinalizerk$np߶fn"fnret"fint"ٹot "runtime.wakefing0nnresh"S~r0Sruntime.createfingn;oruntime.runfinq@oWtframesz"framecap"next" frame"߶fb@" runtime.SetFinalizer`ty|nret~"t~"ٹf~"vye"vyobjufinalizer"uruntime.findObject|S~v߶s"x"߶n"runtime.(*fixalloc).init`~Tfysize"first"arg"߶stat "[runtime.(*fixalloc).alloc`̀v`"߶fy~r0"߶runtime.(*fixalloc).freeЀfyp"߶runtime.gcinitׁruntime.readgogc~r0runtime.gcenable*ch"yruntime/debug.setGCPercent0ރinout"runtime.setGCPhase$xʷruntime.(*gcControllerState).startCycle0czruntime.(*gcControllerState).reviseczruntime.(*gcControllerState).endCycle ЌW_a"H_m_prev"KH_a"KH_T"Kcz~r0"runtime.(*gcControllerState).enlistWorkerЌmyIDd"triesh"czruntime.(*gcControllerState).findRunnableGCWorkergph"Scz_p_"~r1"Sruntime.gcSetTriggerRatiojtrigger"KminTrigger"KtriggerRatioruntime.GCpnX"ʷmp`"gph"Sruntime.gcTrigger.testht]z~r0"+runtime.gcStartpnowh"modeEtrigger"]zruntime.gcMarkDoneܜruntime.gcMarkTerminationzsweepTermCpu|"startTime|"prev|"ns}"ns}"now}"markTermCpu}"i}"i}"sbuf}"{mp"gp"S_g_"SnextTriggerRatioruntime.gcBgMarkStartWorkersJruntime.gcBgMarkPreparePeruntime.gcBgMarkWorkerpˮincnwait"ʷdecnwait"ʷstartTime"park"{gp@"S_p_runtime.gcMarkWorkAvailableЮp~r1"+runtime.gcMark˲iP"gcwX"I|gcw`"I|start_timeruntime.gcSweepвmodeEruntime.gcResetMarkState:sync.runtime_registerPoolCleanup@fsruntime.clearpoolsoiP"sgnextX"dlink`"runtime.gchelperpgcw`"I|_g_h"Sruntime.gchelperstart7runtime.itoaDiv@bufval"Kdec "~r3("runtime.fmtNSAsMS bufns"K~r2 "runtime.(*treapNode).inittruntime.(*mTreap).insertptP"|lastX"rootv|span"runtime.(*mTreap).removeNoderootv|t"~r1"runtime.(*mTreap).removerootv|npages"~r1"runtime.(*mTreap).removeSpan$rootv|span"runtime.scavengetreap0treapnow"Klimit"K~r3"runtime.(*mTreap).rotateLeft rootv|x"runtime.(*mTreap).rotateRightrootv|y"runtime.gcMarkRootPrepareruntime.gcMarkRootCheckiP"gph"Sruntime.markrootAbaseData"ʷbaseBSS"ʷgp"Sfb@" gcwI|i"ʷruntime.markrootBlockPbX"b0n0"ptrmask0"@gcw"I|shard "runtime.markrootFreeGStacks tailX"Sgp`"Sruntime.markrootSpanssg"ʷspans.len@"sP"gcwI|shard"runtime.gcAssistAlloc tracedG"+scanWorkH"gpSruntime.gcAssistAlloc1incnwait"ʷdecnwait@"ʷworkDoneH"startTimeP"gcw`"I|gpSscanWork"runtime.gcWakeAllAssistsuruntime.gcParkAssistGgph"S~r0+runtime.gcFlushBgCreditPscanBytesH"xgp`"Sgph"SscanWorkruntime.scanstackcache}"T~gpSgcw"I|runtime.scanframeworkerYpcdata"targetpc"size"f.datapH"f._funcP"]lframecache" ~gcw"I|runtime.gcDrain`initScanWork@"idleCheckH"gph"SgcwI|flags"runtime.gcDrainNworkFlushed`"gph"SgcwI|scanWork"~r2"runtime.scanblock{bitsD"ʷjH"iP"arena_usedX"arena_start`"b0n0"ptrmask"@gcw"I|runtime.scanobject9hbits.shift"ʷoblet"n@"iH"arena_usedP"arena_startX"s`"hbits.bitph"@bgcw"I|runtime.shade@uhbits.shiftD"ʷobjIndexH"objP"spanX"hbits.bitp`"@gcwh"I|bruntime.greyobjectYmbits.mask_"mbits.index`"mbits.byteph"@objbase"off"hbits"wspan("gcw0"I|objIndex8"runtime.gcDumpObject`size"i"s`"labelJobj"off"runtime.gcmarknewobjectobjsize"scanSize"runtime.gcMarkTinyAllocspP"gcwX"I|c`"'runtime.initCheckmarkssX"runtime.clearCheckmarkssX"runtime.finishsweep_mBruntime.bgsweepPcyruntime.sweeponepsg"ʷnpages@"_g_h"S~r0runtime.gosweeponepretX"~r0runtime.gosweepdone~r0+runtime.(*mspan).ensureSwept sgl"ʷsruntime.(*mspan).sweep Aspc~"/res~"+mbits.mask~"hasFin~"+freeToHeap~"+nfreed~"sweepgen~"ʷsize~"p~"objIndex~"mbits.index~"i~"endOffset~"y"\tmp"\specialp"Uspecial"\mbits.bytep"@c"'_g_"Smbits@"SwabitsX"Swspreserve"+~r1"+runtime.deductSweepCreditPsweptBasis`"KpagesTargeth"spanBytescallerSweepPages"runtime.(*gcSweepBuf).pushnewCap@"cursorH"newSpine`"߶bms"runtime.(*gcSweepBuf).pop9cursorl"ʷbm~r0"runtime.(*gcSweepBuf).numBlocks@Vbm~r0"runtime.(*gcSweepBuf).block`Ubmi"~r1"runtime.init.1`aruntime.(*gcWork).initpwI|runtime.(*gcWork).putwI|obj"runtime.(*gcWork).putFast^wI|obj"~r1"+runtime.(*gcWork).tryGet`Mwbuf`"owbufh"wI|~r0"runtime.(*gcWork).tryGetFastPwI|~r0"runtime.(*gcWork).getwbuf`"owbufh"wI|~r0"runtime.(*gcWork).disposewI|runtime.(*gcWork).balance] wI|runtime.(*gcWork).empty`  wI|~r0"+runtime.(*workbuf).checknonempty  bruntime.(*workbuf).checkempty!W!bruntime.getempty`!u#i"s@"bH"~r0runtime.putempty##bruntime.putfull#8$bruntime.trygetfull@$$~r0runtime.getfull$'incnwaitP"ʷincnwaitT"ʷdecnwaitX"ʷi`"~r0runtime.handoff'(b1h"b~r1"runtime.prepareFreeWorkbufs(S)runtime.freeSomeWbufs`)?*preemptible+~r1"+runtime.(*mspan).base@*O*s~r0"runtime.(*mspan).layoutP**ssize"n"total"runtime.recordspan*-oldAllspans.len"oldAllspans.cap"n"oldAllspans.ptr@"ftnewX"vh߶p"߶runtime.makeSpanClass-.sizeclassnoscan"+~r2"/runtime.spanClass.sizeclass .,.sc/~r0"runtime.spanClass.noscan0.?.sc/~r0"+runtime.inheap@..sh"b~r1"+runtime.inHeapOrStack//sh"b~r1"+runtime.spanOf/F0p~r1"runtime.spanOfUncheckedP00p~r1"runtime.(*mheap).init03iX"i`"hsspansStart"spansBytes"runtime.(*mheap).setArenaUsed 33hsarena_used"racemap"+runtime.(*mheap).mapSpans34hsarena_used"runtime.(*mheap).reclaimList45sgL"ʷsnpagesP"nX"sh"hslist"npages"~r2"runtime.(*mheap).reclaim57reclaimedX"i`"ih"hsnpage"runtime.(*mheap).alloc_m7:s`"_g_h"Shsnpage"spanclass"/large"+~r3"runtime.(*mheap).alloc:;s@"hsnpage"spanclass"/large"+needzero"+~r4"runtime.(*mheap).allocManual<<sh"hsnpage"stat"[~r2"runtime.(*mheap).allocSpanLocked=KAiH"sX"list`"hsnpage"stat"[~r2"runtime.(*mheap).isLargeSpanPAcAhsnpages"~r1"+runtime.(*mheap).allocLargepAAhsnpage"~r1"runtime.(*mheap).growA*Dask@"v`"߶hsnpage"~r1"+runtime.(*mheap).lookup0DDhsv"߶~r1"runtime.(*mheap).lookupMaybeDgEsh"hsv"߶~r1"runtime.(*mheap).freeSpanpEEhss"acct"runtime.(*mheap).freeManualEFhss"stat"[runtime.(*mheap).freeSpanLockedFLp"before`"afterh"hss"acctinuse"+acctidle"+unusedsince"runtime.(*mheap).freeListLLhsnpages"~r1"runtime.(*mheap).busyListLMhsnpages"~r1"runtime.scavengeTreapNode MiNreleased`"sh"tnow"Klimit"K~r3"runtime.scavengelistpNPsumreleasedX"released`"sh"listnow"Klimit"K~r3"runtime.(*mheap).scavengeP1Ssumreleased"i"gph"Shsk"now"Klimit"Kruntime.(*mspan).init@SSspanbase"npages"runtime.(*mspan).inListSSspan~r0"+runtime.(*mSpanList).initSTlistruntime.(*mSpanList).removeTUlistspan"runtime.(*mSpanList).isEmptyUUlist~r0"+runtime.(*mSpanList).insertUVlistspan"runtime.(*mSpanList).insertBackW Xlistspan"runtime.(*mSpanList).takeAll XXlistother"runtime.addspecialYZkindO"offsetP"spanX"mp`"p߶s"\~r2"+runtime.removespecialZ[offsetH"spanP"sX"\mp`"p߶kind"~r2"\runtime.addfinalizer[O^mp@"gcwH"I|baseP"߶p߶f"fnret"fint"ٹot "~r5("+runtime.removefinalizerP^^p߶runtime.setprofilebucket^_p߶b"runtime.freespecial_`s\p"߶size"runtime.(*gcBits).bytep`0abn"~r1"@runtime.(*gcBits).bitp0aabn"bytep"@mask"runtime.(*gcBitsArena).tryAlloca(bbbytes"~r1"runtime.newMarkBits0bcpP"pX"p`"freshh"nelems~r1"runtime.newAllocBitsdFdnelems~r1"runtime.nextMarkBitArenaEpochPderuntime.newArenaMayUnlockee~r0runtime.(*memRecordCycle).addf8fa؂b"؂runtime.newBucket@fgsizeh"typ(nstk"~r2"runtime.(*bucket).stkggb~r0"5runtime.(*bucket).mpg hb~r0"uruntime.(*bucket).bphhb~r0"runtime.stkbuckethkb`"bh"typ(size"stk"5alloc("+~r40"runtime.eqslicelwlx5y"5~r20"+runtime.mProf_NextCyclellruntime.mProf_Flushmgmruntime.mProf_FlushLockedpmOnmp`"ubh"runtime.mProf_PostSweepPnRomp`"ubh"runtime.mProf_Malloc`oqnstk}"stk}" bP"p߶size"runtime.mProf_Free qqbsize"runtime.SetBlockProfileRateqsrrateruntime.blockeventrrcyclesskip"runtime.blocksampledsscycles~r1"+runtime.saveblockeventsCunstk}"stk}" bh"cyclesskip"which"(runtime.SetMutexProfileFractionPu~urate~r1"sync.eventu!vcyclesskip"runtime.(*StackRecord).Stack0vwr߄~r0"5runtime.(*MemProfileRecord).InUseBytes w2wr<~r0"runtime.(*MemProfileRecord).InUseObjects@wSwr<~r0"runtime.(*MemProfileRecord).Stack`wVxr<~r0"5runtime.MemProfile`x {clear"+idx"c"mpP"ubX"b`"bh"p inuseZero"+n "ok("+runtime.record{|r<b"runtime.BlockProfile|}iH"bX"pYn"ok "+runtime.MutexProfile}iH"bX"pYn"ok "+runtime.ThreadCreateProfile*p=n"ok "+runtime.GoroutineProfile0sp~"gp1"Sgp"Sr"=p=n"ok "+runtime.savegPpcsp"gp"Sr"߄runtime.StackPsp"n"gp"Sbufall"+~r2 "runtime.tracealloc^pc"gp@"Sp߶size"typ"ٹruntime.tracefree`މpc@"gpH"Sp߶size"runtime.tracegcՊgph"Sruntime.roundupsizesize~r1"runtime.init.2͌memStatsR"#0runtime.ReadMemStatsЌ@m,runtime.readmemstats_m@stats,runtime.updatememstatstotalAllocX"Kspc`"runtime.cachestatsruntime.flushmcache ch"'iruntime.flushallmcachesih"runtime.purgecachedstatsc'runtime.mSysStatIncsysStat[n"runtime.mSysStatDecpsysStat[n"internal/poll.runtime_pollServerInitpruntime.netpollinited~r0+internal/poll.runtime_pollOpenpd`"fd~r1"~r2"internal/poll.runtime_pollCloseܖpdruntime.(*pollCache).free<cpd"internal/poll.runtime_pollReset@חpdmode"~r2"internal/poll.runtime_pollWaitpdmode"~r2"internal/poll.runtime_pollUnblockwgP"SrgX"Spdruntime.netpollreadywg`">rgh">gpp{pd"mode"runtime.netpollcheckerr^pdmode"~r2"runtime.netpollblockcommit`gpSgpp"߶~r2"+runtime.netpollgoready gpStraceskip"runtime.netpollblockSgpph"pdmode"waitio "+~r3"+runtime.netpollunblock`oldh"pdmode"ioready "+~r3"Sruntime.(*pollCache).allociX"pd`"memh"߶c~r0"runtime.netpollinitruntime.netpollopenev"͊fdpd"~r2"runtime.netpollcloseɡfd~r1"runtime.netpollС*no"gpo">tso"tpo"eventso"rblock+~r1"Sruntime.unimplemented0nameJruntime.semawakeupۤmpruntime.semacreate0mpruntime.osinit0|runtime.getncpu@out\"ʷnout`"mibh"A~r0runtime.getPageSize@out\"ʷnout`"mibh"A~r0runtime.getRandomDataɧfdd"rruntime.goenvsЧzruntime.newosprocoset`"errnod"mpstk"߶runtime.mpreinitmpruntime.minitŪruntime.unminitЪ֪runtime.macherrorrfn"Jruntime.mach_msgh_bits«aʷb"ʷ~r2"ʷruntime.mach_msgЫDhYop"send_size "ʷrcv_size"ʷrcv_name"ʷtimeout"ʷnotify"ʷ~r7 "runtime.machcallPport\"ʷid`"_g_h"ShYmaxsize"rxsize "~r3"runtime.mach_semcreate׮m}"~r0ʷruntime.semasleep1nsecsd"_g_h"Sns~r1"runtime.semasleep vrT"ns~r1"runtime.mach_semreleaseѰsemʷruntime.osyieldruntime.setsigsaX"'iʷfn"runtime.setsigstackosaH"saX"'iʷruntime.getsigsa`"iʷ~r1"runtime.setSignalstackSPssp"runtime.sigaddset0mask,i"runtime.sigdelset0Rmask,i"runtime.sysargs`nd"argcargv"!runtime.panicCheckMallocVerr runtime.panicindex`ǵruntime.panicsliceе7runtime.panicdivide@runtime.panicoverflowruntime.panicfloat runtime.panicmemruntime.throwinit?runtime.deferproc@spH"callerpcP"argpX"dh"sizfn"fruntime.deferclasssiz~r1"runtime.totaldefersizesiz~r1"runtime.testdefersizessiz@"iH"deferscP"m\"Bruntime.deferArgsd~r1"߶runtime.init.3x`"uruntime.newdeferݾsc"pp"gp"Sd"siz~r1"runtime.freedeferLsc"pp@"druntime.freedeferpanicPruntime.freedeferfnruntime.deferreturnEgpH"SfnP"fdX"arg0runtime.preprintpanicsPXpruntime.printpanics`kpruntime.gopanicp>pc~"sp"߶gp"Sd"pH"Meuruntime.getargp@px~r1"runtime.gorecoverpargp~r1"uruntime.startpanicruntime.dopanicpcH"unusedsync.throwsJruntime.throwxsJruntime.recoveryspX"gpSruntime.startpanic_m_g_h"Sruntime.dopanic_mhdocrash"+all"+signame.len"signame.ptr`"@gpSpc"sp"runtime.canpanicp<gpS~r1"+runtime.bytes@sJret"runtime.recordForPanicn`"ih"bruntime.printlockjmph"runtime.printunlockpruntime.gwrite%n`"gph"Sbruntime.printsp0runtime.printnlruntime.printboolov+runtime.printfloatpbufb"vruntime.printcomplex cruntime.printuintbuf" vKruntime.printint.vruntime.printhex0@buf" vKruntime.printpointer@|p߶runtime.printstringsJruntime.printslicesruntime.printefaceferuntime.mainpsneedUnlock_"+c`"gh"Sos.runtime_beforeExitruntime.init.4runtime.forcegchelper&runtime.Gosched0Xruntime.gopark`mp`"gph"Sunlockf]lock"߶reason"JtraceEv "traceskip("runtime.goparkunlockOlockhreason"JtraceEv"traceskip "runtime.goreadyPgpStraceskip"runtime.acquireSudogs"pp"mp@"~r0runtime.releaseSudogpp"p@"mpH"lastP"firstX"sruntime.funcPC afu~r1"runtime.badmcallpfn+runtime.badmcall2fn+runtime.badreflectcall2runtime.badmorestackg0@runtime.badmorestackgsignalruntime.badctxt runtime.allgadd{gpSruntime.schedinit'procsd"_g_h"Sruntime.dumpgstatus0_g_h"SgpSruntime.checkmcountruntime.mcommoninitumpruntime.ready_g_h"SgpStraceskip"next"+runtime.gcprocsnl"~r0runtime.needaddgcproc&nh"~r0+runtime.helpgc0nT"posX"mp`"_g_h"Snprocruntime.freezetheworldHih"runtime.readgstatusP`gpS~r1"ʷruntime.casfrom_Gscanstatus`^gpSoldval"ʷnewval "ʷruntime.castogscanstatus`TgpSoldval"ʷnewval "ʷ~r3"+runtime.casgstatus`x"nextYield@"iH"gpSoldval"ʷnewval "ʷruntime.scangP nextYield`"ih"gpSgcw"I|runtime.restartgP  gpSruntime.stopTheWorld  reasonJruntime.startTheWorld - runtime.stopTheWorldWithSema0 bad.lenH"pX"bad.ptr`"@_g_h"Sruntime.mhelpgc(runtime.startTheWorldWithSema0addO"+p1P"pX"mp`"_g_h"Sruntime.mstartsize`"_g_h"Sruntime.mstart1 _g_h"Sruntime.forEachP\pP"mpX"_p_`"fn|runtime.runSafePointFn`2runtime.allocm@Jmp`"_g_h"S_p_fn"s~r2"runtime.needmPmp`"_g_h"Sxruntime.newextrammi`"ʷcd"ʷmph"runtime.oneNewExtraMpmpX"gp`"Sruntime.dropm sigmaskd"mph"runtime.lockextra s!incro"+nilokay+~r1"runtime.unlockextra!!mpruntime.newm!N#mpP"tsX"fns_p_"runtime.stopmP#$_g_h"Sruntime.mspinning%%runtime.startm %'mp`"_p_spinning"+runtime.handoffp ')_p_runtime.wakep)*runtime.stoplockedm*+_g_h"Sruntime.startlockedm+,mp`"gpSruntime.gcstopm,-_p_h"runtime.execute-d/_g_h"SgpSinheritTime"+runtime.findrunnablep/;9i"i"enum"lgp"Sgp"Sgp@"SgpH"SgpP"S_p_X"_p_`"_g_h"SgpSinheritTime"+runtime.pollWork@9(:~r0+runtime.resetspinning0::runtime.injectglist:H<nX"gp`"Sgph"SglistSruntime.scheduleP<?inheritTimeO"+gpP"S_g_X"Sruntime.dropg?J@_g_h"Sruntime.parkunlock_cP@@gpSlock"߶~r2"+runtime.park_m@mBokg"+_g_h"SgpSruntime.goschedImplpB?CgpSruntime.gosched_m@CCgpSruntime.gopreempt_mCCgpSruntime.goexit1C0Druntime.goexit00DG_g_@"SgpSruntime.saveGHpcsp"runtime.reentersyscall HJ_g_X"Spcsp"runtime.entersyscallJJdummyruntime.entersyscall_sysmonKuKruntime.entersyscall_gcwaitKxL_p_h"runtime.entersyscallblockLNsp1"pc"_g_"Sdummyruntime.entersyscallblock_handoffNEOruntime.exitsyscallPO.Roldp`"_g_h"Sdummyruntime.exitsyscallfast0RSokG"+_g_H"S~r0+runtime.exitsyscallfast_reacquiredST_g_X"Sruntime.exitsyscallfast_pidleTU_p_h"~r0+runtime.exitsyscall0UV_p_`"_g_h"SgpSruntime.malgV}WnewgP"Sstacksize~r1"Sruntime.newprocW6Xargp@"߶sizfn"fruntime.newproc1@XB]siz"spArg@"newgP"S_p_X"_g_`"Sfnfargp"@narg"nret"callerpc"~r5 "Sruntime.gfputP]__p_gp"Sruntime.gfget`bgpH"S_p_~r1"Sruntime.gfpurgeb+dgp`"S_p_runtime.dolockOSThread0dd_g_h"Sruntime.lockOSThreadddruntime.dounlockOSThreadde_g_h"Sruntime.unlockOSThreadef_g_h"Sruntime.badunlockosthreadfOfruntime.gcountPff~r0runtime.mcountff~r0runtime._Systemffruntime._ExternalCodef gruntime._LostExternalCode gPgruntime._GCPggruntime.sigprofgkcgoOff{"stk{"Ֆpcsp"lr"gp"Smp "runtime.sigprofNonGoPCkelpcruntime.setsSPpl4mf._funch"]lpc~r1"+runtime.setcpuprofilerate@mOn_g_h"Shzruntime.procresizePnvold"i"i"i"i"runnablePs"pp"p@"pH"gpP"S_g_X"Snprocs~r1"runtime.acquirepv w_p_runtime.acquirep1wxidL"_g_`"S_p_runtime.releasepx{_p_@"_g_H"S~r0runtime.incidlelocked{ |vruntime.checkdead|i"grunning@"mpP"gpX"Sgp`"S_p_h"runtime.sysmondelay"ʷt.now"scavengelimit"nscavenge"maxsleep"lasttrace"lastscavenge@"idleH"gph"Sruntime.retakesP"ʷiT"nX"_p_h"now~r1"ʷruntime.preemptall`resk"+il"~r0+runtime.preemptone` _p_~r1"+runtime.schedtrace&t~"ʷid2~"id1~"id1~"id~"i~"h~"ʷnow~"id3"id2"gi"mpP"gpX"S_p_`"detailed+runtime.mput0mpruntime.mget ~r0runtime.globrunqputɔgpSruntime.globrunqputheadД_gpSruntime.globrunqputbatch` gheadSgtail"Sn"runtime.globrunqget {nd"gph"S_p_max"~r2"Sruntime.pidleput_p_runtime.pidleget ~r0runtime.runqemptyŘ_p_~r1"+runtime.runqputИoldnexth">_p_gp"Snext"+runtime.runqputslowiw"ʷbatchw"_p_gp"Sh"ʷt"ʷ~r4"+runtime.runqget hd"ʷnexth">_p_gp"SinheritTime"+runtime.runqgrabZnext`">_p_batch"(batchHead"ʷstealRunNextG"+~r4"ʷruntime.runqsteal`ttd"ʷnh"ʷ_p_p2"stealRunNextG"+~r3"Sruntime.procPinџ~r0runtime.procUnpinsync.runtime_procPin&~r0sync.runtime_procUnpin06sync/atomic.runtime_procPin@f~r0sync/atomic.runtime_procUnpinpvsync.runtime_canSpini~r1"+sync.runtime_doSpin Druntime.(*randomOrder).resetPiT"ʷordEcount"ʷruntime.(*randomOrder).startordEi"ʷ~r1"lruntime.(*randomEnum).done 4enump~r0"+runtime.(*randomEnum).next@}enumpruntime.(*randomEnum).positionenump~r0"ʷruntime.gcdaʷb"ʷ~r2"ʷruntime.(*profAtomic).loadx~r0"runtime.(*profAtomic).storeΣxnew"runtime.(*profAtomic).casУxold"new"~r2"+runtime.profIndex.dataCountx~r0"ʷruntime.profIndex.tagCountx~r0"ʷruntime.countSub)xʷy"ʷ~r2"runtime.profIndex.addCountsAndClearFlags0`xdata"tag"~r2"runtime.(*profBuf).hasOverflow`sb'~r0"+runtime.(*profBuf).takeOverflowoverflowh"Kb'count"ʷtime"Kruntime.(*profBuf).incrementOverflow5b'now"runtime.newProfBuf@LiX"bh"'hdrsizebufwords"tags"~r3"'runtime.(*profBuf).canWriteRecordPѨndP"bwX"br`"b'nstk"~r1"+runtime.(*profBuf).canWriteTwoRecordsndP"bwX"br`"b'nstk1"nstk2"~r2"+runtime.(*profBuf).write%hasOverflow"+stk"1skip"old"data.len@"bwH"brP"data.ptr`"[b'tagPtr"?now"hdr"*stk0"5runtime.(*profBuf).close0b'runtime.(*profBuf).wakeupExtraCold`"b'runtime.(*profBuf).readPti~"ti~"skip~"rPrev~"numData"ntag"ntag"i"di"bw"br"b'mode"data"*tags("deof"+runtime.osRelaxrelax+runtime.tickspersecondйt1P"t0X"r`"c0h"~r0syscall.runtime_envs~r0aos.runtime_args 7~r0aruntime.gotraceback@levelall"+crash"+runtime.argv_indexargv!i"~r2"@runtime.argspcv"!runtime.goargspil"runtime.goenvs_unix+nh"il"runtime.environ0U~r0aruntime.testAtomic64`)runtime.check0jz"ʷm@"ii1D"DiH"DeL"j1P"jX"k1`"߶kh"߶runtime.parsedebugvarspp.len"key.len"field.len"value.ptrH"@v.valueP""p.ptrX"@key.ptr`"@runtime/debug.SetTracebacklevelJruntime.timedivGvdiv"rem""~r3"runtime.acquiremPu~r0runtime.releasemmpruntime.gomcache~r0'reflect.typelinksXsections.len~"sections.cap~"ret.len~"ret.cap~"modules.len~"modules.cap~"sections.ptr"?ret.ptr"Umodules.ptr"fmd"~r0d~r1"֗reflect.resolveNameOff`ptrInModule߶off"~r2"߶reflect.resolveTypeOffrtype߶off"~r2"߶reflect.resolveTextOffNrtype߶off"~r2"߶reflect.addReflectOffP9idh"ptr߶~r1"runtime.efaceOf@Kep?~r1"vyruntime.guintptr.ptrP[gp>~r0"Sruntime.(*guintptr).set`ngp{g"Sruntime.(*guintptr).caspgp{old">new">~r2"+runtime.setGNoWBgpnew"Sruntime.puintptr.ptrpp)~r0"runtime.(*puintptr).setpp{p"runtime.muintptr.ptrmp~r0"runtime.(*muintptr).setmpm"runtime.setMNoWB0mpnew"runtime.extendRandom0w`"rn"runtime.(*rwmutex).rlock rwdruntime.(*rwmutex).runlockmrwdsync.runtime_Semacquirepaddrinternal/poll.runtime_Semacquire addrsync.runtime_SemreleaseUaddrhandoff"+sync.runtime_SemacquireMutex`addrlifo"+internal/poll.runtime_Semreleaseaddrruntime.readyWithTimeYstraceskip"runtime.semacquire`addrruntime.semacquire1t0X"s`"rooth"addrlifo"+profile"ɘruntime.semrelease aaddrruntime.semrelease1pt0X"s`"rooth"addrhandoff"+runtime.semroot?addr~r1"runtime.cansemacquire@gaddr~r1"+runtime.(*semaRoot).queuept"pt"hlast"rootaddr"s"lifo"+runtime.(*semaRoot).dequeuet"s@"psH"hrootaddr"found"now"runtime.(*semaRoot).rotateLefty"p"c"b@"aH"rootx"runtime.(*semaRoot).rotateRight x"p"c@"bH"rooty"sync.runtime_notifyListCheckszsync.runtime_nanotime~r0runtime.dumpregs _cruntime.(*sigctxt).sigpc`c~r0"runtime.(*sigctxt).sigspc~r0"runtime.(*sigctxt).siglrc~r0"runtime.(*sigctxt).fault6c~r0"runtime.(*sigctxt).preparePanic@ csig"ʷgp"Sruntime.(*sigctxt).regs-c~r0"]runtime.(*sigctxt).rax0yc~r0"Kruntime.(*sigctxt).rbxc~r0"Kruntime.(*sigctxt).rcxc~r0"Kruntime.(*sigctxt).rdx jc~r0"Kruntime.(*sigctxt).rdipc~r0"Kruntime.(*sigctxt).rsi c~r0"Kruntime.(*sigctxt).rbpZc~r0"Kruntime.(*sigctxt).rsp`c~r0"Kruntime.(*sigctxt).r8c~r0"Kruntime.(*sigctxt).r9Jc~r0"Kruntime.(*sigctxt).r10Pc~r0"Kruntime.(*sigctxt).r11c~r0"Kruntime.(*sigctxt).r12:c~r0"Kruntime.(*sigctxt).r13@c~r0"Kruntime.(*sigctxt).r14c~r0"Kruntime.(*sigctxt).r15*c~r0"Kruntime.(*sigctxt).rip0gc~r0"Kruntime.(*sigctxt).rflagspc~r0"Kruntime.(*sigctxt).cs c~r0"Kruntime.(*sigctxt).fs]c~r0"Kruntime.(*sigctxt).gs`c~r0"Kruntime.(*sigctxt).sigcodec~r0"Kruntime.(*sigctxt).sigaddrc~r0"Kruntime.(*sigctxt).set_rip=cx"Kruntime.(*sigctxt).set_rsp@cx"Kruntime.(*sigctxt).set_sigcodecx"Kruntime.(*sigctxt).set_sigaddrcx"Kruntime.(*sigctxt).fixsigcodecsig"ʷruntime.sighandlerMdocrash"+flags"_g_P"Ssigʷinfo"Zctxt"߶gp"Sos.sigpipePruntime.signamesigʷ~r1"Jruntime.init.5runtime.initsigid"ʷpreinit+runtime.sigInstallGoHandler!sigʷ~r1"+runtime.setProcessCPUProfiler0$hzruntime.setThreadCPUProfiler0!itP"hzruntime.sigpipe0runtime.sigtrampgosetStack~"+sp~"gsignalStack~"gg"Sst@"stX"sigʷinfo"Zctx"߶runtime.sigpanicgX"Sruntime.dieFromSignalsigʷruntime.raisebadsignal(handlerh"sigʷc"runtime.crash01runtime.noSignalStack@sigʷruntime.sigNotOnStacksigʷruntime.signalDuringFork sigʷruntime.badsignal u sigc"runtime.sigfwdgo j"sigʷinfo"Zctx"߶~r3"+runtime.msigsavep""mpruntime.msigrestore""sigmaskruntime.sigblock")#runtime.unblocksig0##setl"sigʷruntime.minitSignalStack#d$_g_P"SstX"runtime.minitSignalMaskp$#%nmaskd"ih"runtime.unminitSignals0%%stX"runtime.setGsignalStack%B&stold"runtime.restoreGsignalStackP&&struntime.signalstack&'stX"sruntime.sigsend'|(sʷ~r1"+runtime.signal_ignored((sʷ~r1"+runtime.maxSliceCap()elemsize~r1"runtime.makeslice))etٹlen"cap"~r3"mgruntime.growslice*-newlenmem"newcap"lenmem@"iH"capmemP"p`"߶etٹold"mgcap "~r3("mgruntime.stackinit..i`"ih"runtime.stacklog2..n~r1"runtime.stackpoolalloc. 1xH"iP"s`"listh"order~r1"runtime.stackpoolfree12sh"xorder"runtime.stackcacherefill23xX"size`"listh"c'order"runtime.stackcacherelease34y@"xH"sizeP"c'order"runtime.stackcache_clear45orderW"yX"x`"c'runtime.stackalloc59order"x"log2npage"sP"cX"'nʷ~r1"runtime.stackfree9<order"log2npage@"vX"߶s`"ch"'stkruntime.adjustpointer<<adjinfovpp"߶runtime.gobv<?=bv~r1"kruntime.ptrbit@==bvi"~r2"runtime.adjustpointers=@p~"i"delta"bvP"kscanp߶cbv"adjinfo"f"Glruntime.adjustframe@cIpcdata~"targetpc"size"f.datap"f._func"]lbvP"bv`"framearg"߶~r2"+runtime.adjustctxtpIIgpSadjinfo"runtime.adjustdefersIJdh"gpSadjinfo"runtime.adjustpanicsJKgpSadjinfo"runtime.adjustsudogs KKsh"gpSadjinfo"runtime.findsghiKLgpSstk"~r2"runtime.syncadjustsudogs LnMsgsizeX"sg`"sgh"gpSused"adjinfo"~r3"runtime.copystackpMPold.lo}"old.hi}"new.lo}"new.hi}"ncopy}"adjinfo}"gpSnewsize"sync"+runtime.round2PPx~r1"runtime.newstackPJ^sp}"thisg~"Sgcw~"I|morebuf~"jmorebuf"jmorebuf"jctxt߶runtime.nilfuncP^V^runtime.gostartcallfn`^^gobuffv"fruntime.shrinkstack^b`gpSruntime.freeStackSpansp`border"i"s@"sH"nextP"nextX"list`"runtime.morestackc bHbruntime.concatstringsPbdx.len"s.len"l"idx"b.len@"b.capH"s.ptrX"@b.ptr`"@bufa"a~r2 "Jruntime.concatstring2d\ebufa"8_~r2("Jruntime.concatstring3`eebufa"|)~r28"Jruntime.concatstring4eBfbufa"*~r2"Jruntime.concatstring5Pffbufa"~r2"Jruntime.slicebytetostringfgph"߶bufb"str "Jruntime.stringDataOnStackhghsJ~r1"+runtime.rawstringtmpphibufl"s"Jb "runtime.stringtoslicebyte ijb.lenX"b.cap`"b.ptrh"@bufs"J~r2"runtime.stringtoslicerunejknP"a.lenX"a.cap`"bufs"J~r2"runtime.slicerunetostringkmdum"isize2"size1"s.len"b.len@"b.capH"s.ptrX"@b.ptr`"@bufa"~r2 "Jruntime.stringStructOfmmspE~r1"qruntime.intstringmns.len`"s.ptrh"@buf(v"~r2"Jruntime.rawstringnoph"߶sizes"Jb"runtime.rawbytesliceovpcap`"ph"߶sizeb"runtime.rawruneslicepqmemX"ph"߶sizeb"runtime.gostringqrs.lenX"l`"s.ptrh"@p@~r1"Jruntime.indexrsih"sJt"J~r2 "runtime.containssssJt"J~r2 "+runtime.hasprefixs\tsJt"J~r2 "+runtime.atoi`tusJ~r1"~r2"+runtime.atoi32uvsJ~r1"~r2"+runtime.findnullvOvs@~r1"runtime.gostringnocopyPvvss`"qstr@~r1"Jruntime.addvvp߶x"~r2"߶runtime.badsystemstackvvreflect.memclrNoHeapPointerswFwptr߶n"runtime.fastrandPw}w~r0ʷruntime.fastrandnwwnʷ~r1"ʷruntime.noescapewwp߶~r1"߶runtime.getcallerspwwargp߶~r1"runtime.roundwwna"~r2"runtime.bool2intx xx+~r1"runtime.sbrk0xx~r0runtime.CallersFrames xxcih"8callers5~r1"8runtime.(*stackExpander).initxwysecallers"5~r1 "5runtime.(*Frames).Nextyzci8frame"~'more"+runtime.(*stackExpander).nextz}secallers"5ncallers "5frame8"~'more"+runtime.(*pcExpander).init}expc"panicCall"+runtime.(*pcExpander).nextcall.parent~"call.line~"call.file~"frame~"~'frame~"~'ex~r0"~'runtime.expandCgoFramesframes.len~"frames.cap~"frames.ptr~"warg~"Ypc~r1"kruntime.(*Func).rawf'~r0"]lruntime.(*Func).funcInfo&fnh"]lf'~r0"Glruntime.activeModules0s~r0runtime.modulesiniti@"modulesP"ӟmdX"runtime.moduledataverifydataph"runtime.moduledataverify1nftab|"f2name.len|"end|"pcCache|"T~f2name.ptr~"@modulehash"-datapruntime.FuncForPC ~pc~r1"'runtime.(*Func).Name f'~r0"Jruntime.findmoduledatapLpc~r1"runtime.funcInfo.validP`fGl~r0"+runtime.funcInfo._Func`kfGl~r0"'runtime.findfuncpx`"dataph"pc~r1"Glruntime.pcvalue val"pc"p.len"p.cap@"p.ptr`"@fGloff"targetpc"cache " ~strict("+~r50"runtime.cfuncnamefGl~r1"@runtime.funcnamefGl~r1"Jruntime.funcnameFromNameofffGlnameoff"~r2"Jruntime.funcfilefGlfileno"~r2"Jruntime.funcline15fGltargetpc"strict"+file "Jline0"runtime.funcline@fGltargetpc"file"Jline("runtime.funcspdeltaxL"fGltargetpc"cache" ~~r3 "runtime.pcdatavalueLfGltable"targetpc"cache " ~~r4("runtime.funcdataPmph"߶fGli"~r2"߶runtime.steppBppc"val ""first("+newp0"ok"+runtime.readvarintPpread"ʷval"ʷruntime.stackmapdataFstkmap n"~r2"runtime.gostartcallP̩buffn"߶ctxt"߶time.SleepЩīth"pnstime.startTimerЫ tptime.stopTimerUtp~r1"+runtime.goroutineReady`Ҭarguseq"runtime.addtimer<tpruntime.addtimerLocked@tpruntime.deltimer lastX"i`"tp~r1"+runtime.timerprocRseq"now"last"delta@"tP"pfX"!arg.type`"@arg.datah"@runtime.timejump`cgph"S~r0Sruntime.siftupTimerpwhen"t.len@"pH"t.ptrP"iruntime.siftdownTimer+when"n"c@"t.ptrP"itime.runtimeNano0l~r0runtime.traceBufPtr.ptrp{tp~r0"xruntime.(*traceBufPtr).settpb"xruntime.traceBufPtrOfbx~r1"runtime.StartTrace>status~"ʷpid~"stackID~"Ki~"mp"gp@"SbufpH"bufP"x_g_X"S~r0 runtime.StopTrace@wp`"runtime.ReadTracemdata.len"data.cap@"bufH"bufP"data.ptr`"@~r0runtime.traceReaderpwgph"S~r0Sruntime.traceProcFree bufh"ppruntime.traceFullQueuebufruntime.traceFullDequeueEbufh"~r0runtime.traceEventPnarg"pid"tickDiff"KstartPos"mpH"lenpP"@bufpX"buf`"xevskip"args"*runtime.traceStackIDgph"Smpbuf"5skip "~r3("Kruntime.traceAcquireBuffer mppid"bufp"runtime.traceReleaseBuffer?pidruntime.traceFlush@dolock_"+bufph"xbuf~r1"runtime.traceStringbufxs"J~r2"K~r3 "xruntime.traceAppend-bufv"K~r2 "runtime.(*traceBuf).varint0bufxv"Kruntime.(*traceBuf).bytebufxv"runtime.traceStackPtr.ptr tp ~r0"runtime.(*traceStack).stackVts~r0"5runtime.(*traceStackTable).put`vid\"ʷhash`"stkh"tabOpcs"5~r1 "ʷruntime.(*traceStackTable).findstkh"tabOpcs"5hash "~r2("ʷruntime.(*traceStackTable).newStacktabOn"~r1"runtime.allFrames|more~"+frames.len~"frames.cap~"frames.ptr~"wci~"8f~"~'pcs5~r1"kruntime.(*traceStackTable).dump.tmpbuf.len{"tmpbuf.cap{"frames.len{"frame.line{"Kframe.funcID{"Kframe.fileID{"Ktmp{"tmpbuf.ptr~"@stk~"frames.ptr~"wbuf~"xf~"~'tabOruntime.traceFrameForPC0iframe.funcID`"Kbufxf"~'~r2"~r3"xruntime.traceAllocBlockPtr.ptrp{p ~r0"runtime.(*traceAllocBlockPtr).setpx"runtime.(*traceAlloc).alloc'an"~r1"߶runtime.(*traceAlloc).drop0blockh"aruntime.traceGomaxprocs1procsruntime.traceProcStart@runtime.traceProcStoppoldp`")mph"ppruntime.traceGCStartpruntime.traceGCDone[runtime.traceGCScanStart`runtime.traceGCScanDoneruntime.traceGCSweepStart runtime.traceGCSweepSpan|_p_h"bytesSweptruntime.traceGCSweepDonez_p_h"runtime.traceGCMarkAssistStartruntime.traceGCMarkAssistDone;runtime.traceGoCreate@CnewgSpc"runtime.traceGoStartPO_p_")_g_h"Sruntime.traceGoEndPruntime.traceGoSched&runtime.traceGoPreempt0runtime.traceGoParkRtraceEvskip"runtime.traceGoUnpark`qgpSskip"runtime.traceGoSysCallruntime.traceGoSysExittsruntime.traceGoSysBlockoldp`")mph"ppruntime.traceHeapAllocruntime.traceNextGCruntime.tracebackinitruntime.tracebackdefersfn~"ff.datap"f._func"]ld"frame"gpScallback",v"߶runtime.gentraceback Nwaspanicz"+printingz"+linez"level{"tracepc{"tracepc{"sp{"nprint{"name.len{"name.len{"n{"logicalSkipped{"i{"file.len{"cgoCtxt.len{"cache|"T~name.ptr~"@name.ptr~"@g~"Sflr.datap~"flr._func~"]lfile.ptr~"@f.datap~"f._func~"]lcgoCtxt.ptr~"_defer~"frame"pc0sp0"lr0"gp"Sskip "pcbuf("max0"callback8",v"߶flags"~r10"runtime.getArgInfoP2framef"GlneedArgMap"+ctxt "farglen("argmap0"runtime.tracebackCgoContext@anySymbolized{"+pc{"cgoPCs{" arg"Ypcbufprinting"+ctxt"n"max "~r5("runtime.printcreatedbyOtracepc"file.len"file.ptrP"@f.datapX"f._func`"]lgpSruntime.tracebackPpcsp"lr"gp"Sruntime.tracebacktrap#pcsp"lr"gp"Sruntime.traceback10!cgoCallers}"pcsp"lr"gp"Sflags "runtime.callers!"sp"n"skippcbuf"5~r2 "runtime.gcallers"#gpSskip"pcbuf"5~r3("runtime.showframe#%level\"name.len`"name.ptrh"@fGlgp"SfirstFrame"+~r3 "+runtime.isExportedRuntime%%nameJ~r1"+runtime.goroutineheader%w(waitforP"status.lenX"status.ptrh"@gpSruntime.tracebackothers(+level"gpP"SgpX"Sg`"SmeSruntime.topofstack++fGl~r1"+runtime.isSystemGoroutine+,gpS~r1"+runtime.printCgoTraceback ,-c"arg"Ycallersruntime.printOneCgoTraceback-/cP"pcmax"arg"J~r3"runtime.callCgoSymbolizer/L0callh"argJruntime.cgoContextPCsP0K1callH"argP"2ctxtbuf"5runtime.(*_type).stringP11tٹ~r0"Jruntime.(*_type).uncommon22tٹ~r0"2rruntime.reflectOffsLock22runtime.reflectOffsUnlock2.3runtime.resolveNameOff03N6foundG"+baseH"res`"߶nexth"ptrInModule߶off"M~r2"runtime.(*_type).nameOffP66tٹoff"M~r1"runtime.resolveTypeOff6:base@"resX"߶next`"mdh"ptrInModule߶off"a~r2"ٹruntime.(*_type).typeOff :n:tٹoff"a~r1"ٹruntime.(*_type).textOffp:=baseH"res`"߶nexth"tٹoff"O~r1"߶runtime.(*functype).in=l>tc~r0"{runtime.(*functype).outp>??tc~r0"{runtime.(*functype).dotdotdot@?U?tc~r0"+runtime.name.data`??noff"~r1"@runtime.name.isExported??n~r0"+runtime.name.nameLen?V@n~r0"runtime.name.tagLen`@=An~r0"runtime.name.name@A Bnlh"ns"Jruntime.name.tagBBtlh"ns"Jruntime.name.pkgPathB DnameOffd"Mn~r0"Jruntime.typelinksinitDJtl|"tlist.len|"typehash|"tm|"t|"ٹt}"ٹprev}"md}"candidate}"ٹruntime.typesEqualK?Zkind}"vout.len}"vin.len}"tout.len}"tin.len~"pkgpatht.len~"i~"i~"i~"vout.ptr~"qvname.bytes~"@vm~"rvin.ptr~"quv~"2rut~"2rtout.ptr~"qtname.bytes"@tm"rtityp"ٹtin.ptr"qpkgpatht.ptr"@tٹv"ٹseen">~r3"+runtime.isDirectIface@ZSZtٹ~r1"+runtime.readUnaligned32`ZlZp߶~r1"ʷruntime.readUnaligned64pZ~Zp߶~r1"Kruntime.decoderuneZF\sJk"r"pos "runtime.encoderuneP\]pr"~r2 "runtime.writeErr] ^bruntime.cgocallbackg1.func1^0^gpSruntime.cgoCheckWriteBarrier.func10^^src`"runtime.cgoCheckTypedBlock.func1_V_runtime.cgoCheckTypedBlock.func2`__runtime.cgoCheckBits.func1__runtime.chansend.func1_!`runtime.chanrecv.func10`q`runtime.(*mcache).nextFree.func1``runtime.mallocgc.func1`4a&sh"ftruntime.persistentalloc.func1@aa&ph"?runtime.writebarrierptr_prewrite1.func1absrcX"mp`"dsth"runtime.writebarrierptr.func1bicsrc`"dsth"runtime.writebarrierptr_prewrite.func1pccruntime.typedslicecopy.func1cfn"i@"iH"&typX"q&srcp`"?&dstph"?runtime.freemcache.func1f}gch"'runtime.SetFinalizer.func1ggruntime.SetFinalizer.func2gNhruntime.(*gcControllerState).findRunnableGCWorker.func1Phhptrz~r1"+runtime.gcStart.func1hhruntime.gcMarkDone.func1.1hi_p_runtime.gcMarkDone.func1iNiruntime.gcMarkTermination.func1Piiruntime.gcMarkTermination.func2ij&startTimeh"zruntime.gcBgMarkWorker.func1jkkp`"gSparkp"߶~r2"+runtime.gcBgMarkWorker.func2pklgpX"S_p_`"runtime.gcMarkRootPrepare.func1lmbytes~r1"runtime.markroot.func1mRnselfScanW"+userGX"Sgp`"Sgcwh"I|runtime.gcAssistAlloc.func1`nnruntime.scanstack.func1noframeunused"߶~r2"+runtime.gosweepone.func1oXo&reth"runtime.getempty.func1`oo&sh"ftruntime.freeSomeWbufs.func1oppreemptibleW"+iX"gp`"Sruntime.(*mheap).alloc.func1pq&sh"ftruntime.(*mheap).freeSpan.func1 qNracctT"sX"mp`"hh"sruntime.mProf_Malloc.func1Prrruntime.GoroutineProfile.func1rsgp1S~r1"+runtime.GoroutineProfile.func2 ssruntime.Stack.func1s&uall"+sp@"pcH"gpP"Sg0X"S&nh"2runtime.tracealloc.func10uuruntime.tracefree.func1uuruntime.ReadMemStats.func1u+vruntime.semacreate.func10vzvmph"runtime.semasleep.func1vv&rh""runtime.mach_semrelease.func1vwruntime.newdefer.func1 wysc"ppH"runtime.newdefer.func2y4z&dh"_|runtime.freedefer.func1@zM|sc"ppH"lastP"firstX"d`"runtime.preprintpanics.func1P||runtime.dopanic.func1| }runtime.main.func1}W}runtime.main.func2`}}&needUnlock4runtime.goready.func1}}runtime.casgstatus.func1}~runtime.casgstatus.func2~~runtime.reentersyscall.func1runtime.entersyscallblock.func1\sp3H"sp2P"sp1X"runtime.entersyscallblock.func2`spH"runtime.exitsyscall.func1runtime.exitsyscallfast.func1oldpX"_g_`"S&okh"4runtime.exitsyscallfast_reacquired.func1runtime.malg.func1 xnewgh"Sruntime.newproc.func1runtime.gfget.func1Igph"Sruntime.(*rwmutex).rlock.func1PrwX"dm`"runtime.morestackc.func1 _runtime.callers.func1`&nh"2runtime.init  runtime.skipPleaseUseCallersFrames  runtime.rt0_go -runtime.asminit01runtime.gosave@}runtime.gogoruntime.mcallfruntime.systemstack_switchpqruntime.systemstack,runtime.morestack0čruntime.morestack_noctxtЍ׍reflect.callruntime.reflectcallˏcallRetЏruntime.call32~runtime.call64runtime.call128runtime.call256`runtime.call512`runtime.call1024runtime.call2048pruntime.call4096p6runtime.call8192@runtime.call16384֖runtime.call32768runtime.call65536vruntime.call131072Fruntime.call262144Pruntime.call524288 runtime.call1048576runtime.call2097152runtime.call4194304Vruntime.call8388608`&runtime.call167772160runtime.call33554432Ɵruntime.call67108864Пruntime.call134217728fruntime.call268435456p6runtime.call536870912@runtime.call1073741824֣runtime.procyieldruntime.publicationBarrierruntime.jmpdefergosave Uruntime.asmcgocall`runtime.cgocallback_gofunc !runtime.setg0?setg_gcc@Jruntime.stackcheckPiruntime.getcallerpcpruntime.cputicksruntime.memhash_varlenruntime.aeshash$runtime.aeshashstr0Fruntime.aeshashbodyPruntime.aeshash32Ӭruntime.aeshash64runtime.checkASM =runtime.memequal@druntime.memequal_varlenpruntime.eqstringĭruntime.memeqbodyЭruntime.cmpstring.runtime.cmpbody0istrings.indexShortStrpbytes.indexShortStrruntime.indexShortStrбbytes.IndexByteشstrings.IndexByteruntime.indexbytebodybytes.Equal Istrings.countBytePhruntime.countBytep޷runtime.return0runtime.goexitruntime.prefetcht0 runtime.prefetcht1runtime.prefetcht2 )runtime.prefetchnta09runtime.duffzero@qruntime.duffcopyruntime.memclrNoHeapPointersruntime.memmove[_rt0_amd64_darwin`rmainruntime.exitruntime.exit1runtime.openruntime.closefdruntime.read0runtime.write0Qruntime.raise`eruntime.raiseprocpruntime.setitimerruntime.madviseruntime.nanotime<time.now@+runtime.sigprocmask0Sruntime.sigaction`runtime.sigfwdruntime.sigtrampruntime.mmap*runtime.munmap0Oruntime.sigaltstackPqruntime.usleepruntime.bsdthread_createruntime.bsdthread_start3runtime.bsdthread_register@nruntime.mach_msg_trappruntime.mach_task_selfruntime.mach_reply_portruntime.mach_semaphore_waitruntime.mach_semaphore_timedwaitruntime.mach_semaphore_signalruntime.settls6runtime.sysctl@uruntime.kqueueruntime.keventruntime.closeonexectype..hash.runtime._funcnp]lh"~r2"type..eq.runtime._funcpp]lq"]l~r2"+type..hash.runtime.uncommontype~p2rh"~r2"type..eq.runtime.uncommontypep2rq"2r~r2"+type..hash.runtime.modulehashTph"~r2"type..eq.runtime.modulehash`Bpq"~r2"+type..hash.runtime.bitvectorPph"~r2"type..eq.runtime.bitvectorpq"~r2"+type..hash.runtime.Framepwh"~r2"type..eq.runtime.Framepwq"w~r2"+type..hash.struct { Size uint32; Mallocs uint64; Frees uint64 }nph"~r2"type..eq.struct { Size uint32; Mallocs uint64; Frees uint64 }ppq"~r2"+type..hash.[61]struct { Size uint32; Mallocs uint64; Frees uint64 }ih"ph"~r2"type..eq.[61]struct { Size uint32; Mallocs uint64; Frees uint64 } vpq"~r2"+type..hash.runtime.MemStatsFp,h"~r2"type..eq.runtime.MemStatsP-p,q",~r2"+type..hash.runtime.TypeAssertionError0pih"~r2"type..eq.runtime.TypeAssertionErrorHpiq"i~r2"+type..hash.runtime._panicPph"~r2"type..eq.runtime._panicpq"~r2"+type..hash.runtime._defer>ph"~r2"type..eq.runtime._defer@pq"~r2"+type..hash.runtime.sysmontickjp-h"~r2"type..eq.runtime.sysmontickpp-q"-~r2"+type..hash.runtime.specialp\h"~r2"type..eq.runtime.special xp\q"\~r2"+type..hash.runtime.markBitspiwh"~r2"type..eq.runtime.markBits<piwq"iw~r2"+type..hash.runtime.mcache@p'h"~r2"type..eq.runtime.mcache,p'q"'~r2"+type..hash.runtime.hchan0ph"~r2"type..eq.runtime.hchanApq"~r2"+type..hash.runtime.sudogPph"~r2"type..eq.runtime.sudogapq"~r2"+type..hash.runtime.cpuProfileppih"~r2"type..eq.runtime.cpuProfileopiq"i~r2"+type..hash.runtime.dbgVarpph"~r2"type..eq.runtime.dbgVarpq"~r2"+runtime.(*errorString).Error.thisG~r0"Jtype..hash.runtime.finblockp h"~r2"type..eq.runtime.finblock!p q" ~r2"+type..hash.runtime.forcegcstate0pbh"~r2"type..eq.runtime.forcegcstatepbq"b~r2"+type..hash.runtime.functypeIpch"~r2"type..eq.runtime.functypePpcq"c~r2"+type..hash.runtime.gcControllerStatepzh"~r2"type..eq.runtime.gcControllerStateWpzq"z~r2"+type..hash.runtime.gcSweepBuf`pmh"~r2"type..eq.runtime.gcSweepBufpmq"m~r2"+type..hash.runtime.gcTrigger yp~h"~r2"type..eq.runtime.gcTriggerp~q"~~r2"+type..hash.runtime.heapBits9ph"~r2"type..eq.runtime.heapBits@ipq"~r2"+type..hash.runtime.hiterpp4ph"~r2"type..eq.runtime.hiter|p4pq"4p~r2"+type..hash.runtime.treapNodeph"~r2"type..eq.runtime.treapNode8pq"~r2"+type..hash.runtime.mcentral@p_xh"~r2"type..eq.runtime.mcentral?p_xq"_x~r2"+type..hash.[2]runtime.gcSweepBuf@ih"ph"~r2"type..eq.[2]runtime.gcSweepBuf:ih"pq"~r2"+type..hash.struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }@p̪h"~r2"type..eq.struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }/p̪q"̪~r2"+type..hash.[134]struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }0ih"ph"~r2"type..eq.[134]struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }Ui`"pq"~r2"+type..hash.struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }`peh"~r2"type..eq.struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }peq"e~r2"+type..hash.[67]struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 } ih"ph"~r2"type..eq.[67]struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }pq"~r2"+type..hash.runtime.mstats%ph"~r2"type..eq.runtime.mstats0pq"~r2"+runtime.(*plainError).Error@.this'~r0"Jtype..hash.runtime.rwmutex@pdh"~r2"type..eq.runtime.rwmutexQpdq"d~r2"+type..hash.runtime.semaRoot`ph"~r2"type..eq.runtime.semaRootpq"~r2"+type..hash.runtime.sigTabT pAh"~r2"type..eq.runtime.sigTabTpAq"A~r2"+type..hash.runtime.stackmap yp h"~r2"type..eq.runtime.stackmapp q" ~r2"+type..hash.runtime.sweepdata^pXh"~r2"type..eq.runtime.sweepdata`pXq"X~r2"+type..hash.runtime.traceStacknph"~r2"type..eq.runtime.traceStackppq"~r2"+type..hash.runtime.traceStackTablenpOh"~r2"type..eq.runtime.traceStackTableppOq"O~r2"+type..hash.[14]runtime.dbgVar ih"pqh"~r2"type..eq.[14]runtime.dbgVarZi`"pqq"q~r2"+type..hash.struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }`ph"~r2"type..eq.struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }qpq"~r2"+type..hash.[251]struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }ih"pҬh"~r2"type..eq.[251]struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }pҬq"Ҭ~r2"+type..hash.[2]string.ih"ph"~r2"type..eq.[2]string0pq"~r2"+type..hash.[32]runtime.sigTabTOih"p/h"~r2"type..eq.[32]runtime.sigTabTP ih"p/q"/~r2"+type..hash.[33]float64{ih"pJh"~r2"type..eq.[33]float64pJq"J~r2"+type..hash.[3]string.ih"p]h"~r2"type..eq.[3]string0p]q"]~r2"+type..hash.[4]stringNih"pnh"~r2"type..eq.[4]stringPpnq"n~r2"+type..hash.[5]stringnih"ph"~r2"type..eq.[5]stringppq"~r2"+type..hash.[6]string ih"ph"~r2"type..eq.[6]string:pq"~r2"+type..hash.[9]string@ih"ph"~r2"type..eq.[9]stringZpq"~r2"+type..hash.struct { runtime.cycle uint32; runtime.flushed bool }`ph"~r2"type..eq.struct { runtime.cycle uint32; runtime.flushed bool }pq"~r2"+type..hash.struct { runtime.enabled bool; runtime.pad [3]uint8; runtime.needed bool; runtime.cgo bool; runtime.alignme uint64 }nph"~r2"type..eq.struct { runtime.enabled bool; runtime.pad [3]uint8; runtime.needed bool; runtime.cgo bool; runtime.alignme uint64 }ppq"~r2"+type..hash.struct { runtime.full runtime.lfstack; runtime.empty runtime.lfstack; runtime.pad0 [64]uint8; runtime.wbufSpans struct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }; _ uint32; runtime.bytesMarked uint64; runtime.markrootNext uint32; runtime.markrootJobs uint32; runtime.nproc uint32; runtime.tstart int64; runtime.nwait uint32; runtime.ndone uint32; runtime.alldone runtime.note; runtime.helperDrainBlock bool; runtime.nFlushCacheRoots int; runtime.nDataRoots int; runtime.nBSSRoots int; runtime.nSpanRoots int; runtime.nStackRoots int; runtime.markrootDone bool; runtime.startSema uint32; runtime.markDoneSema uint32; runtime.bgMarkReady runtime.note; runtime.bgMarkDone uint32; runtime.mode runtime.gcMode; runtime.userForced bool; runtime.totaltime int64; runtime.initialHeapLive uint64; runtime.assistQueue struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }; runtime.sweepWaiters struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }; runtime.cycles uint32; runtime.stwprocs int32; runtime.maxprocs int32; runtime.tSweepTerm int64; runtime.tMark int64; runtime.tMarkTerm int64; runtime.tEnd int64; runtime.pauseNS int64; runtime.pauseStart int64; runtime.heap0 uint64; runtime.heap1 uint64; runtime.heap2 uint64; runtime.heapGoal uint64 } pkh"~r2"type..eq.struct { runtime.full runtime.lfstack; runtime.empty runtime.lfstack; runtime.pad0 [64]uint8; runtime.wbufSpans struct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }; _ uint32; runtime.bytesMarked uint64; runtime.markrootNext uint32; runtime.markrootJobs uint32; runtime.nproc uint32; runtime.tstart int64; runtime.nwait uint32; runtime.ndone uint32; runtime.alldone runtime.note; runtime.helperDrainBlock bool; runtime.nFlushCacheRoots int; runtime.nDataRoots int; runtime.nBSSRoots int; runtime.nSpanRoots int; runtime.nStackRoots int; runtime.markrootDone bool; runtime.startSema uint32; runtime.markDoneSema uint32; runtime.bgMarkReady runtime.note; runtime.bgMarkDone uint32; runtime.mode runtime.gcMode; runtime.userForced bool; runtime.totaltime int64; runtime.initialHeapLive uint64; runtime.assistQueue struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }; runtime.sweepWaiters struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }; runtime.cycles uint32; runtime.stwprocs int32; runtime.maxprocs int32; runtime.tSweepTerm int64; runtime.tMark int64; runtime.tMarkTerm int64; runtime.tEnd int64; runtime.pauseNS int64; runtime.pauseStart int64; runtime.heap0 uint64; runtime.heap1 uint64; runtime.heap2 uint64; runtime.heapGoal uint64 }  pkq"k~r2"+type..hash.struct { runtime.lock runtime.mutex; runtime.pad uint32; runtime.val uint64 } ^ ph"~r2"type..eq.struct { runtime.lock runtime.mutex; runtime.pad uint32; runtime.val uint64 }`  pq"~r2"+type..hash.struct { runtime.note runtime.note; runtime.mask [1]uint32; runtime.wanted [1]uint32; runtime.ignored [1]uint32; runtime.recv [1]uint32; runtime.state uint32; runtime.inuse bool }  ph"~r2"type..eq.struct { runtime.note runtime.note; runtime.mask [1]uint32; runtime.wanted [1]uint32; runtime.ignored [1]uint32; runtime.recv [1]uint32; runtime.state uint32; runtime.inuse bool }Xpq"~r2"+type..hash.struct { F uintptr; runtime.buf *[]uint8; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr; runtime.all bool; runtime.n *int }`pδh"~r2"type..eq.struct { F uintptr; runtime.buf *[]uint8; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr; runtime.all bool; runtime.n *int }Xpδq"δ~r2"+type..hash.struct { F uintptr; runtime.c *runtime.mcache; runtime.spc runtime.spanClass }`pah"~r2"type..eq.struct { F uintptr; runtime.c *runtime.mcache; runtime.spc runtime.spanClass }paq"a~r2"+type..hash.struct { F uintptr; runtime.h *runtime.mheap; runtime.s *runtime.mspan; runtime.acct int32 } yph"~r2"type..eq.struct { F uintptr; runtime.h *runtime.mheap; runtime.s *runtime.mspan; runtime.acct int32 }pq"~r2"+type..hash.struct { F uintptr; runtime.newg *runtime.g; runtime.stacksize int32 }9ph"~r2"type..eq.struct { F uintptr; runtime.newg *runtime.g; runtime.stacksize int32 }@pq"~r2"+type..hash.struct { F uintptr; runtime.preemptible bool }pih"~r2"type..eq.struct { F uintptr; runtime.preemptible bool }+piq"i~r2"+type..hash.struct { F uintptr; runtime.r int32 }0ph"~r2"type..eq.struct { F uintptr; runtime.r int32 }pq"~r2"+type..hash.struct { F uintptr; runtime.s **runtime.mspan; runtime.h *runtime.mheap; runtime.npage uintptr; runtime.spanclass runtime.spanClass; runtime.large bool }p̶h"~r2"type..eq.struct { F uintptr; runtime.s **runtime.mspan; runtime.h *runtime.mheap; runtime.npage uintptr; runtime.spanclass runtime.spanClass; runtime.large bool } xp̶q"̶~r2"+type..hash.struct { F uintptr; runtime.s **runtime.mspan; runtime.size *uintptr; runtime.needzero bool; runtime.noscan bool }pmh"~r2"type..eq.struct { F uintptr; runtime.s **runtime.mspan; runtime.size *uintptr; runtime.needzero bool; runtime.noscan bool }8pmq"m~r2"+type..hash.struct { F uintptr; runtime.siz int32; runtime.d **runtime._defer }@ph"~r2"type..eq.struct { F uintptr; runtime.siz int32; runtime.d **runtime._defer }pq"~r2"+errors.NewtextJ~r1" errors.(*errorString).Errore2~r0"Jinternal/race.Enableinternal/race.Errors~r0sync.newEntry&ih"?iu~r1"Jsync.(*Map).Loade~"Jread~"ĸmkey"uvalue"uok("+sync.(*entry).loadp`"߶eJvalue"uok"+sync.(*Map).Store j"&value~"?read~"ĸmkey"uvalue"u@ok}"+e}"Jok}"+e}"Jok}"+e}"Jsync.(*entry).tryStorep"D#ph"߶eJi"?~r1"+sync.(*entry).unexpungeLockedP##eJwasExpunged"+sync.(*entry).storeLocked#$eJi"?sync.(*Map).LoadOrStore$,read~"ĸmkey"uvalue"uactual("uloaded8"+ok}"+e}"J%w&ok}"+loaded}"+actual~"u@ok}"+e}"Jok}"+e}"Jsync.(*entry).tryLoadOrStore,>.pH"߶&ich"?eJi"uactual"uloaded("+ok)"+sync.(*Map).missLocked@./msync.(*Map).dirtyLocked/t2read~"ĸm072e~"Jk~"usync.(*entry).tryExpungeLocked2E3ph"߶eJisExpunged"+sync.(*Mutex).LockP36starving"+awoke"+old"waitStartTimeP"iterX"m^new" queueLifo"+delta"sync.(*Mutex).Unlock788newl"m^W77oldh"sync.(*Once).Do@8P9opf"ssync.(*Pool).PutP9o;lP"p>x"usync.(*Pool).Getp;=lX"x`"up>~r0"ulastH"sync.(*Pool).getSlow=Z?size"pid"local`"߶p>x"uiH"Plast@"lh"sync.(*Pool).pin`?%@sH"pidP"lX"߶p>~r0"sync.(*Pool).pinSlow0@LCsize"s"pid"l"߶localX"p>~r0"sync.poolCleanupPCFi~"p">i~" l"pj~"sync.init.0F.Gsync.indexLocal0GhGlph"߶l߶i"~r2"sync.init.1pGGnP"sync.(*RWMutex).RLockG:Hrwsync.(*RWMutex).RUnlock@HIrwrh"sync.(*RWMutex).Lock IIrd"rwsync.(*RWMutex).UnlockIJr\"rwLJJi`"sync.initJKio.WriteStringKzNws"Jn "err(" K>Mok~"+sw~"ݾio.CopyNOdstsrc"written "err(" io.copyBufferOIVdstsrc"buf "written8"err" PQok}"+wt~"%QSok}"+rt~"Knr}"er~" Pnw}"ew~" io.initPVYsyscall.readIntYZboff"size "u("Kok0"+syscall.readIntLEZ]bsize"~r2 "Ksyscall.ParseDirent]doriglen}"bufmax"names "aconsumed8"count"newnames"aok}"+reclen}"Knamlen}"Kino}"Krec"name@" c}"i~"syscall.copyenvdhpi~"s"Jj~"key"JPok~"+syscall.Getenvh*kok"+i"sP"JkeyJvalue"Jfound "+i"syscall.CloseOnExec0k~kfdsyscall.SetNonblockklflag"fdnonblocking"+err" syscall.rsaAlignOflVmsalignh"salen~r1"syscall.itoa`mXnval~r1"Jsyscall.uitoa`n3pi"buf"jval~r1"Jsyscall.ByteSliceFromString@pra@"sJ~r1"~r2(" i~"syscall.BytePtrFromStringroterr" a@"sJ~r1"@~r2" syscall.ReadDirentptubase@"fdbuf"n "err(" syscall.Getwduyerr~" buf"attrs@"^~r0J~r1"  wd~"Jsyscall.direntInoyVzbuf~r1"K~r2 "+syscall.direntReclen`z{buf~r1"K~r2 "+syscall.direntNamlen {{buf~r1"K~r2 "+syscall.getAttrList{size}"ʷe1}"T*_p0~"@dat@"pathJattrList" =attrBuf("options"attrs"^err" pi}"ʷend}"ʷdatOff}"attrLen}"ʷheader" r}"ʷsyscall.Pipep1err" syscall.Errno.ErrorDžeT*~r0"J@ sP"Jsyscall.errnoErrЅeT*~r1" syscall.Read fdp"n "err(" syscall.Writefdp"n "err(" syscall.fcntlr0P"e1X"T*fdcmd"arg"val"err " syscall.piper1@"r0H"e1P"T*rw"err" syscall.Chmodwe1"T*_p0H"@pathJmode"ʷerr" syscall.Close1e1`"T*fderr" syscall.Exit@codesyscall.Fstat\e1X"T*fdstat"err" syscall.Getdirentries` r0"e1"T*_p0`"߶fdbuf"basep "n("err0" syscall.Lstate1"T*_p0@"@pathJstat"err" syscall.OpenGr0"e1"T*_p0H"@pathJmode"perm"ʷfd "err(" syscall.PreadPr0"e1@"T*_p0h"߶fdp"offset "n("err0" syscall.readJr0"e1@"T*_p0h"߶fdp"n "err(" syscall.SeekPAr0P"e1X"T*fdoffset"whence"newoffset"err " syscall.StatP˘e1"T*_p0@"@pathJstat"err" syscall.writeИ*r0"e1@"T*_p0h"߶fdp"n "err(" syscall.mmap0Qr0P"e1X"T*addrlength"prot"flag"fd "pos("ret0"err8" syscall.munmap`e1`"T*addrlength"err" syscall.init asyscall.Syscallpҝsyscall.Syscall6Hsyscall.RawSyscallPsyscall.(*Errno).ErrorO.thisc~r0"Jtype..hash.syscall.attrListPph"~r2"type..eq.syscall.attrListpq"~r2"+type..hash.[106]string>iX"pxh"~r2"type..eq.[106]string@]i"pxq"x~r2"+time.startsWithLowerCase`ʢcg"strJ~r1"+time.nextStdChunkТlayoutJprefix"Jstd "suffix("J iq" cq" chq"jq"` stdq"time.appendIntu~"i~"buf"bx"width "~r3(" q~"#w~"time.formatNano ^u~"buf"bnanosec"n "trim("+~r40" start~"time.Time.String`s"Jt~r0"J sign~"wid~"m2~"Km1~"Km0~"Kbuf@"time.Time.Formatmax"bX"tlayout"J~r1("J1wbuf"time.Time.AppendFormat6yeary"secz"offsetz"monthz"minz"hourz"dayz"absz"Kname|"Jtb"layout0"J~r2"p stdz"suffix|"Jprefix|"J yy" m}"J` s|"J hrz" hrz"0 zoney"absoffsetz"p zoney"time.isDigit@cg"sJi"~r2"+time.leadingInti"sJx"rem"Jerr("  c"time.leadingFractionNoverflow"+i@"sJx"scale"rem "J c"y"time.ParseDurationP!neg|"+d}"orig~"JsJ~r1"~r2" c|"pre|"+post|"+ok|"+v|"unit|"scale|"pl}"i}"f}"u~"Jerr~"  pl|"`c|"time.when!["tX"d~r1"time.(*Timer).Stop`""t2~r0"+time.AfterFunc"a$tX"2df"s~r2"2time.goFuncp$$arguseq"time.readFile$*n^"f^"buf^" err~" ret"nameJ~r1"~r2(" time.open*+fd@"errP" nameJ~r1"~r2" time.closefd+,,fdtime.preadn0,/whence"fdbuf"off "~r3(" ,1-err" m"err" time.isNotExist /p/err ~r1"+time.(*Time).nsecp//t'~r0"time.(*Time).sec//t'~r0"time.(*Time).unixSec/Q0t'~r0"time.(*Time).addSec`0S1t'd"01secX"dsec`"time.(*Time).stripMono`11t'time.Time.After23us`"tsh"tu"~r10"+time.Time.Before3I4tu"~r10"+time.Time.EqualP4C5tu"~r10"+time.Month.StringP5=7n"buf@"m~r0"Jtime.Weekday.String@77d~r0"Jtime.Time.locabs79sec@"lX"tname"Joffset("abs0"Ktime.absWeekday9F:sech"KabsK~r1"time.absClockP:";absKhour"min"sec"time.Time.Nanosecond0;;t~r0"time.Duration.String;Cneg|"+w|"u|"Kbuf}"jd~r0"Jprec|"time.fmtFracC9Eprint"+w"bufv"Kprec "nw("nv0"K@i@"digitH"Ktime.fmtInt@E=FwP"bufv"K~r2 "time.Duration.Nanoseconds@FTFd~r0"time.Duration.Seconds`FFsec`"nsech"d~r0"time.Time.AddGHnsec@"dsecX"td"~r1 "teP"time.Time.SubI,Ld"tu"~r10"cI)Jue"te"d@"time.Since0LLt~r1"time.absDateLPy~"Kn~"Kend~"d"Kbegin"absKfull"+year"month"day "yday("time.NowPRnsec"sec"mono"~r0time.unixTimeRSsecnsec"~r2"time.Time.UnixSdSt~r0"time.Time.UnixNanopSSt~r0"time.UnixS`Usecnsec"~r2"n"time.isLeap`UVyear~r1"+time.(*Location).getVVl~r0"time.(*Location).StringVWl~r0"Jtime.(*Location).lookup W+\lo"hi"zone@"txX"lsec"name"Joffset "isDST("+start0"end8"PzoneH"zoneP"m"lim"time.(*Location).lookupFirstZone0\A^l~r0" zi@"`ziH"time.(*Location).firstZoneUsedP^H_l~r0"+c^9_tx"time.fileSizeError.ErrorP__f~r0"Jtime.(*data).read`apX"dNn"~r1"time.(*data).big4abpX"dNn"ʷok "+time.(*data).bytebcpX"dNn"ok "+time.byteStringcep~r1"Ji@"time.loadZoneData exsecy"n{"?zone}"txzones}"tx}"p}"isutc~"isstd~"abbrev~"zonedata"txtimes"dP"bytesl"err " magic}"0iy"poky"+nny"ʷiy"oky"+by"ny"ʷPiy"oky"+ny"ʷiy"time.loadZoneFiley}buf@"dirJname"Jl "err(" time.get4}V~b~r1"time.get2`~~b~r1"time.loadZoneZip~sizey"offy"ny"fdy"buf}"zipfileJname"Jl "err(" wׂerr{" ~err{"  iy"pxleny"sizey"offy"nameleny"methy"fcleny"zname}"err{" Jqerrz" time.initLocalok~"+tz"J z~"err" pz~"err" time.loadLocation firstErr" nameJ~r1"~r2" zoneDir~"Jz~"err" time.inittime.(*Duration).String_.thisU1~r0"Jtype..hash.time.zone`ph"~r2"type..eq.time.zonepq"~r2"+type..hash.time.zoneTransWp8h"~r2"type..eq.time.zoneTrans`ˤp8q"8~r2"+time.(*Month).StringФo.this~r0"Jtime.(*Time).Stringp,.this'~r0"Jtime.(*Weekday).String0Ϧ.this~r0"Jtime.(*fileSizeError).ErrorЦ.this~r0"Jtype..hash.[12]string.iX"ph"~r2"type..eq.[12]string0Mi"pq"~r2"+type..hash.[7]stringPiX"ph"~r2"type..eq.[7]stringi"pq"~r2"+internal/poll.errClosing oisFile+~r1" internal/poll.(*TimeoutError).Errorpe~r0"Jinternal/poll.(*fdMutex).incref_mu3~r0"+old`"Knewh"Kinternal/poll.(*fdMutex).increfAndClose`ڭmu3~r0"+0oldH"KnewP"Kinternal/poll.(*fdMutex).decrefmu3~r0"+pold`"Knewh"Kinternal/poll.(*fdMutex).rwlockmutexWaitP"KmutexMaskX"KmutexBit`"KmutexSemah"mu3read"+~r1"+old@"KnewH"Kinternal/poll.(*fdMutex).rwunlockpmutexWaitH"KmutexMaskP"KmutexBitX"KmutexSemah"mu3read"+~r1"+old"Knew@"Kinternal/poll.(*FD).increfp%fdP~r0" internal/poll.(*FD).decref0fdP~r0" internal/poll.(*FD).readLockfdP~r0" internal/poll.(*FD).readUnlockfdPinternal/poll.(*FD).writeLockʵfdP~r0" internal/poll.(*FD).writeUnlockе4fdPinternal/poll.(*pollDesc).init@zerrnoH"ctxP"pdhfd"P~r1" internal/poll.(*pollDesc).closepdhinternal/poll.(*pollDesc).evictLpdhinternal/poll.(*pollDesc).preparePresX"pdhmode"isFile"+~r2" internal/poll.(*pollDesc).prepareRead pdhisFile"+~r1" internal/poll.(*pollDesc).prepareWritepdhisFile"+~r1" internal/poll.(*pollDesc).wait resH"pdhmode"isFile"+~r2" internal/poll.(*pollDesc).waitReadpdhisFile"+~r1" internal/poll.(*pollDesc).waitWritepdhisFile"+~r1" internal/poll.(*pollDesc).pollable*pdh~r0"+internal/poll.convertErr0bresisFile"+~r2" internal/poll.(*FD).eofErrorp߽fdPn"err" ~r2 " internal/poll.(*FD).Init7fdPnet"Jpollable"+~r2 " internal/poll.(*FD).destroy@err`" fdP~r0" internal/poll.(*FD).ClosefdP~r0" internal/poll.(*FD).ReadqfdPp"~r1 "~r2(" 3errP" &err@" Pn"err" internal/poll.(*FD).Preadn"err@" fdPp"off "~r2("~r30" 5errP" internal/poll.(*FD).WriteAnn~"fdPp"~r1 "~r2(" Serr" err" n~"max~"err" internal/poll.(*FD).ReadDirentP4fdPbuf"~r1 "~r2("  errP" n"err@" internal/poll.(*FD).Fstat@DfdPs"~r1" serrP" internal/poll.initP~type..hash.internal/poll.FDpPh"~r2"type..eq.internal/poll.FD[pPq"P~r2"+os.(*File).Readdirnames`_f*n"names"aerr(" os.(*File).readdirnames`size~"d~"]-f*n"names"aerr("  nc~"nb~"Kerrno~" os.GetenvvP"JkeyJ~r1"Jos.(*PathError).Errore~r0"Jos.(*SyscallError).Errore~r0"Jos.NewSyscallErrorsyscallJerr" ~r2 " os.IsNotExist8err ~r1"+os.underlyingError@err ~r1" errX">cerrP"BerrH"os.wrapSyscallError nameJerr" ~r2 " okn"+os.isNotExisterr ~r1"+os.(*File).Namef*~r0"Jos.(*LinkError).Error ReB~r0"Jos.(*File).Read`+e@" f*b"n "err(" *err" os.(*File).ReadAt0vf*b"off "n("err0" err" m~"e" os.(*File).WriteeP" f*b"n "err(" <err@" os.(*File).WriteString?f*s"Jn"err " os.Open@CnameJ~r1"*~r2" os.CreatePSnameJ~r1"*~r2" os.(*File).wrapErr`f*op"Jerr" ~r2(" os.ChmodnameJmode"~r2" os.syscallModeio"ʷos.chmodnameJmode"~r2"  eP" os.(*File).checkValid f*op"J~r1" os.fixLongPath7pathJ~r1"Jos.NewFile@fdname"J~r2"*os.newFileCfdi"f"*fdname"Jpollable"+~r3 "*err`" PerrP" os.epipecheckPfile*e" os.OpenFile%chmod"+r"nameJflag"perm"~r3 "*~r4(" err" e@" os.(*File).Close0f*~r0" os.(*file).close=errP" file+~r0" e`" os.(*File).read@0f*b"n "err(" os.(*File).pread00f*b"off "n("err0" os.(*File).write0 f*b"n "err(" os.Getwd root{" dot|" dirJerr" Perr|" d|" : s{"Je|" err{" d|" parent{"Jfd{"*pd{" err|" `err|" names"aname{"Jd|" os.init.0os.useSyscallwdDarwinPerr ~r1"+os.IsPathSeparatorPdc~r1"+os.basenamepi@"nameJ~r1"Jos.Pipe1p"e" r*w"*err" os.init.1@os.Exitcodeos.fillFileStatFromSys fs1name"Jos.timespecToTimetsM~r1"os.(*File).Statr"&fsX"1err`" f*~r0" ~r1" os.Stat"%&fsX"1err`" nameJ~r1" ~r2 " os.Lstat%'&fsX"1err`" nameJ~r1" ~r2 " os.FileMode.String'+w~"buf"jm~r0"J c~"i~"`c~"i~"os.FileMode.IsDir++m~r0"+os.FileMode.Perm++m~r0"os.(*fileStat).Name++fs1~r0"Jos.(*fileStat).IsDir,^,fs1~r0"+os.SameFile`,-ok2K"+ok1L"+fs2P"1fs1X"1fi1 fi2" ~r2 "+os.(*fileStat).Size--fs1~r0"os.(*fileStat).Mode--fs1~r0"os.(*fileStat).ModTime-.fs1~r0"os.(*fileStat).Sys.Z.fs1~r0"uos.sameFile`..fs11fs2"1~r2"+os.glob..func1..~r1"+os.init.h3type..hash.os.filep3*4p+h"~r2"type..eq.os.file04d5p+q"+~r2"+os.(*FileMode).Stringp5 6.this~r0"Jos.(*FileMode).IsDir66.this~r0"+type..hash.os.LinkError6g7pBh"~r2"type..eq.os.LinkErrorp79pBq"B~r2"+type..hash.os.PathError::ph"~r2"type..eq.os.PathError:<pq"~r2"+type..hash.os.SyscallError<7=ph"~r2"type..eq.os.SyscallError@=m>pq"~r2"+type..hash.os.fileStatp>3?p1h"~r2"type..eq.os.fileStat@?@p1q"1~r2"+type..hash.struct { sync.Mutex; os.dir string }AAph"~r2"type..eq.struct { sync.Mutex; os.dir string }ABpq"~r2"+internal/cpu.init.0BEosSupportsAVX"+maxIdH"ʷedx1L"ʷecx1P"ʷebx7T"ʷeaxX"ʷinternal/cpu.isSetEFbitposvalue"ʷ~r2"+internal/cpu.init FFinternal/cpu.cpuidFFinternal/cpu.xgetbvFFtype..hash.internal/cpu.x86F+Gph"~r2"type..eq.internal/cpu.x860GGpq"~r2"+math.AbsGHx~r1"math.InfHHv`"Ksign~r1"math.NaNH I~r0math.Float32bitsI(IfD~r1"ʷmath.Float32frombits0IMIbʷ~r1"Dmath.Float64bitsPIkIf~r1"Kmath.Float64frombitspIIbK~r1"math.initIJmath.ExpJKunicode/utf8.DecodeRuneK}NxL"szM"p0N"b3O"b2P"b1Q"acceptR";Pnh"pr"size "maskT"unicode/utf8.DecodeRuneInStringNmQxL"szM"s3N"s2O"s1P"s0Q"acceptR";Pnh"sJr"size" maskT"unicode/utf8.DecodeLastRunepQSstart"lim"end"pr"size "unicode/utf8.DecodeLastRuneInStringTjVstart"lim"end@"sJr"size"unicode/utf8.RuneLenpVWr~r1"unicode/utf8.EncodeRune WYpr"~r2 "7WYil"ʷunicode/utf8.RuneCountY\np"n"p~r1"`i@"x"c"accept";Psize"c"Pc"c"unicode/utf8.RuneCountInString \f^ns"sJn"i@"0 x"c"accept";Psize" c" c"0!c"unicode/utf8.RuneStartp^^b~r1"+unicode/utf8.ValidRune^^r~r1"+strconv.ParseBool^mfstrJ~r1"+~r2" strconv.FormatBoolpffb+~r1"Jstrconv.equalIgnoreCasefgs1Js2"J~r2 "+!iH"!c2D"c1E"strconv.specialgQksJf"ok"+strconv.(*decimal).set`krsawdot~"+sawdigits~"+i~"bps"Jok"+"esign~"e~"strconv.readFloatsysawdot~"+sawdigits~"+ndMant~"nd~"i~"dp~"sJmantissa"Kexp"neg "+trunc!"+ok""+`"c~""esign~"e~"strconv.(*decimal).floatBitsy mant"Kexp"bits"Kdpflt"b"Koverflow"+#n~"P#n~">~~n"strconv.atof64exactDmantissaKexp"neg"+f"ok "+strconv.atof32exactPmantissaKexp"neg"+f"Dok"+strconv.atof32ovfx"+bx"Kdy"sJf"Derr" քpokx"+valx"#truncx"+okx"+negx"+mantissax"Kexpx"#ext@"(Wokx"+fx"DV~okx"+~ovfx"+bx"Kstrconv.atof64uovfx"+bx"Kdy"sJf"err" Vokx"+valx" $truncx"+okx"+negx"+mantissax"Kexpx"`$ext@"(Ɏ\okx"+fx"̋okx"+ovfx"+bx"Kstrconv.ParseFloatFsJbitSize"~r2"~r3 " f"Derr" strconv.(*NumError).ErrorPie~r0"Jstrconv.syntaxErrorpfnJstr"J~r2 "strconv.rangeErrorfnJstr"J~r2 "strconv.ParseUintn~"KmaxVal~"Ki~"cutoff"KerrP" sJbase"bitSize"~r3 "K~r4(" $v~"d~"n1~"Kstrconv.ParseIntneg~"+un~"Kn~"cutoff~"Ks0"JsJbase"bitSize"i "err(" strconv.Atoi_i64"errP" sJ~r1"~r2" $ok"+nerr@"strconv.(*decimal).String`wz"nz"buf|"ap~r0"Jstrconv.digitZero dst~r1"0%iP"strconv.trimnapstrconv.(*decimal).Assignp-n"bufX"{apv"Kp%v1"Kstrconv.rightShift0w~"r~"n"mask"apk"%c"&dig"c"@&dig"strconv.prefixIsLessThanbs"J~r2("+&iP"strconv.leftShift w~"r~"n"delta"apk"&rem~"quo~" 'rem~"quo~"strconv.(*decimal).Shiftapk"strconv.shouldRoundUpapnd"~r2"+strconv.(*decimal).Roundapnd"strconv.(*decimal).RoundDownVapnd"strconv.(*decimal).RoundUp`apnd"p'iX"'cV"strconv.(*decimal).RoundedIntegerpn@"KiH"ap~r0"Kstrconv.(*extFloat).floatBitspmant"Kexp"f(flt"bits"Koverflow"+7n"strconv.(*extFloat).AssignComputeBoundsexpBiasedH"f(mant"Kexp"neg"+flt "lower("7Eupper"7Estrconv.(*extFloat).Normalizemant~"Kexp"f(shift"strconv.(*extFloat).MultiplyHrem"Kglo"Kghi"Kflo"Kfhi"Kcross2"Kcross1"Kf(g"7Estrconv.(*extFloat).AssignDecimalPshift"mant_extra"Ki"halfway"Kextrabits"errors"denormalExp"adjExp"f(mantissa"Kexp10"neg"+trunc"+flt "ok("+strconv.(*extFloat).frexp105i@"approxExp10P"f(exp10"index"'expH"strconv.frexp10Many@QiX"a(b"(c"(exp10"strconv.(*extFloat).FixedDecimal`ok}"+rest}"ʷinteger}"ʷε}"Kshift~"pow10~"Kpos~"needed~"nd~"integerDigits~"fraction~"Kexp10~"bufP"jf(d"@n"~r2"+@(pow~"Ki~"(v}"ʷ(v1}"ʷ)i~"@)digit~"K)i~"strconv.adjustLastDigitFixedqd@num"Kden"Kshift"ε "K~r5("+)i"strconv.(*extFloat).ShortestDecimalinteger}"ʷtargetDiff}"Kshift}"multiplier~"KintegerDigits~"fraction~"Kexp10~"digit~"allowance~"Kf(d"@lower"(upper"(~r3 "+*nd~"n~"bufX"{P*v}"K*v1}"K*i~"+pow}"Ki~"P+i~"+digit}"ʷpow}"KcurrentDiff~"Kstrconv.adjustLastDigitd@currentDiff"KtargetDiff"KmaxDiff"KulpDecimal "KulpBinary("K~r60"+strconv.FormatFloatHffmt"prec"bitSize"~r4 "Jstrconv.AppendFloatP<dstf"fmt "prec("bitSize0"~r58"strconv.genericFtoa@shortest{"+ok{"+neg{"+mant{"Kexp{"bits{"Kflt}"digs@"dstval"fmt "prec("bitSize0"~r58"+s}"J,upper{"7Elower|"7Ebuf}"jf}"(P,digits{"f|"7Ebuf|"{strconv.bigFtoa* shortestx"+d~"pdigs@"dstprec"fmt "neg!"+mant("Kexp0"flt8"~r7"strconv.formatDigits0  dstshortest"+neg"+digs "prec"fmt"~r6",exp~"eprec~"strconv.roundShortest L inclusiver"+minexpr"mantlor"Kexplor"upper`"plowerh"pdpmant"Kexp"flt",ir"-ur"okupr"+okdownr"+mr"lr"strconv.fmtEP  ch"exp"dstneg"+d "prec"fmt"~r5"`-m"i"strconv.fmtF  dstneg"+d "prec"~r4"-m".i"@.ch".j"strconv.fmtB  dstneg"+mant "Kexp("flt0"~r58"strconv.min  ab"~r2"strconv.max  ab"~r2"strconv.FormatUint O" s@"JiKbase"~r2"Jstrconv.FormatIntP" # s@"Jibase"~r2"Jstrconv.Itoa# U$ i~r1"Jstrconv.small`$ % offH"i~r1"Jstrconv.formatBits % - i}"a~"dstu"Kbase "neg("+append_)"+d0"s"J.us}"is}"0/is}"/s}"/m}"b}"K 0b}"Kp0q}"Kstrconv.quoteWith- / sJquote"ASCIIonly"+graphicOnly"+~r4"Jstrconv.quoteRuneWith / 0 rquote"ASCIIonly"+graphicOnly"+~r4"Jstrconv.appendQuotedWith0 A6 bufs"Jquote("ASCIIonly)"+graphicOnly*"+~r50"0width"1r"strconv.appendQuotedRuneWithP6 *8 bufr"quote"ASCIIonly"+graphicOnly"+~r5 "strconv.appendEscapedRune08 ?O runeTmp|"ibufr"quote"ASCIIonly"+graphicOnly"+~r5 "`1n|"C D s|"E F s|"strconv.Quote@O O sJ~r1"Jstrconv.AppendQuoteO P dsts"J~r2("strconv.QuoteToASCIIP 5Q sJ~r1"Jstrconv.AppendQuoteToASCII@Q R dsts"J~r2("strconv.QuoteRune R R r~r1"Jstrconv.AppendQuoteRuneR eS dstr"~r2 "strconv.AppendQuoteRuneToASCIIpS 5T dstr"~r2 "strconv.CanBackquote@T U sJ~r1"+1rP"widX"strconv.bsearch16U iV jP"iX"aEx"~r2 "2h`"strconv.bsearch32pV &W jP"iX"ax"ʷ~r2 "P2h`"strconv.IsPrint0W  ] rr}"ʷj}"i~"isPrint~"isNotPrint~"Er~r1"+2rr}"j}"i~"isPrint~"EisNotPrint~"Estrconv.isInGraphicList] ] rr^"i`"r~r1"+strconv.init^ _ type..hash.strconv.NumError _ _ ph"~r2"type..eq.strconv.NumError_ a pq"~r2"+type..hash.strconv.decimala 7b pph"~r2"type..eq.strconv.decimal@b b ppq"p~r2"+type..hash.strconv.extFloatb c p(h"~r2"type..eq.strconv.extFloat c c p(q"(~r2"+type..hash.strconv.leftCheatc  d ph"~r2"type..eq.strconv.leftCheat d d pq"~r2"+type..hash.[11]float32e e iX"ph"~r2"type..eq.[11]float32e Ff iX"pq"~r2"+type..hash.[23]float64Pf f iX"ph"~r2"type..eq.[23]float64g g iX"pq"~r2"+type..hash.[61]strconv.leftCheatg Rh iX"p(h"~r2"type..eq.[61]strconv.leftCheat`h i i"p(q"(~r2"+type..hash.[87]strconv.extFloati rj iX"pEh"~r2"type..eq.[87]strconv.extFloatj tk iX"pEq"E~r2"+type..hash.[8]strconv.extFloatk 2l iX"pah"~r2"type..eq.[8]strconv.extFloat@l 4m iX"paq"a~r2"+unicode.IsPrint@m m r~r1"+unicode.Inm n rranges"YP~r2 "+n n inside@"Punicode.IsSpacen o r~r1"+unicode.is16o  r lo"hi@"rangesQr"~r2 "+2i" 3range_h"`3m"range_`"unicode.is32r ?t lo"hi"rangesQr"ʷ~r2 "+3i"3range_h"04m"range_\"+Runicode.Is@t u r32@"Qr16X"QrangeTabPr"~r2"+unicode.isExcludingLatinv >x r32"Qr16@"QrangeTabPr"~r2"+4off"unicode.to@x y loH"hiP"_caser"caseRange"@R~r3("4m@"cr\"R 5delta"unicode.Toy Lz _caser"~r2"unicode.ToUpperPz z r~r1"unicode.ToLowerz { r~r1"unicode.SimpleFold{ } loX"hi`"r~r1"`5mP"!} M} lH"unicode.init} ; reflect.makeMethodValue@ Y fl~"qMcode~"stack~"Ofv~"funcType~"Kdummy~"srcvr"KopJv"K~r2("Kreflect.Swapper`  hasPtr}"+size}"typ}"Ktmp}"߶s}"v~"Kss~"aps~"dis"is"is@"isX"[dsliceu~r1"wreflect.(*structField).offset  f~r0"reflect.(*structField).anon  f~r0"+reflect.name.data N noff"~r1"@reflect.name.isExportedP i n~r0"+reflect.name.nameLenp  n~r0"reflect.name.tagLen  offH"n~r0"reflect.name.name   hdr`"bh"(ns"Jreflect.name.tag  tlP"nlX"hdr`"ns"Jreflect.name.pkgPath  nameOff~"off~"pkgPathName~"n~r0"J5tl~"reflect.newName " bits}"l}"b~"nJtag"JpkgPath "Jexported0"+~r48"5tb~"reflect.Kind.String" # kJ~r0"Jreflect.(*uncommonType).methods# $ t~r0"reflect.resolveReflectName$ $ n~r1"IMreflect.(*rtype).nameOff$ _% tKoff"IM~r1"reflect.(*rtype).typeOff`% % tKoff"]M~r1"Kreflect.(*rtype).textOff% & tKoff"B~r1"߶reflect.(*rtype).uncommon & ' tK~r0"reflect.(*rtype).String( ( sP"JtK~r0"Jreflect.(*rtype).Size) ) tK~r0"reflect.(*rtype).Bits ) b* kH"JtK~r0"reflect.(*rtype).Alignp* * tK~r0"reflect.(*rtype).FieldAlign* * tK~r0"reflect.(*rtype).Kind* * tK~r0"Jreflect.(*rtype).pointers* * tK~r0"+reflect.(*rtype).common* + tK~r0"Kreflect.(*rtype).exportedMethods+ 3 found|"+allExported|"+ut}"methodsi~"umethods~"allm~"tK~r0"@6m}".6name}"e0 K2 m}".6name}"reflect.(*rtype).NumMethod 3 4 tK~r0"j3 3 ttP"lreflect.(*rtype).Method4  > fl{"qMp{".pname{"mtyp{"Kft|"$fn|"߶&tfn|"?mt|"Kout}"methods}"in}"tKi"m"oK7tt{"l7 N9 arg|"K9 ; ret{"Kreflect.(*rtype).MethodByName > YB ut}"utmethods}"tKname"Jm"oKok"+@7tt}"l7i}"7p}".pname}"reflect.(*rtype).PkgPath`B VC utP"tK~r0"Jreflect.(*rtype).Name`C D i"sP"JtK~r0"Jreflect.(*rtype).ChanDirD ?E tth"tK~r0"reflect.(*rtype).IsVariadic@E E tth"$tK~r0"+reflect.(*rtype).ElemE TH tK~r0"KRF F tt"}F G tt" G mG tt"mG G tt~"G 'H tt"reflect.(*rtype).Field`H I tt"rtKi"~r1"Nreflect.(*rtype).FieldByIndexI K tt"rtKindex"1~r1 "Nreflect.(*rtype).FieldByName K M tt~"rtKname"J~r1"N~r2"+reflect.(*rtype).FieldByNameFunc M O tt~"rtKmatch"Q~r1"N~r2"+reflect.(*rtype).InO P tt@"$tKi"~r1"Kreflect.(*rtype).KeyP P ttX"tK~r0"Kreflect.(*rtype).LenP _Q tth"}tK~r0"reflect.(*rtype).NumField`Q Q tth"rtK~r0"reflect.(*rtype).NumInR R tth"$tK~r0"reflect.(*rtype).NumOutR IS ttP"$tK~r0"reflect.(*rtype).OutPS PT tt@"$tKi"~r1"Kreflect.(*funcType).inPT 9U uadd@"t$~r0"vreflect.(*funcType).out@U V outCount"uadd@"t$~r0"vreflect.addV V p߶x"~r2"߶reflect.ChanDir.StringV W d~r0"Jreflect.(*interfaceType).MethodW VZ pname"p"htli"m"oKreflect.(*interfaceType).NumMethod`Z Z tl~r0"reflect.(*interfaceType).MethodByNameZ \ p~"htlname"Jm"oKok"+08i~"reflect.(*structType).Field] "` p~"tri"f"N8tag"Jreflect.(*structType).FieldByIndex0` &c trindex"1f "N`  c x~"i~"8ft"Kreflect.(*structType).FieldByNameFunc0c q visited{"nextCount|"next}"current}"trmatch"Qresult"Nok"+9count|"@9scan~"9t{"r9i{":styp{"rntyp{"Kf|"fname|"Jindex}"1reflect.(*structType).FieldByNameq u hasAnon|"+trname"Jf"Npresent"+p:i|":tf}"reflect.TypeOfu zv efaceP"iu~r1"Kreflect.(*rtype).ptrTov } prototype}"&pp~"s~"Jpi~"uiptr~"utK~r0"K;ok|"+pi~"u@;tt}"K;p}"pi~"ureflect.fnv1} I~ xʷlist"~r2 "ʷ} 7~ b"reflect.(*rtype).ImplementsP~ [ tKu"K~r1"+reflect.(*rtype).AssignableTo` R uuh"KtKu"K~r1"+reflect.(*rtype).ConvertibleTo` + uu`"KtKu"K~r1"+reflect.(*rtype).Comparable0 j tK~r0"+reflect.implementsp S i|"v}"t~"lvmethodsX"TKV"K~r2"+;i|"v}"l<j|"P<vmName}"vm}"htmName}"tm}"h<vmPkgPath~"JtmPkgPath"J<j|" =vm}".vmName}"tmName}"tm~"hp=vmPkgPath~"JtmPkgPath~"Jreflect.directlyAssignable`  TKV"K~r2"+reflect.haveIdenticalType ׎ TKV"KcmpTags "+~r3("+reflect.haveIdenticalUnderlyingType  kind{"JTKV"KcmpTags"+~r3"+0 ) v|"$t|"$  i{"  i{"P  v|"lt|"l=v|"rt|"r=i{"0>vf|"tf|">vp}"Jtp}"Jreflect.rtypeOff  section߶off"~r2"Kreflect.typesByString ٤ sections~"dret~"voffset~"֗sJ~r1"v>offsI}"offs~"?j}"i}"section}"߶P?h}"?j}"?typ}"Kreflect.FuncOf ȸ hashx"ʷnx"prototypez"$ftz"$addToCachez"Lstr|"Jifunc|"uargs}"vinout"variadic0"+~r38"KT  fixedz"  fixedz"C  fixedz"  fixedz"s _ fixedz"sd з fixedz"P@in|"K@tz"K@out|"K Atz"KpAokx"+ts{"uAtz"KBokx"+ts|"uPBtz"K  ttz"Kreflect.funcStrи . repr}"out}"vft$~r1"JBiz"t|"KBi{"t|"Kreflect.toType0  tK~r1"Kreflect.funcLayout  argNy"ʷoffsety"xz"Kttz"$ptrmap{"Os{"Jlti{"uk|"=lt~"NtKrcvr"Kframetype"KargSize"retOffset "stk("OframePool0">Coky"+lti{"uPClt~"N<  arg{"K I resz"Kreflect.ifaceIndir  tK~r1"+reflect.(*bitVector).append  bvObit"reflect.addTypeBits  bvOoffset"t"Kp  ttX"}  i"Ctt`"rCi"Dfh"reflect.flag.kind ( fqM~r0"Jreflect.Value.pointer0  vK~r0"߶reflect.packEface " t@"KeP"i`"uvK~r1"uPDptrH"߶  cX"߶reflect.unpackEface0  f"qMt"Ke"iu~r1"Kreflect.(*ValueError).Error Q e~r0"Jreflect.methodName` ( pcH"fX"'~r0Jreflect.flag.mustBe0 7 fqMexpected"Jreflect.flag.mustBeAssignable@  fqMreflect.Value.Bool ( vK~r0"+reflect.Value.Bytes0  vK~r0"reflect.Value.runes  vK~r0"reflect.Value.CanAddr & vK~r0"+reflect.methodReceiver0  i~"opJv"KmethodIndex("rcvrtype0"Kt8"Kfn"߶Dtt~"lm~"hiface~" Dm~".ut~"&ifn"?reflect.storeRcvr > tH"KvKp"߶ EifaceP" reflect.callMethod@ j retOffset~"argSize~"t~"Krcvrtype~"Kframetype~"KframePool~">fn"߶args"߶rcvrX"Kctxtframe"߶?  callerRetOffset~"reflect.Value.Complexp  kH"JvK~r0"reflect.Value.Elem  k~"JvK~r0"KF  eface"ux"K O fl~"qMtyp~"Ktt~"ptr~"߶reflect.Value.Field  fl~"qMtyp"Ktt"rptr"߶field@"vKi"~r1 "Kreflect.Value.Float M kH"JvK~r0"reflect.Value.IndexP U vKi"~r1 "K`Eoffset~"fl~"qMval~"߶typ~"Ktt~"}Efl~"qMval~"߶typ~"Ktt~"s"Efl~"qMs~"p"߶reflect.Value.Int` $ k@"JpX"߶vK~r0"reflect.Value.CanInterface0   vK~r0"+reflect.Value.Interface  vKi"ureflect.valueInterface  vKsafe"+~r2 "ureflect.Value.IsNil [ k@"JvK~r0"+ FptrX"߶reflect.Value.IsValid` u vK~r0"+reflect.Value.Kind  vK~r0"Jreflect.Value.Len ; k"JvK~r0"8 g ttH"}reflect.Value.MapIndex@ 7 fl~"qMtyp~"Ktt"k"߶e"߶vKkey"K~r10"K^ - c"߶reflect.Value.MapKeys@  mlen~"i~"fl~"qMtt~"m~"߶keyType~"Kit~"߶a"vK~r0"`Fkey~"߶Fc~"߶reflect.Value.NumMethod  vK~r0"reflect.Value.NumField   tth"rvK~r0"reflect.Value.Pointer  k"JvK~r0"3  pH"߶P ~ fP"sreflect.Value.SetBytes  vKx"reflect.Value.setRunes  vKx"reflect.Value.SetString a vKx"Jreflect.Value.Slicep % fl~"qMcap~"typ~"s~"base~"߶&x"vKi"j "~r2("KGkind~"JPGtt~"}" " s~"Gs~"&t"reflect.Value.String% ' vK~r0"J& & k@"Jreflect.Value.Type' * i~"f~"qMm".ut"vK~r0"KGtt"lm"hreflect.Value.Uint* , k@"JpX"߶vK~r0"Kreflect.arrayAt, , p߶i"eltSize"~r3"߶reflect.ValueOf, . iu~r1"Kreflect.Zero. 0 fl"qMt"KtypK~r1"Kreflect.New 0 1 fl"qMptr@"߶typK~r1"Kreflect.Value.assignTo1 6 vKcontext"Jdst("Ktarget0"߶~r38"Kg2 h3 fl~"qMh3 `5 x"ureflect.convertOp6 > dstKsrc"K~r2"Freflect.makeInt> @ typ"Kptr"߶fqMbits"Kt"K~r3 "Kreflect.makeFloat@ 0B typ"Kptr@"߶fqMv"t"K~r3 "Kreflect.makeComplex0B C typ"Kptr@"߶fqMv"t"K~r3("Kreflect.makeStringC E ret@"KfqMv"Jt"K~r3("Kreflect.makeBytesE MF ret@"KfqMv"t "K~r30"Kreflect.makeRunesPF G ret@"KfqMv"t "K~r30"Kreflect.cvtIntG H vKt"K~r2("Kreflect.cvtUintH I vKt"K~r2("Kreflect.cvtFloatIntI J vKt"K~r2("Kreflect.cvtFloatUintJ K vKt"K~r2("Kreflect.cvtIntFloatK L vKt"K~r2("Kreflect.cvtUintFloatL N vKt"K~r2("Kreflect.cvtFloat N O vKt"K~r2("Kreflect.cvtComplex O @P vKt"K~r2("Kreflect.cvtIntString@P bQ vKt"K~r2("Kreflect.cvtUintStringpQ R vKt"K~r2("Kreflect.cvtBytesStringR S vKt"K~r2("Kreflect.cvtStringBytesS nU vKt"K~r2("Kreflect.cvtRunesStringpU V vKt"K~r2("Kreflect.cvtStringRunesV >X vKt"K~r2("Kreflect.cvtDirect@X Y f"qMt@"KptrH"߶vKtyp"K~r2("KX )Y cP"߶reflect.cvtT2IY \ target"߶xH"uvKtyp"K~r2("Kreflect.cvtI2I\ ^ vKtyp"K~r2("K\ ,] ret"Kreflect.escapes ^ ^ xureflect.Swapper.func1^ ^ ij"reflect.Swapper.func2^ X_ ij"reflect.Swapper.func3`_ ` &psP"ij"reflect.Swapper.func4` a &ss@"Pij"reflect.Swapper.func5a b &isP"`ij"reflect.Swapper.func6b c &isP"Uij"reflect.Swapper.func7c Ed &isP"oij"reflect.Swapper.func8Pd e &isP"~ij"reflect.Swapper.func9 e f size@"val2H"߶val1P"߶typX"Ktmp`"߶sh"ij"reflect.(*structType).FieldByName.func1f 5g name`"JsJ~r1"+reflect.FuncOf.func1@g j hash~"ʷrts"vttK~r1"KHok~"+rti~"ureflect.funcLayout.func1j "k x`"K~r0ureflect.init0k Nl reflect.methodValueCallPl l reflect.(*ChanDir).Stringl ?m .this~r0"Jreflect.(*Kind).String@m m .this~r0"Jtype..hash.reflect.uncommonTypem }n ph"~r2"type..eq.reflect.uncommonTypen n pq"~r2"+reflect.(*Value).Kindn yo .this{~r0"Jreflect.(*Value).Leno p .this{~r0"reflect.(*Value).NumMethod p p .this{~r0"reflect.(*Value).NumFieldp Yq .this{~r0"reflect.(*Value).String`q r .this{~r0"Jtype..hash.reflect.Method r s ph"~r2"type..eq.reflect.Methods u pq"~r2"+type..hash.reflect.ValueErroru  v ph"~r2"type..eq.reflect.ValueError v v pq"~r2"+reflect.(*arrayType).uncommonv  w .this}~r0"reflect.(*arrayType).Stringw 3w .this}~r0"Jreflect.(*arrayType).Size@w Zw .this}~r0"reflect.(*arrayType).Bits`w zw .this}~r0"reflect.(*arrayType).Alignw w .this}~r0"reflect.(*arrayType).FieldAlignw w .this}~r0"reflect.(*arrayType).Kindw w .this}~r0"Jreflect.(*arrayType).commonw w .this}~r0"Kreflect.(*arrayType).NumMethodx x .this}~r0"reflect.(*arrayType).Method x Px .this}i"m"oKreflect.(*arrayType).MethodByNamePx x .this}name"Jm"oKok"+reflect.(*arrayType).PkgPathx x .this}~r0"Jreflect.(*arrayType).Namex x .this}~r0"Jreflect.(*arrayType).ChanDirx  y .this}~r0"reflect.(*arrayType).IsVariadicy &y .this}~r0"+reflect.(*arrayType).Elem0y Sy .this}~r0"Kreflect.(*arrayType).Field`y y .this}i"~r1"Nreflect.(*arrayType).FieldByIndexy y .this}index"1~r1 "Nreflect.(*arrayType).FieldByNamey !z .this}name"J~r1"N~r2"+reflect.(*arrayType).FieldByNameFunc0z qz .this}match"Q~r1"N~r2"+reflect.(*arrayType).Inz z .this}i"~r1"Kreflect.(*arrayType).Keyz z .this}~r0"Kreflect.(*arrayType).Lenz z .this}~r0"reflect.(*arrayType).NumField{ { .this}~r0"reflect.(*arrayType).NumIn { :{ .this}~r0"reflect.(*arrayType).NumOut@{ Z{ .this}~r0"reflect.(*arrayType).Out`{ { .this}i"~r1"Kreflect.(*arrayType).Implements{ { .this}u"K~r1"+reflect.(*arrayType).AssignableTo{ { .this}u"K~r1"+reflect.(*arrayType).ConvertibleTo{ { .this}u"K~r1"+reflect.(*arrayType).Comparable{ | .this}~r0"+reflect.(*chanType).uncommon| *| .this~r0"reflect.(*chanType).String0| S| .this~r0"Jreflect.(*chanType).Size`| z| .this~r0"reflect.(*chanType).Bits| | .this~r0"reflect.(*chanType).Align| | .this~r0"reflect.(*chanType).FieldAlign| | .this~r0"reflect.(*chanType).Kind| | .this~r0"Jreflect.(*chanType).common} } .this~r0"Kreflect.(*chanType).NumMethod } :} .this~r0"reflect.(*chanType).Method@} p} .thisi"m"oKreflect.(*chanType).MethodByNamep} } .thisname"Jm"oKok"+reflect.(*chanType).PkgPath} } .this~r0"Jreflect.(*chanType).Name} ~ .this~r0"Jreflect.(*chanType).ChanDir~ *~ .this~r0"reflect.(*chanType).IsVariadic0~ F~ .this~r0"+reflect.(*chanType).ElemP~ s~ .this~r0"Kreflect.(*chanType).Field~ ~ .thisi"~r1"Nreflect.(*chanType).FieldByIndex~ ~ .thisindex"1~r1 "Nreflect.(*chanType).FieldByName A .thisname"J~r1"N~r2"+reflect.(*chanType).FieldByNameFuncP  .thismatch"Q~r1"N~r2"+reflect.(*chanType).In  .thisi"~r1"Kreflect.(*chanType).Key  .this~r0"Kreflect.(*chanType).Len  .this~r0"reflect.(*chanType).NumField : .this~r0"reflect.(*chanType).NumIn@ Z .this~r0"reflect.(*chanType).NumOut` z .this~r0"reflect.(*chanType).Out  .thisi"~r1"Kreflect.(*chanType).Implements ƀ .thisu"K~r1"+reflect.(*chanType).AssignableToЀ  .thisu"K~r1"+reflect.(*chanType).ConvertibleTo  .thisu"K~r1"+reflect.(*chanType).Comparable & .this~r0"+reflect.(*structType).uncommon0 J .thisr~r0"reflect.(*structType).StringP s .thisr~r0"Jreflect.(*structType).Size  .thisr~r0"reflect.(*structType).Bits  .thisr~r0"reflect.(*structType).Align ځ .thisr~r0"reflect.(*structType).FieldAlign  .thisr~r0"reflect.(*structType).Kind  .thisr~r0"Jreflect.(*structType).common : .thisr~r0"Kreflect.(*structType).NumMethod@ Z .thisr~r0"reflect.(*structType).Method`  .thisri"m"oKreflect.(*structType).MethodByName ł .thisrname"Jm"oKok"+reflect.(*structType).PkgPathЂ  .thisr~r0"Jreflect.(*structType).Name # .thisr~r0"Jreflect.(*structType).ChanDir0 J .thisr~r0"reflect.(*structType).IsVariadicP f .thisr~r0"+reflect.(*structType).Elemp  .thisr~r0"Kreflect.(*structType).In à .thisri"~r1"Kreflect.(*structType).KeyЃ  .thisr~r0"Kreflect.(*structType).Len  .thisr~r0"reflect.(*structType).NumField : .thisr~r0"reflect.(*structType).NumIn@ Z .thisr~r0"reflect.(*structType).NumOut` z .thisr~r0"reflect.(*structType).Out  .thisri"~r1"Kreflect.(*structType).Implements Ƅ .thisru"K~r1"+reflect.(*structType).AssignableToЄ  .thisru"K~r1"+reflect.(*structType).ConvertibleTo  .thisru"K~r1"+reflect.(*structType).Comparable & .thisr~r0"+type..hash.reflect.funcType0  p$h"~r2"type..eq.reflect.funcType  p$q"$~r2"+reflect.(*funcType).uncommon * .this$~r0"reflect.(*funcType).String0 S .this$~r0"Jreflect.(*funcType).Size` z .this$~r0"reflect.(*funcType).Bits  .this$~r0"reflect.(*funcType).Align  .this$~r0"reflect.(*funcType).FieldAlign چ .this$~r0"reflect.(*funcType).Kind  .this$~r0"Jreflect.(*funcType).common  .this$~r0"Kreflect.(*funcType).NumMethod : .this$~r0"reflect.(*funcType).Method@ p .this$i"m"oKreflect.(*funcType).MethodByNamep  .this$name"Jm"oKok"+reflect.(*funcType).PkgPath Ӈ .this$~r0"Jreflect.(*funcType).Name  .this$~r0"Jreflect.(*funcType).ChanDir * .this$~r0"reflect.(*funcType).IsVariadic0 F .this$~r0"+reflect.(*funcType).ElemP s .this$~r0"Kreflect.(*funcType).Field  .this$i"~r1"Nreflect.(*funcType).FieldByIndex  .this$index"1~r1 "Nreflect.(*funcType).FieldByName A .this$name"J~r1"N~r2"+reflect.(*funcType).FieldByNameFuncP  .this$match"Q~r1"N~r2"+reflect.(*funcType).In É .this$i"~r1"Kreflect.(*funcType).KeyЉ  .this$~r0"Kreflect.(*funcType).Len  .this$~r0"reflect.(*funcType).NumField : .this$~r0"reflect.(*funcType).NumIn@ Z .this$~r0"reflect.(*funcType).NumOut` z .this$~r0"reflect.(*funcType).Out  .this$i"~r1"Kreflect.(*funcType).Implements Ɗ .this$u"K~r1"+reflect.(*funcType).AssignableToЊ  .this$u"K~r1"+reflect.(*funcType).ConvertibleTo  .this$u"K~r1"+reflect.(*funcType).Comparable & .this$~r0"+type..hash.reflect.funcTypeFixed1280  ph"~r2"type..eq.reflect.funcTypeFixed128 ˌ pq"~r2"+reflect.(*funcTypeFixed128).uncommonЌ  .this~r0"reflect.(*funcTypeFixed128).String  .this~r0"Jreflect.(*funcTypeFixed128).Size : .this~r0"reflect.(*funcTypeFixed128).Bits@ Z .this~r0"reflect.(*funcTypeFixed128).Align` z .this~r0"reflect.(*funcTypeFixed128).FieldAlign  .this~r0"reflect.(*funcTypeFixed128).Kind  .this~r0"Jreflect.(*funcTypeFixed128).common ڍ .this~r0"Kreflect.(*funcTypeFixed128).NumMethod  .this~r0"reflect.(*funcTypeFixed128).Method 0 .thisi"m"oKreflect.(*funcTypeFixed128).MethodByName0 e .thisname"Jm"oKok"+reflect.(*funcTypeFixed128).PkgPathp  .this~r0"Jreflect.(*funcTypeFixed128).Name Î .this~r0"Jreflect.(*funcTypeFixed128).ChanDirЎ  .this~r0"reflect.(*funcTypeFixed128).IsVariadic  .this~r0"+reflect.(*funcTypeFixed128).Elem 3 .this~r0"Kreflect.(*funcTypeFixed128).Field@ y .thisi"~r1"Nreflect.(*funcTypeFixed128).FieldByIndex  .thisindex"1~r1 "Nreflect.(*funcTypeFixed128).FieldByName  .thisname"J~r1"N~r2"+reflect.(*funcTypeFixed128).FieldByNameFunc Q .thismatch"Q~r1"N~r2"+reflect.(*funcTypeFixed128).In`  .thisi"~r1"Kreflect.(*funcTypeFixed128).Key  .this~r0"Kreflect.(*funcTypeFixed128).Len ڐ .this~r0"reflect.(*funcTypeFixed128).NumField  .this~r0"reflect.(*funcTypeFixed128).NumIn  .this~r0"reflect.(*funcTypeFixed128).NumOut : .this~r0"reflect.(*funcTypeFixed128).Out@ c .thisi"~r1"Kreflect.(*funcTypeFixed128).Implementsp  .thisu"K~r1"+reflect.(*funcTypeFixed128).AssignableTo  .thisu"K~r1"+reflect.(*funcTypeFixed128).ConvertibleTo Ƒ .thisu"K~r1"+reflect.(*funcTypeFixed128).ComparableБ  .this~r0"+type..hash.reflect.funcTypeFixed16  ph"~r2"type..eq.reflect.funcTypeFixed16  pq"~r2"+reflect.(*funcTypeFixed16).uncommon  .this~r0"reflect.(*funcTypeFixed16).String ӓ .this~r0"Jreflect.(*funcTypeFixed16).Size  .this~r0"reflect.(*funcTypeFixed16).Bits  .this~r0"reflect.(*funcTypeFixed16).Align : .this~r0"reflect.(*funcTypeFixed16).FieldAlign@ Z .this~r0"reflect.(*funcTypeFixed16).Kind` z .this~r0"Jreflect.(*funcTypeFixed16).common  .this~r0"Kreflect.(*funcTypeFixed16).NumMethod  .this~r0"reflect.(*funcTypeFixed16).Method  .thisi"m"oKreflect.(*funcTypeFixed16).MethodByName % .thisname"Jm"oKok"+reflect.(*funcTypeFixed16).PkgPath0 S .this~r0"Jreflect.(*funcTypeFixed16).Name`  .this~r0"Jreflect.(*funcTypeFixed16).ChanDir  .this~r0"reflect.(*funcTypeFixed16).IsVariadic ƕ .this~r0"+reflect.(*funcTypeFixed16).ElemЕ  .this~r0"Kreflect.(*funcTypeFixed16).Field 9 .thisi"~r1"Nreflect.(*funcTypeFixed16).FieldByIndex@ y .thisindex"1~r1 "Nreflect.(*funcTypeFixed16).FieldByName  .thisname"J~r1"N~r2"+reflect.(*funcTypeFixed16).FieldByNameFuncЖ  .thismatch"Q~r1"N~r2"+reflect.(*funcTypeFixed16).In C .thisi"~r1"Kreflect.(*funcTypeFixed16).KeyP s .this~r0"Kreflect.(*funcTypeFixed16).Len  .this~r0"reflect.(*funcTypeFixed16).NumField  .this~r0"reflect.(*funcTypeFixed16).NumIn ڗ .this~r0"reflect.(*funcTypeFixed16).NumOut  .this~r0"reflect.(*funcTypeFixed16).Out # .thisi"~r1"Kreflect.(*funcTypeFixed16).Implements0 F .thisu"K~r1"+reflect.(*funcTypeFixed16).AssignableToP f .thisu"K~r1"+reflect.(*funcTypeFixed16).ConvertibleTop  .thisu"K~r1"+reflect.(*funcTypeFixed16).Comparable  .this~r0"+type..hash.reflect.funcTypeFixed32 @ psh"~r2"type..eq.reflect.funcTypeFixed32@ K psq"s~r2"+reflect.(*funcTypeFixed32).uncommonP j .thiss~r0"reflect.(*funcTypeFixed32).Stringp  .thiss~r0"Jreflect.(*funcTypeFixed32).Size  .thiss~r0"reflect.(*funcTypeFixed32).Bits ښ .thiss~r0"reflect.(*funcTypeFixed32).Align  .thiss~r0"reflect.(*funcTypeFixed32).FieldAlign  .thiss~r0"reflect.(*funcTypeFixed32).Kind : .thiss~r0"Jreflect.(*funcTypeFixed32).common@ Z .thiss~r0"Kreflect.(*funcTypeFixed32).NumMethod` z .thiss~r0"reflect.(*funcTypeFixed32).Method  .thissi"m"oKreflect.(*funcTypeFixed32).MethodByName  .thissname"Jm"oKok"+reflect.(*funcTypeFixed32).PkgPath  .thiss~r0"Jreflect.(*funcTypeFixed32).Name C .thiss~r0"Jreflect.(*funcTypeFixed32).ChanDirP j .thiss~r0"reflect.(*funcTypeFixed32).IsVariadicp  .thiss~r0"+reflect.(*funcTypeFixed32).Elem  .thiss~r0"Kreflect.(*funcTypeFixed32).Field  .thissi"~r1"Nreflect.(*funcTypeFixed32).FieldByIndex 9 .thissindex"1~r1 "Nreflect.(*funcTypeFixed32).FieldByName@  .thissname"J~r1"N~r2"+reflect.(*funcTypeFixed32).FieldByNameFunc ѝ .thissmatch"Q~r1"N~r2"+reflect.(*funcTypeFixed32).In  .thissi"~r1"Kreflect.(*funcTypeFixed32).Key 3 .thiss~r0"Kreflect.(*funcTypeFixed32).Len@ Z .thiss~r0"reflect.(*funcTypeFixed32).NumField` z .thiss~r0"reflect.(*funcTypeFixed32).NumIn  .thiss~r0"reflect.(*funcTypeFixed32).NumOut  .thiss~r0"reflect.(*funcTypeFixed32).Out  .thissi"~r1"Kreflect.(*funcTypeFixed32).Implements  .thissu"K~r1"+reflect.(*funcTypeFixed32).AssignableTo & .thissu"K~r1"+reflect.(*funcTypeFixed32).ConvertibleTo0 F .thissu"K~r1"+reflect.(*funcTypeFixed32).ComparableP f .thiss~r0"+type..hash.reflect.funcTypeFixed4p  ph"~r2"type..eq.reflect.funcTypeFixed4  pq"~r2"+reflect.(*funcTypeFixed4).uncommon * .this~r0"reflect.(*funcTypeFixed4).String0 S .this~r0"Jreflect.(*funcTypeFixed4).Size` z .this~r0"reflect.(*funcTypeFixed4).Bits  .this~r0"reflect.(*funcTypeFixed4).Align  .this~r0"reflect.(*funcTypeFixed4).FieldAlign ڡ .this~r0"reflect.(*funcTypeFixed4).Kind  .this~r0"Jreflect.(*funcTypeFixed4).common  .this~r0"Kreflect.(*funcTypeFixed4).NumMethod : .this~r0"reflect.(*funcTypeFixed4).Method@ p .thisi"m"oKreflect.(*funcTypeFixed4).MethodByNamep  .thisname"Jm"oKok"+reflect.(*funcTypeFixed4).PkgPath Ӣ .this~r0"Jreflect.(*funcTypeFixed4).Name  .this~r0"Jreflect.(*funcTypeFixed4).ChanDir * .this~r0"reflect.(*funcTypeFixed4).IsVariadic0 F .this~r0"+reflect.(*funcTypeFixed4).ElemP s .this~r0"Kreflect.(*funcTypeFixed4).Field  .thisi"~r1"Nreflect.(*funcTypeFixed4).FieldByIndex  .thisindex"1~r1 "Nreflect.(*funcTypeFixed4).FieldByName A .thisname"J~r1"N~r2"+reflect.(*funcTypeFixed4).FieldByNameFuncP  .thismatch"Q~r1"N~r2"+reflect.(*funcTypeFixed4).In ä .thisi"~r1"Kreflect.(*funcTypeFixed4).KeyФ  .this~r0"Kreflect.(*funcTypeFixed4).Len  .this~r0"reflect.(*funcTypeFixed4).NumField : .this~r0"reflect.(*funcTypeFixed4).NumIn@ Z .this~r0"reflect.(*funcTypeFixed4).NumOut` z .this~r0"reflect.(*funcTypeFixed4).Out  .thisi"~r1"Kreflect.(*funcTypeFixed4).Implements ƥ .thisu"K~r1"+reflect.(*funcTypeFixed4).AssignableToХ  .thisu"K~r1"+reflect.(*funcTypeFixed4).ConvertibleTo  .thisu"K~r1"+reflect.(*funcTypeFixed4).Comparable & .this~r0"+type..hash.reflect.funcTypeFixed640  psh"~r2"type..eq.reflect.funcTypeFixed64 ˧ psq"s~r2"+reflect.(*funcTypeFixed64).uncommonЧ  .thiss~r0"reflect.(*funcTypeFixed64).String  .thiss~r0"Jreflect.(*funcTypeFixed64).Size : .thiss~r0"reflect.(*funcTypeFixed64).Bits@ Z .thiss~r0"reflect.(*funcTypeFixed64).Align` z .thiss~r0"reflect.(*funcTypeFixed64).FieldAlign  .thiss~r0"reflect.(*funcTypeFixed64).Kind  .thiss~r0"Jreflect.(*funcTypeFixed64).common ڨ .thiss~r0"Kreflect.(*funcTypeFixed64).NumMethod  .thiss~r0"reflect.(*funcTypeFixed64).Method 0 .thissi"m"oKreflect.(*funcTypeFixed64).MethodByName0 e .thissname"Jm"oKok"+reflect.(*funcTypeFixed64).PkgPathp  .thiss~r0"Jreflect.(*funcTypeFixed64).Name é .thiss~r0"Jreflect.(*funcTypeFixed64).ChanDirЩ  .thiss~r0"reflect.(*funcTypeFixed64).IsVariadic  .thiss~r0"+reflect.(*funcTypeFixed64).Elem 3 .thiss~r0"Kreflect.(*funcTypeFixed64).Field@ y .thissi"~r1"Nreflect.(*funcTypeFixed64).FieldByIndex  .thissindex"1~r1 "Nreflect.(*funcTypeFixed64).FieldByName  .thissname"J~r1"N~r2"+reflect.(*funcTypeFixed64).FieldByNameFunc Q .thissmatch"Q~r1"N~r2"+reflect.(*funcTypeFixed64).In`  .thissi"~r1"Kreflect.(*funcTypeFixed64).Key  .thiss~r0"Kreflect.(*funcTypeFixed64).Len ګ .thiss~r0"reflect.(*funcTypeFixed64).NumField  .thiss~r0"reflect.(*funcTypeFixed64).NumIn  .thiss~r0"reflect.(*funcTypeFixed64).NumOut : .thiss~r0"reflect.(*funcTypeFixed64).Out@ c .thissi"~r1"Kreflect.(*funcTypeFixed64).Implementsp  .thissu"K~r1"+reflect.(*funcTypeFixed64).AssignableTo  .thissu"K~r1"+reflect.(*funcTypeFixed64).ConvertibleTo Ƭ .thissu"K~r1"+reflect.(*funcTypeFixed64).ComparableЬ  .thiss~r0"+type..hash.reflect.funcTypeFixed8  pCh"~r2"type..eq.reflect.funcTypeFixed8  pCq"C~r2"+reflect.(*funcTypeFixed8).uncommon  .thisC~r0"reflect.(*funcTypeFixed8).String Ӯ .thisC~r0"Jreflect.(*funcTypeFixed8).Size  .thisC~r0"reflect.(*funcTypeFixed8).Bits  .thisC~r0"reflect.(*funcTypeFixed8).Align : .thisC~r0"reflect.(*funcTypeFixed8).FieldAlign@ Z .thisC~r0"reflect.(*funcTypeFixed8).Kind` z .thisC~r0"Jreflect.(*funcTypeFixed8).common  .thisC~r0"Kreflect.(*funcTypeFixed8).NumMethod  .thisC~r0"reflect.(*funcTypeFixed8).Method  .thisCi"m"oKreflect.(*funcTypeFixed8).MethodByName % .thisCname"Jm"oKok"+reflect.(*funcTypeFixed8).PkgPath0 S .thisC~r0"Jreflect.(*funcTypeFixed8).Name`  .thisC~r0"Jreflect.(*funcTypeFixed8).ChanDir  .thisC~r0"reflect.(*funcTypeFixed8).IsVariadic ư .thisC~r0"+reflect.(*funcTypeFixed8).Elemа  .thisC~r0"Kreflect.(*funcTypeFixed8).Field 9 .thisCi"~r1"Nreflect.(*funcTypeFixed8).FieldByIndex@ y .thisCindex"1~r1 "Nreflect.(*funcTypeFixed8).FieldByName  .thisCname"J~r1"N~r2"+reflect.(*funcTypeFixed8).FieldByNameFuncб  .thisCmatch"Q~r1"N~r2"+reflect.(*funcTypeFixed8).In C .thisCi"~r1"Kreflect.(*funcTypeFixed8).KeyP s .thisC~r0"Kreflect.(*funcTypeFixed8).Len  .thisC~r0"reflect.(*funcTypeFixed8).NumField  .thisC~r0"reflect.(*funcTypeFixed8).NumIn ڲ .thisC~r0"reflect.(*funcTypeFixed8).NumOut  .thisC~r0"reflect.(*funcTypeFixed8).Out # .thisCi"~r1"Kreflect.(*funcTypeFixed8).Implements0 F .thisCu"K~r1"+reflect.(*funcTypeFixed8).AssignableToP f .thisCu"K~r1"+reflect.(*funcTypeFixed8).ConvertibleTop  .thisCu"K~r1"+reflect.(*funcTypeFixed8).Comparable  .thisC~r0"+reflect.(*interfaceType).uncommon ʳ .thisl~r0"reflect.(*interfaceType).Stringг  .thisl~r0"Jreflect.(*interfaceType).Size  .thisl~r0"reflect.(*interfaceType).Bits : .thisl~r0"reflect.(*interfaceType).Align@ Z .thisl~r0"reflect.(*interfaceType).FieldAlign` z .thisl~r0"reflect.(*interfaceType).Kind  .thisl~r0"Jreflect.(*interfaceType).common  .thisl~r0"Kreflect.(*interfaceType).PkgPath  .thisl~r0"Jreflect.(*interfaceType).Name  .thisl~r0"Jreflect.(*interfaceType).ChanDir : .thisl~r0"reflect.(*interfaceType).IsVariadic@ V .thisl~r0"+reflect.(*interfaceType).Elem`  .thisl~r0"Kreflect.(*interfaceType).Field ɵ .thisli"~r1"Nreflect.(*interfaceType).FieldByIndexе  .thislindex"1~r1 "Nreflect.(*interfaceType).FieldByName Q .thislname"J~r1"N~r2"+reflect.(*interfaceType).FieldByNameFunc`  .thislmatch"Q~r1"N~r2"+reflect.(*interfaceType).In Ӷ .thisli"~r1"Kreflect.(*interfaceType).Key  .thisl~r0"Kreflect.(*interfaceType).Len * .thisl~r0"reflect.(*interfaceType).NumField0 J .thisl~r0"reflect.(*interfaceType).NumInP j .thisl~r0"reflect.(*interfaceType).NumOutp  .thisl~r0"reflect.(*interfaceType).Out  .thisli"~r1"Kreflect.(*interfaceType).Implements ַ .thislu"K~r1"+reflect.(*interfaceType).AssignableTo  .thislu"K~r1"+reflect.(*interfaceType).ConvertibleTo  .thislu"K~r1"+reflect.(*interfaceType).Comparable 6 .thisl~r0"+reflect.(*mapType).uncommon@ Z .this~r0"reflect.(*mapType).String`  .this~r0"Jreflect.(*mapType).Size  .this~r0"reflect.(*mapType).Bits ʸ .this~r0"reflect.(*mapType).Alignи  .this~r0"reflect.(*mapType).FieldAlign  .this~r0"reflect.(*mapType).Kind * .this~r0"Jreflect.(*mapType).common0 J .this~r0"Kreflect.(*mapType).NumMethodP j .this~r0"reflect.(*mapType).Methodp  .thisi"m"oKreflect.(*mapType).MethodByName չ .thisname"Jm"oKok"+reflect.(*mapType).PkgPath  .this~r0"Jreflect.(*mapType).Name 3 .this~r0"Jreflect.(*mapType).ChanDir@ Z .this~r0"reflect.(*mapType).IsVariadic` v .this~r0"+reflect.(*mapType).Elem  .this~r0"Kreflect.(*mapType).Field  .thisi"~r1"Nreflect.(*mapType).FieldByIndex ) .thisindex"1~r1 "Nreflect.(*mapType).FieldByName0 q .thisname"J~r1"N~r2"+reflect.(*mapType).FieldByNameFunc  .thismatch"Q~r1"N~r2"+reflect.(*mapType).Inл  .thisi"~r1"Kreflect.(*mapType).Key # .this~r0"Kreflect.(*mapType).Len0 J .this~r0"reflect.(*mapType).NumFieldP j .this~r0"reflect.(*mapType).NumInp  .this~r0"reflect.(*mapType).NumOut  .this~r0"reflect.(*mapType).Out Ӽ .thisi"~r1"Kreflect.(*mapType).Implements  .thisu"K~r1"+reflect.(*mapType).AssignableTo  .thisu"K~r1"+reflect.(*mapType).ConvertibleTo 6 .thisu"K~r1"+reflect.(*mapType).Comparable@ V .this~r0"+reflect.(*ptrType).uncommon` z .this~r0"reflect.(*ptrType).String  .this~r0"Jreflect.(*ptrType).Size ʽ .this~r0"reflect.(*ptrType).Bitsн  .this~r0"reflect.(*ptrType).Align  .this~r0"reflect.(*ptrType).FieldAlign * .this~r0"reflect.(*ptrType).Kind0 J .this~r0"Jreflect.(*ptrType).commonP j .this~r0"Kreflect.(*ptrType).NumMethodp  .this~r0"reflect.(*ptrType).Method  .thisi"m"oKreflect.(*ptrType).MethodByName  .thisname"Jm"oKok"+reflect.(*ptrType).PkgPath # .this~r0"Jreflect.(*ptrType).Name0 S .this~r0"Jreflect.(*ptrType).ChanDir` z .this~r0"reflect.(*ptrType).IsVariadic  .this~r0"+reflect.(*ptrType).Elem ÿ .this~r0"Kreflect.(*ptrType).Fieldп  .thisi"~r1"Nreflect.(*ptrType).FieldByIndex I .thisindex"1~r1 "Nreflect.(*ptrType).FieldByNameP  .thisname"J~r1"N~r2"+reflect.(*ptrType).FieldByNameFunc  .thismatch"Q~r1"N~r2"+reflect.(*ptrType).In  .thisi"~r1"Kreflect.(*ptrType).Key C .this~r0"Kreflect.(*ptrType).LenP j .this~r0"reflect.(*ptrType).NumFieldp  .this~r0"reflect.(*ptrType).NumIn  .this~r0"reflect.(*ptrType).NumOut  .this~r0"reflect.(*ptrType).Out  .thisi"~r1"Kreflect.(*ptrType).Implements  .thisu"K~r1"+reflect.(*ptrType).AssignableTo 6 .thisu"K~r1"+reflect.(*ptrType).ConvertibleTo@ V .thisu"K~r1"+reflect.(*ptrType).Comparable` v .this~r0"+reflect.(*sliceType).uncommon  .this~r0"reflect.(*sliceType).String  .this~r0"Jreflect.(*sliceType).Size  .this~r0"reflect.(*sliceType).Bits  .this~r0"reflect.(*sliceType).Align * .this~r0"reflect.(*sliceType).FieldAlign0 J .this~r0"reflect.(*sliceType).KindP j .this~r0"Jreflect.(*sliceType).commonp  .this~r0"Kreflect.(*sliceType).NumMethod  .this~r0"reflect.(*sliceType).Method  .thisi"m"oKreflect.(*sliceType).MethodByName  .thisname"Jm"oKok"+reflect.(*sliceType).PkgPath C .this~r0"Jreflect.(*sliceType).NameP s .this~r0"Jreflect.(*sliceType).ChanDir  .this~r0"reflect.(*sliceType).IsVariadic  .this~r0"+reflect.(*sliceType).Elem  .this~r0"Kreflect.(*sliceType).Field ) .thisi"~r1"Nreflect.(*sliceType).FieldByIndex0 i .thisindex"1~r1 "Nreflect.(*sliceType).FieldByNamep  .thisname"J~r1"N~r2"+reflect.(*sliceType).FieldByNameFunc  .thismatch"Q~r1"N~r2"+reflect.(*sliceType).In 3 .thisi"~r1"Kreflect.(*sliceType).Key@ c .this~r0"Kreflect.(*sliceType).Lenp  .this~r0"reflect.(*sliceType).NumField  .this~r0"reflect.(*sliceType).NumIn  .this~r0"reflect.(*sliceType).NumOut  .this~r0"reflect.(*sliceType).Out  .thisi"~r1"Kreflect.(*sliceType).Implements 6 .thisu"K~r1"+reflect.(*sliceType).AssignableTo@ V .thisu"K~r1"+reflect.(*sliceType).ConvertibleTo` v .thisu"K~r1"+reflect.(*sliceType).Comparable  .this~r0"+type..hash.struct { F uintptr; reflect.hash uint32 }  ph"~r2"type..eq.struct { F uintptr; reflect.hash uint32 } M pq"~r2"+type..hash.struct { F uintptr; reflect.name string }P  pqh"~r2"type..eq.struct { F uintptr; reflect.name string }  pqq"q~r2"+type..hash.[27]string n iX"pRh"~r2"type..eq.[27]stringp  i"pRq"R~r2"+type..hash.struct { reflect.b bool; reflect.x interface {} }  pdh"~r2"type..eq.struct { reflect.b bool; reflect.x interface {} }  pdq"d~r2"+fmt.(*fmt).clearflags  ffmt.(*fmt).init i fbuf"fmt.(*fmt).writePaddingp  padByte~"oldLen~"newLen~"padding~"]buf"]fn"PHi~"fmt.(*fmt).pad s width`"fb"fmt.(*fmt).padString  width`"fs"Jfmt.(*fmt).fmt_boolean f fv"+fmt.(*fmt).fmt_unicodep N oldZero~"+prec~"i~"buf"fu"KHwidth~"fmt.(*fmt).fmt_integerP % oldZero}"+negative}"+prec~"i~"buf@"fu"Kbase"isSigned"+digits "JHwidth~" U oldZero}"+Inext~"Kfmt.(*fmt).truncate0  fs"J~r1"JPIn"Ii"fmt.(*fmt).fmt_s  fs"Jfmt.(*fmt).fmt_sbx  c"width"length"bufX"]fs"Jb"digits0"JIi"fmt.(*fmt).fmt_sx _ fs"Jdigits"Jfmt.(*fmt).fmt_bx`  fb"digits "Jfmt.(*fmt).fmt_q  buf"fs"Jfmt.(*fmt).fmt_c  r"w"buf"fc"Kfmt.(*fmt).fmt_qc  r"buf"fc"Kfmt.(*fmt).fmt_float  num~"fv"size"verb"prec "JoldZero}"+PJhasDecimalPoint}"+tailBuf}"digits}"tail~"Ji}"fmt.(*buffer).Write F bp"fmt.(*buffer).WriteStringP  bs"Jfmt.(*buffer).WriteByte  bc"fmt.(*buffer).WriteRune  w~"n~"b"]bpr"fmt.newPrinter  pP"9~r09fmt.(*pp).free  p9fmt.(*pp).Width n p9wid"ok"+fmt.(*pp).Precisionp  p9prec"ok"+fmt.(*pp).Flag  p9b"~r1"+fmt.(*pp).Write  p9b"ret "err(" fmt.Fprintf  pX"9wformat"Ja "Nn8"err" fmt.Printf  formatJa"Nn("err0" fmt.Sprintf  pX"9s`"JformatJa"N~r2("Jfmt.Errorf  formatJa"N~r2(" fmt.Fprint  pX"9wa"Nn("err0" fmt.Fprintln > pX"9wa"Nn("err0" fmt.Println@ Q aNn"err " fmt.getField`  valX"KvKi"~r2 "Kfmt.tooLarge  x~r1"+fmt.parsenum  sJstart"end"num "isnum("+newi0"fmt.(*pp).unknownType  p9v"Kfmt.(*pp).badVerb  p9verb"fmt.(*pp).fmtBool t p9v"+verb "fmt.(*pp).fmt0x64 # sharpo"+p9v"Kleading0x"+fmt.(*pp).fmtInteger0 ! p9v"KisSigned"+verb"fmt.(*pp).fmtFloat! U# p9v"size"verb"fmt.(*pp).fmtComplex`# $ p9v"size"verb "JoldPlus["+fmt.(*pp).fmtString% & p9v"Jverb"fmt.(*pp).fmtBytes& ,- p9v"verb "typeString("J( ) c}"i~") * c}"i~"fmt.(*pp).fmtPointer0- 0 u"p9value"Kverb "fmt.(*pp).catchPanic0 [3 p9arg"uverb"0KerrH"upKoldFlags"KvX"Kfmt.(*pp).handleMethods`3 : p9verb"handled"+3 %5 ok~"+formatter"$<5 6 ok~"+stringer~"7 }8 v~" 8 9 v~"Kfmt.(*pp).printArg : L p9arg"uverb"< < f}"+D D f}"Di= = f~"B C f}"0E E f~"J  K f~"FG tG f}"I I f}"j!F NF f}"D DD f}"|H H f}"5B bB f}"OJ |J f}"G G f}"ʷC C f~"KF F f}"I VI f~"J7? ? f"Lf"K@Lf~"ufmt.(*pp).printValueL j p9value"Kverb "depth("Lf}"KLkeys|"` c ix"key|"KYg  nsop{"mbs{"ns|"Jmb|"Jr~r0("Jtesting.BenchmarkResult.MemString@  r~r0("Jtesting.benchmarkName  nameJn"~r2"Jtesting.runBenchmarks  maxprocs}"main~"ctx~"bs~"AimportPathJmatchString"benchmarks"A~r30"+ \ procs}"  Benchmark"@`matched}"+`benchName~"J`l}"testing.(*benchContext).processBench  ctxb"Ү  procsz"iz"arz"results{"JbenchName{"JPapz"testing.(*B).Run ' partial"+ok"+sub"benchNameP"Jbname"Jf"~r2 "+testing.(*B).add0 " rh"bother"testing.(*B).trimOutput0  banlCount~"j"testing.mustBeNil  err testing.coverReport  county"ʷtotaly"activey"fz"*errz" anamez"Jcounts|"bblocks}"(2Pbiy"bstmtsy"berrz" testing.runExamples  eg"LmatchStringexamples"ran "+ok!"+0cmatched}"+err~" testing.sortLines  linesX"aoutputJ~r1"Jtesting.runExample  w}"*stdout~"*r~"*outC~"Nerr~" start"egLok0"+testing.newMatcher  filter~"amatchStringpatterns"Jname"J~r3("pci|"s}"J k i|"s}"Jcerr}" testing.(*matcher).fullName S elem@"amc"subname"Jname "Jok0"+partial1"+ci~"s"J@dok~"+testing.splitRegexp` b cs~"cp~"a@"asJ~r1"adi~"testing.(*matcher).uniquep  empty}"+name~"Jmparent"Jsubname"J~r2("Jdexists}"+next}"testing.rewrite  b"sJ~r1"Jer~"Pes~"Jtesting.isSpace  r~r1"+testing.(*common).frameSkip  more}"+n}"frames~"8&pc~"frame~"~'cskip"~r1"ei}"eok}"+testing.(*common).decorateok}"+skip}"line}"buf}"file~"Jlines"acs"J~r1"J0findex}"fl}"Ji}"line~"Jtesting.(*common).flushToParent p`"cformat"Jargs"Ntesting.indenter.Write wb"n "err(" fend~"testing.fmtDuration d~r1"Jtesting.(*common).Name Rc~r0"Jtesting.(*common).setRan`ctesting.(*common).Fail ctesting.(*common).Failed.failedg"+c~r0"+testing.(*common).log0kcs"Jtesting.(*common).Errorfp"cformat"Jargs"Ntesting.(*common).Skipped0c~r0"+testing.callerNamen~"frames~"8&pc~"$frame~"~'skip~r1"Jtesting.tRunnergtfn"testing.(*T).Runpdok~"+testName"Jtname"Jf"~r2 "+ groot~"testing.newTestContextp maxParallelm"~r2"(testing.(*testContext).waitParallel !c(testing.(*testContext).release!"c(testing.MainStart"'$depsNtests"Vbenchmarks("Aexamples"~r4"dtesting.(*M).Run0$,testRan|"+testOk|"+exampleRan|"+exampleOk|"+md~r0"testing.(*T).report,3format|"Jdstr|"Jttesting.listTests3M<matchStringtests"Vbenchmarks "Aexamples8"`gerr{" 57test|"gokz"+79bench}"gokz"+9<example"L hokz"+testing.runTestsP<@matchStringtests"Vran "+ok!"+<@procs~"`ht~"ctx"(testing.(*M).before@ImdTADf|"*err}" PCDerr}" ErHf|"*err}" GrHerr}" testing.(*M).afterIBXmdhfz"*err{" hfz"*err{"  ifz"*err{" testing.toOutputDirPXl[pathJ~r1"Jtesting.startAlarmp[\testing.stopAlarm\e\testing.parseCpuListp\)b\`val~"J`icpu}"err~" _`i}"abi}"testing.(*B).run1.func1.10bbbtesting.(*B).run1.func1bcbtesting.(*B).run.func1 c-fb~"testing.(*B).launch.func10ffbtesting.runBenchmarks.func1fg&bs"bfgBenchmark"testing.coverReport.func1g.hf*testing.runExample.func10hj&buf"err" r*outC"Ntesting.runExample.func2jmvwantz"Joutz"Jgot{"Jfail{"Jerr{"udstr{"Jstartw"*stdout "*outC("Neg0"L&ok"4testing.tRunner.func1pvV{err"utwx>ysub~"testing.runTests.func1.1`{{ttesting.runTests.func1{ }&tests"5t{|test"testing.startAlarm.func1}~testing.init~testing.(*T).Name C.this~r0"Jtesting.(*B).NamePs.this~r0"Jtesting.(testDeps).MatchString-fmrcvrP"Na0Ja1"Jr0 "+r1(" testing.(*BenchmarkResult).StringZ.this~r0"Jtype..hash.testing.CoverBlock`pSh"~r2"type..eq.testing.CoverBlockpSq"S~r2"+testing.(*indenter).Write.thismb"n "err(" type..hash.[4]interface {}iX"ph"~r2"type..eq.[4]interface {}i"pq"~r2"+type..hash.[7]interface {}niX"ph"~r2"type..eq.[7]interface {}pui"pq"~r2"+type..hash.struct { F uintptr; R testing.testDeps }ph"~r2"type..eq.struct { F uintptr; R testing.testDeps }ђpq"~r2"+regexp/syntax.patchList.next\ih";lp"H5~r1"regexp/syntax.patchList.patch`lp"H5val"ʷiih";regexp/syntax.patchList.appendlastd"ih";l1p"H5l2"~r2"jnext`"regexp/syntax.Compile fX"ch";re~r1"H5~r2" regexp/syntax.(*compiler).init cregexp/syntax.(*compiler).compilecre"~r1"@jf|"jj|"jf1|"ksub|"ket|"bra|"!Xf|"2i|"sub~"XΥf|"lsub~"regexp/syntax.(*compiler).inst  f"cop"g6~r1"regexp/syntax.(*compiler).nopfh"c~r0"regexp/syntax.(*compiler).failc~r0"regexp/syntax.(*compiler).capfh"carg"ʷ~r1"regexp/syntax.(*compiler).catqcf1"f2"~r2"regexp/syntax.(*compiler).altf`"ih";cf1"f2"~r2"regexp/syntax.(*compiler).questӬf`"ih";cf1"nongreedy"+~r2"regexp/syntax.(*compiler).starf`"ih";cf1"nongreedy"+~r2"regexp/syntax.(*compiler).pluscf1"nongreedy"+~r2"regexp/syntax.(*compiler).empty=fh"cop"7~r1"regexp/syntax.(*compiler).rune@²f"ih";cr"flags "~r2("regexp/syntax.(*Error).Errorвe~r0"Jregexp/syntax.ErrorCode.StringeA~r0"Jregexp/syntax.(*parser).newRegexp 'reh"pwop"x~r1"regexp/syntax.(*parser).reuse0ϵpwre"regexp/syntax.(*parser).pushе˼pwre"~r1"regexp/syntax.(*parser).maybeConcatмn~"re2"re1"pwr"flags "~r2"+regexp/syntax.(*parser).newLiteralreP"pwr"flags "~r2"regexp/syntax.minFoldRune r0h"minl"r~r1"regexp/syntax.(*parser).literalepwr"regexp/syntax.(*parser).oppre`"pwop"x~r1"regexp/syntax.(*parser).repeatgflags}"n}"sub~"re~"pwop"xmin"max"before "Jafter0"JlastRepeat"J~r6"J~r7" regexp/syntax.repeatIsValidp]ren"~r2"+Pkm"j+sub@"regexp/syntax.(*parser).concat`i"subsX"pw~r0"regexp/syntax.(*parser).alternateei"subsX"pw~r0"regexp/syntax.cleanAltpreregexp/syntax.(*parser).collapse)re~"pwsubs"op "x~r2("ksub~"kold~"regexp/syntax.(*parser).factor0strflagsy"starty"first|"str}"out}"pwsub"~r1 " liz"`liflagsy"istr}"lsamey"msuffix|"re|"prefix|"`mjy"miz"mifirst|"@nsuffix|"re|"prefix|"njy"nreusey"+ oiz"`omaxy"ojy"ojy"0piz"regexp/syntax.(*parser).leadingStringpwre"~r1"~r2("regexp/syntax.(*parser).removeLeadingStringpwre"n"~r2"ppsub"pold"regexp/syntax.(*parser).leadingRegexppwre"~r1"psubh"regexp/syntax.(*parser).removeLeadingRegexppwre"reuse"+~r2"0qoldH"regexp/syntax.literalRegexp re"sJflags"~r2"pqc~"regexp/syntax.Parse ]-opx"xcx"nx"&pz"wtz"JlastRepeat{"Jerr{" sJflags"~r2"~r3 "   err{" qrepeatz"Jrbefore{"Jafter|"J`rokx"+minx"maxx"before{"Jafter|"Jrrey"slit{"J@six"!"cx"restz"Jerr{" ~restz"Jerr{" r~" restz"Jr~"regexp/syntax.(*parser).parseRepeat`-O1ok1"+pws"Jmin"max "rest("Jok8"+regexp/syntax.(*parser).parsePerlFlagsP1+<sawFlag}"+flags}"c}"sign}"t~"Jpws"Jrest"Jerr(" send}"re~"name~"Jcapture~"Jregexp/syntax.isValidCaptureName0<f=nameJ~r1"+q<M=cH"regexp/syntax.(*parser).parseIntp=H@t`"Jpws"Jn"rest "Jok0"+si"regexp/syntax.isCharClassP@@re~r1"+regexp/syntax.matchRune@Brer"~r2"+ tiP"regexp/syntax.(*parser).parseVerticalBarB7Cpw~r0" regexp/syntax.mergeCharClass@CHdstsrc"regexp/syntax.(*parser).swapVerticalBarHLn"pw~r0"+`tre3H"re1`"tre2P"re1X"regexp/syntax.(*parser).parseRightParenLQn"re2"re1"pw~r0" regexp/syntax.(*parser).parseEscapeQv_c}"t~"Jpws"Jr"rest "Jerr0" ti}"HZ=_y}"x}"[]nhex}"0uv}"regexp/syntax.(*parser).parseClassChar_cpws"JwholeClass"Jr("rest0"Jerr" regexp/syntax.(*parser).parsePerlClassEscapecafgP"_pws"Jr"out0"rest"Jregexp/syntax.(*parser).parseNamedClasspfki~"name~"JgP"_pws"Jr"out0"rest"Jerr" regexp/syntax.(*parser).appendGroupkopwr"g "_~r2"putmpX"regexp/syntax.unicodeTable oDqnameJ~r1"P~r2"Po~pth"P~pqt`"Pregexp/syntax.(*parser).parseUnicodeClassPq`~c}"sign}"tab~"Pfold~"Pt~"Jseq~"Jname~"Jpws"Jr"out0"rest"Jerr" uend}"vtmpX"regexp/syntax.(*parser).parseClass`~firstz"+signz"re{"t{"Jclass~"pws"Jrest"Jerr(" @vloz"hiz"rng|"Jnt|"Jerr|" nclass~"vsizez"Ӄnt|"Jerr|" nclass~"nt|"Jnclass~"regexp/syntax.cleanClassw~"r@"rpU~r1"vi~" wlo~"hi~"regexp/syntax.appendLiteralKrx"flags"~r3 "regexp/syntax.appendRangePkn"rlo"hi"~r3 "wi"wrlo"rhi"regexp/syntax.appendFoldedRangeprlo"hi"~r3 "Oc"7:f"regexp/syntax.appendClassrx"~r20"xiX"regexp/syntax.appendFoldedClass rx"~r20"PxiX"regexp/syntax.appendNegatedClassnextLo@"rx"~r20"xiP"xloD"hiH"regexp/syntax.appendTablerx"P~r2 "Bxr~"Q ystride~"lo~"hi~"=c~"Bmxr"+R`ystride~"lo~"hi~"էhc~"regexp/syntax.appendNegatedTableǮnextLo~"rx"P~r2 "xr~"Qystride~"lo~"hi~"ժc~"xr"+Rystride~"lo~"hi~"Ic~"regexp/syntax.negateClassЮnextLo"w"r~r1" zi@"`zlo"hi"regexp/syntax.ranges.LessвpX"rali"j"~r2"+regexp/syntax.ranges.Lenвral~r0"regexp/syntax.ranges.Swap pX"rali"j"regexp/syntax.checkUTF8~sJ~r1" zruneH"sizeP"regexp/syntax.nextRunesize"sJc"t"Jerr(" regexp/syntax.isalnumc~r1"+regexp/syntax.unhexoc~r1"regexp/syntax.InstOp.Stringpig6~r0"Jregexp/syntax.EmptyOpContextYopf"7boundaryg"r1r2"~r2"7regexp/syntax.IsWordChar`r~r1"+regexp/syntax.(*Prog).String&bX"pH5~r0"Jregexp/syntax.(*Prog).skipNopxih";pH5pc"ʷ~r1";~r2"ʷregexp/syntax.(*Inst).op̽opn"g6i;~r0"g6regexp/syntax.(*Prog).Prefixн|i";&bufX"pH5prefix"Jcomplete"+regexp/syntax.(*Prog).StartCondflaga"7pcd"ʷih";pH5~r0"7regexp/syntax.(*Inst).MatchRunei;r"~r1"+regexp/syntax.(*Inst).MatchRunePosrlo"hi"runeX"i;r"~r1"{r0"r1"@{j"{m"{c"regexp/syntax.(*Inst).Stringo&bX"i;~r0"Jregexp/syntax.bwpvbargs"a\s"Jregexp/syntax.dumpProgbp"H50|j~"p|i~";pc~"Jregexp/syntax.u32iʷ~r1"Jregexp/syntax.dumpInstJbi";regexp/syntax.(*Regexp).EqualPxy"~r1"+|r~"i~"}i~"sub~"regexp/syntax.writeRegexp$bre"r|"@}i}"}lo|"hi|"}i}"~lo|"hi|"`~sub~"Xsub~"i}"sub~"regexp/syntax.(*Regexp).String0&bX"re~r0"Jregexp/syntax.escape gbr"force "+-sP"Jregexp/syntax.(*Regexp).MaxCappm"re~r0"usub@"~n"regexp/syntax.(*Regexp).CapNamesnamesX"are~r0"aregexp/syntax.(*Regexp).capNamesrenames"a:sub@"regexp/syntax.(*Regexp).Simplify |re~r0"~nre|"@i{"sub|"nsub|"sub|"sub|"prefix|"nre|"i{"  i{"Psuffix|"  i{"nre2|"regexp/syntax.simplify1opxflags"sub"re"~r4"regexp/syntax.init:regexp/syntax.(*ErrorCode).String:O;.this~r0"Jtype..hash.regexp/syntax.ErrorP;;ph"~r2"type..eq.regexp/syntax.Error;=pq"~r2"+regexp/syntax.(*InstOp).String ==.this~r0"Jregexp/syntax.(*ranges).Less=U>.thisi"j"~r2"+regexp/syntax.(*ranges).Len`>>.this~r0"regexp/syntax.(*ranges).Swap>p?.thisi"j"type..hash.[11]stringp?@iX"p-h"~r2"type..eq.[11]string @=Ai"p-q"-~r2"+regexp.maxBitStateLen@AAprogH5~r1"regexp.newBitStateACprogH5~r1"8regexp.shouldBacktrackCICprogH5~r1"+regexp.(*bitState).resetPC~GvisitedSize~"b8end"ncap"Ѐi~"i~"regexp.(*bitState).shouldVisitG|HnH"b8pc"ʷpos"~r2"+regexp.(*bitState).pushHJb8pc"ʷpos"arg"regexp.(*machine).tryBacktrackJ|Vlongest}"+m7b"8i"ypc "ʷpos("~r40"+Ppc}"ʷpos}"l~"arg~"instH"O6RSr}"width}"r}"width}"TyUr}"width}"DTTr}"width}"regexp.(*machine).backtrackVz[startCond"7width"bh"8m7i"ypos"end "ncap("~r40"+i"aYYadvance"regexp.(*machine).newInputBytes[:\m7b"~r1 "yregexp.(*machine).newInputString@\\m7s"J~r1"yregexp.(*machine).newInputReader\]m7r"M<~r1"yregexp.progMachine]bncap}"n}"m~"7pH5op"6~r2"7regexp.(*machine).initbcm7ncap" t@":regexp.(*machine).alloccetP":m7i";~r1":`n"regexp.(*machine).matchemstartCond~"7flag~"7r1~"r~"width1~"width~"runqH"nextqP"m7i"ypos"~r2 "+i~"gijadvance~"regexp.(*machine).clearmom7q"mod":regexp.(*machine).stepozlongest}"+m7runq"nextq"pos"nextPos "c("nextCond,"7j}" add}"+t~":i~";d~"d~":regexp.(*machine).add zxj~"i";d"m7q"pc"ʷpos"cap "1cond8"7t":~r6":j~"ʷopos~"regexp.(*machine).onepassGstartCond~"7flag~"7r1~"r~"width1~"width~"pc~"inst"o7m7i"ypos"ncap "~r3("+Pi~"regexp.(*Regexp).doMatchPnre3r"M<b"s0"J~r3"+regexp.(*Regexp).doExecutepsize"m"7i"yre3r"M<b"s0"Jpos"ncap"dstCap"1~r6"1regexp.onePassPrefixNi@";&bufX"pH5prefix"Jcomplete"+pc"ʷregexp.onePassNextPnexth"i.r"~r2"ʷregexp.iop lopn"g6i;~r1"g6regexp.(*queueOnePass).emptypqH~r0"+regexp.(*queueOnePass).nextqHn"ʷregexp.(*queueOnePass).clear-qHregexp.(*queueOnePass).contains0qHu"ʷ~r1"+regexp.(*queueOnePass).insertmqHu"ʷregexp.(*queueOnePass).insertNewp#qHu"ʷregexp.newQueue0sizeq"Hregexp.mergeRuneSetsȤok~"+rightLen~"leftLen~"ix~"extend"&rx"2&lx"2next"merged"leftRunesUrightRunes"UleftPC"ʷrightPC"ʷ~r4"~r50"regexp.cleanupOnePassФprog6original"H5ix~"instOriginal~"O6regexp.onePassCopy p}"6progH5~r1"6Єi|"inst}"O6pc|"Ppatch|"+p_B_Other|"p_B_Alt|"p_A_Other|"p_A_Alt}"instOther~"o7instAlt~"o7regexp.runeSlice.Len?p_~r0"regexp.runeSlice.Less@p_i"j "~r2("+regexp.runeSlice.Swap5p_i"j "regexp.makeOnePass@visitQueue~"HinstQueue~"Hcheck~"onePassRunes"֗m".p6~r1"6pc~"ʷi~"regexp.compileOnePassprogH5p"60inst"O6popOut~"g6regexp.(*Regexp).String;re3~r0"Jregexp.Compile@;exprJ~r1"3~r2" regexp.compile@maxCap~"regexp~"3re~"prog~"H5err~" capNames@"aexprJmode"longest"+~r3"3~r4 " regexp.(*Regexp).getzX"7re3~r0"7nH"z`"7regexp.(*Regexp).putre3z"7regexp.(*inputString).step`ipos"~r1"~r2"@c"regexp.(*inputString).canCheckPrefix`ki~r0"+regexp.(*inputString).hasPrefixpire"3~r1"+regexp.(*inputString).indexire"3pos"~r2"regexp.(*inputString).contextr2"r1"ipos"~r1"7regexp.(*inputBytes).stepGipos"~r1"~r2"c"regexp.(*inputBytes).canCheckPrefixP[i~r0"+regexp.(*inputBytes).hasPrefix` ire"3~r1"+regexp.(*inputBytes).indexire"3pos"~r2"regexp.(*inputBytes).context7r2"r1"ipos"~r1"7regexp.(*inputReader).step@r"w"errP" ipos"~r1"~r2"regexp.(*inputReader).canCheckPrefixi~r0"+regexp.(*inputReader).hasPrefixire"3~r1"+regexp.(*inputReader).indexire"3pos"~r2"regexp.(*inputReader).contextipos"~r1"7regexp.(*Regexp).MatchString re3s"J~r1"+regexp.init.0b"regexp.mergeRuneSets.func1&ok4&merged"U&next"`regexp.mergeRuneSets.func2&nextX"`&merged`"U&ixh"2newLow2newArray"Upc"ʷ~r3"+regexp.makeOnePass.func17visitQueuey"HinstQueuey"Hinsty".&pz"&onePassRunesz"h&checkz"pcʷm".ok "+matchOutv"+matchArgv"+`iv"iv"runesz"0r0v"r1v"iv"runesz"r0v" r1v"`iv"iv"regexp.init@regexp.(*onePassInst).String.this.~r1"Jtype..hash.regexp.jobpSh"~r2"type..eq.regexp.jobpSq"S~r2"+type..hash.regexp.entryph"~r2"type..eq.regexp.entrypq"~r2"+type..hash.regexp.inputReaderph"~r2"type..eq.regexp.inputReaderpq"~r2"+regexp.(*runeSlice).LenI.this~r0"regexp.(*runeSlice).LessP.thisi"j"~r2"+regexp.(*runeSlice).Swap.thisi"j"encoding/binary.littleEndian.Uint16b~r1"encoding/binary.littleEndian.PutUint16}bv"encoding/binary.littleEndian.Uint32,b~r1"ʷencoding/binary.littleEndian.PutUint320bv"ʷencoding/binary.littleEndian.Uint643b~r1"Kencoding/binary.littleEndian.PutUint64@bv"Kencoding/binary.littleEndian.String~r0Jencoding/binary.littleEndian.GoString~r0Jencoding/binary.bigEndian.Uint16ob~r1"encoding/binary.bigEndian.PutUint16pbv"encoding/binary.bigEndian.Uint32b~r1"ʷencoding/binary.bigEndian.PutUint32Cbv"ʷencoding/binary.bigEndian.Uint64P b~r1"Kencoding/binary.bigEndian.PutUint64  bv"Kencoding/binary.bigEndian.String ( ~r0Jencoding/binary.bigEndian.GoString0 X ~r0Jencoding/binary.init` 3 encoding/binary.(*bigEndian).Uint16@  .thisb"~r1 "encoding/binary.(*bigEndian).PutUint16 l .thisb"v "encoding/binary.(*bigEndian).Uint32p  .thisb"~r1 "ʷencoding/binary.(*bigEndian).PutUint32.thisb"v "ʷencoding/binary.(*bigEndian).Uint64=.thisb"~r1 "Kencoding/binary.(*bigEndian).PutUint64@.thisb"v "Kencoding/binary.(*bigEndian).Stringg.this~r0"Jencoding/binary.(*bigEndian).GoStringp.this~r0"Jencoding/binary.(*littleEndian).Uint16.thisb"~r1 "encoding/binary.(*littleEndian).PutUint16<.thisb"v "encoding/binary.(*littleEndian).Uint32@.thisb"~r1 "ʷencoding/binary.(*littleEndian).PutUint32j.thisb"v "ʷencoding/binary.(*littleEndian).Uint64p .thisb"~r1 "Kencoding/binary.(*littleEndian).PutUint64.thisb"v "Kencoding/binary.(*littleEndian).String7.this~r0"Jencoding/binary.(*littleEndian).GoString@.this~r0"Jcontext.(*emptyCtx).Stringe_~r0"Jcontext.init.0context.initbufio.NewWriterSizeok"+b@"wwsize"~r2"wbufio.NewWriterGw~r1"wbufio.(*Writer).FlushP n~"err~" bw~r0" bufio.(*Writer).Available c bw~r0"bufio.(*Writer).Bufferedp  bw~r0"bufio.(*Writer).Write &n}"bwp"nn "err(" n}"bufio.(*Writer).WriteString &r*nn}"n~"bws"J~r1"~r2 " 0n~"bufio.(*Writer).ReadFrom*/m~"bwr"n"err " *|,ok~"+w~"Knr~",-err1" bufio.init0 4text/tabwriter.(*Writer).addLine45btext/tabwriter.(*Writer).reset56btext/tabwriter.(*Writer).Init6B8boutput"minwidth"tabwidth "padding("padchar0"flags8"~r6"ЋiP"text/tabwriter.(*Writer).write0P89n"err@" bbuf"text/tabwriter.(*Writer).writeN9:bsrc"n "text/tabwriter.(*Writer).writePadding:<btextw"cellw"useTabs"+nP"text/tabwriter.(*Writer).writeLines<Dbpos0"line0"line1"pos "Pi}"useTabs|"+line~"j}"c}"8text/tabwriter.(*Writer).formatDJcolumn~"bpos0"line0"line1"pos " this~"`lineX"discardable~"+width~"c"8Pw~"text/tabwriter.(*Writer).appendJJbtext"text/tabwriter.(*Writer).updateWidthJ(Lbtext/tabwriter.(*Writer).startEscape0LLbch"text/tabwriter.(*Writer).endEscapeLMbtext/tabwriter.(*Writer).terminateCellMOlineX"Cbhtab"+~r1"text/tabwriter.handlePanicOQerrop"Je@"u.PPok"+nerr"text/tabwriter.(*Writer).FlushQ Rb~r0" text/tabwriter.(*Writer).flushRSberr" text/tabwriter.(*Writer).WriteSW[bbuf"n "err(" Ўch~"i~"ncells~"`j~"text/tabwriter.NewWriter`['\outputminwidth"tabwidth"padding "padchar("flags0"~r68"text/tabwriter.init0\\type..hash.text/tabwriter.cell\]ph"~r2"type..eq.text/tabwriter.cell]{]pq"~r2"+math/bits.Reverse16]]x~r1"compress/flate.(*compressor).fillDeflate]en|"db"~r1 "delta|"v|"ʷi|"0v|"ʷi|"compress/flate.(*compressor).writeBlockefdtokens" index "~r2(" pwindowX"compress/flate.(*compressor).fillWindowfln}"loops}"db"j}"newH}"ʷindex}"end~"dstSize~"toCheck~"dst"jkval}"ʷi}"Kkkdi~"hh~"compress/flate.(*compressor).findMatchlSqwEnd~"tries~"nice~"minMatchLook~"minIndex~"win"wPos@"dpos"prevHead"prevLength"lookahead "length("offset0"ok8"+Pi"n~"compress/flate.(*compressor).writeStoredBlock`qurdbuf"~r1 " compress/flate.hash4rsb~r1"ʷcompress/flate.bulkHash4 sthbD"ʷendP"bdst"iH"compress/flate.matchLentuab"max0"~r38"@av"i"compress/flate.(*compressor).encSpeedv|dcompress/flate.(*compressor).initDeflate|~dcompress/flate.(*compressor).deflate~dprevOffset{"prevLength{"minIndex|"lookahead|"hh}"0ok{"+newOffset{"newLength{"pnewIndex{"hh}"i|"compress/flate.(*compressor).fillStore'n"db"~r1 "compress/flate.(*compressor).store0dcompress/flate.(*compressor).storeHuffdcompress/flate.(*compressor).write -db"n "err(" compress/flate.(*compressor).init0dw"level"err " compress/flate.(*compressor).reset٥dw"`i"i@"compress/flate.(*compressor).closeld~r0" compress/flate.NewWriterp&dwX"wlevel"~r2"~r3 " Verr`" compress/flate.(*dictWriter).Writewb"n "err(" compress/flate.(*Writer).WriteŪwdata"n "err(" compress/flate.(*Writer).CloseЪ>w~r0" compress/flate.(*Writer).Reset@wdst"okN"+dwP"compress/flate.load32ѭbi"~r2 "ʷcompress/flate.load64bi"~r2 "Kcompress/flate.hashuʷ~r1"ʷcompress/flate.newDeflateFast~r0r compress/flate.(*deflateFast).encodesLimit}"s}"nextHash}"ʷnextEmit}"cv}"ʷer dst" src "~r28"  skip}"nextS}"candidate~"q offset}"now}"ʷbytesBetweenHashLookups}"Еt}"prevHash}"ʷoffset}"l}"currHash}"ʷx~"Kcompress/flate.emitLiteral<dst lit"~r20" ػv"compress/flate.(*deflateFast).matchLen@tp}"n}"s1}"b"aX"er s"t "src"~r3(" b"a@"`i~"i}"i}"compress/flate.(*deflateFast).reset}er compress/flate.(*deflateFast).resetAll#er  iX"compress/flate.newHuffmanBitWriter0w~r1" compress/flate.(*huffmanBitWriter).reset)w writer"compress/flate.(*huffmanBitWriter).flush0n"w compress/flate.(*huffmanBitWriter).writew b"compress/flate.(*huffmanBitWriter).writeBitsnw b"nb"`n"bits"Kbytes@"compress/flate.(*huffmanBitWriter).writeBytespn"w bytes"compress/flate.(*huffmanBitWriter).generateCodegen"size}"outIndex}"count~"codegen@"cgnlX"w numLiterals"numOffsets"litEnc"}aoffEnc "}ai}"i}"0i}"pinIndex}"nextSize}"n}"`n}"compress/flate.(*huffmanBitWriter).dynamicSize0{header"w litEnc"}aoffEnc"}aextraBits"size "numCodegens("compress/flate.(*huffmanBitWriter).fixedSize^w extraBits"~r1"compress/flate.(*huffmanBitWriter).storedSize`w in"~r1 "~r2("+compress/flate.(*huffmanBitWriter).writeCodew c"bn"bits"Kbytes@"compress/flate.(*huffmanBitWriter).writeDynamicHeaderfirstBits"i"w numLiterals"numOffsets"numCodegens"isEof "+i"@value"codeWord"compress/flate.(*huffmanBitWriter).writeStoredHeaderxflagl"w length"isEof"+compress/flate.(*huffmanBitWriter).writeFixedHeadervaluel"w isEof"+compress/flate.(*huffmanBitWriter).writeBlock{storable~"+storedSize~"size~"numOffsets~"numLiterals~"numCodegens~"extraBits~"dynamicSize~"offsetEncoding"}aliteralEncoding"}aw tokens" eof "+input("lengthCode~"0offsetCode~"compress/flate.(*huffmanBitWriter).writeBlockDynamic^size~"numOffsets~"numLiterals~"numCodegens~"w tokens" eof "+input("pstorable~"+ssize~"compress/flate.(*huffmanBitWriter).indexTokens`w tokens" numLiterals "numOffsets("i~"i~"0t}"poffset~"ʷlength~"ʷcompress/flate.(*huffmanBitWriter).writeTokensw tokens" leCodes "7boeCodes8"7bМt"offsetCode"ʷoffset"ʷlengthCode"ʷlength"ʷextraOffsetBits"extraLengthBits"pextraLength"extraOffset"compress/flate.init.0 wh" compress/flate.(*huffmanBitWriter).writeBlockHuff size}"numCodegens}"n}"encoding~"7bw eof"+input"i}"0storable}"+ssize}"pt}"c}"bbits}"Kbytes"compress/flate.histogram bh"t"compress/flate.(*hcode).set  h`code"length "compress/flate.maxNode $ ~r0Yccompress/flate.newHuffmanEncoder0 _ size~r1"}acompress/flate.generateFixedLiteralEncoding` ' chD"hP"}acodesX"7b~r0}aPsizeB"bitsF"compress/flate.generateFixedOffsetEncoding0 QhP"}acodesX"7b~r0}ach"compress/flate.(*huffmanEncoder).bitLength`ytotal"h}afreq"~r1 "f"i"compress/flate.(*huffmanEncoder).bitCountsns"levels"bitss"levelst"zleafCountsv"]counts~"|bitCount~"h}alist"bmaxBits "~r2(" levels"`prevFreqs"l~"Рns" levels"compress/flate.(*huffmanEncoder).assignEncodingAndSizecode~"h}abitCount"list "b`bits~"n~"chunk"bnode~"Yccompress/flate.(*huffmanEncoder).generate"count~"list~"bbitCount"h}afreq"maxBits "0f}"i~"pnode}"Yci~"compress/flate.(*byLiteral).sort"?#sa"bcompress/flate.byLiteral.Len@#o#sc~r0"compress/flate.byLiteral.Lessp##sci"j "~r2("+compress/flate.byLiteral.Swap#$sci"j "compress/flate.(*byFreq).sort$?%sa"bcompress/flate.byFreq.Len@%o%s@d~r0"compress/flate.byFreq.Lessp%&s@di"j "~r2("+compress/flate.byFreq.Swap&T's@di"j "compress/flate.reverseBits`''numberbitLength"~r2"compress/flate.InternalError.Error'](eBa~r0"Jcompress/flate.literalToken`(q(literalʷ~r1"compress/flate.matchToken((xlengthʷxoffset"ʷ~r2"compress/flate.token.literal((t~r0"ʷcompress/flate.token.offset((t~r0"ʷcompress/flate.token.length((t~r0"ʷcompress/flate.lengthCode)@)lenʷ~r1"ʷcompress/flate.offsetCode@)*offʷ~r1"ʷcompress/flate.init*+compress/flate.(*byLiteral).Len++.this~r0"compress/flate.(*byLiteral).Less+Z,.thisi"j"~r2"+compress/flate.(*byLiteral).Swap`,,.thisi"j"compress/flate.(*byFreq).Len--.this~r0"compress/flate.(*byFreq).Less-J..thisi"j"~r2"+compress/flate.(*byFreq).SwapP...thisi"j"compress/flate.(*InternalError).Error./.this~r0"Jtype..hash.compress/flate.literalNode/=0ph"~r2"type..eq.compress/flate.literalNode@0}0pq"~r2"+hash.init00hash/crc32.ieeeInit01hash/crc32.Update1O3crcʷtab"_p"~r3("ʷhash/crc32.archAvailableIEEEP3r3~r0+hash/crc32.archInitIEEE3.4hash/crc32.archUpdateIEEE04o6crcʷp"~r2 "ʷleft"do"hash/crc32.simpleMakeTablep66th"_polyʷ~r1"_hash/crc32.simplePopulateTable67polyʷt"_iX"0crcH"ʷ#7z7jP"hash/crc32.simpleUpdate78crcʷtab"_p"~r3("ʷ78v"hash/crc32.slicingMakeTable8:th"epolyʷ~r1"epiP"crcD"ʷjH"hash/crc32.slicingUpdate:=crcʷtab"ep"~r3("ʷhash/crc32.ieeeInit.func1 ==crcʷp"~r2 "ʷhash/crc32.init=Z>hash/crc32.ieeeCLMUL`>@compress/gzip.NewWriterLevel @TBz")wlevel"~r2")~r3 " compress/gzip.(*Writer).init`BCcompressor~"z)w"level"compress/gzip.(*Writer).writeBytesCqFerr" z)b"~r1 " compress/gzip.(*Writer).writeStringFKneedconv~"+z)s"Jerr" FHv~"HEJb@"tHIv~"compress/gzip.(*Writer).WriteKgVn~"z)p"~r1 "~r2(" compress/gzip.(*Writer).ClosepVZz)~r0" compress/gzip.initZ[path/filepath.init[]io/ioutil.readAll ]^buf"rcapacity"b"err0" io/ioutil.ReadFile^bn~"f~"*err~" filenameJ~r1"~r2(" 0fi~" err~" psize~"io/ioutil.readAll.func1cdeP"u&errok"+panicErr@" io/ioutil.initderuntime/pprof.elfBuildID ee{shoffy"shnumy"shentsizey"fz"*errz" byteOrderz"buf{"fileJ~r1"J~r2 " errz" @iy"sizey"offy"errz"  typx"ʷ`noteTypey"nameSizey"descSizey"descOffy"errz" errz" runtime/pprof.(*profMap).lookupp{-h}"last~"e~"mstk"*tag "߶~r2("{|x}"K0e~"pj}"j}"runtime/pprof.lockProfiles0runtime/pprof.unlockProfilesމruntime/pprof.LookupnameJ~r1"Gruntime/pprof.(*Profile).NameˊpG~r0"Jruntime/pprof.(*Profile).WriteToЊqall~"ppGw"debug"~r2 " 8ԍstk~"5runtime/pprof.stackProfile.LenxP~r0"runtime/pprof.stackProfile.StackxPi"~r1 "5runtime/pprof.stackProfile.Swap qxPi"j "runtime/pprof.stackProfile.Lessu"5t@"5xPi"j "~r2("+k~"runtime/pprof.printCountProfileʤny"keyz"oindexz"`<countz"`<bz" &buf{"values}"locs}"*keys}"awdebug"name"Jp("~r48" K iy"@k{"J@twz"Ϟk|"Jk{"Jaddry"ly"Kruntime/pprof.(*keysByCount).LenФx~r0"runtime/pprof.(*keysByCount).Swappxi"j"runtime/pprof.(*keysByCount).Lesspecj"ci"kj@"JkiP"Jxi"j"~r2"+runtime/pprof.printStackRecordp show|"+frames|"8wstk"5allFrames("+more|"+name|"Jframe~"~'runtime/pprof.WriteHeapProfile w~r1" runtime/pprof.countHeapn`"~r0runtime/pprof.writeHeap ok"+n"totalн"܅twm"sm",bm"wpw" wdebug"~r2" pi"rm"<i"0rm"<"pc"runtime/pprof.countThreadCreate n`"~r0runtime/pprof.writeThreadCreate>wdebug"~r2" runtime/pprof.countGoroutine@~r0runtime/pprof.writeGoroutinewdebug"~r2" runtime/pprof.writeGoroutineStackserr" bufX"w~r1" i"n"runtime/pprof.writeRuntimeProfileok"+n"p@"=wdebug"name"Jfetch("~r40" runtime/pprof.runtimeProfile.Lenp~r0"runtime/pprof.runtimeProfile.Stackjpi"~r1 "5runtime/pprof.StartCPUProfilep3w~r1" runtime/pprof.profileWriter@tb~" err~" weof~"+tags"ddata"*Pe~" runtime/pprof.StopCPUProfileOruntime/pprof.countBlockPn`"~r0runtime/pprof.countMutex/n`"~r0runtime/pprof.writeBlock0^ok{"+n{"tw|"b|"wp}"Ywdebug"~r2" i{"Ыr|" pc{"runtime/pprof.writeMutex`okz"+nz"tw{"b{"wp}"Ywdebug"~r2"  iz"`r{"`dpcz"runtime/pprof.lostProfileEventruntime/pprof.funcPC fu~r1"runtime/pprof.(*profileBuilder).stringIndex  ok"+id"b s"J~r1"runtime/pprof.(*profileBuilder).flush k b runtime/pprof.(*profileBuilder).pbValueTypep  startX"b tag"typ"Junit "Jruntime/pprof.(*profileBuilder).pbSample  starth"b values"locs "*labels8"sruntime/pprof.(*profileBuilder).pbLabel startX"b tag"key"Jstr "Jnum0"runtime/pprof.(*profileBuilder).pbLine starth"b tag"funcID"Kline"runtime/pprof.(*profileBuilder).pbMappingstartX"b tag"id"Kbase"Klimit "Koffset("Kfile0"JbuildID"Jruntime/pprof.(*profileBuilder).locForPC@!morex"+startx"idx"Kframesy"8newFuncsz" frame{"~'b addr"~r1"KfuncIDy"Kiy" fnz"ostartx"runtime/pprof.newProfileBuilder@!%zw~")b~" w~r1" runtime/pprof.(*profileBuilder).addCPUData&-b data"*tags "d~r28" Pcount~"Ktag~"߶stkX"*runtime/pprof.(*profileBuilder).build-M6e~"values~"locs~"*b ~r0" labels~"s2R4i}"addr}"l}"Kruntime/pprof.(*profileBuilder).readMappingP67data@"b runtime/pprof.parseProcSelfMaps7W@next}"#line~"dataaddMapping"!#@offset|"Klo|"Ki|"hi|"Kfile}"Jerr}" buildID}"Jperm~"inode~"addr~"runtime/pprof.(*profileBuilder).addMapping`@fBb lo"Khi"Koffset"Kfile "JbuildID0"Jruntime/pprof.(*protobuf).varintpBmDb!x"Kruntime/pprof.(*protobuf).lengthpDDb!tag"len"runtime/pprof.(*protobuf).uint64DBEb!tag"x"Kruntime/pprof.(*protobuf).uint64sPENLb!tag"x"*n3|"n2|"n1|"EFu{"KRKLu{"Kruntime/pprof.(*protobuf).uint64OptPLLb!tag"x"Kruntime/pprof.(*protobuf).int64LMuh"Kb!tag"x"runtime/pprof.(*protobuf).int64Opt MMb!tag"x"runtime/pprof.(*protobuf).int64sMTb!tag"x"n3|"n2|"n1|"MNu{"S_Tu{"runtime/pprof.(*protobuf).stringT^Vb!tag"x"Jruntime/pprof.(*protobuf).strings`VbWb!tag"x"aVNWs"Jruntime/pprof.(*protobuf).startMessagepWWb!~r0"runtime/pprof.(*protobuf).endMessageW\n3|"n2|"n1}"b!tag"start"runtime/pprof.writeHeapProto]NfblockSizex"b~" values~"locs~"*wp" rate("~r30"  ry"܅`hideRuntimex"+triesx"d`qbaddrx"lx"K@f~"'runtime/pprof.scaleHeapSamplePfgscaleX"avgSize`"countsize"rate"~r3"~r4 "runtime/pprof.printCountProfile.func1gj&buf"stk5~r1"JlhFjpc~"runtime/pprof.writeHeap.func1jik&ph"L%ij"~r2"+runtime/pprof.writeBlock.func1pkk&ph"n%ij"~r2"+runtime/pprof.writeMutex.func1kpl&ph"n%ij"~r2"+runtime/pprof.(*profileBuilder).locForPC.func1plladdr`"bh" i~r1"+runtime/pprof.(*profileBuilder).build.func1lZnb~" &e~"!m@nv~"Jk~"Jruntime/pprof.parseProcSelfMaps.func1`nqj"&line"f@"~r0n~ofX"runtime/pprof.writeHeapProto.func1 qqblockSize`"bh" runtime/pprof.initq/sruntime/pprof.(*profileBuilder).(runtime/pprof.addMapping)-fm0ssrcvrh" a0Ka1"Ka2"Ka3"Ja4("Jtype..hash.runtime/pprof.newFunc·1sztp h"~r2"type..eq.runtime/pprof.newFunc·1tup q" ~r2"+runtime/pprof.(*runtimeProfile).Lenuv.thisV(~r0"runtime/pprof.(*runtimeProfile).Stackvxw.thisV(i"~r1"5runtime/pprof.(*stackProfile).Lenwx.thisz(~r0"runtime/pprof.(*stackProfile).Stack xy.thisz(i"~r1"5runtime/pprof.(*stackProfile).Swapyy.thisz(i"j"runtime/pprof.(*stackProfile).LessyZz.thisz(i"j"~r2"+type..hash.[5]interface {}`z{iX"ph"~r2"type..eq.[5]interface {}{|i"pq"~r2"+type..hash.[8]runtime/pprof.newFunc·1 ||iX"p(h"~r2"type..eq.[8]runtime/pprof.newFunc·1|~i"p(q"(~r2"+type..hash.struct { sync.Mutex; runtime/pprof.profiling bool; runtime/pprof.done chan bool }p(h"~r2"type..eq.struct { sync.Mutex; runtime/pprof.profiling bool; runtime/pprof.done chan bool }p(q"(~r2"+testing/internal/testdeps.TestDeps.MatchString 6patJstr"Jresult "+err(" testing/internal/testdeps.TestDeps.StartCPUProfile@w~r1" testing/internal/testdeps.TestDeps.StopCPUProfiletesting/internal/testdeps.TestDeps.WriteHeapProfilefw~r1" testing/internal/testdeps.TestDeps.WriteProfileTop*nameJw"debug "~r3(" testing/internal/testdeps.TestDeps.ImportPath0[~r0Jtesting/internal/testdeps.init`҄testing/internal/testdeps.(*TestDeps).MatchString.this)pat"Jstr"Jresult("+err0" testing/internal/testdeps.(*TestDeps).StartCPUProfile ҆.this)w"~r1" testing/internal/testdeps.(*TestDeps).StopCPUProfileB.this)testing/internal/testdeps.(*TestDeps).WriteHeapProfileP.this)w"~r1" testing/internal/testdeps.(*TestDeps).WriteProfileTo.this)name"Jw"debug("~r30" testing/internal/testdeps.(*TestDeps).ImportPath.this)~r0"Jgithub.com/go-kit/kit/metrics.NewTimerh)~r1")github.com/go-kit/kit/metrics.(*Timer).ObserveDurationmd`"t)github.com/go-kit/kit/metrics.(*Timer).Unitpt)u"github.com/go-kit/kit/metrics.inittype..hash.github.com/go-kit/kit/metrics.Timerp)h"~r2"type..eq.github.com/go-kit/kit/metrics.Timerp)q")~r2"+github.com/VividCortex/gohistogram.init(github.com/go-kit/kit/metrics/internal/lv.LabelValues.With0lvs*labelValues"a~r10"*github.com/go-kit/kit/metrics/internal/lv.init github.com/go-kit/kit/metrics/generic.NewSimpleHistogram/~r0,+github.com/go-kit/kit/metrics/generic.(*SimpleHistogram).With0h,+labelValues"a~r1 ")github.com/go-kit/kit/metrics/generic.(*SimpleHistogram).Observeih,+value"github.com/go-kit/kit/metrics/generic.(*SimpleHistogram).ApproximateMovingAverageph,+~r0"github.com/go-kit/kit/metrics/generic.initgithub.com/go-kit/kit/metrics_test.TestTimerFastHtolerance~"h~",+twant~"have~"github.com/go-kit/kit/metrics_test.TestTimerSlowPtolerance~"timer~")h",+tаwant~"have~"github.com/go-kit/kit/metrics_test.TestTimerUnittolerance~"timer~")h",+twant~"have~"github.com/go-kit/kit/metrics_test.initlmain.init.0pmain.mainؠmh"dmain.initd voidunsafe.Pointer uintptr runtime._type0size#ptrdata#hash#ʷtflag#շalign#fieldalign#kind#alg#gcdata# @str#(MptrToThis#,aruntime._type uint32 runtime.tflag uint8*runtime.typeAlgruntime.typeAlghash#Nequal#runtime.typeAlgfunc(unsafe.Pointer, uintptr) uintptr ߶  func(unsafe.Pointer, uintptr) uintptrN*uintptrfunc(unsafe.Pointer, unsafe.Pointer) bool ߶ ߶ 4func(unsafe.Pointer, unsafe.Pointer) bool bool*bool+*uint8 runtime.nameOff runtime.typeOffruntime.arraytypeHtyp#elem#0ٹslice#8ٹlen#@runtime.arraytypeu*runtime._typeruntime.chantype@typ#elem#0ٹdir#8runtime.chantyperuntime.functype8typ#inCount#0outCount#2runtime.functypeA uint16 runtime.maptypeXtyp#key#0ٹelem#8ٹbucket#@ٹhmap#Hٹkeysize#Pindirectkey#Q+valuesize#Rindirectvalue#S+bucketsize#Treflexivekey#V+needkeyupdate#W+runtime.maptyperuntime.ptrtype8typ#elem#0ٹruntime.ptrtyperuntime.slicetype8typ#elem#0ٹruntime.slicetyperuntime.structtypePtyp#pkgPath#0fields#8¼runtime.structtype3runtime.namebytes#@runtime.name[]runtime.structfield array#=hlen#cap#runtime.structfieldname#typ#ٹoffsetAnon#runtime.structfield runtime.interfacetypePtyp#pkgpath#0mhdr#8ʽruntime.interfacetypei[]runtime.imethod array#rlen#cap#runtime.imethodname#Mityp#aruntime.imethod runtime.itab(inter#_type#ٹlink#hash#ʷbad#+inhash#+unused#fun# 1runtime.itabR*runtime.interfacetype*runtime.itab׾[2]uint8 [1]uintptr stringstr#@len#struct { runtime.enabled bool; runtime.pad [3]uint8; runtime.needed bool; runtime.cgo bool; runtime.alignme uint64 }enabled#+pad#4needed#+cgo#+alignme#K[3]uint8  uint64 []testing.InternalTestarray#Hlen#cap#testing.InternalTestName#JF#testing.InternalTestfunc(*testing.T) func(*testing.T)*testing.T*testing.Tcommon#isParallel#+context#(testing.T*testing.commonmu#output#w#0ran#@+failed#A+skipped#B+done#C+helpers#HOchatty#P+finished#Q+hasSub#TraceErrors#Xrunner#`Jparent#plevel#xname#Jstart#duration#barrier#signal#sub#testing.commonsync.RWMutexw#pwriterSem#ʷreaderSem# ʷreaderCount#readerWait#sync.RWMutexsync.Mutexstate#sema#ʷsync.Mutexp int32[]uint8array#@len#cap#io.Writerio.Writerruntime.ifacetab#data#߶runtime.ifacemap[string]struct {}PJrstruct {} int*testing.commontime.Timewall#Kext#loc#time.Time int64*time.Locationtime.LocationXname#Jzone#tx#(cacheStart#@cacheEnd#HcacheZone#Ptime.Location[]time.zonearray#len#cap#time.zone name#Joffset#isDST#+time.zone[]time.zoneTransQarray#8len#cap#time.zoneTranswhen#index#isstd# +isutc# +time.zoneTransQ*time.zone time.Durationchan boolAZ+[]*testing.Tarray##len#cap#*testing.testContextCtesting.testContext0match#mu#startParallel#running#numWaiting# maxParallel#(testing.testContextC*testing.matchertesting.matcher0filter#amatchFunc#mu# subNames#("testing.matcher[]stringJarray#Elen#cap#func(string, string) (bool, error) J J 4 func(string, string) (bool, error)error<error*errormap[string]int64MOJ[]testing.InternalBenchmarkarray#len#cap#testing.InternalBenchmarkName#JF#testing.InternalBenchmarkfunc(*testing.B) func(*testing.B)*testing.B$testing.Bcommon#importPath#Jcontext#N#previousN#previousDuration#benchFunc#benchTime#bytes#missingBytes#+timerOn#+showAllocResult#+result#&parallelism#startAllocs#KstartBytes#KnetAllocs#KnetBytes#Ktesting.B$*testing.benchContexttesting.benchContextmatch#maxLen#extLen#testing.benchContexttesting.BenchmarkResult(N#T#Bytes#MemAllocs#KMemBytes# Ktesting.BenchmarkResult&[]testing.InternalExamplearray#/len#cap#testing.InternalExample0Name#JF#iOutput#JUnordered#(+testing.InternalExamplefunc()func()i[3]testing.InternalTestH [0]testing.InternalBenchmark [0]testing.InternalExampleL [14]runtime.typeAlg9 [128]uint8 [4]uintptr  struct { runtime.allocfreetrace int32; runtime.cgocheck int32; runtime.efence int32; runtime.gccheckmark int32; runtime.gcpacertrace int32; runtime.gcshrinkstackoff int32; runtime.gcrescanstacks int32; runtime.gcstoptheworld int32; runtime.gctrace int32; runtime.invalidptr int32; runtime.sbrk int32; runtime.scavenge int32; runtime.scheddetail int32; runtime.schedtrace int32 }8allocfreetrace#cgocheck#efence#gccheckmark# gcpacertrace#gcshrinkstackoff#gcrescanstacks#gcstoptheworld#gctrace# invalidptr#$sbrk#(scavenge#,scheddetail#0schedtrace#4runtime.mheapllock#free#Bfreelarge#busy#Bbusylarge# sweepgen# ʷsweepdone# ʷsweepers# ʷallspans# spans# sweepSpans# _#!ʷpagesInUse#!KpagesSwept#!KpagesSweptBasis#!KsweepHeapLiveBasis#!KsweepPagesPerByte#!largealloc#!Knlargealloc#!Klargefree#!Knlargefree#!Knsmallfree#"bitmap#&bitmap_mapped#&arena_start#&arena_used#&arena_alloc#&arena_end#&arena_reserved#&+_#&ʷcentral#&spanalloc#i cachealloc#jtreapalloc#jspecialfinalizeralloc#kspecialprofilealloc#kspeciallock#l/runtime.mheapruntime.mutexkey#runtime.mutex[128]runtime.mSpanListi runtime.mSpanListfirst#last#runtime.mSpanListi*runtime.mspanruntime.mspannext#prev#list#startAddr#npages# manualFreeList#(freeindex#0nelems#8allocCache#@KallocBits#HgcmarkBits#Psweepgen#XʷdivMul#\baseMask#^allocCount#`spanclass#b/incache#c+state#dEneedzero#edivShift#fdivShift2#gelemsize#hunusedsince#pnpreleased#xlimit#speciallock#/specials#\runtime.mspan*runtime.mSpanList runtime.gclinkptr *runtime.gcBits runtime.gcBits runtime.spanClass runtime.mSpanState*runtime.specialsruntime.specialnext#\offset#kind# runtime.specialsruntime.mTreaptreap#runtime.mTreap*runtime.treapNoderuntime.treapNode0right#left#parent#npagesKey#spanKey# priority#(ʷruntime.treapNode[]*runtime.mspanarray#ftlen#cap#[2]runtime.gcSweepBuf P runtime.gcSweepBuf(spineLock#/spine#߶spineLen#spineCap#index# ʷruntime.gcSweepBuf  float64[67]uint64K C[134]struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }C struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }@mcentral#upad#8runtime.mcentral8lock#/spanclass#/nonempty#empty# nmalloc#0Kruntime.mcentralu[8]uint8 runtime.fixallocHsize#first#arg#߶list#chunk# nchunk#(ʷinuse#0stat#8[zero#@+runtime.fixalloc func(unsafe.Pointer, unsafe.Pointer) ߶ ߶func(unsafe.Pointer, unsafe.Pointer)*runtime.mlink(runtime.mlinknext#runtime.mlink(*uint64Kruntime.plainErrorstr#@len#runtime.cpuProfile>lock#/on#+log#'extra#numExtra#>lostExtra#>Kruntime.cpuProfile*runtime.profBuf>runtime.profBufr#w#overflow#KoverflowTime#Keof# ʷhdrsize#(data#0*tags#HdrNext#`overflowBuf#h*wait#runtime.profBuf> runtime.profAtomic []uint64Karray#[len#cap#[]unsafe.Pointer߶array#?len#cap# runtime.profIndex runtime.notekey#runtime.note[1000]uintptr> struct { runtime.signalLock uint32; runtime.hz int32 }signalLock#ʷhz#runtime.schedtgoidgen#Klastpoll#Klock#/midle#nmidle# nmidlelocked#$mcount#(maxmcount#,ngsys#0ʷpidle#8)npidle#@ʷnmspinning#Dʷrunqhead#H>runqtail#P>runqsize#Xgflock#`/gfreeStack#hSgfreeNoStack#pSngfree#xsudoglock#/sudogcache#deferlock#/deferpool#Bgcwaiting#ʷstopwait#stopnote#sysmonwait#ʷsysmonnote#safePointFn#csafePointWait#safePointNote#profilehz#procresizetime#totaltime#runtime.schedte runtime.muintptr runtime.puintptr runtime.guintptr *runtime.gdruntime.gstack#stackguard0#stackguard1#_panic# _defer#(m#0sched#8jsyscallsp#psyscallpc#xstktopsp#param#߶atomicstatus#ʷstackLock#ʷgoid#waitsince#waitreason#Jschedlink#>preempt#+paniconfault#+preemptscan#+gcscandone#+gcscanvalid#+throwsplit#+raceignore#sysblocktraced#+sysexitticks#traceseq#Ktracelastp#)lockedm#sig#ʷwritebuf#sigcode0#sigcode1#sigpc#gopc#startpc#racectx#waiting#cgoCtxt#5labels#߶timer#pgcAssistBytes#runtime.gdruntime.stacklo#hi#runtime.stack*runtime._panicruntime._panic(argp#߶arg#alink#recovered# +aborted#!+runtime._panicinterface {}interface {}aruntime.eface_type#ٹdata#߶runtime.eface*runtime._deferruntime._defer0siz#started#+sp#pc#fn#f_panic# link#(runtime._defer*runtime.funcval}runtime.funcvalfn#runtime.funcval}*runtime.mruntime.mg0#Smorebuf#divmod#@ʷprocid#HKgsignal#PSsigmask#Xtls#`mstartfn#scurg#Scaughtsig#>p#)nextp#)id#mallocing#throwing#preemptoff#Jlocks#softfloat#dying#profilehz#helpgc#spinning#+blocked#+inwb#+newSigstack#+printlock#incgo#+fastrand#ʷncgocall#Kncgo#cgoCallersUse#ʷcgoCallers#park#alllink#schedlink#mcache#'lockedg#Screatestack# freglo#(freghi#(fflag#ʷlocked#ʷnextwaitm#needextram#+traceback#waitunlockf#߶waitlock#߶waittraceev#waittraceskip#startingtrace#+syscalltick#ʷthread#libcall#Alibcallpc#libcallsp#libcallg#>syscall#mOS#runtime.mruntime.gobuf8sp#pc#g#>ctxt#߶ret# }lr#(bp#0runtime.gobuf runtime/internal/sys.Uintreg runtime.sigset [6]uintptr0  int8*runtime.cgoCallersruntime.cgoCallers  runtime.cgoCallers*runtime.mcache=runtime.mcache next_sample#local_scan#tiny#tinyoffset#local_tinyallocs# alloc#(Vstackcache#zlocal_nlookup# local_largefree# local_nlargefree# local_nsmallfree# runtime.mcache=[134]*runtime.mspan [4]runtime.stackfreelist@ runtime.stackfreelistlist#size#runtime.stackfreelist[67]uintptr C[32]uintptr  [16]uint32ʷ@ runtime.libcall0fn#n#args#r1#r2# err#(runtime.libcallAruntime.mOSmachport#ʷwaitsema#ʷruntime.mOS*runtime.sudogruntime.sudog`g#Sselectdone#next#prev#elem# ߶acquiretime#(releasetime#0ticket#8ʷparent#@waitlink#Hwaittail#Pc#Xruntime.sudog*uint32ʷ*runtime.hchanruntime.hchan`qcount#dataqsiz#buf#߶elemsize#closed#ʷelemtype# ٹsendx#(recvx#0recvq#8sendq#H"lock#X/runtime.hchan uintruntime.waitqfirst#last#runtime.waitq[]uintptrarray#len#cap#*runtime.timerruntime.timer8i#when#period#f#arg# useq#0runtime.timerfunc(interface {}, uintptr) u func(interface {}, uintptr)[5]*runtime._defer( func(*runtime.p) func(*runtime.p)c*runtime.pruntime.p%lock#/id#status# ʷlink#)schedtick#ʷsyscalltick#ʷsysmontick# /m#@mcache#H'racectx#Pdeferpool#Xdeferpoolbuf#goidcache# Kgoidcacheend# Krunqhead# ʷrunqtail# ʷrunq# ]runnext#>gfree#Sgfreecnt#sudogcache#sudogbuf#tracebuf#$traceSweep#$+traceSwept#$traceReclaimed#$palloc#$gcAssistTime#$gcBgMarkWorker#$>gcMarkWorkerMode#$Ugcw#$rrunSafePointFn#%ʷpad#%runtime.pruntime.sysmontick schedtick#ʷschedwhen#syscalltick#ʷsyscallwhen#runtime.sysmontick/[5][]*runtime._deferx []*runtime._deferarray#_|len#cap#[5][32]*runtime._defer:  [32]*runtime._defer  [256]runtime.guintptr> []*runtime.sudogarray#hlen#cap#[128]*runtime.sudog  runtime.traceBufPtr runtime.persistentAllocbase#߶off#runtime.persistentAlloc runtime.gcMarkWorkerModeruntime.gcWork wbuf1#wbuf2#bytesMarked#KscanWork#runtime.gcWorkr*runtime.workbufruntime.workbufworkbufhdr#@obj#runtime.workbufruntime.workbufhdrnode#nobj#runtime.workbufhdr@runtime.lfnodenext#Kpushcnt#runtime.lfnode[253]uintptr [64]uint8@ @[6]stringJ` [9]stringJ  [33]float64 ![1024]uint8 []*runtime.gSarray#len#cap#runtime.moduledatapclntable#ftab#$filetab#0findfunctab#Hminpc#Pmaxpc#Xtext#`etext#hnoptrdata#penoptrdata#xdata#edata#bss#ebss#noptrbss#enoptrbss#end#gcdata#gcbss#types#etypes#textsectmap#typelinks#itablinks#ptab#pluginpath#Jpkghashes#modulename#Jmodulehashes#gcdatamask#Sgcbssmask#typemap#next#runtime.moduledata[]runtime.functabgarray#-len#cap#runtime.functabentry#funcoff#runtime.functabg[]uint32ʷarray#len#cap#[]runtime.textsect.array#-len#cap#runtime.textsectvaddr#length#baseaddr#runtime.textsect.[]int32array#"len#cap#[]*runtime.itabarray#rlen#cap#[]runtime.ptabEntryIarray#,len#cap#runtime.ptabEntryname#Mtyp#aruntime.ptabEntryI[]runtime.modulehasharray#len#cap#runtime.modulehash(modulename#Jlinktimehash#Jruntimehash# Eruntime.modulehash*stringJruntime.bitvectorn#bytedata#@runtime.bitvectorSmap[runtime.typeOff]*runtime._typeMaٹ*runtime.moduledata runtime.mstats.alloc#Ktotal_alloc#Ksys#Knlookup#Knmalloc# Knfree#(Kheap_alloc#0Kheap_sys#8Kheap_idle#@Kheap_inuse#HKheap_released#PKheap_objects#XKstacks_inuse#`Kstacks_sys#hKmspan_inuse#pKmspan_sys#xKmcache_inuse#Kmcache_sys#Kbuckhash_sys#Kgc_sys#Kother_sys#Knext_gc#Klast_gc_unix#Kpause_total_ns#Kpause_ns# pause_end# numgc#!ʷnumforcedgc#!ʷgc_cpu_fraction#!enablegc#!+debuggc#!+by_size#!<last_gc_nanotime#.Ktinyallocs#.KtriggerRatio#.gc_trigger#.Kheap_live#.Kheap_scan#.Kheap_marked#.Kruntime.mstats[256]uint64K [67]struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }  Cstruct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }size#ʷnmalloc#Knfree#K[1009]*runtime.itab? *unsafe.Pointer߶[67]uint16 C[129]uint8 [249]uint8 struct { runtime.mutex; runtime.persistentAlloc }mutex#/persistentAlloc#8[256]uint8 [67]uint8C Cstruct { runtime.lock runtime.mutex; runtime.lockOwner *runtime.g; runtime.enabled bool; runtime.shutdown bool; runtime.headerWritten bool; runtime.footerWritten bool; runtime.shutdownSema uint32; runtime.seqStart uint64; runtime.ticksStart int64; runtime.ticksEnd int64; runtime.timeStart int64; runtime.timeEnd int64; runtime.seqGC uint64; runtime.reading runtime.traceBufPtr; runtime.empty runtime.traceBufPtr; runtime.fullHead runtime.traceBufPtr; runtime.fullTail runtime.traceBufPtr; runtime.reader runtime.guintptr; runtime.stackTab runtime.traceStackTable; runtime.strings map[string]uint64; runtime.stringSeq uint64; runtime.markWorkerLabels [3]uint64; runtime.bufLock runtime.mutex; runtime.buf runtime.traceBufPtr }ȁlock#/lockOwner#Senabled#+shutdown#+headerWritten#+footerWritten#+shutdownSema#ʷseqStart#KticksStart# ticksEnd#(timeStart#0timeEnd#8seqGC#@Kreading#Hempty#PfullHead#XfullTail#`reader#h>stackTab#p strings# stringSeq#KmarkWorkerLabels# bufLock#/buf#runtime.traceStackTablelock#/seq#ʷmem#B tab# runtime.traceStackTable runtime.traceAllochead# off#runtime.traceAllocB  runtime.traceAllocBlockPtr [8192]runtime.traceStackPtr  @ runtime.traceStackPtr map[string]uint64+LJK[3]uint64K runtime.gcControllerStatescanWork#bgScanCredit#assistTime#dedicatedMarkTime#fractionalMarkTime# idleMarkTime#(markStartTime#0dedicatedMarkWorkersNeeded#8assistWorkPerByte#@assistBytesPerWork#HfractionalUtilizationGoal#P_#XfractionalMarkWorkersNeeded#_#runtime.gcControllerState* *runtime.finblock runtime.finblockalllink# next# cnt#ʷ_#fin#Kruntime.finblock [101]runtime.finalizerq eruntime.finalizer(fn#farg#߶nret#fint#ٹot# runtime.finalizerq*runtime.ptrtypeֻ[5]uint8 struct { runtime.full runtime.lfstack; runtime.empty runtime.lfstack; runtime.pad0 [64]uint8; runtime.wbufSpans struct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }; _ uint32; runtime.bytesMarked uint64; runtime.markrootNext uint32; runtime.markrootJobs uint32; runtime.nproc uint32; runtime.tstart int64; runtime.nwait uint32; runtime.ndone uint32; runtime.alldone runtime.note; runtime.helperDrainBlock bool; runtime.nFlushCacheRoots int; runtime.nDataRoots int; runtime.nBSSRoots int; runtime.nSpanRoots int; runtime.nStackRoots int; runtime.markrootDone bool; runtime.startSema uint32; runtime.markDoneSema uint32; runtime.bgMarkReady runtime.note; runtime.bgMarkDone uint32; runtime.mode runtime.gcMode; runtime.userForced bool; runtime.totaltime int64; runtime.initialHeapLive uint64; runtime.assistQueue struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }; runtime.sweepWaiters struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }; runtime.cycles uint32; runtime.stwprocs int32; runtime.maxprocs int32; runtime.tSweepTerm int64; runtime.tMark int64; runtime.tMarkTerm int64; runtime.tEnd int64; runtime.pauseNS int64; runtime.pauseStart int64; runtime.heap0 uint64; runtime.heap1 uint64; runtime.heap2 uint64; runtime.heapGoal uint64 }full#empty#pad0#wbufSpans#P_#xʷbytesMarked#KmarkrootNext#ʷmarkrootJobs#ʷnproc#ʷtstart#nwait#ʷndone#ʷalldone#helperDrainBlock#+nFlushCacheRoots#nDataRoots#nBSSRoots#nSpanRoots#nStackRoots#markrootDone#+startSema#ʷmarkDoneSema#ʷbgMarkReady#bgMarkDone#ʷmode#EuserForced#+totaltime#initialHeapLive#KassistQueue#XsweepWaiters#cycles#ʷstwprocs#maxprocs#tSweepTerm#tMark#tMarkTerm#tEnd#pauseNS#pauseStart#heap0#Kheap1#Kheap2#KheapGoal#K runtime.lfstack struct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }(lock#/free#busy# runtime.gcModestruct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }lock#/head#>tail#>struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }lock#/head#>[1025]*runtime.p@ runtime.sweepdata lock#/g#Sparked#+started#+nbgsweep#ʷnpausesweep#ʷruntime.sweepdatap[1]uint8 [67]runtime.divMagic9 Cruntime.divMagicshift#shift2#mul#baseMask#runtime.divMagic9struct { runtime.lock runtime.mutex; runtime.free *runtime.gcBitsArena; runtime.next *runtime.gcBitsArena; runtime.current *runtime.gcBitsArena; runtime.previous *runtime.gcBitsArena }(lock#/free#next#current#previous# *runtime.gcBitsArenaruntime.gcBitsArenafree#next#bits#$runtime.gcBitsArena[65520]runtime.gcBits *[179999]*runtime.bucketk[179999]*runtime.bucketW  *runtime.bucketruntime.bucket0next#allnext#typ#(hash#size# nstk#(runtime.bucket runtime.bucketTypestruct { runtime.cycle uint32; runtime.flushed bool }cycle#ʷflushed#+runtime.pollCachelock#/first#runtime.pollCache*runtime.pollDescruntime.pollDesclink#lock#/fd#closing#+seq# rg#(rt#0rd#hwg#pwt#xwd#user#ʷruntime.pollDescruntime.machndrmig_vers#if_vers#reserved1#mig_encoding#int_rep#char_rep#float_rep#reserved2#runtime.machndr[512]uint8 runtime.forcegcstatelock#/g#Sidle#ʷruntime.forcegcstateruntime.rwmutex0rLock#/readers#readerPass#ʷwLock#/writer# readerCount#(ʷreaderWait#,ʷruntime.rwmutexruntime.randomOrder count#ʷcoprimes#runtime.randomOrder [1]unsafe.Pointer߶ struct { runtime.lock runtime.mutex; runtime.pad uint32; runtime.val uint64 }lock#/pad#ʷval#K**uint8@[]runtime.dbgVar!array#len#cap#runtime.dbgVarname#Jvalue#"runtime.dbgVar!*int32struct { runtime.lock runtime.mutex; runtime.next int32; runtime.m map[int32]unsafe.Pointer; runtime.minv map[unsafe.Pointer]int32 } lock#/next#m#"minv##map[int32]unsafe.PointerJ߶map[unsafe.Pointer]int320I߶[251]struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }#} struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }@root##pad#A$runtime.semaRootlock#/treap#nwait#ʷruntime.semaRoot#[40]uint8( ([32]runtime.sigTabT|$  runtime.sigTabTflags#name#Jruntime.sigTabT|$[32]uint32ʷ  struct { runtime.note runtime.note; runtime.mask [1]uint32; runtime.wanted [1]uint32; runtime.ignored [1]uint32; runtime.recv [1]uint32; runtime.state uint32; runtime.inuse bool } note#mask#%wanted# %ignored#%recv#%state#ʷinuse#+[1]uint32ʷ [33]uintptr !runtime.errorStringstr#@len#[4]runtime.mSpanList@ struct { runtime.lock runtime.mutex; runtime.free [26]runtime.mSpanList }lock#/free#&[26]runtime.mSpanList runtime.Frame@PC#Func#'Function#JFile# JLine#0Entry#8runtime.Frame'*runtime.Func'runtime.Funcopaque#rruntime.Func'struct { runtime.lock runtime.mutex; runtime.gp *runtime.g; runtime.created bool; runtime.sleeping bool; runtime.rescheduling bool; runtime.sleepUntil int64; runtime.waitnote runtime.note; runtime.t []*runtime.timer }@lock#/gp#Screated#+sleeping#+rescheduling#+sleepUntil#waitnote# t#(:)[]*runtime.timerparray#len#cap#[3]stringJ0 [1]uint64K []map[runtime.typeOff]*runtime._typearray#len#cap#[4]stringJ@ [14]runtime.dbgVar " [7]stringJp  syscall.Errno func(error) bool  4func(error) boolf*struct { sync.Mutex; os.dir string }Mutex#dir#J*os.File*os.Filefile#+os.File**os.file$+os.filePpfd#{+name#0Jdirinfo#@]-nonblock#H+os.file$+internal/poll.FD0fdmu#,Sysfd#pd#z,iovecs# ,IsStream#(+ZeroReadIsEOF#)+isFile#*+internal/poll.FD{+internal/poll.fdMutexstate#Krsema#ʷwsema# ʷinternal/poll.fdMutex,internal/poll.pollDescruntimeCtx#internal/poll.pollDescz,*[]syscall.Iovec,[]syscall.Iovec-array#,len#cap#syscall.IovecBase#@Len#Ksyscall.Iovec-*os.dirInfoo-os.dirInfo(buf#nbuf#bufp# os.dirInfoo-runtime.MemStats-Alloc#KTotalAlloc#KSys#KLookups#KMallocs# KFrees#(KHeapAlloc#0KHeapSys#8KHeapIdle#@KHeapInuse#HKHeapReleased#PKHeapObjects#XKStackInuse#`KStackSys#hKMSpanInuse#pKMSpanSys#xKMCacheInuse#KMCacheSys#KBuckHashSys#KGCSys#KOtherSys#KNextGC#KLastGC#KPauseTotalNs#KPauseNs# PauseEnd# NumGC#!ʷNumForcedGC#!ʷGCCPUFraction#!EnableGC#!+DebugGC#!+BySize#!90runtime.MemStats-[61]struct { Size uint32; Mallocs uint64; Frees uint64 }0  =struct { Size uint32; Mallocs uint64; Frees uint64 }Size#ʷMallocs#KFrees#Ksync.Once m#done#ʷsync.Once0[]intarray#2len#cap#*time.Durationtesting.Cover0Mode#JCounters#1Blocks#1CoveredPackages# Jtesting.Coverj1map[string][]uint32GJmap[string][]testing.CoverBlock*FJ(2[]testing.CoverBlockn2array#Slen#cap#testing.CoverBlockLine0#ʷCol0#Line1#ʷCol1# Stmts#testing.CoverBlockn2*int*time.Timer3time.Timer@C#83r#S3time.Timer3<-chan time.TimeZXtime.runtimeTimer8i#when#period#f#!arg# useq#0time.runtimeTimerS3*uint*regexp.Regexp3regexp.RegexpregexpRO#F4mu#machine#7regexp.Regexp3regexp.regexpROexpr#Jprog#H5onepass#6prefix# JprefixBytes#0prefixComplete#H+prefixRune#LprefixEnd#Pʷcond#T7numSubexp#XsubexpNames#`alongest#x+regexp.regexpROF4*regexp/syntax.Progb5regexp/syntax.Prog(Inst#5Start#NumCap# regexp/syntax.Progb5[]regexp/syntax.Inst6array#;len#cap#regexp/syntax.Inst(Op#g6Out#ʷArg#ʷRune#regexp/syntax.Inst6 regexp/syntax.InstOp*regexp.onePassProg6regexp.onePassProg(Inst#6Start#NumCap# regexp.onePassProg6[]regexp.onePassInst<7array#.len#cap#regexp.onePassInst@Inst#O6Next#(regexp.onePassInst<7 regexp/syntax.EmptyOp[]*regexp.machine7array#Qlen#cap#*regexp.machine7regexp.machinere#3p#H5op#6maxBitStateLen#b# 8q0#(9q1#X/:pool#*;matched#+matchcap#1inputBytes#l;inputString#;inputReader#;regexp.machine7*regexp.bitState 9regexp.bitStateXprog#H5end#cap#1jobs#(|9visited#@regexp.bitState 9[]regexp.job9array#Slen#cap#regexp.jobpc#ʷarg#pos#regexp.job9regexp.queue0sparse#dense#A:regexp.queue9[]regexp.entry:array#len#cap#regexp.entrypc#ʷt#:regexp.entry:*regexp.thread:regexp.thread inst#;cap#1regexp.thread:*regexp/syntax.InstO6[]*regexp.thread:array#len#cap#regexp.inputBytesstr#regexp.inputBytesl;regexp.inputStringstr#Jregexp.inputString;regexp.inputReader r#8<atEOT#+pos#regexp.inputReader;io.RuneReader<io.RuneReader8<map[string]intDJsyscall.attrListbitmapCount#_#CommonAttr#ʷVolAttr#ʷDirAttr# ʷFileAttr#ʷForkattr#ʷsyscall.attrList}<[106]stringJ  jsyscall.mmapper Mutex#active#=mmap#=munmap#p>syscall.mmapper==map[*uint8][]uint8`C@func(uintptr, uintptr, int, int, int, int64) (uintptr, error)        func(uintptr, uintptr, int, int, int, int64) (uintptr, error)=func(uintptr, uintptr) error   func(uintptr, uintptr) errorp>[]*sync.Pool>array#len#cap#*sync.Pool?sync.PoolnoCopy#l?local#߶localSize#New#?sync.Pool?sync.noCopysync.noCopyl?func() interface {} ?func() interface {}?*interface {}u[6]int0 [12]stringJ  [13]int324  func(int) error  func(int) error@internal/poll.TimeoutErrorinternal/poll.TimeoutErrorO@*flag.FlagSet@flag.FlagSet`Usage#sname#Jparsed#+actual# GAformal#(GAargs#0aerrorHandling#HAoutput#Pflag.FlagSet@map[string]*flag.FlagAJkA*flag.Flag|Aflag.Flag@Name#JUsage#JValue# ADefValue#0Jflag.Flag|Aflag.Value<flag.ValueA flag.ErrorHandlinginternal/cpu.x86_#HasAES#@+HasAVX#A+HasAVX2#B+HasBMI1#C+HasBMI2#D+HasERMS#E+HasOSXSAVE#F+HasPCLMULQDQ#G+HasPOPCNT#H+HasSSE2#I+HasSSE3#J+HasSSSE3#K+HasSSE41#L+HasSSE42#M+_#Ninternal/cpu.x86Bstrconv.floatInfomantbits#expbits#bias#strconv.floatInfoKC[]float64array#len#cap#[]float32Darray#len#cap# float32 []strconv.leftCheatpDarray#len#cap#strconv.leftCheatdelta#cutoff#Jstrconv.leftCheatpD[20]uint64K [87]strconv.extFloatD Wstrconv.extFloatmant#Kexp#neg#+strconv.extFloatD[8]strconv.extFloat7E [37]uint %[]uint16array#len#cap#[9]intH  [23]float64 [11]float32D,  [61]strconv.leftCheatD  =[462]uint16 [139]uint16 [378]uint32ʷ  [82]uint16 R[16]uint16  [0]int [16]uint8 [0]int32 [4]int32 [2]int32 struct { runtime/pprof.mu sync.Mutex; runtime/pprof.m map[string]*runtime/pprof.Profile }mu#m#Gmap[string]*runtime/pprof.Profiled@JG*runtime/pprof.ProfileGruntime/pprof.Profile0name#Jmu#m#dHcount# Hwrite#(Hruntime/pprof.ProfileGmap[interface {}][]uintptr>u5func() int 2func() intHfunc(io.Writer, int) error   func(io.Writer, int) errorH[1]int64 struct { sync.Mutex; runtime/pprof.profiling bool; runtime/pprof.done chan bool }Mutex#profiling#+done#[1]stringJ [2]int64 [4]int64  sync.Map(mu#read#4Jdirty#Jmisses# sync.MapIsync/atomic.ValuenoCopy#|Jv#usync/atomic.Value4Jsync/atomic.noCopysync/atomic.noCopy|Jmap[interface {}]*sync.entry9=uJ*sync.entryJsync.entryp#߶sync.entryJreflect.MethodPName#JPkgPath#JType# KFunc#0KIndex#Hreflect.MethodKreflect.Type<reflect.TypeKreflect.Valuetyp#Kptr#߶flag#qMreflect.ValueK*reflect.rtype Lreflect.rtype0size#ptrdata#hash#ʷtflag#Lalign#fieldAlign#kind#alg#Lgcdata# @str#(IMptrToThis#,]Mreflect.rtype L reflect.tflag*reflect.typeAlgMreflect.typeAlghash#equal#reflect.typeAlgM reflect.nameOff reflect.typeOff reflect.flag reflect.StructFieldhName#JPkgPath#JType# KTag#0NOffset#@Index#H1Anonymous#`+reflect.StructFieldMreflect.StructTagstr#@len#struct { sync.Mutex; reflect.m sync.Map }0Mutex#m#&Jreflect.layoutType(t#KargSize#retOffset#stack#OframePool# >reflect.layoutTypeN*reflect.bitVector0Oreflect.bitVector n#ʷdata#reflect.bitVector0Ostruct { reflect.b bool; reflect.x interface {} }b#+x#u[27]stringJ [5]unicode/utf8.acceptRangeP  unicode/utf8.acceptRangelo#hi#unicode/utf8.acceptRangeP[]*unicode.RangeTableParray#|len#cap#*unicode.RangeTablePunicode.RangeTable8R16#QR32#QLatinOffset#0unicode.RangeTableP[]unicode.Range16[Qarray#len#cap#unicode.Range16Lo#Hi#Stride#unicode.Range16[Q[]unicode.Range32Qarray#len#cap#unicode.Range32 Lo#ʷHi#ʷStride#ʷunicode.Range32Q[]unicode.CaseRangeRarray#,len#cap#unicode.CaseRangeLo#ʷHi#ʷDelta#Runicode.CaseRangeRunicode.d  unicode.dR[128]uint16 []unicode.foldPair`Sarray#,len#cap#unicode.foldPairFrom#To#unicode.foldPair`Smap[string]*unicode.RangeTable;JP[5]*unicode.RangeTableP( [304]unicode.CaseRangeR/ [88]unicode.foldPairS X[357]unicode.Range16Q [179]unicode.Range32+R [176]unicode.Range16Q [66]unicode.Range32+R B[66]unicode.Range16Q B[47]unicode.Range32+R /[112]unicode.Range16Q p[35]unicode.Range32+R #[127]unicode.Range16Q [62]unicode.Range32+R >[5]unicode.Range16Q [14]unicode.Range16QT [7]unicode.Range32+RT [2]unicode.Range16Q  [11]unicode.Range16QB  [5]unicode.Range32+R< [1]unicode.Range16Q [2]unicode.Range32+R [117]unicode.Range16Q u[33]unicode.Range32+R ![40]unicode.Range16Q ([4]unicode.Range32+R0 [280]unicode.Range16Q  [140]unicode.Range32+R  [7]unicode.Range16Q* [103]unicode.Range16Q g[96]unicode.Range16Q `[40]unicode.Range32+R ([173]unicode.Range16Q [77]unicode.Range32+R M[37]unicode.Range16Q %[17]unicode.Range32+R [28]unicode.Range16Q [31]unicode.Range32+R [22]unicode.Range16Q [6]unicode.Range16Q$ [109]unicode.Range16Q m[36]unicode.Range32+R $[25]unicode.Range16Q [12]unicode.Range16QH  [23]unicode.Range16Q [43]unicode.Range16Q +[6]unicode.Range32+RH [101]unicode.Range16Q e[58]unicode.Range32+R :[0]unicode.Range16Q [3]unicode.Range32+R$ [1]unicode.Range32+R  [21]unicode.Range16Q~ [3]unicode.Range16Q [4]unicode.Range16Q [93]unicode.Range16Q ][72]unicode.Range32+R H[8]unicode.Range16Q0 [32]unicode.Range16Q  [15]unicode.Range32+R [33]unicode.Range16Q ![16]unicode.Range16Q` [9]unicode.Range16Q6  [20]unicode.Range16Qx [8]unicode.Range32+R` [18]unicode.Range16Ql [31]unicode.Range16Q [13]unicode.Range16QN  [121]unicode.Range16Q y[10]unicode.Range16Q<  [16]unicode.Range32+R [146]unicode.Range16Q [48]unicode.Range32+R 0[15]unicode.Range16QZ [70]unicode.Range16Q F[64]unicode.Range32+R @[44]unicode.Range16Q ,[22]unicode.Range32+R [13]unicode.Range32+R  [63]unicode.Range16Q ?[102]unicode.Range16Q fmap[string]regexp/syntax.charGroup9J^regexp/syntax.charGroup sign#class#regexp/syntax.charGroup^[2]stringJ  [6]int32 [8]int32  [11]stringJ  *context.emptyCtx_ context.emptyCtxchan struct {}_Vr*hash/crc32.Table_hash/crc32.Tableʷ hash/crc32.Table_[10]uint8   []compress/flate.compressionLevel`array#,len#cap#compress/flate.compressionLevel0level#good#lazy#nice#chain# fastSkipHashing#(compress/flate.compressionLevel`compress/flate.InternalErrorstr#@len#*compress/flate.huffmanEncoderacompress/flate.huffmanEncodercodes#7bfreqcache#bbitCount#0yclns#xclfs#ccompress/flate.huffmanEncodera[]compress/flate.hcodebarray#`len#cap#compress/flate.hcodecode#len#compress/flate.hcodeb[]compress/flate.literalNodecarray#len#cap#compress/flate.literalNodeliteral#freq#compress/flate.literalNodec[17]int32D compress/flate.byLiteralYcarray#len#cap#compress/flate.byLiteralccompress/flate.byFreqYcarray#len#cap#compress/flate.byFreqc[]int8array#t,len#cap#[256]uint32ʷ [10]compress/flate.compressionLevela  [29]int8 [29]uint32ʷt [44]int8, ,[44]uint32ʷ ,[19]uint32ʷL func(uint32, []uint8) uint32 ʷ  func(uint32, []uint8) uint32\e*hash/crc32.slicing8Tableehash/crc32.slicing8Table`@ hash/crc32.slicing8Tablee*sync/atomic.ValueeJ*sync/atomic.ifaceWordsJfsync/atomic.ifaceWordstyp#߶data#߶sync/atomic.ifaceWordsJf*[]uintptr5**runtime.moduledatastruct { F uintptr; runtime.src uintptr; runtime.dst *uintptr }.F#src#dst#runtime.slicearray#߶len#cap#runtime.slice2gstruct { F uintptr; runtime.typ *runtime._type; runtime.src unsafe.Pointer; runtime.off uintptr; runtime.size uintptr }(.F#typ#ٹsrc#߶off#size# *runtime.structfieldP*runtime.chantype+struct { F uintptr; runtime.c *runtime.hchan }.F#c#*runtime.mutex/**runtime.hchan**runtime.sudog**uint32*runtime.waitq"*runtime.cpuProfile[2]uintptr *runtime.timevaliiruntime.timevaltv_sec#tv_usec#pad_cgo_0# iruntime.timevalii[4]uint8 *runtime.TypeAssertionErroriruntime.TypeAssertionError@interfaceString#JconcreteString#JassertedString# JmissingMethod#0Jruntime.TypeAssertionErrori int16[32]uint8   runtime.stackExpanderhpcExpander#)kwasPanic#X+skip#`runtime.stackExpanderjruntime.pcExpanderXmore#+pc#frames#kfuncInfo#(linlTree#8 mfile#@Jline#PinlIndex#Truntime.pcExpander)k[]runtime.Frame~'array#wlen#cap#runtime.funcInfo_func#]ldatap#runtime.funcInfol*runtime._funcrlruntime._func(entry#nameoff#args# _#pcsp#pcfile#pcln#npcdata# nfuncdata#$runtime._funcrl*[1048576]runtime.inlinedCallDm[1048576]runtime.inlinedCalltm @runtime.inlinedCallparent#file#line#func_# runtime.inlinedCalltm[3]uintptr *runtime.bmap nruntime.bmaptophash#runtime.bmap n*runtime.maptype*runtime.hmaplnruntime.hmap0count#flags#B# noverflow# hash0# ʷbuckets#߶oldbuckets#߶nevacuate# extra#(!oruntime.hmapln*runtime.mapextra9oruntime.mapextraoverflow#onextOverflow#mruntime.mapextra9o[2]*[]*runtime.bmapo *[]*runtime.bmapo[]*runtime.bmapmarray#plen#cap#**runtime.bmapm**runtime.mapextra!o*runtime.hiterIpruntime.hiter`key#߶value#߶t#Anh#Xnbuckets# ߶bptr#(moverflow#0ostartBucket#@offset#Hwrapped#I+B#Ji#Kbucket#PcheckBucket#Xruntime.hiterIp**runtime.hmapXn**runtime.maptypeAn**[]*runtime.bmapo*runtime.stringStructqruntime.stringStructstr#߶len#runtime.stringStructq**runtime._typeٹ*runtime.imethod=**runtime.itab*runtime.uncommontypeNrruntime.uncommontypepkgpath#Mmcount#_#moff#ʷ_# ʷruntime.uncommontypeNr*runtime.iface<*runtime.lfstack*runtime.lfnode*runtime.note*runtime.mheapstruct { F uintptr; runtime.c *runtime.mcache; runtime.spc runtime.spanClass }.F#c#'spc#/struct { F uintptr; runtime.s **runtime.mspan; runtime.size *uintptr; runtime.needzero bool; runtime.noscan bool } .F#s#ftsize#needzero#+noscan#+**runtime.mspanstruct { F uintptr; runtime.p *unsafe.Pointer; runtime.size uintptr; runtime.align uintptr; runtime.sysStat *uint64 }(.F#p#?size#align#sysStat# [*runtime.persistentAlloc8struct { F uintptr; runtime.mp *runtime.m; runtime.src uintptr; runtime.dst *uintptr } .F#mp#src#dst#struct { F uintptr; runtime.dst *uintptr; runtime.src uintptr }.F#dst#src#struct { F uintptr; runtime.srcp *unsafe.Pointer; runtime.dstp *unsafe.Pointer; runtime.n int; runtime.typ **runtime._type }(.F#srcp#?dstp#?n#typ# qruntime.markBitsbytep#@mask#index#runtime.markBitsw*runtime.markBitsSwruntime.heapBitsbitp#@shift#ʷruntime.heapBitsw*runtime.gclinkwruntime.gclinknext#runtime.gclinkwstruct { F uintptr; runtime.c *runtime.mcache }.F#c#'*runtime.mcentral**runtime.ptrtypestruct { F uintptr; runtime.e *runtime.eface; runtime.f *runtime.eface; runtime.nret uintptr; runtime.fint *runtime._type; runtime.ot *runtime.ptrtype }0.F#e#vyf#vynret#fint# ٹot#(*runtime.efacestruct { F uintptr; runtime.e *runtime.eface }.F#e#vy*runtime.fixallocchan intjT*runtime.gcControllerState runtime.gcTriggerkind#tznow#n#ʷruntime.gcTrigger!z runtime.gcTriggerKindstruct { F uintptr; runtime.startTime *int64 }.F#startTime#z*int64[5]int64( [3]int64 [24]uint8 **runtime.pstruct { F uintptr; runtime.gp *runtime.g; runtime._p_ *runtime.p }.F#gp#S_p_#*runtime.puintptr)*runtime.guintptr>*runtime.parkInfo·2{runtime.parkInfo·2m#attach#)runtime.parkInfo·2{*runtime.gcWork**runtime._defer*runtime.mTreap**runtime.treapNodestruct { F uintptr; runtime.gp *runtime.g; runtime.gcw *runtime.gcWork }.F#gp#Sgcw#I|struct { F uintptr; runtime.gp *runtime.g; runtime.scanWork int64 }.F#gp#SscanWork#struct { F uintptr; runtime.cache *runtime.pcvalueCache; runtime.gcw *runtime.gcWork }.F#cache# ~gcw#I|*runtime.pcvalueCache)~runtime.pcvalueCacheentries#n~runtime.pcvalueCache)~[16]runtime.pcvalueCacheEnt~ runtime.pcvalueCacheEnttargetpc#off#val# runtime.pcvalueCacheEnt~ runtime.hex *runtime.stkframe&runtime.stkframeXfn#Glpc#continpc#lr# sp#(fp#0varp#8argp#@arglen#Hargmap#Pruntime.stkframe&*runtime.bitvector runtime.gcDrainFlagsstruct { F uintptr; runtime.ret *uintptr }.F#ret#**runtime.special\*runtime.gcSweepBufystruct { F uintptr; runtime.s **runtime.mspan }.F#s#ftstruct { F uintptr; runtime.preemptible bool }.F#preemptible#+*[]*runtime.mspanstruct { F uintptr; runtime.s **runtime.mspan; runtime.h *runtime.mheap; runtime.npage uintptr; runtime.spanclass runtime.spanClass; runtime.large bool }(.F#s#fth#snpage#spanclass# /large#!+struct { F uintptr; runtime.h *runtime.mheap; runtime.s *runtime.mspan; runtime.acct int32 } .F#h#ss#acct#**runtime.funcvalf*runtime.memRecordCycleruntime.memRecordCycle allocs#frees#alloc_bytes#free_bytes#runtime.memRecordCycle*runtime.memRecordruntime.memRecordactive#Yfuture# ܃runtime.memRecord[3]runtime.memRecordCycleY` *runtime.blockRecordruntime.blockRecordcount#cycles#runtime.blockRecordstruct { F uintptr; runtime.p unsafe.Pointer; runtime.b *runtime.bucket }.F#p#߶b#*runtime.StackRecordruntime.StackRecordStack0# runtime.StackRecord*runtime.MemProfileRecord\runtime.MemProfileRecordAllocBytes#FreeBytes#AllocObjects#FreeObjects#Stack0# runtime.MemProfileRecord\*[32]uintptr []runtime.MemProfileRecord܅array#<len#cap#[]runtime.BlockProfileRecordarray#len#cap#runtime.BlockProfileRecordCount#Cycles#StackRecord##runtime.BlockProfileRecord*runtime.BlockProfileRecord[]runtime.StackRecord#array#߄len#cap#struct { F uintptr; runtime.pc uintptr; runtime.sp uintptr; runtime.gp *runtime.g; runtime.r *[]runtime.StackRecord }(.F#pc#sp#gp#Sr# 9*[]runtime.StackRecord=struct { F uintptr; runtime.gp *runtime.g }.F#gp#S**runtime.gSstruct { F uintptr; runtime.buf *[]uint8; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr; runtime.all bool; runtime.n *int }8.F#buf#gp#Spc#sp# all#(+n#02*[]uint8struct { F uintptr; runtime.pc uintptr; runtime.sp uintptr; runtime.gp *runtime.g } .F#pc#sp#gp#S*runtime.MemStats#0struct { F uintptr; runtime.m *runtime.MemStats }.F#m#,*runtime.pollCache*func(interface {}, uintptr)![2]runtime.keventt@ runtime.keventt ident#Kfilter#jflags# fflags# ʷdata#udata#@runtime.keventt[64]runtime.keventt] @*runtime.timespecruntime.timespectv_sec#tv_nsec#runtime.timespecstruct { F uintptr; runtime.mp *runtime.m }.F#mp#[2]uint32ʷ *runtime.machheadersruntime.machheadermsgh_bits#ʷmsgh_size#ʷmsgh_remote_port#ʷmsgh_local_port# ʷmsgh_reserved#ʷmsgh_id#runtime.machheadersstruct { F uintptr; runtime.r *int32; runtime.ns int64 }.F#r#"ns#struct { F uintptr; runtime.r int32 }.F#r#runtime.sigactiont__sigaction_u#sa_tramp#߶sa_mask#ʷsa_flags#runtime.sigactiontčruntime.usigactiont__sigaction_u#sa_mask#ʷsa_flags# runtime.usigactiont?*runtime.stacktruntime.stacktss_sp#@ss_size#ss_flags#pad_cgo_0#iruntime.stackt*runtime.sigset[5]int32 struct { F uintptr; runtime.pp *runtime.p; runtime.sc uintptr }.F#pp#sc#struct { F uintptr; runtime.siz int32; runtime.d **runtime._defer }.F#siz#d#_|*[]*runtime._defer**runtime._panicstruct { F uintptr; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr } .F#gp#Spc#sp#[14]uint8  complex128[100]uint8d dfunc(*runtime.g, unsafe.Pointer) bool S ߶ 4func(*runtime.g, unsafe.Pointer) bool%struct { F uintptr; runtime.gp *runtime.g; runtime.traceskip int }.F#gp#Straceskip#*[]*runtime.sudogfunc(*runtime.g) Sfunc(*runtime.g)struct { F uintptr; runtime.oldval uint32; runtime.newval uint32 }.F#oldval#ʷnewval# ʷ**runtime.mruntime.cgothreadstartg#>tls#[fn#߶runtime.cgothreadstartƒruntime.randomEnumi#ʷcount#ʷpos#ʷinc# ʷruntime.randomEnum!**runtime.timerpstruct { F uintptr; runtime._g_ *runtime.g }.F#_g_#Sstruct { F uintptr; runtime.sp1 uintptr; runtime.sp2 uintptr; runtime.sp3 uintptr; runtime._g_ *runtime.g }(.F#sp1#sp2#sp3#_g_# Sstruct { F uintptr; runtime.sp uintptr; runtime._g_ *runtime.g }.F#sp#_g_#Sstruct { F uintptr; runtime.ok *bool; runtime.oldp *runtime.p; runtime._g_ *runtime.g } .F#ok#4oldp#_g_#Sstruct { F uintptr; runtime.newg *runtime.g; runtime.stacksize int32 }.F#newg#Sstacksize#struct { F uintptr; runtime.fn **runtime.funcval; runtime.argp unsafe.Pointer; runtime.siz *int32; runtime.pc uintptr }(.F#fn#argp#߶siz#"pc# *runtime.gobufj[64]uintptr @*runtime.muintptr[129]*runtime.gS *[256]runtime.guintptr]*runtime.randomOrder *[]uint32*runtime.randomEnuml*runtime.profAtomic runtime.profBufReadMode*runtime.dbgVar "[][]int32array#Ulen#cap#*[1]unsafe.Pointer *[1][]int32<[1][]int32 *[]int32*runtime.rwmutex struct { F uintptr; runtime.rw *runtime.rwmutex }.F#rw#d runtime.semaProfileFlags*runtime.semaRoot+$*runtime.sigctxtruntime.sigctxtinfo#Zctxt#߶runtime.sigctxt*runtime.siginfoqruntime.siginfohsi_signo#si_errno#si_code#si_pid# si_uid#ʷsi_status#si_addr#Ksi_value# si_band#(__pad#0Eruntime.siginfoq[7]uint64K8 *runtime.regs64sruntime.regs64rax#Krbx#Krcx#Krdx#Krdi# Krsi#(Krbp#0Krsp#8Kr8#@Kr9#HKr10#PKr11#XKr12#`Kr13#hKr14#pKr15#xKrip#Krflags#Kcs#Kfs#Kgs#Kruntime.regs64sruntime.itimerval it_interval#iit_value#iruntime.itimervalruntime.gsignalStack(stack#stackguard0#stackguard1#stktopsp# runtime.gsignalStack*runtime.gsignalStackg*runtime.stack*runtime.adjustinfo̜runtime.adjustinfoold#delta#cache#T~sghi#runtime.adjustinfo̜runtime.gobitvector n#bytedata#runtime.gobitvector6*runtime.gobitvectork*runtime.tmpBufruntime.tmpBuf   runtime.tmpBuf[5]stringJP *[32]int32[32]int32  *[4]uint8i*runtime.FramesNruntime.Framescallers#5stackExpander#kruntime.FramesN*runtime.stackExpanderk*runtime.pcExpanderkruntime.cgoSymbolizerArg8pc#file#@lineno#funcName#@entry# more#(data#0runtime.cgoSymbolizerArg՞*runtime.Frame~'[]*runtime.moduledataarray#flen#cap#*[]*runtime.moduledata*runtime.modulehash-*runtime.stackmap"runtime.stackmap n#nbit#bytedata#runtime.stackmap"*runtime.traceBufruntime.traceBuftraceBufHeader#arr#sruntime.traceBufruntime.traceBufHeaderlink#lastTicks#Kpos#stk#Vruntime.traceBufHeader[128]uintptr [64488]uint8 *runtime.traceBufPtr*runtime.traceStackǡruntime.traceStack(link# hash#id#ʷn#stk# 6runtime.traceStackǡ[0]uintptr *runtime.traceStackTable% *runtime.traceStackPtr [5140]uint8( (runtime.traceFramefuncID#KfileID#Kline#Kruntime.traceFrame*runtime.traceAllocBlock#runtime.traceAllocBlocknext# data#zruntime.traceAllocBlock#[65528]uint8 *runtime.traceAllocBlockPtr *runtime.traceAlloct [2]uint64K func(*runtime.stkframe, unsafe.Pointer) bool  ߶ 4func(*runtime.stkframe, unsafe.Pointer) boolstruct { F uintptr; runtime.n *int; runtime.pc uintptr; runtime.sp uintptr; runtime.gp *runtime.g; runtime.skip *int; runtime.pcbuf []uintptr }H.F#n#2pc#sp#gp# Sskip#(2pcbuf#05*runtime.cgoSymbolizerArgYfunc(unsafe.Pointer, unsafe.Pointer) int32 ߶ ߶ "func(unsafe.Pointer, unsafe.Pointer) int32jruntime.cgoTracebackArg context#sigContext#buf#max#runtime.cgoTracebackArgץ runtime.textOff*runtime.functype[]*runtime._typeٹarray#qlen#cap#noalg.map.bucket[uint32][]*runtime._typetopbits#keys#[values#(overflow#֧noalg.map.bucket[uint32][]*runtime._typenoalg.[8]uint32ʷ  noalg.[8]uint32[noalg.[8][]*runtime._type{ noalg.[8][]*runtime._type*map.bucket[uint32][]*runtime._type-noalg.map.hdr[uint32][]*runtime._type0count#flags#B# noverflow# hash0# ʷbuckets#֧oldbuckets#֧nevacuate# overflow#(߶noalg.map.hdr[uint32][]*runtime._type*map[runtime.typeOff]*runtime._typemap[uint32][]*runtime._type;8ʷ{map[runtime._typePair]struct {}6lrruntime._typePairt1#ٹt2#ٹruntime._typePairl*struct { Size uint32; Mallocs uint64; Frees uint64 }0*[61]struct { Size uint32; Mallocs uint64; Frees uint64 }90*runtime.sysmontick*runtime.errorString0&*runtime.forcegcstate*runtime.gcTrigger]z*runtime.heapBitsw*[2]runtime.gcSweepBuf*struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }*[134]struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }*struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }*[67]struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }<*runtime.mstats *runtime.plainErrori*runtime.sigTabT$*runtime.sweepdata*[14]runtime.dbgVar**struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }#*[251]struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }6#*[2]string8_*[32]runtime.sigTabTY$*[33]float647*[3]string|)*[4]string**[5]string*[6]string*[9]string*struct { runtime.cycle uint32; runtime.flushed bool }?*struct { runtime.enabled bool; runtime.pad [3]uint8; runtime.needed bool; runtime.cgo bool; runtime.alignme uint64 }o*struct { runtime.full runtime.lfstack; runtime.empty runtime.lfstack; runtime.pad0 [64]uint8; runtime.wbufSpans struct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }; _ uint32; runtime.bytesMarked uint64; runtime.markrootNext uint32; runtime.markrootJobs uint32; runtime.nproc uint32; runtime.tstart int64; runtime.nwait uint32; runtime.ndone uint32; runtime.alldone runtime.note; runtime.helperDrainBlock bool; runtime.nFlushCacheRoots int; runtime.nDataRoots int; runtime.nBSSRoots int; runtime.nSpanRoots int; runtime.nStackRoots int; runtime.markrootDone bool; runtime.startSema uint32; runtime.markDoneSema uint32; runtime.bgMarkReady runtime.note; runtime.bgMarkDone uint32; runtime.mode runtime.gcMode; runtime.userForced bool; runtime.totaltime int64; runtime.initialHeapLive uint64; runtime.assistQueue struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }; runtime.sweepWaiters struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }; runtime.cycles uint32; runtime.stwprocs int32; runtime.maxprocs int32; runtime.tSweepTerm int64; runtime.tMark int64; runtime.tMarkTerm int64; runtime.tEnd int64; runtime.pauseNS int64; runtime.pauseStart int64; runtime.heap0 uint64; runtime.heap1 uint64; runtime.heap2 uint64; runtime.heapGoal uint64 } *struct { runtime.lock runtime.mutex; runtime.pad uint32; runtime.val uint64 }!*struct { runtime.note runtime.note; runtime.mask [1]uint32; runtime.wanted [1]uint32; runtime.ignored [1]uint32; runtime.recv [1]uint32; runtime.state uint32; runtime.inuse bool }$*struct { F uintptr; runtime.buf *[]uint8; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr; runtime.all bool; runtime.n *int }*struct { F uintptr; runtime.c *runtime.mcache; runtime.spc runtime.spanClass }1s*struct { F uintptr; runtime.h *runtime.mheap; runtime.s *runtime.mspan; runtime.acct int32 }/*struct { F uintptr; runtime.newg *runtime.g; runtime.stacksize int32 }*struct { F uintptr; runtime.preemptible bool }Ҁ*struct { F uintptr; runtime.r int32 }*struct { F uintptr; runtime.s **runtime.mspan; runtime.h *runtime.mheap; runtime.npage uintptr; runtime.spanclass runtime.spanClass; runtime.large bool }>*struct { F uintptr; runtime.s **runtime.mspan; runtime.size *uintptr; runtime.needzero bool; runtime.noscan bool }s*struct { F uintptr; runtime.siz int32; runtime.d **runtime._defer }*errors.errorStringLerrors.errorStrings#Jerrors.errorStringL*sync.Map&Jsync.readOnlym#Jamended#+sync.readOnly**sync.entryJnoalg.map.iter[interface {}]*sync.entry`key#?val#׸t#@h#buckets# bptr#(overflow0#0߶overflow1#8߶startBucket#@stuff#Hbucket#PcheckBucket#Xnoalg.map.iter[interface {}]*sync.entry*map.hdr[interface {}]*sync.entry)noalg.map.hdr[interface {}]*sync.entry0count#flags#B# noverflow# hash0# ʷbuckets#oldbuckets#nevacuate# overflow#(߶noalg.map.hdr[interface {}]*sync.entry)*map.bucket[interface {}]*sync.entry@noalg.map.bucket[interface {}]*sync.entrytopbits#keys#values#!overflow#noalg.map.bucket[interface {}]*sync.entry@noalg.[8]interface {}u noalg.[8]interface {}noalg.[8]*sync.entryJ@ noalg.[8]*sync.entry!*sync.Mutex*sync.Once1*sync.poolLocalsync.poolLocalpoolLocalInternal#pad#0sync.poolLocalsync.poolLocalInternal0private#ushared#NMutex#(sync.poolLocalInternal[]interface {}uarray#?len#cap#[80]uint8P P*[]interface {}N[]sync.poolLocalӼarray#len#cap#**sync.Pool>*[0]*sync.Pool%[0]*sync.Pool> sync.notifyList wait#ʷnotify#ʷlock#head#߶tail#߶sync.notifyListA*sync.RWMutex^io.stringWriter<io.stringWriterƾio.Reader<io.Readerio.WriterTo<io.WriterToio.ReaderFrom<io.ReaderFrom6[][]uint8array#len#cap#*syscall.attrList =*syscall.Stat_tǿsyscall.Stat_tDev#Mode#Nlink#Ino#KUid#ʷGid#ʷRdev#Pad_cgo_0#iAtimespec# Mtimespec#0MCtimespec#@MBirthtimespec#PMSize#`Blocks#hBlksize#pFlags#tʷGen#xʷLspare#|Qspare#Isyscall.Stat_tǿsyscall.TimespecSec#Nsec#syscall.Timespec*syscall.ErrnoT**[106]string"=[20]uint8 [9]uint8   time.Month time.Weekdaytime.fileSizeErrorstr#@len#[4096]uint8   *time.Time*time.zoneTrans*time.data_time.data p#error#+time.data_[22]uint8 *time.Month*time.Weekday*time.fileSizeError*[12]string?*[7]string<**internal/poll.TimeoutErrorn@*internal/poll.fdMutex_,*internal/poll.FD,*internal/poll.pollDesc,*os.PathErroros.PathError0Op#JPath#JErr# os.PathError*os.SyscallErroros.SyscallError Syscall#JErr# os.SyscallError*os.LinkErrorVos.LinkError@Op#JOld#JNew# JErr#0 os.LinkErrorV os.FileMode func(*os.file) error + func(*os.file) erroros.FileInfo<os.FileInfo[2]int *os.fileStatDos.fileStatname#Jsize#mode#modTime# sys#8 os.fileStatD*os.FileMode*struct { sync.Mutex; os.dir string }**internal/cpu.x865C*strconv.NumErrorstrconv.NumError0Func#JNum#JErr# strconv.NumError*strconv.decimalstrconv.decimald#nd#dp#neg#+trunc#+strconv.decimal[800]uint8 *strconv.floatInfoC*strconv.extFloat7E*strconv.decimalSlice\strconv.decimalSlice0d#nd#dp# neg#(+strconv.decimalSlice\[65]uint8A A*[800]uint8*strconv.leftCheatD*[11]float32E*[23]float64E*[61]strconv.leftCheat F*[87]strconv.extFloatD*[8]strconv.extFloatME**unicode.RangeTableP*unicode.Range16Q*unicode.Range32+R*reflect.methodValuereflect.methodValue0fn#stack#Omethod#rcvr#Kreflect.methodValue reflect.Kindfunc(int, int)  func(int, int)[[]int16jarray#g,len#cap#[]int64array#zlen#cap#*reflect.ValueErrorreflect.ValueErrorMethod#JKind#Jreflect.ValueError*struct { F uintptr; reflect.ps []unsafe.Pointer }struct { F uintptr; reflect.ps []unsafe.Pointer } .F#ps#d*struct { F uintptr; reflect.ss []string }struct { F uintptr; reflect.ss []string } .F#ss#a*struct { F uintptr; reflect.is []int64 }struct { F uintptr; reflect.is []int64 } .F#is#*struct { F uintptr; reflect.is []int32 }struct { F uintptr; reflect.is []int32 } .F#is#*struct { F uintptr; reflect.is []int16 }|struct { F uintptr; reflect.is []int16 } .F#is#*struct { F uintptr; reflect.is []int8 }struct { F uintptr; reflect.is []int8 } .F#is#[d*struct { F uintptr; reflect.s *reflect.sliceHeader; reflect.size uintptr; reflect.typ *reflect.rtype; reflect.tmp unsafe.Pointer }struct { F uintptr; reflect.s *reflect.sliceHeader; reflect.size uintptr; reflect.typ *reflect.rtype; reflect.tmp unsafe.Pointer }(.F#s#size#typ#Ktmp# ߶*reflect.sliceHeaderreflect.sliceHeaderData#߶Len#Cap#reflect.sliceHeader*reflect.structFieldreflect.structFieldname#styp#KoffsetAnon#reflect.structFieldreflect.namebytes#@reflect.names*reflect.stringHeaderreflect.stringHeaderData#߶Len#reflect.stringHeader*reflect.uncommonType+reflect.uncommonTypepkgPath#IMmcount#_#moff#ʷ_# ʷreflect.uncommonType+[]reflect.methodarray#Vlen#cap#reflect.methodname#IMmtyp#]Mifn#Btfn# Breflect.method reflect.textOff*reflect.method.*reflect.interfaceTypereflect.interfaceTypePrtype#LpkgPath#0methods#8reflect.interfaceType[]reflect.imethod2array#hlen#cap#reflect.imethodname#IMtyp#]Mreflect.imethod2[]*reflect.rtypeKarray#len#cap#[]reflect.TypeKarray#len#cap#**reflect.rtypeK*reflect.MethodoK*reflect.funcType<reflect.funcType8rtype#LinCount#0outCount#2reflect.funcType< reflect.ChanDir*reflect.chanTypereflect.chanType@rtype#Lelem#0Kdir#8reflect.chanType*reflect.sliceType3reflect.sliceType8rtype#Lelem#0Kreflect.sliceType3*reflect.arrayTypereflect.arrayTypeHrtype#Lelem#0Kslice#8Klen#@reflect.arrayType*reflect.mapTypereflect.mapTypeXrtype#Lkey#0Kelem#8Kbucket#@Khmap#HKkeysize#Pindirectkey#Qvaluesize#Rindirectvalue#Sbucketsize#Treflexivekey#V+needkeyupdate#W+reflect.mapType*reflect.ptrType,reflect.ptrType8rtype#Lelem#0Kreflect.ptrType,*reflect.structTypereflect.structTypePrtype#LpkgPath#0fields#8reflect.structType[]reflect.structFieldZarray#len#cap#func(string) bool J 4func(string) bool2*reflect.imethoda*[1]int[1]int [1]reflect.fieldScan  reflect.fieldScan typ#rindex#1reflect.fieldScan[]reflect.fieldScanarray#len#cap#*[0]reflect.fieldScano[0]reflect.fieldScan *[1]reflect.fieldScan*reflect.fieldScan*[]int1map[*reflect.structType]int4rmap[*reflect.structType]boolj3r+struct { F uintptr; reflect.name string }.F#name#J*struct { F uintptr; reflect.name string })reflect.emptyInterfacetyp#Kword#߶reflect.emptyInterface*[1]uint8func(reflect.Value, reflect.Type) reflect.Value K K {func(reflect.Value, reflect.Type) reflect.Value*reflect.ValueK*reflect.TypeK*struct { F uintptr; reflect.hash uint32 }struct { F uintptr; reflect.hash uint32 }.F#hash#ʷfunc(*reflect.rtype) reflect.Type K func(*reflect.rtype) reflect.Type*reflect.funcTypeFixed32reflect.funcTypeFixed32funcType#args#8reflect.funcTypeFixed32[32]*reflect.rtypeK  *reflect.funcTypeFixed128.reflect.funcTypeFixed128funcType#args#8reflect.funcTypeFixed128.[128]*reflect.rtypeK *reflect.funcTypeFixed4reflect.funcTypeFixed4XfuncType#args#8#reflect.funcTypeFixed4[4]*reflect.rtypeK  *reflect.funcTypeFixed8areflect.funcTypeFixed8xfuncType#args#8reflect.funcTypeFixed8a[8]*reflect.rtypeK@ *reflect.funcTypeFixed16reflect.funcTypeFixed16funcType#args#8Qreflect.funcTypeFixed16[16]*reflect.rtypeK *reflect.funcTypeFixed64reflect.funcTypeFixed64funcType#args#8reflect.funcTypeFixed64[64]*reflect.rtypeK @reflect.layoutKeyt#Krcvr#Kreflect.layoutKey*struct { F uintptr; reflect.x *reflect.rtype }struct { F uintptr; reflect.x *reflect.rtype }.F#x#K*func() interface {}?*reflect.emptyInterface*reflect.nonEmptyInterface.reflect.nonEmptyInterfaceitab#word#߶reflect.nonEmptyInterface.*struct { reflect.ityp *reflect.rtype; reflect.typ *reflect.rtype; reflect.link unsafe.Pointer; reflect.bad int32; reflect.unused int32; reflect.fun [100000]unsafe.Pointer };struct { reflect.ityp *reflect.rtype; reflect.typ *reflect.rtype; reflect.link unsafe.Pointer; reflect.bad int32; reflect.unused int32; reflect.fun [100000]unsafe.Pointer }0ityp#Ktyp#Klink#߶bad#unused#fun# A[100000]unsafe.Pointer߶0 interface { M() }<interface { M() }j[]reflect.ValueKarray#{len#cap#*[]unsafe.Pointerd*uint16*float32D*float64*complex640 complex64*complex128*[]stringa*[]int64*[]int16*[]int8[d*reflect.ChanDir*reflect.KindJ*[128]*reflect.rtype*[16]*reflect.rtypeQ*[32]*reflect.rtype*[4]*reflect.rtype#*[64]*reflect.rtype*[8]*reflect.rtype*[27]stringO*struct { reflect.b bool; reflect.x interface {} }vO*fmt.fmtfmt.fmtpbuf#fmtFlags#mwid#prec# intbuf#(!fmt.fmt*fmt.buffer!fmt.bufferarray#@len#cap#fmt.buffer!fmt.fmtFlags widPresent#+precPresent#+minus#+plus#+sharp#+space#+zero#+plusV#+sharpV#+fmt.fmtFlagsm[68]uint8D D*fmt.ppGfmt.ppbuf#]arg#uvalue#(Kfmt#@reordered#+goodArgNum#+panicking#+erroring#+fmt.ppGfmt.GoStringer<fmt.GoStringerfmt.Formatter<fmt.Formatterfmt.Stringer<fmt.Stringer7*fmt.fmtFlagsfunc(int) bool  4func(int) boolqsort.Interface<sort.Interfacefunc(int, int) bool   4func(int, int) boolsort.lessSwapLess#Swap#wsort.lessSwap sort.StringSliceJarray#Elen#cap#sort.StringSliceK*sort.StringSlice*flag.boolValue flag.boolValue*flag.intValue flag.intValue*flag.int64Value" flag.int64Value*flag.uintValueL flag.uintValue*flag.uint64Valuew flag.uint64Value *flag.stringValueflag.stringValuestr#@len#*flag.float64Value flag.float64Value*flag.durationValue flag.durationValue[]*flag.FlagkAarray#zlen#cap#noalg.map.iter[string]*flag.Flag`key#Eval#zt#@h#buckets# bptr#(overflow0#0߶overflow1#8߶startBucket#@stuff#Hbucket#PcheckBucket#Xnoalg.map.iter[string]*flag.Flagq**flag.FlagkA*map.hdr[string]*flag.Flagnoalg.map.hdr[string]*flag.Flag0count#flags#B# noverflow# hash0# ʷbuckets#oldbuckets#nevacuate# overflow#(߶noalg.map.hdr[string]*flag.Flag*map.bucket[string]*flag.Flagnoalg.map.bucket[string]*flag.Flagtopbits#keys#Bvalues#voverflow#noalg.map.bucket[string]*flag.Flagnoalg.[8]stringJ noalg.[8]stringBnoalg.[8]*flag.FlagkA@ noalg.[8]*flag.Flagvfunc(*flag.Flag) kAfunc(*flag.Flag)struct { F uintptr; flag.f *flag.FlagSet }.F#f#@*struct { F uintptr; flag.f *flag.FlagSet }[1]interface {}u *[1]interface {}X[2]interface {}u  *[2]interface {}[3]interface {}u0 flag.boolFlag<flag.boolFlag*[3]interface {}*struct { F uintptr; R *flag.FlagSet }Lstruct { F uintptr; R *flag.FlagSet }F#R#@*bytes.Bufferbytes.Bufferhbuf#off#lastRead# bootstrap#(bytes.Buffer bytes.readOp*bytes.Reader'bytes.Reader(s#i#prevRune# bytes.Reader'func(int32) bool  4func(int32) boolrstruct { F uintptr; testing.b *testing.B }.F#b#*struct { F uintptr; testing.b *testing.B }*testing.InternalBenchmark*struct { F uintptr; testing.bs []testing.InternalBenchmark }struct { F uintptr; testing.bs []testing.InternalBenchmark } .F#bs#A*func(*testing.B)*testing.BenchmarkResult[7]interface {}up noalg.map.iter[string][]uint32`key#Eval#`t#@h#6buckets# /bptr#(/overflow0#0߶overflow1#8߶startBucket#@stuff#Hbucket#PcheckBucket#Xnoalg.map.iter[string][]uint321*map.hdr[string][]uint32Unoalg.map.hdr[string][]uint320count#flags#B# noverflow# hash0# ʷbuckets#/oldbuckets#/nevacuate# overflow#(߶noalg.map.hdr[string][]uint32U*map.bucket[string][]uint32Qnoalg.map.bucket[string][]uint32topbits#keys#avalues#overflow#/noalg.map.bucket[string][]uint32Qnoalg.[8][]uint32 noalg.[8][]uint32*[7]interface {}*testing.InternalExampleLchan stringRJ[4]interface {}u@ *[4]interface {}d*[0]uint8[0]uint8 *[50]uintptr[50]uintptr 2testing.indenterc#testing.indenter*[2]uintptr9itesting.testDeps<testing.testDeps6*testing.Mutesting.MXdeps#Ntests#Vbenchmarks#(Aexamples#@testing.Mustruct { F uintptr; R testing.testDeps }F#R#N*struct { F uintptr; R testing.testDeps }*testing.InternalTeststruct { F uintptr; testing.tests []testing.InternalTest } .F#tests#V*struct { F uintptr; testing.tests []testing.InternalTest }d*[]testing.InternalBenchmarkA**testing.T*[]testing.InternalTestV*testing.CoverBlock2*testing.indenter regexp/syntax.patchList *regexp/syntax.Regexpregexp/syntax.RegexppOp#xFlags#Sub#Sub0# Rune#(Rune0#@GMin#HMax#PCap#XName#`Jregexp/syntax.Regexp regexp/syntax.Op regexp/syntax.Flags []*regexp/syntax.Regexparray#len#cap#[1]*regexp/syntax.Regexp regexp/syntax.compilerp#H5regexp/syntax.compilerregexp/syntax.fragi#ʷout#regexp/syntax.fragW*regexp/syntax.compiler;**regexp/syntax.Regexp*regexp/syntax.Errorregexp/syntax.Error Code#AExpr#Jregexp/syntax.Errorregexp/syntax.ErrorCodestr#@len#*regexp/syntax.parserregexp/syntax.parserXflags#stack#free# numCap#(wholeRegexp#0JtmpClass#@regexp/syntax.parser*[]*regexp/syntax.Regexpregexp/syntax.rangesp#Uregexp/syntax.rangesH*[1]stringI*[1]*regexp/syntax.Regexp*regexp/syntax.charGroup_*regexp/syntax.ErrorCodeA*regexp/syntax.InstOpg6*regexp/syntax.rangesl*[11]string~_*[]regexp.job|9*regexp.job9regexp.input<regexp.inpute*regexp.inputBytes;*regexp.inputString;*regexp.inputReader <**regexp.thread:*regexp.queue/:*[]*regexp.thread*;*regexp.entry:*regexp.onePassInsto7*regexp.queueOnePasscregexp.queueOnePass8sparse#dense#size#0ʷnextIndex#4ʷregexp.queueOnePasscstruct { F uintptr; regexp.ix *int; regexp.merged *[]int32; regexp.next *[]uint32 } .F#ix#2merged#Unext#`*struct { F uintptr; regexp.ix *int; regexp.merged *[]int32; regexp.next *[]uint32 }func(*int, *[]int32, uint32) bool 2 U ʷ 4func(*int, *[]int32, uint32) boolregexp.runeSlicearray#"len#cap#regexp.runeSlicestruct { F uintptr; regexp.p **regexp.onePassProg; regexp.visitQueue *regexp.queueOnePass; regexp.check *func(uint32, []bool) bool; regexp.onePassRunes [][]int32; regexp.instQueue *regexp.queueOnePass }@.F#p#visitQueue#Hcheck#onePassRunes# ֗instQueue#8H**regexp.onePassProg6*func(uint32, []bool) boolfunc(uint32, []bool) bool ʷ . 4func(uint32, []bool) bool[]bool+array#4len#cap#*struct { F uintptr; regexp.p **regexp.onePassProg; regexp.visitQueue *regexp.queueOnePass; regexp.check *func(uint32, []bool) bool; regexp.onePassRunes [][]int32; regexp.instQueue *regexp.queueOnePass }u*[]*regexp.machine7**regexp.machine7*[][]int32֗*[0]int32F*[1]uint32%*regexp.runeSlice_*encoding/binary.bigEndianencoding/binary.bigEndianencoding/binary.bigEndian*encoding/binary.littleEndian4encoding/binary.littleEndianencoding/binary.littleEndian4*bufio.Writerbufio.Writer@err# buf#n#(wr#0bufio.Writer*text/tabwriter.Writertext/tabwriter.Writeroutput#minwidth#tabwidth#padding# padbytes#(flags#0buf#8pos#cell#endChar#lines#Qwidths#1text/tabwriter.Writertext/tabwriter.cellsize#width#htab#+text/tabwriter.cell[][]text/tabwriter.cellarray#Clen#cap#[]text/tabwriter.cell8array#len#cap#*[0]text/tabwriter.cell[0]text/tabwriter.cell8 *[][]text/tabwriter.cellQ*[]text/tabwriter.celltext/tabwriter.osErrorerr# text/tabwriter.osError`*text/tabwriter.cell8*compress/flate.compressorcompress/flate.compressor(compressionLevel#aw#0 bulkHasher#8n fill#@ step#H# sync#P+bestSpeed#Xr chainHead#`hashHead#h hashPrev# hashOffset#(index#(window#(windowEnd#(blockStart#(byteAvailable#(+tokens#( length#(offset#ȁ(hash#Ё(ʷmaxInsertIndex#؁(err#( hashMatch#(2compress/flate.compressor*compress/flate.huffmanBitWriter compress/flate.huffmanBitWriterwriter#bits#Knbits#bytes# ; codegenFreq#V nbytes#literalFreq#offsetFreq#codegen#literalEncoding#}aoffsetEncoding#}acodegenEncoding#}aerr# compress/flate.huffmanBitWriter [248]uint8 [19]int32L func([]uint8, []uint32)  func([]uint8, []uint32)n func(*compress/flate.compressor, []uint8) int   2func(*compress/flate.compressor, []uint8) int func(*compress/flate.compressor) func(*compress/flate.compressor)# *compress/flate.deflateFast compress/flate.deflateFasttable# prev#cur#compress/flate.deflateFast [16384]compress/flate.tableEntry6  compress/flate.tableEntryval#ʷoffset#compress/flate.tableEntry6 [131072]uint32ʷ  [32768]uint32ʷ []compress/flate.tokenarray#llen#cap# compress/flate.token [257]uint32ʷ *[]compress/flate.token *compress/flate.token*compress/flate.Writercompress/flate.Writer(d# dict#(compress/flate.Writer*compress/flate.dictWritercompress/flate.dictWriterw#compress/flate.dictWriter*compress/flate.hcodeb*[16]int32[16]int32@ *compress/flate.levelInfocompress/flate.levelInfolevel#lastFreq#nextCharFreq#nextPairFreq# needed#compress/flate.levelInfo[16][16]int32 [16]compress/flate.levelInfo? *compress/flate.literalNodeYc*compress/flate.byLiteralc*compress/flate.byFreq@d*compress/flate.InternalErrorBa*compress/gzip.WriterEcompress/gzip.WriterHeader#w#Xlevel#hwroteHeader#p+compressor#xdigest#ʷsize#ʷclosed#+buf#-`err# compress/gzip.WriterEcompress/gzip.HeaderXComment#JExtra#ModTime#(Name#@JOS#Pcompress/gzip.Headerencoding/binary.ByteOrder<encoding/binary.ByteOrder*runtime/pprof.profMapruntime/pprof.profMapHhash#qall#last#free#TfreeStk#05runtime/pprof.profMapmap[uintptr]*runtime/pprof.profMapEntry1*runtime/pprof.profMapEntryruntime/pprof.profMapEntry8nextHash#nextAll#stk#5tag#(߶count#0runtime/pprof.profMapEntry[]runtime/pprof.profMapEntry4array#len#cap#**runtime/pprof.profMapEntry**runtime/pprof.ProfileGnoalg.map.iter[interface {}][]uintptr`key#?val#ft#@h#buckets# bptr#(overflow0#0߶overflow1#8߶startBucket#@stuff#Hbucket#PcheckBucket#Xnoalg.map.iter[interface {}][]uintptr*map.hdr[interface {}][]uintptrnoalg.map.hdr[interface {}][]uintptr0count#flags#B# noverflow# hash0# ʷbuckets#oldbuckets#nevacuate# overflow#(߶noalg.map.hdr[interface {}][]uintptr*map.bucket[interface {}][]uintptr-noalg.map.bucket[interface {}][]uintptrtopbits#keys#values#overflow#noalg.map.bucket[interface {}][]uintptr-noalg.[8][]uintptr5 noalg.[8][]uintptrruntime/pprof.stackProfile5array#flen#cap#runtime/pprof.stackProfile[][]uintptr5array#flen#cap#runtime/pprof.countProfile<runtime/pprof.countProfile*runtime/pprof.keysByCountruntime/pprof.keysByCount keys#acount#`<runtime/pprof.keysByCount*struct { F uintptr; runtime/pprof.buf *bytes.Buffer }struct { F uintptr; runtime/pprof.buf *bytes.Buffer }.F#buf#*[1]int64H*runtime/pprof.profileBuilder.runtime/pprof.profileBuilderstart#end#havePeriod#0+period#8m#@Vw#zw#)pb#6strings#astringMap#`<locs#funcs#`<mem#runtime/pprof.profileBuilder.runtime/pprof.protobuf0data#tmp#Fnest#(runtime/pprof.protobuf6map[uintptr]int0[]runtime/pprof.memMaparray#$len#cap#runtime/pprof.memMapstart#end#runtime/pprof.memMapfunc([]uintptr) string 5 Efunc([]uintptr) stringK[5]interface {}uP *[5]interface {}struct { F uintptr; runtime/pprof.p []runtime.MemProfileRecord } .F#p# *struct { F uintptr; runtime/pprof.p []runtime.MemProfileRecord }func([]runtime.StackRecord) (int, bool) = 2 4func([]runtime.StackRecord) (int, bool)druntime/pprof.runtimeProfile#array#߄len#cap#runtime/pprof.runtimeProfilestruct { F uintptr; runtime/pprof.p []runtime.BlockProfileRecord } .F#p#Y*struct { F uintptr; runtime/pprof.p []runtime.BlockProfileRecord }; runtime/pprof.msgOffset[8]runtime/pprof.newFunc·1* runtime/pprof.newFunc·1(id#Kname#Jfile#Jruntime/pprof.newFunc·1*struct { F uintptr; runtime/pprof.b *runtime/pprof.profileBuilder; runtime/pprof.addr uintptr }.F#b# addr#[]runtime/pprof.newFunc·1oarray# len#cap#*[1]uintptr1*struct { F uintptr; runtime/pprof.b *runtime/pprof.profileBuilder; runtime/pprof.addr uintptr }*runtime/pprof.newFunc·1o*[1]uint64)struct { F uintptr; runtime/pprof.e **runtime/pprof.profMapEntry; runtime/pprof.b *runtime/pprof.profileBuilder }.F#e#b# *runtime/pprof.protobufz*[2]int64I*struct { F uintptr; runtime/pprof.e **runtime/pprof.profMapEntry; runtime/pprof.b *runtime/pprof.profileBuilder } !struct { F uintptr; R *runtime/pprof.profileBuilder }F#R# *struct { F uintptr; R *runtime/pprof.profileBuilder }K"func(uint64, uint64, uint64, string, string) K K K J Jfunc(uint64, uint64, uint64, string, string)"struct { F uintptr; runtime/pprof.line *[]uint8 }.F#line#*struct { F uintptr; runtime/pprof.line *[]uint8 }S#func() []uint8 func() []uint8#*runtime/pprof.memMap1*[]runtime/pprof.memMapstruct { F uintptr; runtime/pprof.blockSize int64; runtime/pprof.b *runtime/pprof.profileBuilder }.F#blockSize#b# *[4]int64I*struct { F uintptr; runtime/pprof.blockSize int64; runtime/pprof.b *runtime/pprof.profileBuilder }A$*[]runtime.MemProfileRecord *[]runtime.BlockProfileRecordYnoalg.map.iter[string]string`key#Eval#Et#@h#&buckets# 'bptr#('overflow0#0߶overflow1#8߶startBucket#@stuff#Hbucket#PcheckBucket#Xnoalg.map.iter[string]string%*map.hdr[string]string&noalg.map.hdr[string]string0count#flags#B# noverflow# hash0# ʷbuckets#'oldbuckets#'nevacuate# overflow#(߶noalg.map.hdr[string]string&*map.bucket[string]string'noalg.map.bucket[string]stringtopbits#keys#avalues#aoverflow#'noalg.map.bucket[string]string'runtime/pprof.labelMap.JJ*runtime/pprof.runtimeProfile*runtime/pprof.stackProfileP*[8]runtime/pprof.newFunc·1*struct { sync.Mutex; runtime/pprof.profiling bool; runtime/pprof.done chan bool }I*testing/internal/testdeps.TestDepsB)testing/internal/testdeps.TestDepstesting/internal/testdeps.TestDepsB)github.com/go-kit/kit/metrics.Histogram<github.com/go-kit/kit/metrics.Histogram)*github.com/go-kit/kit/metrics.Timer*github.com/go-kit/kit/metrics.Timer0h#)t#u#(github.com/go-kit/kit/metrics.Timer*github.com/go-kit/kit/metrics/internal/lv.LabelValuesJarray#Elen#cap#github.com/go-kit/kit/metrics/internal/lv.LabelValues**github.com/go-kit/kit/metrics/generic.SimpleHistogrami+github.com/go-kit/kit/metrics/generic.SimpleHistogram@mtx#^lvs#*avg#0n#8Kgithub.com/go-kit/kit/metrics/generic.SimpleHistogrami+runtime.stringStructDWARFstr#@len#runtime.stringStructDWARF,*int16j*int8*compress/flate.compressionLevel`*unicode.foldPair`S*unicode.CaseRangeR*syscall.Iovec-*runtime.ptabEntryI*runtime.textsect.*runtime.functabg[]keyJ []valJ buckettophash#keys#5-values#R-overflow#-*bucketo-hash0count#flags#B# noverflow# hash0# ʷbuckets#-oldbuckets#-nevacuate# extra#(!o*hash-[]key@ []val@ buckettophash#keys#.values#H.overflow#@/*bucket.hash0count#flags#B# noverflow# hash0# ʷbuckets#@/oldbuckets#@/nevacuate# extra#(!o*hash[/[]val<*runtime/pprof.profMapEntry>@ buckettophash#keys#.values#H0overflow#0*bucketM0hash0count#flags#B# noverflow# hash0# ʷbuckets#0oldbuckets#0nevacuate# extra#(!o*hash0[]key<*reflect.structType>r@ []val+ bucket<*reflect.structType,bool>Xtophash#keys#1values#H 2overflow#P2*bucket<*reflect.structType,bool>'2hash<*reflect.structType,bool>0count#flags#B# noverflow# hash0# ʷbuckets#2oldbuckets#2nevacuate# extra#(!o*hash<*reflect.structType,bool>2bucket<*reflect.structType,int>tophash#keys#1values#H.overflow#3*bucket<*reflect.structType,int>3hash<*reflect.structType,int>0count#flags#B# noverflow# hash0# ʷbuckets#3oldbuckets#3nevacuate# extra#(!o*hash<*reflect.structType,int>4[]keyl []valr buckettophash#keys#4values#5overflow#5*bucket>5hash0count#flags#B# noverflow# hash0# ʷbuckets#5oldbuckets#5nevacuate# extra#(!o*hash5[]keyʷ []val<[]*runtime._type>{ buckettophash#keys#6values#(6overflow#`7*bucket6hash0count#flags#B# noverflow# hash0# ʷbuckets#`7oldbuckets#`7nevacuate# extra#(!o*hash7[]val^ buckettophash#keys#5-values#`8overflow#8*bucket8hash0count#flags#B# noverflow# hash0# ʷbuckets#8oldbuckets#8nevacuate# extra#(!o*hash+9[]val<*unicode.RangeTable>P@ buckettophash#keys#5-values#:overflow#:*bucket;:hash0count#flags#B# noverflow# hash0# ʷbuckets#:oldbuckets#:nevacuate# extra#(!o*hash:[]keya []val<*sync.entry>J@ buckettophash#keys#;values#;overflow#\<*bucket;hash0count#flags#B# noverflow# hash0# ʷbuckets#\<oldbuckets#\<nevacuate# extra#(!o*hash<[]val<[]uintptr>5 buckettophash#keys#;values#_=overflow#=*bucket=hash0count#flags#B# noverflow# hash0# ʷbuckets#=oldbuckets#=nevacuate# extra#(!o*hash >[]val<*runtime/pprof.Profile>G@ buckettophash#keys#5-values#>overflow#}?*bucket?hash0count#flags#B# noverflow# hash0# ʷbuckets#}?oldbuckets#}?nevacuate# extra#(!o*hash?[]val<*flag.Flag>kA@ buckettophash#keys#5-values#@overflow#A*bucket@hash0count#flags#B# noverflow# hash0# ʷbuckets#Aoldbuckets#Anevacuate# extra#(!o*hash2A[]key<*uint8>@@ []val<[]uint8> bucket<*uint8,[]uint8>tophash#keys#Avalues#HBoverflow#B*bucket<*uint8,[]uint8>9Bhash<*uint8,[]uint8>0count#flags#B# noverflow# hash0# ʷbuckets#Boldbuckets#Bnevacuate# extra#(!o*hash<*uint8,[]uint8>Bbuckettophash#keys#5-values#.overflow#C*bucket|Chash0count#flags#B# noverflow# hash0# ʷbuckets#Coldbuckets#Cnevacuate# extra#(!o*hashC[]val<[]testing.CoverBlock>(2 buckettophash#keys#5-values#Doverflow#GE*bucketDhash0count#flags#B# noverflow# hash0# ʷbuckets#GEoldbuckets#GEnevacuate# extra#(!o*hashrE[]val<[]uint32> buckettophash#keys#5-values#SFoverflow#F*bucketrFhash0count#flags#B# noverflow# hash0# ʷbuckets#Foldbuckets#Fnevacuate# extra#(!o*hashF[]key߶@ []val bucketptophash#keys#Gvalues#HGoverflow#h[H*bucketGhash0count#flags#B# noverflow# hash0# ʷbuckets#[Holdbuckets#[Hnevacuate# extra#(!o*hashH[]key []val߶@ bucketptophash#keys#RIvalues#(mIoverflow#hI*bucketIhash0count#flags#B# noverflow# hash0# ʷbuckets#Ioldbuckets#Inevacuate# extra#(!o*hashJ[]valK@ buckettophash#keys#5-values#Joverflow#dK*bucketKhash0count#flags#B# noverflow# hash0# ʷbuckets#dKoldbuckets#dKnevacuate# extra#(!o*hashK[]keya []val<*runtime._type>ٹ@ bucketptophash#keys#FLvalues#(kLoverflow#hL*bucketLhash0count#flags#B# noverflow# hash0# ʷbuckets#Loldbuckets#Lnevacuate# extra#(!o*hash)M[]val@ buckettophash#keys#5-values#Noverflow#N*bucket+Nhash0count#flags#B# noverflow# hash0# ʷbuckets#Noldbuckets#Nnevacuate# extra#(!o*hashNbuckettophash#keys#5-values#5overflow#O*bucketgOhash0count#flags#B# noverflow# hash0# ʷbuckets#Ooldbuckets#Onevacuate# extra#(!o*hashOsudoghg#Sselectdone#next#prev#elem# Jacquiretime#(releasetime#0ticket#8ʷparent#@waitlink#Hwaittail#Pc#Xwaitqfirst#Qlast#Q*sudogPhchan`qcount#dataqsiz#buf#߶elemsize#closed#ʷelemtype# ٹsendx#(recvx#0recvq#8Qsendq#HQlock#X/*hchanQsudog`g#Sselectdone#next#prev#elem# acquiretime#(releasetime#0ticket#8ʷparent#@waitlink#Hwaittail#Pc#Xwaitqfirst#Slast#S*sudogRhchan`qcount#dataqsiz#buf#߶elemsize#closed#ʷelemtype# ٹsendx#(recvx#0recvq#8pSsendq#HpSlock#X/*hchanSsudog`g#Sselectdone#next#prev#elem# racquiretime#(releasetime#0ticket#8ʷparent#@waitlink#Hwaittail#Pc#Xwaitqfirst#Ulast#U*sudog|Thchan`qcount#dataqsiz#buf#߶elemsize#closed#ʷelemtype# ٹsendx#(recvx#0recvq#8SUsendq#HSUlock#X/*hchanUsudogpg#Sselectdone#next#prev#elem# acquiretime#(releasetime#0ticket#8ʷparent#@waitlink#Hwaittail#Pc#Xwaitqfirst#Wlast#W*sudogwVhchan`qcount#dataqsiz#buf#߶elemsize#closed#ʷelemtype# ٹsendx#(recvx#0recvq#8NWsendq#HNWlock#X/*hchanWsudog`g#Sselectdone#next#prev#elem# +acquiretime#(releasetime#0ticket#8ʷparent#@waitlink#Hwaittail#Pc#Xwaitqfirst#qYlast#qY*sudogrXhchan`qcount#dataqsiz#buf#߶elemsize#closed#ʷelemtype# ٹsendx#(recvx#0recvq#8DYsendq#HDYlock#X/*hchanYtesting/internal/testdeps.ImportPath "Jruntime.writeBarrier $ogo.itab.testing/internal/testdeps.TestDeps,testing.testDeps  !ʶruntime.zerobase ($main.tests "Vmain.benchmarks `"Amain.examples "main.initdone· 4$main.statictmp_0 "main.statictmp_1  $main.statictmp_2  $runtime.algarray @"runtime.support_aes I$+runtime.support_ssse3 T$+runtime.support_sse41 R$+runtime.useAeshash V$+runtime.aeskeysched @$runtime.hashkey @$7runtime.iscgo E$+runtime.framepointer_enabled .+runtime.main_init_done "runtime.extraMWaiters t$ʷruntime.debug $Pruntime.mheap_ @a#runtime.statictmp_0 8iruntime.blockprofilerate $Kruntime.statictmp_2 8iruntime.statictmp_1 8iruntime.statictmp_4 p9iruntime.statictmp_3 P9i$f64.3ff0000000000000 X/ʶruntime.inf X$runtime.processorVersionInfo $ʷruntime.isIntel C$+runtime.support_avx J$+runtime.useAVXmemmove U$+runtime.cpuprof #runtime.prof $ runtime.sched `"eruntime.gomaxprocs $runtime.newprocs $runtime.ncpu $runtime.allm "runtime._cgo_setenv h"߶runtime._cgo_unsetenv p"߶runtime.statictmp_6 @runtime.statictmp_7  Aruntime.statictmp_8 Bruntime.fastlog2Table !7$f64.3eb0000000000000 .ʶruntime.zeroVal $Rruntime.statictmp_9 9i$f32.40d00000 .ʶruntime.statictmp_10 8iruntime.statictmp_11 8iruntime.statictmp_12 8iruntime.allglen $runtime.allgs "nruntime.firstmoduledata !runtime.memstats `$runtime.ifaceLock P$/runtime.hash !#runtime.cgo_yield `"?runtime.class_to_size !Uruntime.physPageSize $runtime.statictmp_13 <7runtime.gcphase $ʷruntime.gcBlackenEnabled $ʷruntime.MemProfileRate  !runtime.deferType "ٹruntime.size_to_class8 `!oruntime.size_to_class128 !runtime.statictmp_14 8i$f64.403a000000000000 /ʶ$f64.bfe62e42fefa39ef /ʶruntime.globalAlloc 0"runtime.oneBitCount !runtime.emptymspan "runtime.class_to_allocnpages @!runtime.trace @#6runtime.gcController $* runtime.finlock ($/runtime.finq " runtime.finc " runtime.allfin x" runtime.finptrmask $runtime.finalizer1 !runtime.fingwake @$+runtime.fingwait ?$+runtime.fing "Sruntime.fingCreate x$ʷruntime.fingRunning >$+$f64.3fec000000000000 H/ʶruntime.heapminimum 0!K$f64.3ffe000000000000 h/ʶ$f64.43e0000000000000 /ʶruntime.work " runtime.gcpercent $$f64.3fd0000000000000 0/ʶruntime.allp  A#O$f64.4059000000000000 /ʶ$f64.4010000000000000 x/ʶ$f64.3fe0000000000000 8/ʶ$f64.3fee666666666666 P/ʶruntime.sweep @"pruntime.panicking $ʷruntime.forcegcperiod (!runtime.worldsema !ʷruntime.gcBlackenPromptly A$+runtime.runtimeInitTime $runtime.allglock $/runtime.poolcleanup "sruntime.useCheckmark W$+runtime.oneptrmask !runtime.mSpanStateNames  "aruntime.statictmp_15 (0runtime.class_to_divmagic @!runtime.gcBitsArenas  "runtime.bucketmem $runtime.buckhash "Lruntime.mbuckets "runtime.xbuckets "runtime.bbuckets "runtime.proflock $/runtime.mProf h$?$f64.41cdcd6500000000 /ʶruntime.mutexprofilerate $Kruntime.tracelock  $/runtime.sizeof_C_MStats H!runtime.netpollInited $ʷruntime.pollcache p"runtime.netpollWaiters $ʷruntime.kq !runtime.urandom_dev @"runtime.sigset_all  !runtime.zerondr 0$os.executablePath  "Jgo.itab.runtime.errorString,error `!ʶruntime.indexError " runtime.sliceError " runtime.divideError " runtime.overflowError Ж" runtime.floatError " runtime.memoryError " runtime.statictmp_17 00runtime.runningPanicDefers $ʷruntime.paniclk $/runtime.didothers =$+runtime.deadlock $/runtime.printBacklog $runtime.printBacklogIndex $runtime.debuglock $/$f64.4024000000000000 /ʶ$f64.8000000000000000 /ʶ$f64.4014000000000000 /ʶruntime.maxstacksize @!runtime.m0 "_cgo_thread_start "߶_cgo_notify_runtime_init_done "߶runtime.isarchive D$+runtime.islibrary F$+runtime.forcegc "runtime.statictmp_18 8iruntime.badmorestackg0Msg `"Jruntime.badmorestackgsignalMsg p"Jruntime.initSigmask $runtime.buildVersion "Jruntime.freezing |$ʷruntime.cgoHasExtraM <$+runtime.extraMCount p$ʷruntime.earlycgocallback "runtime.extram $runtime.execLock $runtime.stealOrder  " runtime.gogoPC H$runtime.systemstackPC $runtime.mcallPC p$runtime.morestackPC x$runtime.starttime $runtime.overflowTag " runtime.ticks $!runtime.envs "aruntime.argslice "aruntime.traceback_cache !ʷruntime.argc h$runtime.argv "!runtime.test_z64 $Kruntime.test_x64 $Kruntime.dbgvars "!runtime.traceback_env $ʷruntime.reflectOffs "*"runtime.semtable #6#runtime.statictmp_21 9Jruntime.sigtable @"Y$runtime.crashing l$runtime.fwdSig $ runtime.handlingSig $$runtime.signalsOK H$+runtime.sig `$$runtime.maxElems !&runtime.statictmp_23  90&runtime.statictmp_22 90&runtime.statictmp_27 @90&runtime.statictmp_26 090&runtime.stackpool "b&runtime.stackLarge "&runtime.stackpoolmu $/runtime.systemstack_switchPC $runtime.gcBgMarkWorkerPC 8$runtime.skipPC $runtime.sigpanicPC $runtime.statictmp_29 >'runtime.statictmp_28 >~'runtime.cgoSymbolizer "߶runtime.statictmp_31 @?~'runtime.statictmp_32 ?~'runtime.statictmp_30 ?~'runtime.statictmp_33 ?~'runtime.modulesSlice "߶runtime.timers  "'runtime.faketime  $runtime.gcMarkWorkerModeStrings "|)runtime.statictmp_34 `90&$f64.3f90000000000000 /ʶruntime.statictmp_35 80)runtime.goexitPC @$runtime.jmpdeferPC `$runtime.mstartPC $runtime.rt0_goPC $runtime.runfinqPC $runtime.bgsweepPC $runtime.forcegchelperPC 0$runtime.timerprocPC $runtime.cgocallback_gofuncPC $runtime.gStatusStrings  "runtime.externalthreadhandlerp $runtime.cgoTraceback "߶runtime.pinnedTypemaps P")runtime.initdone· B$runtime.chansendpc $runtime.chanrecvpc $runtime.startNano $runtime.memhash_varlen.args_stackmap 2ʶruntime.reflectcall.args_stackmap 2ʶruntime.cgocallback_gofunc.args_stackmap 2ʶruntime.publicationBarrier.args_stackmap  0ʶruntime.asmcgocall.args_stackmap 2ʶruntime.call32.args_stackmap 01ʶruntime.call64.args_stackmap 1ʶruntime.call128.args_stackmap 0ʶruntime.call256.args_stackmap 1ʶruntime.call512.args_stackmap 1ʶruntime.call1024.args_stackmap `0ʶruntime.call2048.args_stackmap 0ʶruntime.call4096.args_stackmap `1ʶruntime.call8192.args_stackmap 1ʶruntime.call16384.args_stackmap 0ʶruntime.call32768.args_stackmap @1ʶruntime.call65536.args_stackmap 1ʶruntime.call131072.args_stackmap 0ʶruntime.call262144.args_stackmap 1ʶruntime.call524288.args_stackmap 1ʶruntime.call1048576.args_stackmap p0ʶruntime.call2097152.args_stackmap 0ʶruntime.call4194304.args_stackmap p1ʶruntime.call8388608.args_stackmap 1ʶruntime.call16777216.args_stackmap 0ʶruntime.call33554432.args_stackmap P1ʶruntime.call67108864.args_stackmap 1ʶruntime.call134217728.args_stackmap 0ʶruntime.call268435456.args_stackmap  1ʶruntime.call536870912.args_stackmap 1ʶruntime.call1073741824.args_stackmap 0ʶruntime.checkASM.args_stackmap 2ʶruntime..gobytes.2 Д!ʶruntime..gobytes.5 `!ʶ_cgo_init "߶_cgo_yield "߶runtime.staticbytes !runtime.statictmp_38 `"*runtime.statictmp_43 0"0&runtime.statictmp_44 @"0&runtime.statictmp_40 "0&runtime.statictmp_41 "0&runtime.statictmp_42  "0&runtime.statictmp_39 "0&runtime.g0 "runtime.statictmp_45  "*runtime.lfenceBeforeRdtsc G$+runtime.support_avx2 K$+runtime.support_bmi1 L$+runtime.support_bmi2 M$+runtime.support_erms N$+runtime.support_osxsave O$+runtime.support_popcnt P$+runtime.support_sse2 Q$+runtime.support_sse42 S$+runtime.lastmoduledatap 8!runtime.no_pointers_stackmap 0ʶruntime.mainPC 0ʶmasks Cʶshifts Dʶos.ErrInvalid " io.EOF @" go.itab.*os.SyscallError,error  !ʶgo.itab.*os.PathError,error !ʶgo.itab.*os.LinkError,error !ʶgo.itab.syscall.Errno,error !ʶos.ErrExist " os.ErrNotExist " os.ErrPermission " os.errFinished " os.initCwdErr @" os.initCwd 0"Jos.statictmp_1 `B<*io.ErrShortWrite " internal/poll.ErrFileClosing  " os.ErrClosed " os.statictmp_4 /T*os.useSyscallwd P"f*os.getwdCache p"*os.statictmp_5 /T*syscall.ForkLock $^os.Args P"ago.itab.*os.fileStat,os.FileInfo !ʶos.initdone· 7$syscall.Stdin H$os.Stdin 0"*syscall.Stdout X!os.Stdout 8"*syscall.Stderr P!os.Stderr ("*testing.memStats $-testing.benchmarkLock `$testing.labelsOnce $0testing.statictmp_0 =$f64.412e848000000000 /ʶtesting.matchBenchmarks `"Etesting.cpuList "1go.itab.*os.File,io.Writer `!ʶtesting.chatty 0"4testing.benchTime "U1testing.benchmarkMemory "4testing.cover "j1testing.coverProfile @"Etesting.match X"Etesting.matchMutex h$testing.short "4testing.statictmp_2 ;Jgo.itab.*bytes.Buffer,io.Writer !ʶgo.itab.*bytes.Reader,io.Reader  !ʶtesting.statictmp_3 ;Jgo.itab.testing.indenter,io.Writer !ʶtesting.statictmp_6 .+testing.errMain " testing.matchList h"Etesting.haveExamples `$+testing.statictmp_8 0;Jtesting.statictmp_9 @;Jtesting.statictmp_7  ;Jtesting.statictmp_10 :Jtesting.statictmp_11 :Jtesting.statictmp_12 :Jtesting.parallel "2testing.memProfileRate x"2testing.cpuProfile P"Etesting.traceFile "Etesting.blockProfile  "Etesting.blockProfileRate ("2testing.mutexProfile "Etesting.mutexProfileFraction "2testing.memProfile p"Etesting.outputDir "Etesting.statictmp_14 .testing.timeout "U1testing.timer "2testing.cpuListStr H"Etesting.count 8"3testing.statictmp_15 .+testing.statictmp_16 :Jtesting.statictmp_17 :Jtesting.statictmp_18 .+go.itab.*os.File,io.Reader  !ʶtesting.statictmp_19 .+testing.initdone· a$testing/internal/testdeps.matchRe "3testing/internal/testdeps.matchPat "Jtesting/internal/testdeps.initdone· b$github.com/go-kit/kit/metrics.initdone· )$go.itab.*github.com/go-kit/kit/metrics/generic.SimpleHistogram,github.com/go-kit/kit/metrics.Histogram  !ʶ$f64.3fa999999999999a /ʶgithub.com/go-kit/kit/metrics_test.initdone· ,$io.ErrShortBuffer p" io.ErrUnexpectedEOF " io.errOffset " io.errWhence " io.ErrClosedPipe P" io.initdone· 2$io.ErrNoProgress `" syscall.statictmp_2 :Jsyscall.env "`<syscall.envs "asyscall.envOnce $1syscall.envLock  $^syscall.minRoutingSockaddrLen X$syscall.statictmp_19 H0T*syscall.statictmp_33 ;}<syscall.statictmp_32 P0T*syscall.statictmp_35 X0T*syscall.errors ""=syscall.errENOENT p" syscall.errEINVAL `" syscall.errEAGAIN P" syscall._zero P$syscall.initdone· _$syscall.statictmp_43 "==syscall.Syscall.args_stackmap 3ʶsyscall.Syscall6.args_stackmap 3ʶsyscall.RawSyscall.args_stackmap 2ʶsyscall.statictmp_40 `!T*syscall.statictmp_41 h!T*syscall.statictmp_42 p!T*go.itab.*errors.errorString,error !ʶsync.expunged "߶sync.statictmp_2 `:Jsync.statictmp_1 P:Jsync.statictmp_3 p:Jsync.allPoolsMu @$sync.allPools ">sync.initdone· ^$sync/atomic.statictmp_2 :Jsync/atomic.statictmp_1 :Jsync/atomic.CompareAndSwapUint64.args_stackmap 2ʶsync/atomic.CompareAndSwapUintptr.args_stackmap 2ʶsync/atomic.StoreUint32.args_stackmap  2ʶsync/atomic.StoreUint64.args_stackmap 02ʶsync/atomic.StoreUintptr.args_stackmap @2ʶtime.std0x !?time.errBad  " time.atoiError " time.Local "time.errLeadingInt 0" time.unitMap ""time.statictmp_1 p;Jgo.itab.time.fileSizeError,error  !ʶtime.utcLoc @"utime.months "?time.days "<*time.localLoc `"utime.daysBefore  !@time.localOnce $1time.errLocation @" time.badData " time.zoneDirs "atime.initdone· d$time.statictmp_12 "*internal/poll.ErrNetClosing 0" internal/poll.statictmp_0 3Jinternal/poll.statictmp_1 3Jinternal/poll.statictmp_2 4Jinternal/poll.statictmp_4  4Jinternal/poll.statictmp_3 4Jinternal/poll.statictmp_5 04Jinternal/poll.serverInit $1internal/poll.ErrTimeout P" internal/poll.statictmp_6 @4Jinternal/poll.CloseFunc H"@internal/poll.initdone· 1$go.itab.*internal/poll.TimeoutError,error !ʶinternal/poll.statictmp_7  $O@flag.CommandLine "@go.itab.*flag.float64Value,flag.Value !ʶgo.itab.*flag.int64Value,flag.Value !ʶgo.itab.*flag.stringValue,flag.Value `!ʶgo.itab.*flag.intValue,flag.Value  !ʶgo.itab.*flag.durationValue,flag.Value `!ʶgo.itab.*flag.uint64Value,flag.Value !ʶgo.itab.*flag.uintValue,flag.Value !ʶgo.itab.*flag.boolValue,flag.Value  !ʶflag.ErrHelp " flag.Usage @"sflag.statictmp_0 3Jflag.initdone· &$fmt.statictmp_0 3Jfmt.ppFree @"]?go.itab.*fmt.pp,fmt.State !ʶfmt.boolError " fmt.complexError " go.itab.*strconv.NumError,error !ʶfmt.initdone· '$bytes.statictmp_2  3Jinternal/cpu.X86 @$Bbytes.shortStringLen $bytes.statictmp_5 03Jbytes.ErrTooLarge " bytes.initdone· !$go.itab.sort.StringSlice,sort.Interface !ʶsort.initdone· [$strings.shortStringLen 8$strings.initdone· ]$strconv.powtab `"1strconv.float64info @!KCstrconv.float64pow10 "C$f64.430c6bf526340000 /ʶ$f64.c30c6bf526340000 /ʶstrconv.float32info  !C$f32.80000000 .ʶstrconv.float32pow10 `"C$f32.4b189680 .ʶ$f32.cb189680 .ʶstrconv.optimize !+strconv.statictmp_0 Astrconv.ErrSyntax " strconv.ErrRange " strconv.leftcheats @"+Dstrconv.uint64pow10 !Dstrconv.powersOfTen `^"Dstrconv.smallPowersOfTen !MEstrconv.statictmp_2 :Jstrconv.statictmp_1 9Jstrconv.statictmp_4  :Jstrconv.statictmp_3 :Jstrconv.statictmp_5 0:Jstrconv.shifts `!pEstrconv.statictmp_6 @:Jstrconv.isPrint16 "Estrconv.isNotPrint16 "Estrconv.isPrint32  "strconv.isNotPrint32 "Estrconv.isGraphic "Estrconv.initdone· \$strconv.statictmp_7 !Estrconv.statictmp_8  !Estrconv.statictmp_9 !Estrconv.statictmp_10 @" Fstrconv.statictmp_11 3"1Fstrconv.statictmp_12  !MFstrconv.statictmp_13  K"iFstrconv.statictmp_14 `!Fstrconv.statictmp_15 @!Fruntime/debug.initdone· X$runtime/trace.initdone· Z$regexp.notBacktrack H"8regexp.statictmp_3 7Jregexp.statictmp_2 7Jregexp.statictmp_0 7Jregexp.statictmp_1 7Jregexp.statictmp_4 7Jgo.itab.*regexp.inputBytes,regexp.input !ʶgo.itab.*regexp.inputString,regexp.input `!ʶgo.itab.*regexp.inputReader,regexp.input !ʶregexp.notOnePass P"6regexp.statictmp_5 7Jregexp.statictmp_6 7Jregexp.statictmp_7 8Jregexp.arrayNoInts  $Fregexp.noRune @"regexp.noNext  "regexp.statictmp_8 8Jregexp.specialBytes $Fgo.itab.regexp.runeSlice,sort.Interface  !ʶregexp.anyRune "regexp.anyRuneNotNL "regexp.initdone· :$regexp.statictmp_10  $Fregexp.statictmp_11 !%regexp.statictmp_12 !Fregexp.statictmp_13 ؐ!Gruntime/pprof.errBadELF " go.itab.encoding/binary.littleEndian,encoding/binary.ByteOrder !ʶruntime/pprof.errNoBuildID " go.itab.encoding/binary.bigEndian,encoding/binary.ByteOrder @!ʶruntime/pprof.profiles "*Gruntime/pprof.goroutineProfile p"Gruntime/pprof.threadcreateProfile "Gruntime/pprof.heapProfile x"Gruntime/pprof.blockProfile h"Gruntime/pprof.mutexProfile "Ggo.itab.runtime/pprof.stackProfile,sort.Interface !ʶgo.itab.runtime/pprof.stackProfile,runtime/pprof.countProfile !ʶruntime/pprof.statictmp_4 9Jgo.itab.*runtime/pprof.keysByCount,sort.Interface !ʶgo.itab.*text/tabwriter.Writer,io.Writer !ʶruntime/pprof.statictmp_5 @0Hgo.itab.*bufio.Writer,io.Writer !ʶgo.itab.runtime/pprof.runtimeProfile,runtime/pprof.countProfile `!ʶruntime/pprof.cpu p"Iruntime/pprof.statictmp_6 .+runtime/pprof.statictmp_7 9Jruntime/pprof.statictmp_8 9Jruntime/pprof.statictmp_9 9Iruntime/pprof.statictmp_10 9Iruntime/pprof.statictmp_11 <Iruntime/pprof.initdone· Y$runtime/pprof.statictmp_12  "IHruntime/pprof.statictmp_13 `"IHruntime/pprof.statictmp_14 "IHruntime/pprof.statictmp_15 "IHruntime/pprof.statictmp_16  "IH$f64.4000000000000000 p/ʶ$f64.40862e42fefa39ef /ʶ$f64.3ff71547652b82fe `/ʶmath.initdone· 5$math.useSSE41 6$+math.Exp.args_stackmap 2ʶ$f64.3fe62e42fefa3000 @/ʶ$f64.3d53de6af278ece6 .ʶ$f64.3fb0000000000000  /ʶ$f64.3efa01a01a01a01a .ʶ$f64.3f2a01a01a01a01a .ʶ$f64.3f56c16c16c16c17 .ʶ$f64.3f81111111111111 /ʶ$f64.3fa5555555555555 /ʶ$f64.3fc5555555555555 (/ʶgithub.com/go-kit/kit/metrics/generic.initdone· *$go.itab.*reflect.rtype,reflect.Type @!ʶreflect.statictmp_1 p4Jreflect.statictmp_2 5Jreflect.kindNames "areflect.statictmp_3 6Jreflect.methodCache "Ireflect.statictmp_4 @6Jreflect.statictmp_6 `@Kreflect.statictmp_5 @oKreflect.statictmp_7 6Jreflect.statictmp_8 6Jreflect.statictmp_9 07Jreflect.statictmp_10 4Jreflect.statictmp_11 4Jreflect.statictmp_12 4Jreflect.statictmp_13  5Jreflect.statictmp_14 05Jreflect.statictmp_15 @5Jreflect.statictmp_16 P5Jreflect.statictmp_17 `5Jreflect.statictmp_18 p5Jreflect.statictmp_19 5Jreflect.statictmp_20 5Jreflect.statictmp_21 5Jreflect.statictmp_22 AMreflect.ptrMap "&Jreflect.statictmp_23 0?reflect.statictmp_24 .reflect.statictmp_26 5Jreflect.statictmp_25 5Jreflect.statictmp_27 5Jreflect.statictmp_28 5Jreflect.statictmp_36 0sreflect.statictmp_39 .reflect.statictmp_40 .reflect.funcLookupCache `"ONreflect.statictmp_38 06Jreflect.statictmp_37  6Jreflect.statictmp_35 6Jreflect.layoutCache `"&Jreflect.statictmp_62 <Nreflect.statictmp_61 P6Jreflect.statictmp_63 `6Jreflect.statictmp_64 p6Jreflect.statictmp_66 6Jreflect.statictmp_67 6Jreflect.statictmp_80 6Jreflect.statictmp_79 6Jreflect.statictmp_81 6Jreflect.uint8Type @"Kreflect.statictmp_85 7Jreflect.statictmp_84 7Jreflect.statictmp_83 6Jreflect.statictmp_86  7Jreflect.statictmp_91 @7Jreflect.statictmp_92 P7Jreflect.statictmp_97 7Jreflect.statictmp_96 p7Jreflect.statictmp_95 `7Jreflect.statictmp_101 4Jreflect.statictmp_100 4Jreflect.statictmp_120 4Jreflect.statictmp_121 4Jreflect.dummy "vOreflect.statictmp_122 4Jreflect.statictmp_123 5Jreflect.statictmp_124 5Jreflect.initdone· 9$reflect.statictmp_126 .reflect.methodValueCall.args_stackmap /ʶreflect.statictmp_125 "Ounicode/utf8.first !unicode/utf8.acceptRanges !Ounicode.properties !unicode.PrintRanges @"YPunicode.White_Space ؕ"Punicode.CaseRanges  "@Runicode.asciiFold !Sunicode.caseOrbit `"Sunicode.initdone· e$unicode.C 0"Punicode.Cc P"Punicode.Cf X"Punicode.Co x"Punicode.Cs "Punicode.L "Punicode.Ll @"Punicode.Lm H"Punicode.Lo P"Punicode.Lt `"Punicode.Lu h"Punicode.M "Punicode.Mc "Punicode.Me "Punicode.Mn "Punicode.N "Punicode.Nd ("Punicode.Nl H"Punicode.No P"Punicode.P "Punicode.Pc 0"Punicode.Pd 8"Punicode.Pe @"Punicode.Pf H"Punicode.Pi `"Punicode.Po h"Punicode.Ps x"Punicode.S "Punicode.Sc "Punicode.Sk "Punicode.Sm "Punicode.So "Punicode.Z "Punicode.Zl "Punicode.Zp "Punicode.Zs "Punicode.Categories "Sunicode.Adlam "Punicode.Ahom "Punicode.Anatolian_Hieroglyphs "Punicode.Arabic "Punicode.Armenian "Punicode.Avestan ȏ"Punicode.Balinese Џ"Punicode.Bamum ؏"Punicode.Bassa_Vah "Punicode.Batak "Punicode.Bengali "Punicode.Bhaiksuki "Punicode.Bopomofo "Punicode.Brahmi "Punicode.Braille "Punicode.Buginese  "Punicode.Buhid ("Punicode.Canadian_Aboriginal 8"Punicode.Carian @"Punicode.Caucasian_Albanian H"Punicode.Chakma `"Punicode.Cham h"Punicode.Cherokee p"Punicode.Common "Punicode.Coptic "Punicode.Cuneiform "Punicode.Cypriot "Punicode.Cyrillic "Punicode.Deseret "Punicode.Devanagari Ȑ"Punicode.Duployan ؐ"Punicode.Egyptian_Hieroglyphs "Punicode.Elbasan "Punicode.Ethiopic "Punicode.Georgian "Punicode.Glagolitic "Punicode.Gothic "Punicode.Grantha "Punicode.Greek  "Punicode.Gujarati ("Punicode.Gurmukhi 0"Punicode.Han 8"Punicode.Hangul @"Punicode.Hanunoo H"Punicode.Hatran P"Punicode.Hebrew X"Punicode.Hiragana h"Punicode.Imperial_Aramaic "Punicode.Inherited "Punicode.Inscriptional_Pahlavi "Punicode.Inscriptional_Parthian "Punicode.Javanese "Punicode.Kaithi "Punicode.Kannada ȑ"Punicode.Katakana Б"Punicode.Kayah_Li ؑ"Punicode.Kharoshthi "Punicode.Khmer "Punicode.Khojki "Punicode.Khudawadi "Punicode.Lao "Punicode.Latin "Punicode.Lepcha "Punicode.Limbu  "Punicode.Linear_A ("Punicode.Linear_B 0"Punicode.Lisu 8"Punicode.Lycian p"Punicode.Lydian x"Punicode.Mahajani "Punicode.Malayalam "Punicode.Mandaic "Punicode.Manichaean "Punicode.Marchen "Punicode.Meetei_Mayek "Punicode.Mende_Kikakui Ȓ"Punicode.Meroitic_Cursive В"Punicode.Meroitic_Hieroglyphs ؒ"Punicode.Miao "Punicode.Modi "Punicode.Mongolian "Punicode.Mro "Punicode.Multani "Punicode.Myanmar "Punicode.Nabataean  "Punicode.New_Tai_Lue 0"Punicode.Newa 8"Punicode.Nko @"Punicode.Ogham `"Punicode.Ol_Chiki h"Punicode.Old_Hungarian p"Punicode.Old_Italic x"Punicode.Old_North_Arabian "Punicode.Old_Permic "Punicode.Old_Persian "Punicode.Old_South_Arabian "Punicode.Old_Turkic "Punicode.Oriya "Punicode.Osage "Punicode.Osmanya "Punicode.Pahawh_Hmong "Punicode.Palmyrene "Punicode.Pau_Cin_Hau ("Punicode.Phags_Pa P"Punicode.Phoenician X"Punicode.Psalter_Pahlavi "Punicode.Rejang "Punicode.Runic "Punicode.Samaritan "Punicode.Saurashtra "Punicode.Sharada Д"Punicode.Shavian ؔ"Punicode.Siddham "Punicode.SignWriting "Punicode.Sinhala "Punicode.Sora_Sompeng "Punicode.Sundanese  "Punicode.Syloti_Nagri ("Punicode.Syriac 0"Punicode.Tagalog 8"Punicode.Tagbanwa @"Punicode.Tai_Le H"Punicode.Tai_Tham P"Punicode.Tai_Viet X"Punicode.Takri `"Punicode.Tamil h"Punicode.Tangut p"Punicode.Telugu x"Punicode.Thaana "Punicode.Thai "Punicode.Tibetan "Punicode.Tifinagh "Punicode.Tirhuta "Punicode.Ugaritic "Punicode.Vai "Punicode.Warang_Citi Е"Punicode.Yi "Punicode.Scripts "Sunicode.ASCII_Hex_Digit "Punicode.Bidi_Control "Punicode.Dash "Punicode.Deprecated "Punicode.Diacritic А"Punicode.Extender "Punicode.Hex_Digit `"Punicode.Hyphen p"Punicode.IDS_Binary_Operator x"Punicode.IDS_Trinary_Operator "Punicode.Ideographic "Punicode.Join_Control "Punicode.Logical_Order_Exception X"Punicode.Noncharacter_Code_Point X"Punicode.Other_Alphabetic "Punicode.Other_Default_Ignorable_Code_Point ȓ"Punicode.Other_Grapheme_Extend Г"Punicode.Other_ID_Continue ؓ"Punicode.Other_ID_Start "Punicode.Other_Lowercase "Punicode.Other_Math "Punicode.Other_Uppercase "Punicode.Pattern_Syntax "Punicode.Pattern_White_Space  "Punicode.Prepended_Concatenation_Mark p"Punicode.Quotation_Mark "Punicode.Radical "Punicode.Sentence_Terminal Ȕ"Punicode.Soft_Dotted "Punicode.Terminal_Punctuation "Punicode.Unified_Ideograph "Punicode.Variation_Selector ȕ"Punicode.Properties "Sunicode.foldL  "Punicode.foldLl ("Punicode.foldLt 0"Punicode.foldLu 8"Punicode.foldM @"Punicode.foldMn H"Punicode.FoldCategory "Sunicode.foldCommon "Punicode.foldGreek "Punicode.foldInherited "Punicode.FoldScript "Sunicode.statictmp_19 "Sunicode.statictmp_20 `"Qunicode.statictmp_23 `"Qunicode.statictmp_25 "Qunicode.statictmp_28 "Qunicode.statictmp_31 "Qunicode.statictmp_1 "Qunicode.statictmp_33  "Qunicode.statictmp_36 "Qunicode.statictmp_39  "Qunicode.statictmp_42 "Qunicode.statictmp_44  "Qunicode.statictmp_4  "Qunicode.statictmp_47 "Qunicode.statictmp_50 "Qunicode.statictmp_52  "Qunicode.statictmp_7 "Qunicode.statictmp_55 `"Qunicode.statictmp_58 "Qunicode.statictmp_61 "Qunicode.statictmp_10 "Qunicode.statictmp_64  "Qunicode.statictmp_66 `"Qunicode.statictmp_68 "Qunicode.statictmp_70  "Qunicode.statictmp_72 `"Qunicode.statictmp_74 "Qunicode.statictmp_77 "Qunicode.statictmp_13 "Qunicode.statictmp_79  "Qunicode.statictmp_81 `"Qunicode.statictmp_84 "Qunicode.statictmp_87 "Qunicode.statictmp_90  "Qunicode.statictmp_92 `"Qunicode.statictmp_94 "Qunicode.statictmp_16 `"Qunicode.statictmp_96 "Qunicode.statictmp_99  "Qunicode.statictmp_102  "Qunicode.statictmp_105 `"Qunicode.statictmp_108 "Qunicode.statictmp_110 "Qunicode.statictmp_113  "Qunicode.statictmp_115 `"Qunicode.statictmp_118 "Qunicode.statictmp_121 "Qunicode.statictmp_123  "Qunicode.statictmp_125 `"Qunicode.statictmp_128 "Qunicode.statictmp_130  "Qunicode.statictmp_133 `"Qunicode.statictmp_135 "Qunicode.statictmp_137 "Qunicode.statictmp_139  "Qunicode.statictmp_141 `"Qunicode.statictmp_144 "Qunicode.statictmp_147 "Qunicode.statictmp_150  "Qunicode.statictmp_152 `"Qunicode.statictmp_154 "Qunicode.statictmp_157 "Qunicode.statictmp_159  "Qunicode.statictmp_162 "Qunicode.statictmp_165 "Qunicode.statictmp_167  "Qunicode.statictmp_170 `"Qunicode.statictmp_172 "Qunicode.statictmp_175 "Qunicode.statictmp_178  "Qunicode.statictmp_181 `"Qunicode.statictmp_183 "Qunicode.statictmp_185 "Qunicode.statictmp_188  "Qunicode.statictmp_191 `"Qunicode.statictmp_194 "Qunicode.statictmp_197 "Qunicode.statictmp_199  "Qunicode.statictmp_201 "Qunicode.statictmp_204 "Qunicode.statictmp_206  "Qunicode.statictmp_208 `"Qunicode.statictmp_211 "Qunicode.statictmp_213 "Qunicode.statictmp_216  "Qunicode.statictmp_219 `"Qunicode.statictmp_222 "Qunicode.statictmp_225 "Qunicode.statictmp_228  "Qunicode.statictmp_230 "Qunicode.statictmp_233 "Qunicode.statictmp_235  "Qunicode.statictmp_238 `"Qunicode.statictmp_240 "Qunicode.statictmp_243 "Qunicode.statictmp_245  "Qunicode.statictmp_248 `"Qunicode.statictmp_251 "Qunicode.statictmp_253  "Qunicode.statictmp_255 `"Qunicode.statictmp_257 "Qunicode.statictmp_259 "Qunicode.statictmp_262  "Qunicode.statictmp_265 `"Qunicode.statictmp_267 "Qunicode.statictmp_270 "Qunicode.statictmp_273  "Qunicode.statictmp_276 `"Qunicode.statictmp_278 "Qunicode.statictmp_280  "Qunicode.statictmp_283 `"Qunicode.statictmp_286 "Qunicode.statictmp_288 "Qunicode.statictmp_291  "Qunicode.statictmp_294 `"Qunicode.statictmp_297 "Qunicode.statictmp_300 "Qunicode.statictmp_303  "Qunicode.statictmp_306 `"Qunicode.statictmp_309 "Qunicode.statictmp_312  "Qunicode.statictmp_314 `"Qunicode.statictmp_317 "Qunicode.statictmp_319 "Qunicode.statictmp_322  "Qunicode.statictmp_324 `"Qunicode.statictmp_326 "Qunicode.statictmp_328 "Qunicode.statictmp_331 `"Qunicode.statictmp_334 "Qunicode.statictmp_337 "Qunicode.statictmp_340  "Qunicode.statictmp_343 `"Qunicode.statictmp_346 "Qunicode.statictmp_349 "Qunicode.statictmp_351  "Qunicode.statictmp_354 `"Qunicode.statictmp_357 "Qunicode.statictmp_360  "Qunicode.statictmp_363 `"Qunicode.statictmp_366 "Qunicode.statictmp_368 "Qunicode.statictmp_371  "Qunicode.statictmp_374 `"Qunicode.statictmp_376 "Qunicode.statictmp_378 "Qunicode.statictmp_380  "Qunicode.statictmp_382 `"Qunicode.statictmp_385 "Qunicode.statictmp_388 "Qunicode.statictmp_391 `"Qunicode.statictmp_394 "Qunicode.statictmp_397 "Qunicode.statictmp_400 `"Qunicode.statictmp_402 "Qunicode.statictmp_404 "Qunicode.statictmp_406  "Qunicode.statictmp_408 `"Qunicode.statictmp_410 "Qunicode.statictmp_412 "Qunicode.statictmp_414  "Qunicode.statictmp_416 `"Qunicode.statictmp_419 "Qunicode.statictmp_421  "Qunicode.statictmp_424 `"Qunicode.statictmp_426 "Qunicode.statictmp_428 "Qunicode.statictmp_430  "Qunicode.statictmp_432 `"Qunicode.statictmp_434 "Qunicode.statictmp_437 "Qunicode.statictmp_440 `"Qunicode.statictmp_442 "Qunicode.statictmp_445 "Qunicode.statictmp_447  "Qunicode.statictmp_449 `"Qunicode.statictmp_451 "Qunicode.statictmp_453 "Qunicode.statictmp_456  "Qunicode.statictmp_459 `"Qunicode.statictmp_462 "Qunicode.statictmp_464 "Qunicode.statictmp_466  "Qunicode.statictmp_468 `"Qunicode.statictmp_470 "Qunicode.statictmp_473  "Qunicode.statictmp_475 `"Qunicode.statictmp_477 "Qunicode.statictmp_480 "Qunicode.statictmp_483  "Qunicode.statictmp_486 `"Qunicode.statictmp_489 "Qunicode.statictmp_491 "Qunicode.statictmp_493  "Qunicode.statictmp_495 `"Qunicode.statictmp_498 "Qunicode.statictmp_501  "Qunicode.statictmp_503 `"Qunicode.statictmp_505 "Qunicode.statictmp_508 "Qunicode.statictmp_510  "Qunicode.statictmp_512 `"Qunicode.statictmp_515 "Qunicode.statictmp_518 "Qunicode.statictmp_521 `"Qunicode.statictmp_524 "Qunicode.statictmp_527 "Qunicode.statictmp_529 w"Sunicode.statictmp_530 !Tunicode.statictmp_531  "Qunicode.statictmp_533 `"Qunicode.statictmp_536 "Qunicode.statictmp_538 "Qunicode.statictmp_541  "Qunicode.statictmp_543 `"Qunicode.statictmp_545 "Qunicode.statictmp_547 "Qunicode.statictmp_549  "Qunicode.statictmp_2 f"BTunicode.statictmp_3 o"gTunicode.statictmp_5 G"Tunicode.statictmp_6 )"Tunicode.statictmp_8 !Tunicode.statictmp_9 `"Tunicode.statictmp_11 "Uunicode.statictmp_12 !>Uunicode.statictmp_14 #"aUunicode.statictmp_15  "Uunicode.statictmp_17 !Uunicode.statictmp_21 !Uunicode.statictmp_22 !Uunicode.statictmp_24 ! Vunicode.statictmp_26 !-Vunicode.statictmp_27 !OVunicode.statictmp_29 T!pVunicode.statictmp_30 `!Vunicode.statictmp_32 \!pVunicode.statictmp_34 "Vunicode.statictmp_35 !Vunicode.statictmp_37 !Vunicode.statictmp_38  !Wunicode.statictmp_40  Q"=Wunicode.statictmp_41 W"bWunicode.statictmp_43 !Wunicode.statictmp_45 "Wunicode.statictmp_46 `!>Uunicode.statictmp_48 "Wunicode.statictmp_49 @!Wunicode.statictmp_51 !Uunicode.statictmp_53 B"Xunicode.statictmp_54 @7"7Xunicode.statictmp_56 !ZXunicode.statictmp_57 !}Xunicode.statictmp_59 `!Wunicode.statictmp_60 !Wunicode.statictmp_62 !Xunicode.statictmp_63 !Xunicode.statictmp_65 !Uunicode.statictmp_67 !-Vunicode.statictmp_69 !Xunicode.statictmp_71 !Uunicode.statictmp_73 ! Yunicode.statictmp_75 "*Yunicode.statictmp_76 !NYunicode.statictmp_78 !qYunicode.statictmp_80 !Yunicode.statictmp_82 !Yunicode.statictmp_83 !Vunicode.statictmp_85 !Yunicode.statictmp_86 @!Yunicode.statictmp_88  "Zunicode.statictmp_89 @"AZunicode.statictmp_91  ! Yunicode.statictmp_93 Đ!pVunicode.statictmp_95 ̐!pVunicode.statictmp_97  $dZunicode.statictmp_98 `!Zunicode.statictmp_100  $dZunicode.statictmp_101 `!Zunicode.statictmp_103  $dZunicode.statictmp_104 !Zunicode.statictmp_106 `!Zunicode.statictmp_107 !>Uunicode.statictmp_109 ! Yunicode.statictmp_111  $dZunicode.statictmp_112 `!Vunicode.statictmp_114 ! Vunicode.statictmp_116 ,!pVunicode.statictmp_117 !Zunicode.statictmp_119  $dZunicode.statictmp_120 !Vunicode.statictmp_122 Б! Vunicode.statictmp_124 !Uunicode.statictmp_126  $dZunicode.statictmp_127  !Wunicode.statictmp_129 @!Zunicode.statictmp_131  $dZunicode.statictmp_132 !Zunicode.statictmp_134 4!pVunicode.statictmp_136 ! Vunicode.statictmp_138 \unicode.statictmp_221 `!Uunicode.statictmp_223  $dZunicode.statictmp_224 `!Vunicode.statictmp_226  $dZunicode.statictmp_227 !Vunicode.statictmp_229 !Zunicode.statictmp_231  $dZunicode.statictmp_232 p!Zunicode.statictmp_234 !Uunicode.statictmp_236 !Wunicode.statictmp_237 !Zunicode.statictmp_239 ! Vunicode.statictmp_241  $dZunicode.statictmp_242 !`\unicode.statictmp_244 ! [unicode.statictmp_246  $dZunicode.statictmp_247 !Vunicode.statictmp_249  $dZunicode.statictmp_250 !Vunicode.statictmp_252 !\unicode.statictmp_254 !\unicode.statictmp_256 !Zunicode.statictmp_258  !Uunicode.statictmp_260  $dZunicode.statictmp_261 !Zunicode.statictmp_263  $dZunicode.statictmp_264  !Uunicode.statictmp_266 L!pVunicode.statictmp_268  $dZunicode.statictmp_269 !Zunicode.statictmp_271  $dZunicode.statictmp_272 !Vunicode.statictmp_274  $dZunicode.statictmp_275 !Zunicode.statictmp_277 !\unicode.statictmp_279 В! Vunicode.statictmp_281  $dZunicode.statictmp_282  !Vunicode.statictmp_284  $dZunicode.statictmp_285 !Zunicode.statictmp_287 !Zunicode.statictmp_289  $dZunicode.statictmp_290 @!Vunicode.statictmp_292  $dZunicode.statictmp_293  !Zunicode.statictmp_295  $dZunicode.statictmp_296 !Zunicode.statictmp_298  $dZunicode.statictmp_299 `!Zunicode.statictmp_301  $dZunicode.statictmp_302 !Vunicode.statictmp_304 ! Yunicode.statictmp_305 !Zunicode.statictmp_307  $dZunicode.statictmp_308 !Zunicode.statictmp_310  $dZunicode.statictmp_311  !OVunicode.statictmp_313 !Zunicode.statictmp_315  $dZunicode.statictmp_316 !Vunicode.statictmp_318 ! [unicode.statictmp_320  $dZunicode.statictmp_321  !Zunicode.statictmp_323 d!pVunicode.statictmp_325 l!pVunicode.statictmp_327 t!pVunicode.statictmp_329  $dZunicode.statictmp_330 `!Zunicode.statictmp_332  $dZunicode.statictmp_333 !Zunicode.statictmp_335  $dZunicode.statictmp_336 !Zunicode.statictmp_338  $dZunicode.statictmp_339  !Zunicode.statictmp_341  $dZunicode.statictmp_342 !Vunicode.statictmp_344  $dZunicode.statictmp_345 0!Zunicode.statictmp_347  $dZunicode.statictmp_348 @!Zunicode.statictmp_350 !Uunicode.statictmp_352  $dZunicode.statictmp_353 !Vunicode.statictmp_355  $dZunicode.statictmp_356  !Vunicode.statictmp_358  $dZunicode.statictmp_359 `!OVunicode.statictmp_361  $dZunicode.statictmp_362 P!Zunicode.statictmp_364  $dZunicode.statictmp_365 `!Zunicode.statictmp_367 |!pVunicode.statictmp_369  $dZunicode.statictmp_370 @!Vunicode.statictmp_372  $dZunicode.statictmp_373 !Zunicode.statictmp_375 p! Vunicode.statictmp_377 ! Vunicode.statictmp_379 ! Vunicode.statictmp_381 ! Vunicode.statictmp_383  $dZunicode.statictmp_384 `!Vunicode.statictmp_386  $dZunicode.statictmp_387 !Zunicode.statictmp_389  $dZunicode.statictmp_390 !Vunicode.statictmp_392  $dZunicode.statictmp_393 !Zunicode.statictmp_395 !Yunicode.statictmp_396 !Zunicode.statictmp_398  $dZunicode.statictmp_399 !Vunicode.statictmp_401 Г! Vunicode.statictmp_403 !pVunicode.statictmp_405  !Zunicode.statictmp_407 ! Vunicode.statictmp_409 @!Zunicode.statictmp_411 ! Vunicode.statictmp_413 @!Uunicode.statictmp_415 ! Vunicode.statictmp_417  $dZunicode.statictmp_418 !Vunicode.statictmp_420  ![unicode.statictmp_422  $dZunicode.statictmp_423  !Zunicode.statictmp_425 !\unicode.statictmp_427 !pVunicode.statictmp_429 ! Vunicode.statictmp_431  !Wunicode.statictmp_433 `!Zunicode.statictmp_435  $dZunicode.statictmp_436 !Vunicode.statictmp_438  $dZunicode.statictmp_439 !Vunicode.statictmp_441 !pVunicode.statictmp_443  $dZunicode.statictmp_444  !Vunicode.statictmp_446  ! Vunicode.statictmp_448 !Zunicode.statictmp_450 @! [unicode.statictmp_452 !Zunicode.statictmp_454 `!Wunicode.statictmp_455 0!Zunicode.statictmp_457 "\unicode.statictmp_458 !Xunicode.statictmp_460 @!Yunicode.statictmp_461 !OVunicode.statictmp_463 `! Yunicode.statictmp_465 ! ]unicode.statictmp_467 @! Vunicode.statictmp_469 !pVunicode.statictmp_471 !Wunicode.statictmp_472 !Uunicode.statictmp_474 !pVunicode.statictmp_476 !Wunicode.statictmp_478 P! Vunicode.statictmp_479  !.]unicode.statictmp_481  0"Q]unicode.statictmp_482 "v]unicode.statictmp_484  !Wunicode.statictmp_485 `!Wunicode.statictmp_487 !]unicode.statictmp_488 !`\unicode.statictmp_490 `! [unicode.statictmp_492 ! [unicode.statictmp_494 !>\unicode.statictmp_496  !]unicode.statictmp_497 &"]unicode.statictmp_499 `! Vunicode.statictmp_500 !Zunicode.statictmp_502  !Xunicode.statictmp_504 `!Uunicode.statictmp_506 ! [unicode.statictmp_507 p!Zunicode.statictmp_509 `!\unicode.statictmp_511 !Zunicode.statictmp_513 !^unicode.statictmp_514 !$^unicode.statictmp_516 `!\unicode.statictmp_517  !G^unicode.statictmp_519 !j^unicode.statictmp_520 !Xunicode.statictmp_522 !\unicode.statictmp_523 !Wunicode.statictmp_525 ! Vunicode.statictmp_526 !Zunicode.statictmp_528  ! ]unicode.statictmp_532 !pVunicode.statictmp_534  "^unicode.statictmp_535 `!OVunicode.statictmp_537  !\unicode.statictmp_539 "^unicode.statictmp_540 !OVunicode.statictmp_542 ! Vunicode.statictmp_544 ! Vunicode.statictmp_546 !pVunicode.statictmp_548 !pVunicode.statictmp_550 ! Vinternal/cpu.initdone· 0$internal/cpu.cpuid.args_stackmap `2ʶinternal/cpu.xgetbv.args_stackmap p2ʶregexp/syntax.anyRuneNotNL "regexp/syntax.anyRune `"regexp/syntax.statictmp_0  8Jgo.itab.*regexp/syntax.Error,error `!ʶregexp/syntax.perlGroup X"^regexp/syntax.posixGroup `"^regexp/syntax.anyTable X"Pgo.itab.regexp/syntax.ranges,sort.Interface `!ʶregexp/syntax.instOpNames "aregexp/syntax.statictmp_2 `<8_regexp/syntax.statictmp_3 P8Iregexp/syntax.statictmp_4 =*regexp/syntax.statictmp_5 =*regexp/syntax.statictmp_6 >*regexp/syntax.statictmp_7 @>*regexp/syntax.statictmp_8 `8Iregexp/syntax.statictmp_9 p8Iregexp/syntax.statictmp_10 ;8_regexp/syntax.statictmp_12 ;8_regexp/syntax.statictmp_13 @8Iregexp/syntax.statictmp_14 <8_regexp/syntax.statictmp_11 08Iregexp/syntax.statictmp_15 @=*regexp/syntax.statictmp_16  <8_regexp/syntax.statictmp_17 @<8_regexp/syntax.initdone· ;$regexp/syntax.code1 "regexp/syntax.code2 "regexp/syntax.code3 "regexp/syntax.code4 "regexp/syntax.code5  "regexp/syntax.code6 @"regexp/syntax.code7 `"regexp/syntax.code8 "regexp/syntax.code9 "regexp/syntax.code10 "regexp/syntax.code11 "regexp/syntax.code12 "regexp/syntax.code13  "regexp/syntax.code14 @"regexp/syntax.code15 `"regexp/syntax.code16 "regexp/syntax.code17 "regexp/syntax.statictmp_18 !Fregexp/syntax.statictmp_19 !Gregexp/syntax.statictmp_20 `"Qregexp/syntax.statictmp_23 !Gregexp/syntax.statictmp_24 !P_regexp/syntax.statictmp_25 !g_regexp/syntax.statictmp_26 !P_regexp/syntax.statictmp_27 !Fregexp/syntax.statictmp_28 !Gregexp/syntax.statictmp_29 !Fregexp/syntax.statictmp_30  !Fregexp/syntax.statictmp_31 !Gregexp/syntax.statictmp_32 !Gregexp/syntax.statictmp_33 !Gregexp/syntax.statictmp_34 !Gregexp/syntax.statictmp_35 !g_regexp/syntax.statictmp_36 0!Fregexp/syntax.statictmp_37 !Gregexp/syntax.statictmp_38  !g_regexp/syntax.statictmp_39 !P_regexp/syntax.statictmp_40 "~_regexp/syntax.statictmp_21 $!pVregexp/syntax.statictmp_22 !Zencoding/binary.overflow " encoding/binary.initdone· %$context.background "_context.todo "_context.closedchan "_context.Canceled " context.initdone· $$bufio.errNegativeRead " bufio.ErrNegativeCount `" bufio.ErrBufferFull " bufio.ErrInvalidUnreadByte 0" bufio.ErrInvalidUnreadRune @" bufio.errNegativeWrite " bufio.ErrFinalToken  " bufio.ErrTooLong p" bufio.ErrNegativeAdvance P" bufio.ErrAdvanceTooFar " bufio.initdone·  $text/tabwriter.statictmp_0 P;Jtext/tabwriter.tabs "text/tabwriter.statictmp_1 `;Jtext/tabwriter.vbar "text/tabwriter.newline "text/tabwriter.hbar "text/tabwriter.initdone· c$text/tabwriter..gobytes.1 x!ʶtext/tabwriter..gobytes.2 !ʶtext/tabwriter.statictmp_2 !text/tabwriter.statictmp_3 !compress/gzip.ErrHeader " hash/crc32.IEEETable "_compress/gzip.ErrChecksum " compress/gzip.statictmp_0 P2-`compress/gzip.initdone· #$io/ioutil.initdone· 3$github.com/VividCortex/gohistogram.initdone· ($github.com/go-kit/kit/metrics/internal/lv.initdone· +$compress/flate.statictmp_0 @3Jcompress/flate.statictmp_2 `3Jcompress/flate.statictmp_1 P3Jcompress/flate.levels "E`go.itab.*compress/flate.dictWriter,io.Writer `!ʶgo.itab.compress/flate.InternalError,error  !ʶcompress/flate.statictmp_3 p3Bacompress/flate.codegenOrder "compress/flate.fixedLiteralEncoding "}acompress/flate.fixedOffsetEncoding "}acompress/flate.lengthExtraBits "[dcompress/flate.offsetExtraBits  "[dcompress/flate.lengthBase "compress/flate.offsetBase "compress/flate.huffOffset "}acompress/flate.statictmp_5 3Jcompress/flate.statictmp_4 3Jgo.itab.*compress/flate.byLiteral,sort.Interface !ʶgo.itab.*compress/flate.byFreq,sort.Interface `!ʶcompress/flate.lengthCodes :"dcompress/flate.offsetCodes >"dcompress/flate.initdone· "$compress/flate.statictmp_12 `!dcompress/flate.statictmp_13 !dcompress/flate.statictmp_14 !dcompress/flate.statictmp_15 !ecompress/flate.statictmp_16 !)ecompress/flate.statictmp_17 !Cehash/crc32.castagnoliTable "_hash/crc32.updateCastagnoli "\ehash/crc32.ieeeArchImpl .$+hash/crc32.updateIEEE  "ehash/crc32.ieeeTable8 "ehash/crc32.ieeeOnce p$1hash/crc32.archIeeeTable8 "ehash/crc32.statictmp_2 3Jhash/crc32.statictmp_3 3Jhash/crc32.initdone· /$hash/crc32.ieeeCLMUL.args_stackmap 2ʶr2r1 P4ʶr4r3 `4ʶr5 /ʶrupoly 9ʶpath/filepath.ErrBadPattern P" path/filepath.SkipDir `" path/filepath.initdone· 8$math/bits.rev8tab !hash.initdone· -$runtime.pclntab sʶruntime.findfunctab Eʶruntime.typelink ^ʶruntime.itablink @rʶruntime.eitablink sʶruntime.rodata ʶruntime.erodata ]ʶruntime.types ʶruntime.etypes ]ʶruntime.noptrdata !ʶruntime.enoptrdata @"ʶruntime.data @"ʶruntime.edata "ʶruntime.bss "ʶruntime.ebss $ʶruntime.noptrbss  $ʶruntime.enoptrbss %ʶruntime.end %ʶruntime.epclntab !ʶruntime.esymtab sʶruntime.gcdata  -ʶruntime.egcdata .ʶruntime.gcbss )ʶruntime.egcbss -ʶtype.* ʶgo.func.* ʶruntime.symtab sʶruntime.textsectionmap ;ʶ...,.:.P.f.|..//// /(/,0/B8/X@/nH/P/X/`/h/p/x///4/J/`/v/////// " ": "M "Y`l p P*  & " "+ "? 0"Z @"u P" `" p" " "0 $" 8 L1 a$ zP4    . /  " &+ > S0 tD pE G 0E PJ   " 8 P9 -07 =L MC [o`N z 9  !$* M  $ 303Џ.%ЪD@c--P.$+ +: `,[ "|  ~ v ] : fb l 0 |  0 A  d e `q  @ * Q t   0  0 H `w  `  $R pJ~D`o'p s@%p%#&>@#[p#y# " " "` A0 lr "*  "$  "%)? :"Z "y "`(t(   >0a0  "@) >" "`' @3&P3A `!] !y ! ! ! !`3p33:3U(q((pVK`BC&FJ "d "| @Z #$P2 "  " "0=L $$^ "kp @*@ Np r@=d@p0 p D h P`  %$Ah0@"F "_{  0  p  #0 : P g   0  0 p  4 QP g { @  ` @    - ` F P b p y p        0    ! &! " &$M" ^"0 p" " " " "p "3" "  # !#P ;# Q# h#` z# # #P # # # # # $p '$ 7$ F$ [$0 o$p $ $p $ $ $ p $pr $ %0 % +%s >% R% d% v%& %`# %! %0 %0- %% % %`3 &s +& : >&L S& i& t& & & & &@ & & "& "&` &` &Ј ' '$'k ' ,'m ?' L' @"W'3g' t'' ($'(p,(S(v( )$(p(1)0o))) *$*0>* m* +$**P+4+\+ ,$++ !+ !+ !+ `!!, !R, `!, !, !, `!, !- !5- !W- `!|- !- !- !- !E. !o. !. `!. !. !. !. !/ @!A/ !i/ !/ `!/ `!/ !0 !00 !Y0 !0 @!0 !0 !'1 `!S1 `!u1 `!1 !1 !%2 !M2 !i2 !2 !2 !22 203 -$3 "+31=3P3Z3 "t333043 "3 .$3`>3240%4 =?4 p$S4 "i4=y4 /$4p64647484:53,53C5 "_5 "u5 @$5F5`25 F5B5 0$5E 6F6p2@6Z6@t6666P6607@07pM7ph7777е7p8&8F8`n88888@929PT9 z99 99: H": "<: 0"X: P"q:0: :P: 1$::;0;O;@o;p;;; $;3<3"<4<<4V< 4p<04<@4< $<<<N< @"< P"= `"= p"+= "<= "P=K_=Om= "z= "=PV= 2$=^=d= 3$= ]=c= `" > ">$>p0> 4$?>I> "Z> $k> $|> ">C>G>J>2>I>0I>PI>pI?H ?H?I? 5$.? 6$I| XIЀ yI| I~ I I IP~ J~ "J| AJ~ bJ JP J J J0~ J K| ,K DK@} _Kp} K} K K@ K } K`  L !L} =L`| VL0| qL} L| L LЊ L L M 8M ZMP sM M M M MP N 0N GN0 fNЉ ~N N N@ Np N O !O@ ;O YO` tO O O` O0 O OPT P@U &P CP` eP P@ PЎ PБ P $Q EQ@ gQ Q Q Q  Rp 2R` QR xR R R R R0 %S FS kS S S S@ Sp T ;T ^T TЌ T TP T U 2U XUp UЕ U U@ U@ V 7VЖ bV0 V V VP V`  W *W LW tW` W W W W  X ?X0 bX X X X X  Y 3Y SYP vYP Y0 Y Y Z ,Z TZ@ {Z Z Z Zp [ /[ O[@ n[ [ [ [` [ \` B\ d\ \ \ \p \@  ]P .] N]Х u] ] ] ] ^P "^ B^ g^ ^ ^P ^ _  _0 E_Ф c_ _ _@ _p _ ` *`@ J` n`` ` ` `` `0 a 0a Sa` ta a@ aЩ aЬ b .b Nb@ ob b b b cp 5c` Sc yc c c c c0 !d Ad ed d d d@ dp e /e Qe seЧ e eP e e f Dfp lfа f f@ f@ f gб Gg0 lg g gP g` g  h *h Qh` ph h h h h i0 8i Wi xi i i@ i j j @j dj j` j j` jе k 7k` `k k k@ k k k lW t` Ztp* qt` t ) tD t0 t` tE u`H &u* BuI `u K }u M uP~ uO u@E uP u* vP *v4 Bv > `v`C vv`Q vR v 3 vR vPS v`B w) w( 6w* Nw+ ow$ w* wv w% w`% w & x  x@ Bx \x yx x` x x x0 y0 3yp Ty yy y y y@ yP zp z 9z [zP uz z z z z { { 9{ U{p q{ { { { {Є | #|0 A| b| |p |] | |0` }q #}f K}0c q} } }P }Ѓ } ~ ~` 8~ [~ v~ ~@ ~@ ~` ~ Ђ & AP ^ {0 # V  @g "   0 ` %^ ;^ Q`_ g` }a b c Pd Հ e u   0 ! 70 Rp h {  P ` Ɂ  `    0@ G@ ]  t    тp % '  *  1 70 M a x, . V P ˃, ۃ@ N 6 R 4 O G@X Y N jI ~J \ G K ń@P ڄpU S V Y .H >L SpQ i`  " ^  0 ȅ@ }  j  `"7и G a 0 p 0k Ɇ 9$ۆ " `"E 0B '@ 9> I@ aPF sC  @ӇPw "` &0 =Pl U/{ P   p ̈     ( "7`N$ i p44щ4444'4=4S4i55 ". 5֊05@5P5`5*p5?5T5h5}5A0.ы5555%696N0c 6x06.@6.ˌ@ߌ`@P6<`62p6G6\6q6666Í6؍677 7,07@@7UP7j`7p77 0 ʎ!ߎ"  # @"50 Ip\ s pÏP܏HPC7GVPz`ѐ.Nj@`ȑp z5cMVimbe[В\@\,oCJb0pٓp4LPe~@ " " $ÔФٔ@@  :$) 4@G`@AvAԕ0 " @" H" P"&9PLa]t@C̖ $77 $ !. !B ؐ!V7i7|7778ȗ8ۗв::]z =нϘ *KPip 0ș%Ce Ú ?@^}kÛ`0"Hnм՜ p`~5_\Qp=pfɝcP1`-ALiPqBеٞ1P0nH`>=ϟ> >pZ`s  `" " X"Ϡ  p)EfPp̡p "( "= "R "g "| @" `" " "Т " " "  "  @"4 `"H "\ "p ƣ ;$ޣ "P@0<3Ie@}@C ЮΤ!`? X"W `"pв p٥ 8 ;&08A;\@8w<@= <Ȧ@< ! !`<3 `"N $!i ! ! ! !է ! !  !& !AP8[ !v ! ! !Ǩ ! ! 0! !3 !N !i= "=>ҩ@>`8p8 2F oa{yԪ w@w$`wF0vc ]P6P1p:ѫ :2z@{9hNgcgy@TVpUѬ`Ѐ!`~:@?X=op>0a`a֭ Ќ&XPh0ܮ`@2Mg` pƯܯ`P,pD`\~{{P|Ͱ0$=`TlSUW±U߱T X1Jg -۲ `p]0^M_kPef_0dڳf:p,pAH<e=7LLӴEpE  q)FIA_0uPA0DDǵ '3540PJ 3h(@*?׶S @S"@*:P*R,s0,(*η`( }:UqУ۸P?0X`wPԹ $ ?@ZyP ̺P"p<[{Ȼ޻`@P+BY@pʼ0&p= Tlp0`˽@ ?Zu`x޾z[40Oq0ܿ@`_ypPO!  Д! `!|%@o4rD xZ lpwZr0r s0`x !*}?[TЌiuqPR`tggPu7PEsYl@~fPg gf h" p"%P6vGwY0ov{'&[0Y@pII@1JF<\=s KP0 @$ @""* x"9I $Y $j "x "@`\ A# h$ " "`240D0Vpi`|`tu $p@ `"- p"Lc uvf "P $r $sx+D@_w " $ " "9 6 @):Kp[n`0p00 0>Q0r0000'0FZ0|1P1p 1'01DV@1vP1p`1p1`$1B U1v@111П#1F@W1v`1/!`p@`/`B}[~tp$` 3_P--.)_J`_k4,0^P0 <$P, + "0 "E `"W%g 2 $&(^9F00`GPFY $l:}_0: $0 2|  @!: @!T !j0C0d`ee/PfEPb[sl0|@@P/pMApSd #t0 l$n @" " $ $ $ZP2D "Vi@{  =$ "0d|+dD?R`q@0  " $ "@- .s, "?P\R %^&m % @"JKKL`9N[0k "x!l]_sd] z$ $5-ER`POtU0RTSC[0p $ p$ t$ $`  $s, !BPwSwe !x "|pEvp/K  " x$, >$@ ?$Q @$bx ($ $ " !tt " + =N "^t 0$ (!.`)op`@z2FP]]pf_ |$`P P$@5GXt $ " " `nP7pNjkpk 8$ " $ A$ $``4PL[nihlPi.iNgЮ "phв!8Q"bTs) -pP\`$Pf3 $E $Ue,u P@@pw`!`o'$7GWf`tbP] 0" `Дp"</Ч>Ra0DqC @$[ H$ $p`C+P;}Qpc`z%@pB@CP`^qPv-p@oY@m*P $' ' !#  @$*s< 5R@?v4P><5@5P45<-T/n-@0J 0!0 P$!/{-r; "Nбdz X$@. Q` $' B$9I:]pPm@Z% C$+ D$ E$ F$ 1B@rSe@u `$ ! 8! G$01P>dS e "p h$~mpm q`oPrlPn "7K_Ыpp'?v]tPp}`}0 "-.@7?O)aVn  `pP  8R@mpp, ,;,_+wmP  !(  @!! "2@ p$Pdfs`&Э@0,>pV tf`w0p2  "1 `$BO @a#^n|p$# "0( x$<ЍU bh 0"p"%  $0* $C`?U?m@A?BB`@ $PС  $6 $Mb`}`+d@eZ@fl0b@ wy!&W6L@X] $nP PdP^ @03wD $U !g y00 !p  !*:0IY@p Ж" "@ ` $+ $;Lbеu0j@P@ps @a,`E $Z k| P" `@9 p" "` 00C V(rPP| $ $ ,- `/ D[np0`@0%7pK[m $Pn $0p1 $B N\@=k 0##k`#:pLoapvnph`ZpZP@P)7M{\s*MB H "221E2g#xP^Z0:03 6( P 9 P&U d t  z w P     $ @O ` @o  $/  $J \ l } И  `  $ G s  x  5 C V h n  M pN 0  `"   P< ` 0 C 0v\  n v     p   # @ B ' 8 %P a 0  0 @m 0  ^pl%9H@V#h^|p `$`P"-0?N _r( H$& $0 0 g0kG'W !j @"{ ! `! H! $  ",fFk`0.y ./P0 "5423.PA9S.e.w ".1 $ $ 0%+: %I\q $ !88888<8((0=00R8g8{99 909@9>>P9"?7@?L?a?v`980 `" "p9 " " " 0"2 @"G "\@p AB9 "ph 0 *$P#2@CPShmm ij'& I$ J$ K$ L$. M$C N$X O$p P$ Q$ R$ S$ T$ @"s  L%h6iGiWjf0jy ipi`@ $p $+`@ $Q $by; $й` $) "8W+j @# pp P@10Iby`p)B \@rP0P  `6Ney@p.A0uZPl0@ ! $( % `7 uO _  $q @$ @: %    $ c ^!D$!2!KE!@`X!0#k!0!0!e!!!Ъ!0%!*! " @"" U$3" V$F" W$["j"0n{")" "" !"0" $"]""b#` 3#pcZ#|#a# "# $# ($# 0$#$ $ X$,$0G$e$Њ$Ф$p$$p{ %0sI%&t%`@%-%l% &@&plo& & && 'p ='P6i' 'W'L' M'M(pD?(pWf(T(`V(D(PL(PE)pB1)uU)v{)w)y) x)y**p:*W* v* h"*P*@*** + p"*+ eC+ "[+ "v++ p"+ x"+q+ Y$+0 ,), "D,@!d,7,`n,,g,p-@+- "B-Y\-}--X-Pf-.#.D. d.9.<. ". `". ". "/ "!/9;/@0U/.o/9/9/9/ "//00pk40Q0t0 0j0]0 q0`1k"1D1d1 x1 1 1 1 Z$191@1D1@ 2 2 42 @2 K2 U2P j2 2 2P 2 2Б 2p 2 2 2б 3 [$3` %3 =3 K3` ^3@ v3 3 3 3 3P3p34$4`?4a4z4`4y4`k44P5`35P5n55p55P5O 5R  6pS +6@Q F6S6@T h6 "y6 "6pf66P" 6 60W 6# 6^77*7<7@O J7 R \7P q77708 7P6 70 78P8(8<8L8U ^8pV p8 8f8 !8 `"8 @!8 "8 8P 9 9 % &90 ;9@O9@c9^ p9 \$9 "9] 9 "9 "9 "9 "9  : @": +: 7: !H: `^"\: `"k:: / :- ::s:0: : `! ;;`$ -; !F;gV;Aj;9~; @"; 3"; !; K"; `!; @!;:<:$< :8<0:L<@:`< !t< !< !<p<< !<V < ~ <Pm =t =&=`\ 8=Pd E=W W=^ m=pc {=p =0n =o =s =P=0U =@O > _ >R !>T 4>`q F>p\>  i>pt x> ]$>r > 8$>>$> >/ ?@.!?P34?7I?@8Y?p;j?P9{?=?`??0@? I?G?@H?I@#@#=@2\@,y@p"@P#@ "@ @$@u@ "@0G@J@F ApGA ^$&A4APCEAp]A`zAAA AAAB0B@;BP:LB`:]Bp:nByBBB@%BB2 CBC2rC$CC 2CC02D D@2GD@cDpD:D:DDrD@pD EE0k.EBE@OE $`EnE`EhEuEEE]EEPEPE2F ,Fpt?FPLFk`FPmF P!|F H$F X!FpF3FF3FG P$Gd#Gy5G {JG`z_G "kG ${G $G "G P"G `"G p"GЅG "GG{H H _$/H`mS.SS.hS:}S:S.S.S;S;S.S ; T0; T@;4T\FTVTpvlT "|T "TPXT "TTU IU~UPUU "V0=V lV@VVWp7W`VW b$zW "W "WQW6WSX4jWj pjjj`jpjpjpk0kNktok_ k@b k c k d k l z \zPf szz zp z@{*{I{`{0 {{{{{`z{{g |U| | ||P|i } |<}k [}@p}/} } }}F ~%~6=~:U~<p~p3~p>~ r ~u ~0 ~0  5 Xp z0  m +P;Jc0؀PPp-pGc0ā` 04pMi@@ׂ@` )D `Py҃2sU _ qa b c ń .P c``T H0y@+ h`) ُ@' `1`A 3PO`m\` "Ӓ " " "  " ", ȏ"< Џ"M ؏"[ "m "{ " " " "Ó "ғ " " (" 0"  8"' @"6 "I "\ H"w P" X" `" h" p" x"Ŕ "Ԕ " " " " "! ". "A "Q Ȑ"d А"v ؐ" " " "ŕ "֕ " " " "" "1 "A "O ("` 0"q 8"} @" H" P" X" `"̖ h"ݖ p" x" "% "9 "Rm ] "o " "@t @m Ǘn ח " " "  ȑ" Б"- ؑ"> "Q "_ "n " " " " " " ("Ҙ 0" 8" @" H" P" X"1 `"< h"G p"V x"e "o " " " " "ř "Й "ۙ " Ȓ" В" ؒ"< "I "T "a "s " " " " " ("ƚ 0"ښ 8" @" H" P"  X") `"7 h"H p"^ x"q " " " "̛ "ߛ " " "  "$ ȓ"O Г"m ؓ" " " "ɜ " " " " ") "E ("Y 0"d 8"o @"z H" P" X" `" h" p" @" "  x" ". "E "U "d "r "| " " " " Ȕ"֞ Д" ؔ" " "{ - "= "H "S "^ "r " " (" 0" 8"͟ @"ޟ H" P" X" `" h"+ p": x"I "f "u " " " "y z ΠPz ޠ " "  " ȕ"0 Е"D ؕ"X "c "m "x " " ! `" "š "ס " " ("  0" 8"( @"6 H"E} R e$do qr ~v  ! " "Ӣ $ `! " $+ !A `"W `!m ! " ! "ģ "ڣ $ `! " !2 `"H ,!^ !t " $ ! !ˤ " Б! "  !# `"9 $O !e "{ @! " " $ҥ ! `" 4! "* !@ "V  `"T $j ! " " $ !׶ " ! `" $/ !E "[ !q " \! $ !ȷ "޷ d! `"  l!  "6 t!L "b $x " `! `" $ϸ ! " $ !' "= $S !i "~ " $ ! `"ֹ $ 0! " $. @!D "Z !o ! " $ !Ǻ `"ݺ $ !  " $5 `!K "` "v $ P! `" $λ `! " |! "& $< !Q @!g "} $ ! `" p!ռ " ! " !- !B "X !n `" $ `! "ƽ $ܽ ! " $ "3 !I `"_ $u ! " ! !; " $ ! "# Q"8 `"N Г!d "z ! " ! "ҿ ! `" @! W") "? !U "k @! " ! `" $ ! " " !0 "F $\ !r `" ! " ! " ! !  "! !7 `"M `!c "y $ ! " $ ! " `" !( "> $T !j " ! " ! `" " @! " !/ "E `![ 0!q " " ! `" `! @! !  "  `!6 "L !b "x @! `" ! " " ! ! "' != `"S !i " P! ! " " 0" " " !. `!D `"Z !p ! " @! `! " ! "  ! `"5 !K &"a "w `! G" " ! " ! `" `!$ ": !P p!f "| `! ! " ! `" ! ! "+ `!A !W "m ! " ! `" ! ! " ! !2 "H !^ w"t B" ! " ! `" " `!  "# !9 "O "e @7"z ! " ! `" ! " ! "* !@ "V `"k ! ! ! " `! )" ! " !( != "R !g `"| ! " ! " " ! `" !# "8 "M !b "w ! " ! ! `" ! !  " !3 @!H "] "r @" `" " ! `" Đ! " ̐! ". $C `!X "m@x xpQTKN WY \>pVSp^j^ ! ! $f32.40d00000$f32.4b189680$f32.80000000$f32.cb189680$f64.3d53de6af278ece6$f64.3eb0000000000000$f64.3efa01a01a01a01a$f64.3f2a01a01a01a01a$f64.3f56c16c16c16c17$f64.3f81111111111111$f64.3f90000000000000$f64.3fa5555555555555$f64.3fa999999999999a$f64.3fb0000000000000$f64.3fc5555555555555$f64.3fd0000000000000$f64.3fe0000000000000$f64.3fe62e42fefa3000$f64.3fec000000000000$f64.3fee666666666666$f64.3ff0000000000000$f64.3ff71547652b82fe$f64.3ffe000000000000$f64.4000000000000000$f64.4010000000000000$f64.4014000000000000$f64.4024000000000000$f64.403a000000000000$f64.4059000000000000$f64.40862e42fefa39ef$f64.412e848000000000$f64.41cdcd6500000000$f64.430c6bf526340000$f64.43e0000000000000$f64.8000000000000000$f64.bfe62e42fefa39ef$f64.c30c6bf526340000__cgo_init__cgo_notify_runtime_init_done__cgo_thread_start__cgo_yield__rt0_amd64_darwinbufio.(*Writer).Availablebufio.(*Writer).Bufferedbufio.(*Writer).Flushbufio.(*Writer).ReadFrombufio.(*Writer).Writebufio.(*Writer).WriteStringbufio.ErrAdvanceTooFarbufio.ErrBufferFullbufio.ErrFinalTokenbufio.ErrInvalidUnreadBytebufio.ErrInvalidUnreadRunebufio.ErrNegativeAdvancebufio.ErrNegativeCountbufio.ErrTooLongbufio.NewWriterbufio.NewWriterSizebufio.errNegativeReadbufio.errNegativeWritebufio.initbufio.initdone.bytes.(*Buffer).Bytesbytes.(*Buffer).Lenbytes.(*Buffer).Readbytes.(*Buffer).ReadFrombytes.(*Buffer).ReadRunebytes.(*Buffer).Resetbytes.(*Buffer).Stringbytes.(*Buffer).Writebytes.(*Buffer).WriteBytebytes.(*Buffer).WriteRunebytes.(*Buffer).WriteStringbytes.(*Buffer).WriteTobytes.(*Buffer).growbytes.(*Buffer).tryGrowByReslicebytes.(*Reader).Lenbytes.(*Reader).Readbytes.(*Reader).ReadRunebytes.(*Reader).Sizebytes.(*Reader).WriteTobytes.Equalbytes.ErrTooLargebytes.HasPrefixbytes.Indexbytes.IndexBytebytes.NewBufferbytes.NewReaderbytes.hashStrbytes.indexShortStrbytes.initbytes.init.0bytes.initdone.bytes.makeSlicebytes.makeSlice.func1bytes.shortStringLenbytes.statictmp_2bytes.statictmp_5_callRetcompress/flate.(*InternalError).Errorcompress/flate.(*Writer).Closecompress/flate.(*Writer).Resetcompress/flate.(*Writer).Writecompress/flate.(*byFreq).Lencompress/flate.(*byFreq).Lesscompress/flate.(*byFreq).Swapcompress/flate.(*byFreq).sortcompress/flate.(*byLiteral).Lencompress/flate.(*byLiteral).Lesscompress/flate.(*byLiteral).Swapcompress/flate.(*byLiteral).sortcompress/flate.(*compressor).closecompress/flate.(*compressor).deflatecompress/flate.(*compressor).encSpeedcompress/flate.(*compressor).fillDeflatecompress/flate.(*compressor).fillStorecompress/flate.(*compressor).fillWindowcompress/flate.(*compressor).findMatchcompress/flate.(*compressor).initcompress/flate.(*compressor).initDeflatecompress/flate.(*compressor).resetcompress/flate.(*compressor).storecompress/flate.(*compressor).storeHuffcompress/flate.(*compressor).writecompress/flate.(*compressor).writeBlockcompress/flate.(*compressor).writeStoredBlockcompress/flate.(*deflateFast).encodecompress/flate.(*deflateFast).matchLencompress/flate.(*deflateFast).resetcompress/flate.(*deflateFast).resetAllcompress/flate.(*dictWriter).Writecompress/flate.(*hcode).setcompress/flate.(*huffmanBitWriter).dynamicSizecompress/flate.(*huffmanBitWriter).fixedSizecompress/flate.(*huffmanBitWriter).flushcompress/flate.(*huffmanBitWriter).generateCodegencompress/flate.(*huffmanBitWriter).indexTokenscompress/flate.(*huffmanBitWriter).resetcompress/flate.(*huffmanBitWriter).storedSizecompress/flate.(*huffmanBitWriter).writecompress/flate.(*huffmanBitWriter).writeBitscompress/flate.(*huffmanBitWriter).writeBlockcompress/flate.(*huffmanBitWriter).writeBlockDynamiccompress/flate.(*huffmanBitWriter).writeBlockHuffcompress/flate.(*huffmanBitWriter).writeBytescompress/flate.(*huffmanBitWriter).writeCodecompress/flate.(*huffmanBitWriter).writeDynamicHeadercompress/flate.(*huffmanBitWriter).writeFixedHeadercompress/flate.(*huffmanBitWriter).writeStoredHeadercompress/flate.(*huffmanBitWriter).writeTokenscompress/flate.(*huffmanEncoder).assignEncodingAndSizecompress/flate.(*huffmanEncoder).bitCountscompress/flate.(*huffmanEncoder).bitLengthcompress/flate.(*huffmanEncoder).generatecompress/flate.InternalError.Errorcompress/flate.NewWritercompress/flate.bulkHash4compress/flate.byFreq.Lencompress/flate.byFreq.Lesscompress/flate.byFreq.Swapcompress/flate.byLiteral.Lencompress/flate.byLiteral.Lesscompress/flate.byLiteral.Swapcompress/flate.codegenOrdercompress/flate.emitLiteralcompress/flate.fixedLiteralEncodingcompress/flate.fixedOffsetEncodingcompress/flate.generateFixedLiteralEncodingcompress/flate.generateFixedOffsetEncodingcompress/flate.hashcompress/flate.hash4compress/flate.histogramcompress/flate.huffOffsetcompress/flate.initcompress/flate.init.0compress/flate.initdone.compress/flate.lengthBasecompress/flate.lengthCodecompress/flate.lengthCodescompress/flate.lengthExtraBitscompress/flate.levelscompress/flate.literalTokencompress/flate.load32compress/flate.load64compress/flate.matchLencompress/flate.matchTokencompress/flate.maxNodecompress/flate.newDeflateFastcompress/flate.newHuffmanBitWritercompress/flate.newHuffmanEncodercompress/flate.offsetBasecompress/flate.offsetCodecompress/flate.offsetCodescompress/flate.offsetExtraBitscompress/flate.reverseBitscompress/flate.statictmp_0compress/flate.statictmp_1compress/flate.statictmp_12compress/flate.statictmp_13compress/flate.statictmp_14compress/flate.statictmp_15compress/flate.statictmp_16compress/flate.statictmp_17compress/flate.statictmp_2compress/flate.statictmp_3compress/flate.statictmp_4compress/flate.statictmp_5compress/flate.token.lengthcompress/flate.token.literalcompress/flate.token.offsetcompress/gzip.(*Writer).Closecompress/gzip.(*Writer).Writecompress/gzip.(*Writer).initcompress/gzip.(*Writer).writeBytescompress/gzip.(*Writer).writeStringcompress/gzip.ErrChecksumcompress/gzip.ErrHeadercompress/gzip.NewWriterLevelcompress/gzip.initcompress/gzip.initdone.compress/gzip.statictmp_0context.(*emptyCtx).Stringcontext.Canceledcontext.backgroundcontext.closedchancontext.initcontext.init.0context.initdone.context.todoencoding/binary.(*bigEndian).GoStringencoding/binary.(*bigEndian).PutUint16encoding/binary.(*bigEndian).PutUint32encoding/binary.(*bigEndian).PutUint64encoding/binary.(*bigEndian).Stringencoding/binary.(*bigEndian).Uint16encoding/binary.(*bigEndian).Uint32encoding/binary.(*bigEndian).Uint64encoding/binary.(*littleEndian).GoStringencoding/binary.(*littleEndian).PutUint16encoding/binary.(*littleEndian).PutUint32encoding/binary.(*littleEndian).PutUint64encoding/binary.(*littleEndian).Stringencoding/binary.(*littleEndian).Uint16encoding/binary.(*littleEndian).Uint32encoding/binary.(*littleEndian).Uint64encoding/binary.bigEndian.GoStringencoding/binary.bigEndian.PutUint16encoding/binary.bigEndian.PutUint32encoding/binary.bigEndian.PutUint64encoding/binary.bigEndian.Stringencoding/binary.bigEndian.Uint16encoding/binary.bigEndian.Uint32encoding/binary.bigEndian.Uint64encoding/binary.initencoding/binary.initdone.encoding/binary.littleEndian.GoStringencoding/binary.littleEndian.PutUint16encoding/binary.littleEndian.PutUint32encoding/binary.littleEndian.PutUint64encoding/binary.littleEndian.Stringencoding/binary.littleEndian.Uint16encoding/binary.littleEndian.Uint32encoding/binary.littleEndian.Uint64encoding/binary.overflowerrors.(*errorString).Errorerrors.Newflag.(*FlagSet).(flag.defaultUsage)-fmflag.(*FlagSet).Boolflag.(*FlagSet).BoolVarflag.(*FlagSet).Durationflag.(*FlagSet).DurationVarflag.(*FlagSet).Intflag.(*FlagSet).IntVarflag.(*FlagSet).Parseflag.(*FlagSet).Parsedflag.(*FlagSet).PrintDefaultsflag.(*FlagSet).PrintDefaults.func1flag.(*FlagSet).Stringflag.(*FlagSet).StringVarflag.(*FlagSet).Uintflag.(*FlagSet).UintVarflag.(*FlagSet).Varflag.(*FlagSet).VisitAllflag.(*FlagSet).defaultUsageflag.(*FlagSet).failfflag.(*FlagSet).outflag.(*FlagSet).parseOneflag.(*FlagSet).usageflag.(*boolValue).IsBoolFlagflag.(*boolValue).Setflag.(*boolValue).Stringflag.(*durationValue).Setflag.(*durationValue).Stringflag.(*float64Value).Setflag.(*float64Value).Stringflag.(*int64Value).Setflag.(*int64Value).Stringflag.(*intValue).Setflag.(*intValue).Stringflag.(*stringValue).Setflag.(*stringValue).Stringflag.(*uint64Value).Setflag.(*uint64Value).Stringflag.(*uintValue).Setflag.(*uintValue).Stringflag.Boolflag.CommandLineflag.Durationflag.ErrHelpflag.Intflag.NewFlagSetflag.Parseflag.Parsedflag.PrintDefaultsflag.Stringflag.Uintflag.UnquoteUsageflag.Usageflag.commandLineUsageflag.glob..func1flag.initflag.init.0flag.initdone.flag.isZeroValueflag.newBoolValueflag.newDurationValueflag.newIntValueflag.newStringValueflag.newUintValueflag.sortFlagsflag.statictmp_0fmt.(*buffer).Writefmt.(*buffer).WriteBytefmt.(*buffer).WriteRunefmt.(*buffer).WriteStringfmt.(*fmt).clearflagsfmt.(*fmt).fmt_booleanfmt.(*fmt).fmt_bxfmt.(*fmt).fmt_cfmt.(*fmt).fmt_floatfmt.(*fmt).fmt_integerfmt.(*fmt).fmt_qfmt.(*fmt).fmt_qcfmt.(*fmt).fmt_sfmt.(*fmt).fmt_sbxfmt.(*fmt).fmt_sxfmt.(*fmt).fmt_unicodefmt.(*fmt).initfmt.(*fmt).padfmt.(*fmt).padStringfmt.(*fmt).truncatefmt.(*fmt).writePaddingfmt.(*pp).Flagfmt.(*pp).Precisionfmt.(*pp).Widthfmt.(*pp).Writefmt.(*pp).argNumberfmt.(*pp).badArgNumfmt.(*pp).badVerbfmt.(*pp).catchPanicfmt.(*pp).doPrintfmt.(*pp).doPrintffmt.(*pp).doPrintlnfmt.(*pp).fmt0x64fmt.(*pp).fmtBoolfmt.(*pp).fmtBytesfmt.(*pp).fmtComplexfmt.(*pp).fmtFloatfmt.(*pp).fmtIntegerfmt.(*pp).fmtPointerfmt.(*pp).fmtStringfmt.(*pp).freefmt.(*pp).handleMethodsfmt.(*pp).missingArgfmt.(*pp).printArgfmt.(*pp).printValuefmt.(*pp).unknownTypefmt.Errorffmt.Fprintfmt.Fprintffmt.Fprintlnfmt.Printffmt.Printlnfmt.Sprintffmt.boolErrorfmt.complexErrorfmt.getFieldfmt.glob..func1fmt.initfmt.initdone.fmt.intFromArgfmt.newPrinterfmt.parseArgNumberfmt.parsenumfmt.ppFreefmt.statictmp_0fmt.tooLargegithub.com/VividCortex/gohistogram.initgithub.com/VividCortex/gohistogram.initdone.github.com/go-kit/kit/metrics.(*Timer).ObserveDurationgithub.com/go-kit/kit/metrics.(*Timer).Unitgithub.com/go-kit/kit/metrics.NewTimergithub.com/go-kit/kit/metrics.initgithub.com/go-kit/kit/metrics.initdone.github.com/go-kit/kit/metrics/generic.(*SimpleHistogram).ApproximateMovingAveragegithub.com/go-kit/kit/metrics/generic.(*SimpleHistogram).Observegithub.com/go-kit/kit/metrics/generic.(*SimpleHistogram).Withgithub.com/go-kit/kit/metrics/generic.NewSimpleHistogramgithub.com/go-kit/kit/metrics/generic.initgithub.com/go-kit/kit/metrics/generic.initdone.github.com/go-kit/kit/metrics/internal/lv.LabelValues.Withgithub.com/go-kit/kit/metrics/internal/lv.initgithub.com/go-kit/kit/metrics/internal/lv.initdone.github.com/go-kit/kit/metrics_test.TestTimerFastgithub.com/go-kit/kit/metrics_test.TestTimerSlowgithub.com/go-kit/kit/metrics_test.TestTimerUnitgithub.com/go-kit/kit/metrics_test.initgithub.com/go-kit/kit/metrics_test.initdone.go.func.*go.itab.*bufio.Writer,io.Writergo.itab.*bytes.Buffer,io.Writergo.itab.*bytes.Reader,io.Readergo.itab.*compress/flate.byFreq,sort.Interfacego.itab.*compress/flate.byLiteral,sort.Interfacego.itab.*compress/flate.dictWriter,io.Writergo.itab.*errors.errorString,errorgo.itab.*flag.boolValue,flag.Valuego.itab.*flag.durationValue,flag.Valuego.itab.*flag.float64Value,flag.Valuego.itab.*flag.int64Value,flag.Valuego.itab.*flag.intValue,flag.Valuego.itab.*flag.stringValue,flag.Valuego.itab.*flag.uint64Value,flag.Valuego.itab.*flag.uintValue,flag.Valuego.itab.*fmt.pp,fmt.Statego.itab.*github.com/go-kit/kit/metrics/generic.SimpleHistogram,github.com/go-kit/kit/metrics.Histogramgo.itab.*internal/poll.TimeoutError,errorgo.itab.*os.File,io.Readergo.itab.*os.File,io.Writergo.itab.*os.LinkError,errorgo.itab.*os.PathError,errorgo.itab.*os.SyscallError,errorgo.itab.*os.fileStat,os.FileInfogo.itab.*reflect.rtype,reflect.Typego.itab.*regexp.inputBytes,regexp.inputgo.itab.*regexp.inputReader,regexp.inputgo.itab.*regexp.inputString,regexp.inputgo.itab.*regexp/syntax.Error,errorgo.itab.*runtime/pprof.keysByCount,sort.Interfacego.itab.*strconv.NumError,errorgo.itab.*text/tabwriter.Writer,io.Writergo.itab.compress/flate.InternalError,errorgo.itab.encoding/binary.bigEndian,encoding/binary.ByteOrdergo.itab.encoding/binary.littleEndian,encoding/binary.ByteOrdergo.itab.regexp.runeSlice,sort.Interfacego.itab.regexp/syntax.ranges,sort.Interfacego.itab.runtime.errorString,errorgo.itab.runtime/pprof.runtimeProfile,runtime/pprof.countProfilego.itab.runtime/pprof.stackProfile,runtime/pprof.countProfilego.itab.runtime/pprof.stackProfile,sort.Interfacego.itab.sort.StringSlice,sort.Interfacego.itab.syscall.Errno,errorgo.itab.testing.indenter,io.Writergo.itab.testing/internal/testdeps.TestDeps,testing.testDepsgo.itab.time.fileSizeError,errorgo.string.*_gosavehash.inithash.initdone.hash/crc32.IEEETablehash/crc32.Updatehash/crc32.archAvailableIEEEhash/crc32.archIeeeTable8hash/crc32.archInitIEEEhash/crc32.archUpdateIEEEhash/crc32.castagnoliTablehash/crc32.ieeeArchImplhash/crc32.ieeeCLMULhash/crc32.ieeeCLMUL.args_stackmaphash/crc32.ieeeInithash/crc32.ieeeInit.func1hash/crc32.ieeeOncehash/crc32.ieeeTable8hash/crc32.inithash/crc32.initdone.hash/crc32.simpleMakeTablehash/crc32.simplePopulateTablehash/crc32.simpleUpdatehash/crc32.slicingMakeTablehash/crc32.slicingUpdatehash/crc32.statictmp_2hash/crc32.statictmp_3hash/crc32.updateCastagnolihash/crc32.updateIEEEinternal/cpu.X86internal/cpu.cpuidinternal/cpu.cpuid.args_stackmapinternal/cpu.initinternal/cpu.init.0internal/cpu.initdone.internal/cpu.isSetinternal/cpu.xgetbvinternal/cpu.xgetbv.args_stackmapinternal/poll.(*FD).Closeinternal/poll.(*FD).Fstatinternal/poll.(*FD).Initinternal/poll.(*FD).Preadinternal/poll.(*FD).Readinternal/poll.(*FD).ReadDirentinternal/poll.(*FD).Writeinternal/poll.(*FD).decrefinternal/poll.(*FD).destroyinternal/poll.(*FD).eofErrorinternal/poll.(*FD).increfinternal/poll.(*FD).readLockinternal/poll.(*FD).readUnlockinternal/poll.(*FD).writeLockinternal/poll.(*FD).writeUnlockinternal/poll.(*TimeoutError).Errorinternal/poll.(*fdMutex).decrefinternal/poll.(*fdMutex).increfinternal/poll.(*fdMutex).increfAndCloseinternal/poll.(*fdMutex).rwlockinternal/poll.(*fdMutex).rwunlockinternal/poll.(*pollDesc).closeinternal/poll.(*pollDesc).evictinternal/poll.(*pollDesc).initinternal/poll.(*pollDesc).pollableinternal/poll.(*pollDesc).prepareinternal/poll.(*pollDesc).prepareReadinternal/poll.(*pollDesc).prepareWriteinternal/poll.(*pollDesc).waitinternal/poll.(*pollDesc).waitReadinternal/poll.(*pollDesc).waitWriteinternal/poll.CloseFuncinternal/poll.ErrFileClosinginternal/poll.ErrNetClosinginternal/poll.ErrTimeoutinternal/poll.convertErrinternal/poll.errClosinginternal/poll.initinternal/poll.initdone.internal/poll.runtime_Semacquireinternal/poll.runtime_Semreleaseinternal/poll.runtime_pollCloseinternal/poll.runtime_pollOpeninternal/poll.runtime_pollResetinternal/poll.runtime_pollServerInitinternal/poll.runtime_pollUnblockinternal/poll.runtime_pollWaitinternal/poll.serverInitinternal/poll.statictmp_0internal/poll.statictmp_1internal/poll.statictmp_2internal/poll.statictmp_3internal/poll.statictmp_4internal/poll.statictmp_5internal/poll.statictmp_6internal/poll.statictmp_7internal/race.Enableinternal/race.Errorsio.Copyio.EOFio.ErrClosedPipeio.ErrNoProgressio.ErrShortBufferio.ErrShortWriteio.ErrUnexpectedEOFio.WriteStringio.copyBufferio.errOffsetio.errWhenceio.initio.initdone.io/ioutil.ReadFileio/ioutil.initio/ioutil.initdone.io/ioutil.readAllio/ioutil.readAll.func1main.benchmarksmain.examplesmain.initmain.init.0main.initdone.main.mainmain.statictmp_0main.statictmp_1main.statictmp_2main.tests_masksmath.Absmath.Expmath.Exp.args_stackmapmath.Float32bitsmath.Float32frombitsmath.Float64bitsmath.Float64frombitsmath.Infmath.NaNmath.initmath.initdone.math.useSSE41math/bits.Reverse16math/bits.rev8tabos.(*File).Closeos.(*File).Nameos.(*File).Reados.(*File).ReadAtos.(*File).Readdirnamesos.(*File).Statos.(*File).Writeos.(*File).WriteStringos.(*File).checkValidos.(*File).preados.(*File).reados.(*File).readdirnamesos.(*File).wrapErros.(*File).writeos.(*FileMode).IsDiros.(*FileMode).Stringos.(*LinkError).Erroros.(*PathError).Erroros.(*SyscallError).Erroros.(*file).closeos.(*fileStat).IsDiros.(*fileStat).ModTimeos.(*fileStat).Modeos.(*fileStat).Nameos.(*fileStat).Sizeos.(*fileStat).Sysos.Argsos.Chmodos.Createos.ErrClosedos.ErrExistos.ErrInvalidos.ErrNotExistos.ErrPermissionos.Exitos.FileMode.IsDiros.FileMode.Permos.FileMode.Stringos.Getenvos.Getwdos.IsNotExistos.IsPathSeparatoros.Lstatos.NewFileos.NewSyscallErroros.Openos.OpenFileos.Pipeos.SameFileos.Statos.Stderros.Stdinos.Stdoutos.basenameos.chmodos.epipecheckos.errFinishedos.executablePathos.fillFileStatFromSysos.fixLongPathos.getwdCacheos.glob..func1os.initos.init.0os.init.1os.initCwdos.initCwdErros.initdone.os.isNotExistos.newFileos.runtime_argsos.runtime_beforeExitos.sameFileos.sigpipeos.statictmp_1os.statictmp_4os.statictmp_5os.syscallModeos.timespecToTimeos.underlyingErroros.useSyscallwdos.useSyscallwdDarwinos.wrapSyscallErrorpath/filepath.ErrBadPatternpath/filepath.SkipDirpath/filepath.initpath/filepath.initdone._r2r1_r4r3_r5reflect.(*ChanDir).Stringreflect.(*Kind).Stringreflect.(*Value).Kindreflect.(*Value).Lenreflect.(*Value).NumFieldreflect.(*Value).NumMethodreflect.(*Value).Stringreflect.(*ValueError).Errorreflect.(*arrayType).Alignreflect.(*arrayType).AssignableToreflect.(*arrayType).Bitsreflect.(*arrayType).ChanDirreflect.(*arrayType).Comparablereflect.(*arrayType).ConvertibleToreflect.(*arrayType).Elemreflect.(*arrayType).Fieldreflect.(*arrayType).FieldAlignreflect.(*arrayType).FieldByIndexreflect.(*arrayType).FieldByNamereflect.(*arrayType).FieldByNameFuncreflect.(*arrayType).Implementsreflect.(*arrayType).Inreflect.(*arrayType).IsVariadicreflect.(*arrayType).Keyreflect.(*arrayType).Kindreflect.(*arrayType).Lenreflect.(*arrayType).Methodreflect.(*arrayType).MethodByNamereflect.(*arrayType).Namereflect.(*arrayType).NumFieldreflect.(*arrayType).NumInreflect.(*arrayType).NumMethodreflect.(*arrayType).NumOutreflect.(*arrayType).Outreflect.(*arrayType).PkgPathreflect.(*arrayType).Sizereflect.(*arrayType).Stringreflect.(*arrayType).commonreflect.(*arrayType).uncommonreflect.(*bitVector).appendreflect.(*chanType).Alignreflect.(*chanType).AssignableToreflect.(*chanType).Bitsreflect.(*chanType).ChanDirreflect.(*chanType).Comparablereflect.(*chanType).ConvertibleToreflect.(*chanType).Elemreflect.(*chanType).Fieldreflect.(*chanType).FieldAlignreflect.(*chanType).FieldByIndexreflect.(*chanType).FieldByNamereflect.(*chanType).FieldByNameFuncreflect.(*chanType).Implementsreflect.(*chanType).Inreflect.(*chanType).IsVariadicreflect.(*chanType).Keyreflect.(*chanType).Kindreflect.(*chanType).Lenreflect.(*chanType).Methodreflect.(*chanType).MethodByNamereflect.(*chanType).Namereflect.(*chanType).NumFieldreflect.(*chanType).NumInreflect.(*chanType).NumMethodreflect.(*chanType).NumOutreflect.(*chanType).Outreflect.(*chanType).PkgPathreflect.(*chanType).Sizereflect.(*chanType).Stringreflect.(*chanType).commonreflect.(*chanType).uncommonreflect.(*funcType).Alignreflect.(*funcType).AssignableToreflect.(*funcType).Bitsreflect.(*funcType).ChanDirreflect.(*funcType).Comparablereflect.(*funcType).ConvertibleToreflect.(*funcType).Elemreflect.(*funcType).Fieldreflect.(*funcType).FieldAlignreflect.(*funcType).FieldByIndexreflect.(*funcType).FieldByNamereflect.(*funcType).FieldByNameFuncreflect.(*funcType).Implementsreflect.(*funcType).Inreflect.(*funcType).IsVariadicreflect.(*funcType).Keyreflect.(*funcType).Kindreflect.(*funcType).Lenreflect.(*funcType).Methodreflect.(*funcType).MethodByNamereflect.(*funcType).Namereflect.(*funcType).NumFieldreflect.(*funcType).NumInreflect.(*funcType).NumMethodreflect.(*funcType).NumOutreflect.(*funcType).Outreflect.(*funcType).PkgPathreflect.(*funcType).Sizereflect.(*funcType).Stringreflect.(*funcType).commonreflect.(*funcType).inreflect.(*funcType).outreflect.(*funcType).uncommonreflect.(*funcTypeFixed128).Alignreflect.(*funcTypeFixed128).AssignableToreflect.(*funcTypeFixed128).Bitsreflect.(*funcTypeFixed128).ChanDirreflect.(*funcTypeFixed128).Comparablereflect.(*funcTypeFixed128).ConvertibleToreflect.(*funcTypeFixed128).Elemreflect.(*funcTypeFixed128).Fieldreflect.(*funcTypeFixed128).FieldAlignreflect.(*funcTypeFixed128).FieldByIndexreflect.(*funcTypeFixed128).FieldByNamereflect.(*funcTypeFixed128).FieldByNameFuncreflect.(*funcTypeFixed128).Implementsreflect.(*funcTypeFixed128).Inreflect.(*funcTypeFixed128).IsVariadicreflect.(*funcTypeFixed128).Keyreflect.(*funcTypeFixed128).Kindreflect.(*funcTypeFixed128).Lenreflect.(*funcTypeFixed128).Methodreflect.(*funcTypeFixed128).MethodByNamereflect.(*funcTypeFixed128).Namereflect.(*funcTypeFixed128).NumFieldreflect.(*funcTypeFixed128).NumInreflect.(*funcTypeFixed128).NumMethodreflect.(*funcTypeFixed128).NumOutreflect.(*funcTypeFixed128).Outreflect.(*funcTypeFixed128).PkgPathreflect.(*funcTypeFixed128).Sizereflect.(*funcTypeFixed128).Stringreflect.(*funcTypeFixed128).commonreflect.(*funcTypeFixed128).uncommonreflect.(*funcTypeFixed16).Alignreflect.(*funcTypeFixed16).AssignableToreflect.(*funcTypeFixed16).Bitsreflect.(*funcTypeFixed16).ChanDirreflect.(*funcTypeFixed16).Comparablereflect.(*funcTypeFixed16).ConvertibleToreflect.(*funcTypeFixed16).Elemreflect.(*funcTypeFixed16).Fieldreflect.(*funcTypeFixed16).FieldAlignreflect.(*funcTypeFixed16).FieldByIndexreflect.(*funcTypeFixed16).FieldByNamereflect.(*funcTypeFixed16).FieldByNameFuncreflect.(*funcTypeFixed16).Implementsreflect.(*funcTypeFixed16).Inreflect.(*funcTypeFixed16).IsVariadicreflect.(*funcTypeFixed16).Keyreflect.(*funcTypeFixed16).Kindreflect.(*funcTypeFixed16).Lenreflect.(*funcTypeFixed16).Methodreflect.(*funcTypeFixed16).MethodByNamereflect.(*funcTypeFixed16).Namereflect.(*funcTypeFixed16).NumFieldreflect.(*funcTypeFixed16).NumInreflect.(*funcTypeFixed16).NumMethodreflect.(*funcTypeFixed16).NumOutreflect.(*funcTypeFixed16).Outreflect.(*funcTypeFixed16).PkgPathreflect.(*funcTypeFixed16).Sizereflect.(*funcTypeFixed16).Stringreflect.(*funcTypeFixed16).commonreflect.(*funcTypeFixed16).uncommonreflect.(*funcTypeFixed32).Alignreflect.(*funcTypeFixed32).AssignableToreflect.(*funcTypeFixed32).Bitsreflect.(*funcTypeFixed32).ChanDirreflect.(*funcTypeFixed32).Comparablereflect.(*funcTypeFixed32).ConvertibleToreflect.(*funcTypeFixed32).Elemreflect.(*funcTypeFixed32).Fieldreflect.(*funcTypeFixed32).FieldAlignreflect.(*funcTypeFixed32).FieldByIndexreflect.(*funcTypeFixed32).FieldByNamereflect.(*funcTypeFixed32).FieldByNameFuncreflect.(*funcTypeFixed32).Implementsreflect.(*funcTypeFixed32).Inreflect.(*funcTypeFixed32).IsVariadicreflect.(*funcTypeFixed32).Keyreflect.(*funcTypeFixed32).Kindreflect.(*funcTypeFixed32).Lenreflect.(*funcTypeFixed32).Methodreflect.(*funcTypeFixed32).MethodByNamereflect.(*funcTypeFixed32).Namereflect.(*funcTypeFixed32).NumFieldreflect.(*funcTypeFixed32).NumInreflect.(*funcTypeFixed32).NumMethodreflect.(*funcTypeFixed32).NumOutreflect.(*funcTypeFixed32).Outreflect.(*funcTypeFixed32).PkgPathreflect.(*funcTypeFixed32).Sizereflect.(*funcTypeFixed32).Stringreflect.(*funcTypeFixed32).commonreflect.(*funcTypeFixed32).uncommonreflect.(*funcTypeFixed4).Alignreflect.(*funcTypeFixed4).AssignableToreflect.(*funcTypeFixed4).Bitsreflect.(*funcTypeFixed4).ChanDirreflect.(*funcTypeFixed4).Comparablereflect.(*funcTypeFixed4).ConvertibleToreflect.(*funcTypeFixed4).Elemreflect.(*funcTypeFixed4).Fieldreflect.(*funcTypeFixed4).FieldAlignreflect.(*funcTypeFixed4).FieldByIndexreflect.(*funcTypeFixed4).FieldByNamereflect.(*funcTypeFixed4).FieldByNameFuncreflect.(*funcTypeFixed4).Implementsreflect.(*funcTypeFixed4).Inreflect.(*funcTypeFixed4).IsVariadicreflect.(*funcTypeFixed4).Keyreflect.(*funcTypeFixed4).Kindreflect.(*funcTypeFixed4).Lenreflect.(*funcTypeFixed4).Methodreflect.(*funcTypeFixed4).MethodByNamereflect.(*funcTypeFixed4).Namereflect.(*funcTypeFixed4).NumFieldreflect.(*funcTypeFixed4).NumInreflect.(*funcTypeFixed4).NumMethodreflect.(*funcTypeFixed4).NumOutreflect.(*funcTypeFixed4).Outreflect.(*funcTypeFixed4).PkgPathreflect.(*funcTypeFixed4).Sizereflect.(*funcTypeFixed4).Stringreflect.(*funcTypeFixed4).commonreflect.(*funcTypeFixed4).uncommonreflect.(*funcTypeFixed64).Alignreflect.(*funcTypeFixed64).AssignableToreflect.(*funcTypeFixed64).Bitsreflect.(*funcTypeFixed64).ChanDirreflect.(*funcTypeFixed64).Comparablereflect.(*funcTypeFixed64).ConvertibleToreflect.(*funcTypeFixed64).Elemreflect.(*funcTypeFixed64).Fieldreflect.(*funcTypeFixed64).FieldAlignreflect.(*funcTypeFixed64).FieldByIndexreflect.(*funcTypeFixed64).FieldByNamereflect.(*funcTypeFixed64).FieldByNameFuncreflect.(*funcTypeFixed64).Implementsreflect.(*funcTypeFixed64).Inreflect.(*funcTypeFixed64).IsVariadicreflect.(*funcTypeFixed64).Keyreflect.(*funcTypeFixed64).Kindreflect.(*funcTypeFixed64).Lenreflect.(*funcTypeFixed64).Methodreflect.(*funcTypeFixed64).MethodByNamereflect.(*funcTypeFixed64).Namereflect.(*funcTypeFixed64).NumFieldreflect.(*funcTypeFixed64).NumInreflect.(*funcTypeFixed64).NumMethodreflect.(*funcTypeFixed64).NumOutreflect.(*funcTypeFixed64).Outreflect.(*funcTypeFixed64).PkgPathreflect.(*funcTypeFixed64).Sizereflect.(*funcTypeFixed64).Stringreflect.(*funcTypeFixed64).commonreflect.(*funcTypeFixed64).uncommonreflect.(*funcTypeFixed8).Alignreflect.(*funcTypeFixed8).AssignableToreflect.(*funcTypeFixed8).Bitsreflect.(*funcTypeFixed8).ChanDirreflect.(*funcTypeFixed8).Comparablereflect.(*funcTypeFixed8).ConvertibleToreflect.(*funcTypeFixed8).Elemreflect.(*funcTypeFixed8).Fieldreflect.(*funcTypeFixed8).FieldAlignreflect.(*funcTypeFixed8).FieldByIndexreflect.(*funcTypeFixed8).FieldByNamereflect.(*funcTypeFixed8).FieldByNameFuncreflect.(*funcTypeFixed8).Implementsreflect.(*funcTypeFixed8).Inreflect.(*funcTypeFixed8).IsVariadicreflect.(*funcTypeFixed8).Keyreflect.(*funcTypeFixed8).Kindreflect.(*funcTypeFixed8).Lenreflect.(*funcTypeFixed8).Methodreflect.(*funcTypeFixed8).MethodByNamereflect.(*funcTypeFixed8).Namereflect.(*funcTypeFixed8).NumFieldreflect.(*funcTypeFixed8).NumInreflect.(*funcTypeFixed8).NumMethodreflect.(*funcTypeFixed8).NumOutreflect.(*funcTypeFixed8).Outreflect.(*funcTypeFixed8).PkgPathreflect.(*funcTypeFixed8).Sizereflect.(*funcTypeFixed8).Stringreflect.(*funcTypeFixed8).commonreflect.(*funcTypeFixed8).uncommonreflect.(*interfaceType).Alignreflect.(*interfaceType).AssignableToreflect.(*interfaceType).Bitsreflect.(*interfaceType).ChanDirreflect.(*interfaceType).Comparablereflect.(*interfaceType).ConvertibleToreflect.(*interfaceType).Elemreflect.(*interfaceType).Fieldreflect.(*interfaceType).FieldAlignreflect.(*interfaceType).FieldByIndexreflect.(*interfaceType).FieldByNamereflect.(*interfaceType).FieldByNameFuncreflect.(*interfaceType).Implementsreflect.(*interfaceType).Inreflect.(*interfaceType).IsVariadicreflect.(*interfaceType).Keyreflect.(*interfaceType).Kindreflect.(*interfaceType).Lenreflect.(*interfaceType).Methodreflect.(*interfaceType).MethodByNamereflect.(*interfaceType).Namereflect.(*interfaceType).NumFieldreflect.(*interfaceType).NumInreflect.(*interfaceType).NumMethodreflect.(*interfaceType).NumOutreflect.(*interfaceType).Outreflect.(*interfaceType).PkgPathreflect.(*interfaceType).Sizereflect.(*interfaceType).Stringreflect.(*interfaceType).commonreflect.(*interfaceType).uncommonreflect.(*mapType).Alignreflect.(*mapType).AssignableToreflect.(*mapType).Bitsreflect.(*mapType).ChanDirreflect.(*mapType).Comparablereflect.(*mapType).ConvertibleToreflect.(*mapType).Elemreflect.(*mapType).Fieldreflect.(*mapType).FieldAlignreflect.(*mapType).FieldByIndexreflect.(*mapType).FieldByNamereflect.(*mapType).FieldByNameFuncreflect.(*mapType).Implementsreflect.(*mapType).Inreflect.(*mapType).IsVariadicreflect.(*mapType).Keyreflect.(*mapType).Kindreflect.(*mapType).Lenreflect.(*mapType).Methodreflect.(*mapType).MethodByNamereflect.(*mapType).Namereflect.(*mapType).NumFieldreflect.(*mapType).NumInreflect.(*mapType).NumMethodreflect.(*mapType).NumOutreflect.(*mapType).Outreflect.(*mapType).PkgPathreflect.(*mapType).Sizereflect.(*mapType).Stringreflect.(*mapType).commonreflect.(*mapType).uncommonreflect.(*ptrType).Alignreflect.(*ptrType).AssignableToreflect.(*ptrType).Bitsreflect.(*ptrType).ChanDirreflect.(*ptrType).Comparablereflect.(*ptrType).ConvertibleToreflect.(*ptrType).Elemreflect.(*ptrType).Fieldreflect.(*ptrType).FieldAlignreflect.(*ptrType).FieldByIndexreflect.(*ptrType).FieldByNamereflect.(*ptrType).FieldByNameFuncreflect.(*ptrType).Implementsreflect.(*ptrType).Inreflect.(*ptrType).IsVariadicreflect.(*ptrType).Keyreflect.(*ptrType).Kindreflect.(*ptrType).Lenreflect.(*ptrType).Methodreflect.(*ptrType).MethodByNamereflect.(*ptrType).Namereflect.(*ptrType).NumFieldreflect.(*ptrType).NumInreflect.(*ptrType).NumMethodreflect.(*ptrType).NumOutreflect.(*ptrType).Outreflect.(*ptrType).PkgPathreflect.(*ptrType).Sizereflect.(*ptrType).Stringreflect.(*ptrType).commonreflect.(*ptrType).uncommonreflect.(*rtype).Alignreflect.(*rtype).AssignableToreflect.(*rtype).Bitsreflect.(*rtype).ChanDirreflect.(*rtype).Comparablereflect.(*rtype).ConvertibleToreflect.(*rtype).Elemreflect.(*rtype).Fieldreflect.(*rtype).FieldAlignreflect.(*rtype).FieldByIndexreflect.(*rtype).FieldByNamereflect.(*rtype).FieldByNameFuncreflect.(*rtype).Implementsreflect.(*rtype).Inreflect.(*rtype).IsVariadicreflect.(*rtype).Keyreflect.(*rtype).Kindreflect.(*rtype).Lenreflect.(*rtype).Methodreflect.(*rtype).MethodByNamereflect.(*rtype).Namereflect.(*rtype).NumFieldreflect.(*rtype).NumInreflect.(*rtype).NumMethodreflect.(*rtype).NumOutreflect.(*rtype).Outreflect.(*rtype).PkgPathreflect.(*rtype).Sizereflect.(*rtype).Stringreflect.(*rtype).commonreflect.(*rtype).exportedMethodsreflect.(*rtype).nameOffreflect.(*rtype).pointersreflect.(*rtype).ptrToreflect.(*rtype).textOffreflect.(*rtype).typeOffreflect.(*rtype).uncommonreflect.(*sliceType).Alignreflect.(*sliceType).AssignableToreflect.(*sliceType).Bitsreflect.(*sliceType).ChanDirreflect.(*sliceType).Comparablereflect.(*sliceType).ConvertibleToreflect.(*sliceType).Elemreflect.(*sliceType).Fieldreflect.(*sliceType).FieldAlignreflect.(*sliceType).FieldByIndexreflect.(*sliceType).FieldByNamereflect.(*sliceType).FieldByNameFuncreflect.(*sliceType).Implementsreflect.(*sliceType).Inreflect.(*sliceType).IsVariadicreflect.(*sliceType).Keyreflect.(*sliceType).Kindreflect.(*sliceType).Lenreflect.(*sliceType).Methodreflect.(*sliceType).MethodByNamereflect.(*sliceType).Namereflect.(*sliceType).NumFieldreflect.(*sliceType).NumInreflect.(*sliceType).NumMethodreflect.(*sliceType).NumOutreflect.(*sliceType).Outreflect.(*sliceType).PkgPathreflect.(*sliceType).Sizereflect.(*sliceType).Stringreflect.(*sliceType).commonreflect.(*sliceType).uncommonreflect.(*structField).anonreflect.(*structField).offsetreflect.(*structType).Alignreflect.(*structType).AssignableToreflect.(*structType).Bitsreflect.(*structType).ChanDirreflect.(*structType).Comparablereflect.(*structType).ConvertibleToreflect.(*structType).Elemreflect.(*structType).Fieldreflect.(*structType).FieldAlignreflect.(*structType).FieldByIndexreflect.(*structType).FieldByNamereflect.(*structType).FieldByName.func1reflect.(*structType).FieldByNameFuncreflect.(*structType).Implementsreflect.(*structType).Inreflect.(*structType).IsVariadicreflect.(*structType).Keyreflect.(*structType).Kindreflect.(*structType).Lenreflect.(*structType).Methodreflect.(*structType).MethodByNamereflect.(*structType).Namereflect.(*structType).NumFieldreflect.(*structType).NumInreflect.(*structType).NumMethodreflect.(*structType).NumOutreflect.(*structType).Outreflect.(*structType).PkgPathreflect.(*structType).Sizereflect.(*structType).Stringreflect.(*structType).commonreflect.(*structType).uncommonreflect.(*uncommonType).methodsreflect.ChanDir.Stringreflect.FuncOfreflect.FuncOf.func1reflect.Kind.Stringreflect.Newreflect.Swapperreflect.Swapper.func1reflect.Swapper.func2reflect.Swapper.func3reflect.Swapper.func4reflect.Swapper.func5reflect.Swapper.func6reflect.Swapper.func7reflect.Swapper.func8reflect.Swapper.func9reflect.TypeOfreflect.Value.Boolreflect.Value.Bytesreflect.Value.CanAddrreflect.Value.CanInterfacereflect.Value.Complexreflect.Value.Elemreflect.Value.Fieldreflect.Value.Floatreflect.Value.Indexreflect.Value.Intreflect.Value.Interfacereflect.Value.IsNilreflect.Value.IsValidreflect.Value.Kindreflect.Value.Lenreflect.Value.MapIndexreflect.Value.MapKeysreflect.Value.NumFieldreflect.Value.NumMethodreflect.Value.Pointerreflect.Value.SetBytesreflect.Value.SetStringreflect.Value.Slicereflect.Value.Stringreflect.Value.Typereflect.Value.Uintreflect.Value.assignToreflect.Value.pointerreflect.Value.runesreflect.Value.setRunesreflect.ValueOfreflect.Zeroreflect.addreflect.addReflectOffreflect.addTypeBitsreflect.arrayAtreflect.callreflect.callMethodreflect.chanlenreflect.convertOpreflect.cvtBytesStringreflect.cvtComplexreflect.cvtDirectreflect.cvtFloatreflect.cvtFloatIntreflect.cvtFloatUintreflect.cvtI2Ireflect.cvtIntreflect.cvtIntFloatreflect.cvtIntStringreflect.cvtRunesStringreflect.cvtStringBytesreflect.cvtStringRunesreflect.cvtT2Ireflect.cvtUintreflect.cvtUintFloatreflect.cvtUintStringreflect.directlyAssignablereflect.dummyreflect.escapesreflect.flag.kindreflect.flag.mustBereflect.flag.mustBeAssignablereflect.fnv1reflect.funcLayoutreflect.funcLayout.func1reflect.funcLookupCachereflect.funcStrreflect.haveIdenticalTypereflect.haveIdenticalUnderlyingTypereflect.ifaceE2Ireflect.ifaceIndirreflect.implementsreflect.initreflect.initdone.reflect.kindNamesreflect.layoutCachereflect.makeBytesreflect.makeComplexreflect.makeFloatreflect.makeIntreflect.makeMethodValuereflect.makeRunesreflect.makeStringreflect.mapaccessreflect.mapiterinitreflect.mapiterkeyreflect.mapiternextreflect.maplenreflect.memclrNoHeapPointersreflect.methodCachereflect.methodNamereflect.methodReceiverreflect.methodValueCallreflect.methodValueCall.args_stackmapreflect.name.datareflect.name.isExportedreflect.name.namereflect.name.nameLenreflect.name.pkgPathreflect.name.tagreflect.name.tagLenreflect.newNamereflect.packEfacereflect.ptrMapreflect.resolveNameOffreflect.resolveReflectNamereflect.resolveTextOffreflect.resolveTypeOffreflect.rtypeOffreflect.statictmp_1reflect.statictmp_10reflect.statictmp_100reflect.statictmp_101reflect.statictmp_11reflect.statictmp_12reflect.statictmp_120reflect.statictmp_121reflect.statictmp_122reflect.statictmp_123reflect.statictmp_124reflect.statictmp_125reflect.statictmp_126reflect.statictmp_13reflect.statictmp_14reflect.statictmp_15reflect.statictmp_16reflect.statictmp_17reflect.statictmp_18reflect.statictmp_19reflect.statictmp_2reflect.statictmp_20reflect.statictmp_21reflect.statictmp_22reflect.statictmp_23reflect.statictmp_24reflect.statictmp_25reflect.statictmp_26reflect.statictmp_27reflect.statictmp_28reflect.statictmp_3reflect.statictmp_35reflect.statictmp_36reflect.statictmp_37reflect.statictmp_38reflect.statictmp_39reflect.statictmp_4reflect.statictmp_40reflect.statictmp_5reflect.statictmp_6reflect.statictmp_61reflect.statictmp_62reflect.statictmp_63reflect.statictmp_64reflect.statictmp_66reflect.statictmp_67reflect.statictmp_7reflect.statictmp_79reflect.statictmp_8reflect.statictmp_80reflect.statictmp_81reflect.statictmp_83reflect.statictmp_84reflect.statictmp_85reflect.statictmp_86reflect.statictmp_9reflect.statictmp_91reflect.statictmp_92reflect.statictmp_95reflect.statictmp_96reflect.statictmp_97reflect.storeRcvrreflect.toTypereflect.typedmemmovereflect.typedmemmovepartialreflect.typelinksreflect.typesByStringreflect.uint8Typereflect.unpackEfacereflect.unsafe_Newreflect.valueInterfaceregexp.(*Regexp).MatchStringregexp.(*Regexp).Stringregexp.(*Regexp).doExecuteregexp.(*Regexp).doMatchregexp.(*Regexp).getregexp.(*Regexp).putregexp.(*bitState).pushregexp.(*bitState).resetregexp.(*bitState).shouldVisitregexp.(*inputBytes).canCheckPrefixregexp.(*inputBytes).contextregexp.(*inputBytes).hasPrefixregexp.(*inputBytes).indexregexp.(*inputBytes).stepregexp.(*inputReader).canCheckPrefixregexp.(*inputReader).contextregexp.(*inputReader).hasPrefixregexp.(*inputReader).indexregexp.(*inputReader).stepregexp.(*inputString).canCheckPrefixregexp.(*inputString).contextregexp.(*inputString).hasPrefixregexp.(*inputString).indexregexp.(*inputString).stepregexp.(*machine).addregexp.(*machine).allocregexp.(*machine).backtrackregexp.(*machine).clearregexp.(*machine).initregexp.(*machine).matchregexp.(*machine).newInputBytesregexp.(*machine).newInputReaderregexp.(*machine).newInputStringregexp.(*machine).onepassregexp.(*machine).stepregexp.(*machine).tryBacktrackregexp.(*onePassInst).Stringregexp.(*queueOnePass).clearregexp.(*queueOnePass).containsregexp.(*queueOnePass).emptyregexp.(*queueOnePass).insertregexp.(*queueOnePass).insertNewregexp.(*queueOnePass).nextregexp.(*runeSlice).Lenregexp.(*runeSlice).Lessregexp.(*runeSlice).Swapregexp.Compileregexp.anyRuneregexp.anyRuneNotNLregexp.arrayNoIntsregexp.cleanupOnePassregexp.compileregexp.compileOnePassregexp.initregexp.init.0regexp.initdone.regexp.iopregexp.makeOnePassregexp.makeOnePass.func1regexp.maxBitStateLenregexp.mergeRuneSetsregexp.mergeRuneSets.func1regexp.mergeRuneSets.func2regexp.newBitStateregexp.newQueueregexp.noNextregexp.noRuneregexp.notBacktrackregexp.notOnePassregexp.onePassCopyregexp.onePassNextregexp.onePassPrefixregexp.progMachineregexp.runeSlice.Lenregexp.runeSlice.Lessregexp.runeSlice.Swapregexp.shouldBacktrackregexp.specialBytesregexp.statictmp_0regexp.statictmp_1regexp.statictmp_10regexp.statictmp_11regexp.statictmp_12regexp.statictmp_13regexp.statictmp_2regexp.statictmp_3regexp.statictmp_4regexp.statictmp_5regexp.statictmp_6regexp.statictmp_7regexp.statictmp_8regexp/syntax.(*Error).Errorregexp/syntax.(*ErrorCode).Stringregexp/syntax.(*Inst).MatchRuneregexp/syntax.(*Inst).MatchRunePosregexp/syntax.(*Inst).Stringregexp/syntax.(*Inst).opregexp/syntax.(*InstOp).Stringregexp/syntax.(*Prog).Prefixregexp/syntax.(*Prog).StartCondregexp/syntax.(*Prog).Stringregexp/syntax.(*Prog).skipNopregexp/syntax.(*Regexp).CapNamesregexp/syntax.(*Regexp).Equalregexp/syntax.(*Regexp).MaxCapregexp/syntax.(*Regexp).Simplifyregexp/syntax.(*Regexp).Stringregexp/syntax.(*Regexp).capNamesregexp/syntax.(*compiler).altregexp/syntax.(*compiler).capregexp/syntax.(*compiler).catregexp/syntax.(*compiler).compileregexp/syntax.(*compiler).emptyregexp/syntax.(*compiler).failregexp/syntax.(*compiler).initregexp/syntax.(*compiler).instregexp/syntax.(*compiler).nopregexp/syntax.(*compiler).plusregexp/syntax.(*compiler).questregexp/syntax.(*compiler).runeregexp/syntax.(*compiler).starregexp/syntax.(*parser).alternateregexp/syntax.(*parser).appendGroupregexp/syntax.(*parser).collapseregexp/syntax.(*parser).concatregexp/syntax.(*parser).factorregexp/syntax.(*parser).leadingRegexpregexp/syntax.(*parser).leadingStringregexp/syntax.(*parser).literalregexp/syntax.(*parser).maybeConcatregexp/syntax.(*parser).newLiteralregexp/syntax.(*parser).newRegexpregexp/syntax.(*parser).opregexp/syntax.(*parser).parseClassregexp/syntax.(*parser).parseClassCharregexp/syntax.(*parser).parseEscaperegexp/syntax.(*parser).parseIntregexp/syntax.(*parser).parseNamedClassregexp/syntax.(*parser).parsePerlClassEscaperegexp/syntax.(*parser).parsePerlFlagsregexp/syntax.(*parser).parseRepeatregexp/syntax.(*parser).parseRightParenregexp/syntax.(*parser).parseUnicodeClassregexp/syntax.(*parser).parseVerticalBarregexp/syntax.(*parser).pushregexp/syntax.(*parser).removeLeadingRegexpregexp/syntax.(*parser).removeLeadingStringregexp/syntax.(*parser).repeatregexp/syntax.(*parser).reuseregexp/syntax.(*parser).swapVerticalBarregexp/syntax.(*ranges).Lenregexp/syntax.(*ranges).Lessregexp/syntax.(*ranges).Swapregexp/syntax.Compileregexp/syntax.EmptyOpContextregexp/syntax.ErrorCode.Stringregexp/syntax.InstOp.Stringregexp/syntax.IsWordCharregexp/syntax.Parseregexp/syntax.anyRuneregexp/syntax.anyRuneNotNLregexp/syntax.anyTableregexp/syntax.appendClassregexp/syntax.appendFoldedClassregexp/syntax.appendFoldedRangeregexp/syntax.appendLiteralregexp/syntax.appendNegatedClassregexp/syntax.appendNegatedTableregexp/syntax.appendRangeregexp/syntax.appendTableregexp/syntax.bwregexp/syntax.checkUTF8regexp/syntax.cleanAltregexp/syntax.cleanClassregexp/syntax.code1regexp/syntax.code10regexp/syntax.code11regexp/syntax.code12regexp/syntax.code13regexp/syntax.code14regexp/syntax.code15regexp/syntax.code16regexp/syntax.code17regexp/syntax.code2regexp/syntax.code3regexp/syntax.code4regexp/syntax.code5regexp/syntax.code6regexp/syntax.code7regexp/syntax.code8regexp/syntax.code9regexp/syntax.dumpInstregexp/syntax.dumpProgregexp/syntax.escaperegexp/syntax.initregexp/syntax.initdone.regexp/syntax.instOpNamesregexp/syntax.isCharClassregexp/syntax.isValidCaptureNameregexp/syntax.isalnumregexp/syntax.literalRegexpregexp/syntax.matchRuneregexp/syntax.mergeCharClassregexp/syntax.minFoldRuneregexp/syntax.negateClassregexp/syntax.nextRuneregexp/syntax.patchList.appendregexp/syntax.patchList.nextregexp/syntax.patchList.patchregexp/syntax.perlGroupregexp/syntax.posixGroupregexp/syntax.ranges.Lenregexp/syntax.ranges.Lessregexp/syntax.ranges.Swapregexp/syntax.repeatIsValidregexp/syntax.simplify1regexp/syntax.statictmp_0regexp/syntax.statictmp_10regexp/syntax.statictmp_11regexp/syntax.statictmp_12regexp/syntax.statictmp_13regexp/syntax.statictmp_14regexp/syntax.statictmp_15regexp/syntax.statictmp_16regexp/syntax.statictmp_17regexp/syntax.statictmp_18regexp/syntax.statictmp_19regexp/syntax.statictmp_2regexp/syntax.statictmp_20regexp/syntax.statictmp_21regexp/syntax.statictmp_22regexp/syntax.statictmp_23regexp/syntax.statictmp_24regexp/syntax.statictmp_25regexp/syntax.statictmp_26regexp/syntax.statictmp_27regexp/syntax.statictmp_28regexp/syntax.statictmp_29regexp/syntax.statictmp_3regexp/syntax.statictmp_30regexp/syntax.statictmp_31regexp/syntax.statictmp_32regexp/syntax.statictmp_33regexp/syntax.statictmp_34regexp/syntax.statictmp_35regexp/syntax.statictmp_36regexp/syntax.statictmp_37regexp/syntax.statictmp_38regexp/syntax.statictmp_39regexp/syntax.statictmp_4regexp/syntax.statictmp_40regexp/syntax.statictmp_5regexp/syntax.statictmp_6regexp/syntax.statictmp_7regexp/syntax.statictmp_8regexp/syntax.statictmp_9regexp/syntax.u32regexp/syntax.unhexregexp/syntax.unicodeTableregexp/syntax.writeRegexpruntime.(*Frames).Nextruntime.(*Func).Nameruntime.(*Func).funcInforuntime.(*Func).rawruntime.(*MemProfileRecord).InUseBytesruntime.(*MemProfileRecord).InUseObjectsruntime.(*MemProfileRecord).Stackruntime.(*StackRecord).Stackruntime.(*TypeAssertionError).Errorruntime.(*_type).nameOffruntime.(*_type).stringruntime.(*_type).textOffruntime.(*_type).typeOffruntime.(*_type).uncommonruntime.(*bmap).overflowruntime.(*bmap).setoverflowruntime.(*bucket).bpruntime.(*bucket).mpruntime.(*bucket).stkruntime.(*cpuProfile).addruntime.(*cpuProfile).addExtraruntime.(*cpuProfile).addNonGoruntime.(*errorString).Errorruntime.(*fixalloc).allocruntime.(*fixalloc).freeruntime.(*fixalloc).initruntime.(*functype).dotdotdotruntime.(*functype).inruntime.(*functype).outruntime.(*gcBits).bitpruntime.(*gcBits).bytepruntime.(*gcBitsArena).tryAllocruntime.(*gcControllerState).endCycleruntime.(*gcControllerState).enlistWorkerruntime.(*gcControllerState).findRunnableGCWorkerruntime.(*gcControllerState).findRunnableGCWorker.func1runtime.(*gcControllerState).reviseruntime.(*gcControllerState).startCycleruntime.(*gcSweepBuf).blockruntime.(*gcSweepBuf).numBlocksruntime.(*gcSweepBuf).popruntime.(*gcSweepBuf).pushruntime.(*gcWork).balanceruntime.(*gcWork).disposeruntime.(*gcWork).emptyruntime.(*gcWork).getruntime.(*gcWork).initruntime.(*gcWork).putruntime.(*gcWork).putFastruntime.(*gcWork).tryGetruntime.(*gcWork).tryGetFastruntime.(*guintptr).casruntime.(*guintptr).setruntime.(*hmap).createOverflowruntime.(*hmap).growingruntime.(*hmap).incrnoverflowruntime.(*hmap).newoverflowruntime.(*hmap).noldbucketsruntime.(*hmap).oldbucketmaskruntime.(*hmap).sameSizeGrowruntime.(*lfstack).emptyruntime.(*lfstack).popruntime.(*lfstack).pushruntime.(*mSpanList).initruntime.(*mSpanList).insertruntime.(*mSpanList).insertBackruntime.(*mSpanList).isEmptyruntime.(*mSpanList).removeruntime.(*mSpanList).takeAllruntime.(*mTreap).insertruntime.(*mTreap).removeruntime.(*mTreap).removeNoderuntime.(*mTreap).removeSpanruntime.(*mTreap).rotateLeftruntime.(*mTreap).rotateRightruntime.(*markBits).advanceruntime.(*mcache).nextFreeruntime.(*mcache).nextFree.func1runtime.(*mcache).refillruntime.(*mcache).releaseAllruntime.(*mcentral).cacheSpanruntime.(*mcentral).freeSpanruntime.(*mcentral).growruntime.(*mcentral).initruntime.(*mcentral).uncacheSpanruntime.(*memRecordCycle).addruntime.(*mheap).allocruntime.(*mheap).alloc.func1runtime.(*mheap).allocLargeruntime.(*mheap).allocManualruntime.(*mheap).allocSpanLockedruntime.(*mheap).alloc_mruntime.(*mheap).busyListruntime.(*mheap).freeListruntime.(*mheap).freeManualruntime.(*mheap).freeSpanruntime.(*mheap).freeSpan.func1runtime.(*mheap).freeSpanLockedruntime.(*mheap).growruntime.(*mheap).initruntime.(*mheap).isLargeSpanruntime.(*mheap).lookupruntime.(*mheap).lookupMayberuntime.(*mheap).mapBitsruntime.(*mheap).mapSpansruntime.(*mheap).reclaimruntime.(*mheap).reclaimListruntime.(*mheap).scavengeruntime.(*mheap).setArenaUsedruntime.(*mheap).sysAllocruntime.(*mspan).allocBitsForIndexruntime.(*mspan).baseruntime.(*mspan).countAllocruntime.(*mspan).ensureSweptruntime.(*mspan).inListruntime.(*mspan).initruntime.(*mspan).isFreeruntime.(*mspan).layoutruntime.(*mspan).markBitsForBaseruntime.(*mspan).markBitsForIndexruntime.(*mspan).nextFreeIndexruntime.(*mspan).objIndexruntime.(*mspan).refillAllocCacheruntime.(*mspan).sweepruntime.(*muintptr).setruntime.(*pcExpander).initruntime.(*pcExpander).nextruntime.(*plainError).Errorruntime.(*pollCache).allocruntime.(*pollCache).freeruntime.(*profAtomic).casruntime.(*profAtomic).loadruntime.(*profAtomic).storeruntime.(*profBuf).canWriteRecordruntime.(*profBuf).canWriteTwoRecordsruntime.(*profBuf).closeruntime.(*profBuf).hasOverflowruntime.(*profBuf).incrementOverflowruntime.(*profBuf).readruntime.(*profBuf).takeOverflowruntime.(*profBuf).wakeupExtraruntime.(*profBuf).writeruntime.(*puintptr).setruntime.(*randomEnum).doneruntime.(*randomEnum).nextruntime.(*randomEnum).positionruntime.(*randomOrder).resetruntime.(*randomOrder).startruntime.(*rwmutex).rlockruntime.(*rwmutex).rlock.func1runtime.(*rwmutex).runlockruntime.(*semaRoot).dequeueruntime.(*semaRoot).queueruntime.(*semaRoot).rotateLeftruntime.(*semaRoot).rotateRightruntime.(*sigctxt).csruntime.(*sigctxt).faultruntime.(*sigctxt).fixsigcoderuntime.(*sigctxt).fsruntime.(*sigctxt).gsruntime.(*sigctxt).preparePanicruntime.(*sigctxt).r10runtime.(*sigctxt).r11runtime.(*sigctxt).r12runtime.(*sigctxt).r13runtime.(*sigctxt).r14runtime.(*sigctxt).r15runtime.(*sigctxt).r8runtime.(*sigctxt).r9runtime.(*sigctxt).raxruntime.(*sigctxt).rbpruntime.(*sigctxt).rbxruntime.(*sigctxt).rcxruntime.(*sigctxt).rdiruntime.(*sigctxt).rdxruntime.(*sigctxt).regsruntime.(*sigctxt).rflagsruntime.(*sigctxt).ripruntime.(*sigctxt).rsiruntime.(*sigctxt).rspruntime.(*sigctxt).set_ripruntime.(*sigctxt).set_rspruntime.(*sigctxt).set_sigaddrruntime.(*sigctxt).set_sigcoderuntime.(*sigctxt).sigaddrruntime.(*sigctxt).sigcoderuntime.(*sigctxt).siglrruntime.(*sigctxt).sigpcruntime.(*sigctxt).sigspruntime.(*stackExpander).initruntime.(*stackExpander).nextruntime.(*timeval).set_usecruntime.(*traceAlloc).allocruntime.(*traceAlloc).dropruntime.(*traceAllocBlockPtr).setruntime.(*traceBuf).byteruntime.(*traceBuf).varintruntime.(*traceBufPtr).setruntime.(*traceStack).stackruntime.(*traceStackTable).dumpruntime.(*traceStackTable).findruntime.(*traceStackTable).newStackruntime.(*traceStackTable).putruntime.(*treapNode).initruntime.(*waitq).dequeueruntime.(*waitq).enqueueruntime.(*workbuf).checkemptyruntime.(*workbuf).checknonemptyruntime..gobytes.2runtime..gobytes.5runtime.BlockProfileruntime.Callerruntime.Callersruntime.CallersFramesruntime.FuncForPCruntime.GCruntime.GOMAXPROCSruntime.GOROOTruntime.GoroutineProfileruntime.GoroutineProfile.func1runtime.GoroutineProfile.func2runtime.Goschedruntime.MemProfileruntime.MemProfileRateruntime.MutexProfileruntime.NumGoroutineruntime.ReadMemStatsruntime.ReadMemStats.func1runtime.ReadTraceruntime.SetBlockProfileRateruntime.SetCPUProfileRateruntime.SetFinalizerruntime.SetFinalizer.func1runtime.SetFinalizer.func2runtime.SetMutexProfileFractionruntime.Stackruntime.Stack.func1runtime.StartTraceruntime.StopTraceruntime.ThreadCreateProfileruntime._ExternalCoderuntime._GCruntime._LostExternalCoderuntime._Systemruntime._cgo_setenvruntime._cgo_unsetenvruntime.acquireSudogruntime.acquiremruntime.acquirepruntime.acquirep1runtime.activeModulesruntime.addruntime.add1runtime.addbruntime.addfinalizerruntime.additabruntime.addspecialruntime.addtimerruntime.addtimerLockedruntime.adjustctxtruntime.adjustdefersruntime.adjustframeruntime.adjustpanicsruntime.adjustpointerruntime.adjustpointersruntime.adjustsudogsruntime.aeshashruntime.aeshash32runtime.aeshash64runtime.aeshashbodyruntime.aeshashstrruntime.aeskeyschedruntime.algarrayruntime.alginitruntime.allFramesruntime.allfinruntime.allgaddruntime.allglenruntime.allglockruntime.allgsruntime.allmruntime.allocmruntime.allocmcacheruntime.allpruntime.argcruntime.argsruntime.argsliceruntime.argvruntime.argv_indexruntime.asmcgocallruntime.asmcgocall.args_stackmapruntime.asminitruntime.assertE2Iruntime.assertE2I2runtime.assertI2I2runtime.atoiruntime.atoi32runtime.atomicstorepruntime.badctxtruntime.badmcallruntime.badmcall2runtime.badmorestackg0runtime.badmorestackg0Msgruntime.badmorestackgsignalruntime.badmorestackgsignalMsgruntime.badreflectcallruntime.badsignalruntime.badsystemstackruntime.badunlockosthreadruntime.bbucketsruntime.bgsweepruntime.bgsweepPCruntime.blockeventruntime.blockprofilerateruntime.blocksampledruntime.bool2intruntime.bsdthread_createruntime.bsdthread_registerruntime.bsdthread_startruntime.bssruntime.bucketEvacuatedruntime.bucketmemruntime.buckhashruntime.buildVersionruntime.bulkBarrierBitmapruntime.bulkBarrierPreWriteruntime.bytesruntime.c128equalruntime.c128hashruntime.c64equalruntime.c64hashruntime.cachestatsruntime.call1024runtime.call1024.args_stackmapruntime.call1048576runtime.call1048576.args_stackmapruntime.call1073741824runtime.call1073741824.args_stackmapruntime.call128runtime.call128.args_stackmapruntime.call131072runtime.call131072.args_stackmapruntime.call134217728runtime.call134217728.args_stackmapruntime.call16384runtime.call16384.args_stackmapruntime.call16777216runtime.call16777216.args_stackmapruntime.call2048runtime.call2048.args_stackmapruntime.call2097152runtime.call2097152.args_stackmapruntime.call256runtime.call256.args_stackmapruntime.call262144runtime.call262144.args_stackmapruntime.call268435456runtime.call268435456.args_stackmapruntime.call32runtime.call32.args_stackmapruntime.call32768runtime.call32768.args_stackmapruntime.call33554432runtime.call33554432.args_stackmapruntime.call4096runtime.call4096.args_stackmapruntime.call4194304runtime.call4194304.args_stackmapruntime.call512runtime.call512.args_stackmapruntime.call524288runtime.call524288.args_stackmapruntime.call536870912runtime.call536870912.args_stackmapruntime.call64runtime.call64.args_stackmapruntime.call65536runtime.call65536.args_stackmapruntime.call67108864runtime.call67108864.args_stackmapruntime.call8192runtime.call8192.args_stackmapruntime.call8388608runtime.call8388608.args_stackmapruntime.callCgoSymbolizerruntime.callersruntime.callers.func1runtime.canpanicruntime.cansemacquireruntime.casfrom_Gscanstatusruntime.casgstatusruntime.casgstatus.func1runtime.casgstatus.func2runtime.caspruntime.castogscanstatusruntime.cfuncnameruntime.cgoCheckBitsruntime.cgoCheckBits.func1runtime.cgoCheckMemmoveruntime.cgoCheckSliceCopyruntime.cgoCheckTypedBlockruntime.cgoCheckTypedBlock.func1runtime.cgoCheckTypedBlock.func2runtime.cgoCheckUsingTyperuntime.cgoCheckWriteBarrierruntime.cgoCheckWriteBarrier.func1runtime.cgoContextPCsruntime.cgoHasExtraMruntime.cgoInRangeruntime.cgoIsGoPointerruntime.cgoSymbolizerruntime.cgoTracebackruntime.cgo_yieldruntime.cgocallruntime.cgocallback_gofuncruntime.cgocallback_gofunc.args_stackmapruntime.cgocallback_gofuncPCruntime.cgocallbackgruntime.cgocallbackg1runtime.cgocallbackg1.func1runtime.chanbufruntime.chanrecvruntime.chanrecv.func1runtime.chanrecv1runtime.chanrecvpcruntime.chansendruntime.chansend.func1runtime.chansend1runtime.chansendpcruntime.checkruntime.checkASMruntime.checkASM.args_stackmapruntime.checkdeadruntime.checkmcountruntime.class_to_allocnpagesruntime.class_to_divmagicruntime.class_to_sizeruntime.clearCheckmarksruntime.clearpoolsruntime.closechanruntime.closefdruntime.closeonexecruntime.cmpbodyruntime.cmpstringruntime.concatstring2runtime.concatstring3runtime.concatstring4runtime.concatstring5runtime.concatstringsruntime.containsruntime.convT2Eruntime.convT2E16runtime.convT2E32runtime.convT2E64runtime.convT2Enoptrruntime.convT2Esliceruntime.convT2Estringruntime.convT2I64runtime.convT2Isliceruntime.convT2Istringruntime.copystackruntime.countByteruntime.countSubruntime.cpuprofruntime.cputicksruntime.crashruntime.crashingruntime.createfingruntime.dataruntime.dbgvarsruntime.deadlockruntime.debugruntime.debuglockruntime.decoderuneruntime.deductSweepCreditruntime.deferArgsruntime.deferTyperuntime.deferclassruntime.deferprocruntime.deferreturnruntime.deltimerruntime.didothersruntime.dieFromSignalruntime.divideErrorruntime.dolockOSThreadruntime.dopanicruntime.dopanic.func1runtime.dopanic_mruntime.dounlockOSThreadruntime.dropgruntime.dropmruntime.duffcopyruntime.duffzeroruntime.dumpgstatusruntime.dumpregsruntime.earlycgocallbackruntime.ebssruntime.edataruntime.efaceOfruntime.efaceeqruntime.egcbssruntime.egcdataruntime.eitablinkruntime.emptymspanruntime.encoderuneruntime.endruntime.endcgoruntime.enoptrbssruntime.enoptrdataruntime.entersyscallruntime.entersyscall_gcwaitruntime.entersyscall_sysmonruntime.entersyscallblockruntime.entersyscallblock.func1runtime.entersyscallblock.func2runtime.entersyscallblock_handoffruntime.environruntime.envsruntime.epclntabruntime.eqsliceruntime.eqstringruntime.erodataruntime.errorString.Errorruntime.esymtabruntime.etextruntime.etypesruntime.evacuateruntime.evacuatedruntime.execLockruntime.executeruntime.exitruntime.exit1runtime.exitsyscallruntime.exitsyscall.func1runtime.exitsyscall0runtime.exitsyscallfastruntime.exitsyscallfast.func1runtime.exitsyscallfast_pidleruntime.exitsyscallfast_reacquiredruntime.exitsyscallfast_reacquired.func1runtime.expandCgoFramesruntime.extendRandomruntime.externalthreadhandlerpruntime.extraMCountruntime.extraMWaitersruntime.extramruntime.f32equalruntime.f32hashruntime.f64equalruntime.f64hashruntime.faketimeruntime.fastlog2runtime.fastlog2Tableruntime.fastrandruntime.fastrandnruntime.finalizer1runtime.fincruntime.findObjectruntime.findfuncruntime.findfunctabruntime.findmoduledatapruntime.findnullruntime.findrunnableruntime.findsghiruntime.fingruntime.fingCreateruntime.fingRunningruntime.fingwaitruntime.fingwakeruntime.finishsweep_mruntime.finlockruntime.finptrmaskruntime.finqruntime.firstmoduledataruntime.float64bitsruntime.float64frombitsruntime.floatErrorruntime.flushallmcachesruntime.flushmcacheruntime.fmtNSAsMSruntime.forEachPruntime.forcegcruntime.forcegchelperruntime.forcegchelperPCruntime.forcegcperiodruntime.framepointer_enabledruntime.freeSomeWbufsruntime.freeSomeWbufs.func1runtime.freeStackSpansruntime.freedeferruntime.freedefer.func1runtime.freedeferfnruntime.freedeferpanicruntime.freemcacheruntime.freemcache.func1runtime.freespecialruntime.freezetheworldruntime.freezingruntime.funcInfo._Funcruntime.funcInfo.validruntime.funcPCruntime.funcdataruntime.funcfileruntime.funclineruntime.funcline1runtime.funcnameruntime.funcnameFromNameoffruntime.funcspdeltaruntime.fwdSigruntime.g0runtime.gStatusStringsruntime.gcAssistAllocruntime.gcAssistAlloc.func1runtime.gcAssistAlloc1runtime.gcBgMarkPrepareruntime.gcBgMarkStartWorkersruntime.gcBgMarkWorkerruntime.gcBgMarkWorker.func1runtime.gcBgMarkWorker.func2runtime.gcBgMarkWorkerPCruntime.gcBitsArenasruntime.gcBlackenEnabledruntime.gcBlackenPromptlyruntime.gcControllerruntime.gcDrainruntime.gcDrainNruntime.gcDumpObjectruntime.gcFlushBgCreditruntime.gcMarkruntime.gcMarkDoneruntime.gcMarkDone.func1runtime.gcMarkDone.func1.1runtime.gcMarkRootCheckruntime.gcMarkRootPrepareruntime.gcMarkRootPrepare.func1runtime.gcMarkTerminationruntime.gcMarkTermination.func1runtime.gcMarkTermination.func2runtime.gcMarkTinyAllocsruntime.gcMarkWorkAvailableruntime.gcMarkWorkerModeStringsruntime.gcParkAssistruntime.gcResetMarkStateruntime.gcSetTriggerRatioruntime.gcStartruntime.gcStart.func1runtime.gcSweepruntime.gcTrigger.testruntime.gcWakeAllAssistsruntime.gcallersruntime.gcbits.*runtime.gcbssruntime.gcdruntime.gcdataruntime.gcenableruntime.gchelperruntime.gchelperstartruntime.gcinitruntime.gclinkptr.ptrruntime.gcmarknewobjectruntime.gcmarkwb_mruntime.gcountruntime.gcpercentruntime.gcphaseruntime.gcprocsruntime.gcstopmruntime.gentracebackruntime.getArgInforuntime.getPageSizeruntime.getRandomDataruntime.getargpruntime.getcallerpcruntime.getcallerspruntime.getemptyruntime.getempty.func1runtime.getfullruntime.getitabruntime.getncpuruntime.getsigruntime.gfgetruntime.gfget.func1runtime.gfpurgeruntime.gfputruntime.globalAllocruntime.globrunqgetruntime.globrunqputruntime.globrunqputbatchruntime.globrunqputheadruntime.goargsruntime.gobvruntime.goenvsruntime.goenvs_unixruntime.goexitruntime.goexit0runtime.goexit1runtime.goexitPCruntime.gogetenvruntime.gogoruntime.gogoPCruntime.gomaxprocsruntime.gomcacheruntime.gopanicruntime.goparkruntime.goparkunlockruntime.gopreempt_mruntime.goreadyruntime.goready.func1runtime.gorecoverruntime.goroutineReadyruntime.goroutineheaderruntime.gosaveruntime.goschedImplruntime.gosched_mruntime.gostartcallruntime.gostartcallfnruntime.gostringruntime.gostringnocopyruntime.gosweepdoneruntime.gosweeponeruntime.gosweepone.func1runtime.gotracebackruntime.greyobjectruntime.growWorkruntime.growsliceruntime.guintptr.ptrruntime.gwriteruntime.handlingSigruntime.handoffruntime.handoffpruntime.hashruntime.hashGrowruntime.hashkeyruntime.hasprefixruntime.heapBits.bitsruntime.heapBits.clearCheckmarkSpanruntime.heapBits.forwardruntime.heapBits.initCheckmarkSpanruntime.heapBits.initSpanruntime.heapBits.isCheckmarkedruntime.heapBits.isPointerruntime.heapBits.nextruntime.heapBits.setCheckmarkedruntime.heapBitsForAddrruntime.heapBitsForObjectruntime.heapBitsForSpanruntime.heapBitsSetTyperuntime.heapBitsSetTypeGCProgruntime.heapminimumruntime.helpgcruntime.ifaceLockruntime.ifaceeqruntime.inHeapOrStackruntime.incidlelockedruntime.indexruntime.indexErrorruntime.indexShortStrruntime.indexbytebodyruntime.infruntime.inheapruntime.initruntime.init.0runtime.init.1runtime.init.2runtime.init.3runtime.init.4runtime.init.5runtime.initCheckmarksruntime.initSigmaskruntime.initdone.runtime.initsigruntime.injectglistruntime.interequalruntime.interhashruntime.intstringruntime.isDirectIfaceruntime.isExportedRuntimeruntime.isIntelruntime.isSystemGoroutineruntime.isarchiveruntime.iscgoruntime.islibraryruntime.ismapkeyruntime.itabhashruntime.itablinkruntime.itabsinitruntime.itoaDivruntime.jmpdeferruntime.jmpdeferPCruntime.keventruntime.kqruntime.kqueueruntime.largeAllocruntime.lastmoduledatapruntime.lfenceBeforeRdtscruntime.lfstackPackruntime.lfstackUnpackruntime.lockruntime.lockOSThreadruntime.lockextraruntime.m0runtime.mProfruntime.mProf_Flushruntime.mProf_FlushLockedruntime.mProf_Freeruntime.mProf_Mallocruntime.mProf_Malloc.func1runtime.mProf_NextCycleruntime.mProf_PostSweepruntime.mSpanStateNamesruntime.mSysStatDecruntime.mSysStatIncruntime.mach_msgruntime.mach_msg_trapruntime.mach_msgh_bitsruntime.mach_reply_portruntime.mach_semaphore_signalruntime.mach_semaphore_timedwaitruntime.mach_semaphore_waitruntime.mach_semcreateruntime.mach_semreleaseruntime.mach_semrelease.func1runtime.mach_task_selfruntime.machcallruntime.macherrorruntime.madviseruntime.mainruntime.main.func1runtime.main.func2runtime.mainPCruntime.main_init_doneruntime.makeBucketArrayruntime.makeSpanClassruntime.makechanruntime.makemapruntime.makesliceruntime.malgruntime.malg.func1runtime.mallocgcruntime.mallocgc.func1runtime.mallocinitruntime.mapaccess1_fast32runtime.mapaccess1_fast64runtime.mapaccess1_faststrruntime.mapaccess2runtime.mapaccess2_fast32runtime.mapaccess2_fast64runtime.mapaccess2_faststrruntime.mapaccessKruntime.mapassignruntime.mapassign_fast32runtime.mapassign_fast64runtime.mapassign_faststrruntime.mapiterinitruntime.mapiternextruntime.markBits.isMarkedruntime.markBits.setMarkedruntime.markBits.setMarkedNonAtomicruntime.markBitsForAddrruntime.markrootruntime.markroot.func1runtime.markrootBlockruntime.markrootFreeGStacksruntime.markrootSpansruntime.maxElemsruntime.maxSliceCapruntime.maxstacksizeruntime.mbucketsruntime.mcallruntime.mcallPCruntime.mcommoninitruntime.mcountruntime.memclrHasPointersruntime.memclrNoHeapPointersruntime.memeqbodyruntime.memequalruntime.memequal0runtime.memequal128runtime.memequal16runtime.memequal32runtime.memequal64runtime.memequal8runtime.memequal_varlenruntime.memhashruntime.memhash0runtime.memhash128runtime.memhash16runtime.memhash32runtime.memhash64runtime.memhash8runtime.memhash_varlenruntime.memhash_varlen.args_stackmapruntime.memmoveruntime.memoryErrorruntime.memstatsruntime.mgetruntime.mheap_runtime.mhelpgcruntime.minitruntime.minitSignalMaskruntime.minitSignalStackruntime.mmapruntime.moduledataverifyruntime.moduledataverify1runtime.modulesSliceruntime.modulesinitruntime.morestackruntime.morestackPCruntime.morestack_noctxtruntime.morestackcruntime.morestackc.func1runtime.mpreinitruntime.mputruntime.msigrestoreruntime.msigsaveruntime.mspinningruntime.mstartruntime.mstart1runtime.mstartPCruntime.muintptr.ptrruntime.munmapruntime.mutexprofilerateruntime.name.dataruntime.name.isExportedruntime.name.nameruntime.name.nameLenruntime.name.pkgPathruntime.name.tagruntime.name.tagLenruntime.nanotimeruntime.ncpuruntime.needaddgcprocruntime.needmruntime.netpollruntime.netpollInitedruntime.netpollWaitersruntime.netpollblockruntime.netpollblockcommitruntime.netpollcheckerrruntime.netpollcloseruntime.netpollgoreadyruntime.netpollinitruntime.netpollinitedruntime.netpollopenruntime.netpollreadyruntime.netpollunblockruntime.newAllocBitsruntime.newArenaMayUnlockruntime.newBucketruntime.newMarkBitsruntime.newProfBufruntime.newarrayruntime.newdeferruntime.newdefer.func1runtime.newdefer.func2runtime.newextramruntime.newmruntime.newobjectruntime.newosprocruntime.newprocruntime.newproc.func1runtime.newproc1runtime.newprocsruntime.newstackruntime.nextFreeFastruntime.nextMarkBitArenaEpochruntime.nextSampleruntime.nilfuncruntime.nilinterequalruntime.nilinterhashruntime.noSignalStackruntime.no_pointers_stackmapruntime.noescaperuntime.noptrbssruntime.noptrdataruntime.noteclearruntime.notesleepruntime.notetsleepruntime.notetsleep_internalruntime.notetsleepgruntime.notewakeupruntime.oneBitCountruntime.oneNewExtraMruntime.oneptrmaskruntime.openruntime.osRelaxruntime.osinitruntime.osyieldruntime.overLoadFactorruntime.overflowErrorruntime.overflowTagruntime.panicCheckMallocruntime.panicdivideruntime.panicdottypeEruntime.panicdottypeIruntime.panicfloatruntime.panicindexruntime.panickingruntime.paniclkruntime.panicmemruntime.panicoverflowruntime.panicsliceruntime.panicwrapruntime.park_mruntime.parkunlock_cruntime.parsedebugvarsruntime.pcdatavalueruntime.pclntabruntime.pcvalueruntime.persistentallocruntime.persistentalloc.func1runtime.persistentalloc1runtime.physPageSizeruntime.pidlegetruntime.pidleputruntime.pinnedTypemapsruntime.plainError.Errorruntime.pollWorkruntime.pollcacheruntime.poolcleanupruntime.preemptallruntime.preemptoneruntime.prefetchntaruntime.prefetcht0runtime.prefetcht1runtime.prefetcht2runtime.prepareFreeWorkbufsruntime.preprintpanicsruntime.preprintpanics.func1runtime.printBacklogruntime.printBacklogIndexruntime.printCgoTracebackruntime.printOneCgoTracebackruntime.printanyruntime.printboolruntime.printcomplexruntime.printcreatedbyruntime.printefaceruntime.printfloatruntime.printhexruntime.printintruntime.printlockruntime.printnlruntime.printpanicsruntime.printpointerruntime.printsliceruntime.printspruntime.printstringruntime.printuintruntime.printunlockruntime.procPinruntime.procUnpinruntime.processorVersionInforuntime.procresizeruntime.procyieldruntime.profruntime.profIndex.addCountsAndClearFlagsruntime.profIndex.dataCountruntime.profIndex.tagCountruntime.profileallocruntime.proflockruntime.progToPointerMaskruntime.ptrbitruntime.publicationBarrierruntime.publicationBarrier.args_stackmapruntime.puintptr.ptrruntime.purgecachedstatsruntime.putemptyruntime.putfullruntime.queuefinalizerruntime.raiseruntime.raisebadsignalruntime.raiseprocruntime.rawbytesliceruntime.rawrunesliceruntime.rawstringruntime.rawstringtmpruntime.readruntime.readUnaligned32runtime.readUnaligned64runtime.readgogcruntime.readgstatusruntime.readmemstats_mruntime.readvarintruntime.readyruntime.readyWithTimeruntime.recordruntime.recordForPanicruntime.recordspanruntime.recoveryruntime.recvruntime.recvDirectruntime.reentersyscallruntime.reentersyscall.func1runtime.reflectOffsruntime.reflectOffsLockruntime.reflectOffsUnlockruntime.reflectcallruntime.reflectcall.args_stackmapruntime.reflectcallmoveruntime.releaseSudogruntime.releasemruntime.releasepruntime.removefinalizerruntime.removespecialruntime.resetspinningruntime.resolveNameOffruntime.resolveTypeOffruntime.restartgruntime.restoreGsignalStackruntime.retakeruntime.return0runtime.rodataruntime.rotl_31runtime.roundruntime.round2runtime.roundupsizeruntime.rt0_goruntime.rt0_goPCruntime.runGCProgruntime.runSafePointFnruntime.runfinqruntime.runfinqPCruntime.runningPanicDefersruntime.runqemptyruntime.runqgetruntime.runqgrabruntime.runqputruntime.runqputslowruntime.runqstealruntime.runtimeInitTimeruntime.saveruntime.saveblockeventruntime.savegruntime.sbrk0runtime.scanblockruntime.scanframeworkerruntime.scangruntime.scanobjectruntime.scanstackruntime.scanstack.func1runtime.scavengeTreapNoderuntime.scavengelistruntime.scavengetreapruntime.schedruntime.schedinitruntime.schedtraceruntime.scheduleruntime.semacquireruntime.semacquire1runtime.semacreateruntime.semacreate.func1runtime.semasleepruntime.semasleep.func1runtime.semasleep1runtime.semawakeupruntime.semreleaseruntime.semrelease1runtime.semrootruntime.semtableruntime.sendruntime.sendDirectruntime.setGCPhaseruntime.setGNoWBruntime.setGsignalStackruntime.setMNoWBruntime.setProcessCPUProfilerruntime.setSignalstackSPruntime.setThreadCPUProfilerruntime.setcpuprofilerateruntime.setgruntime.setitimerruntime.setprofilebucketruntime.setsSPruntime.setsigruntime.setsigstackruntime.settlsruntime.shaderuntime.showframeruntime.shrinkstackruntime.siftdownTimerruntime.siftupTimerruntime.sigruntime.sigInstallGoHandlerruntime.sigNotOnStackruntime.sigactionruntime.sigaddsetruntime.sigaltstackruntime.sigblockruntime.sigdelsetruntime.sigfwdruntime.sigfwdgoruntime.sighandlerruntime.signalDuringForkruntime.signal_ignoredruntime.signalsOKruntime.signalstackruntime.signameruntime.sigpanicruntime.sigpanicPCruntime.sigpiperuntime.sigprocmaskruntime.sigprofruntime.sigprofNonGoPCruntime.sigsendruntime.sigset_allruntime.sigtableruntime.sigtrampruntime.sigtrampgoruntime.size_to_class128runtime.size_to_class8runtime.sizeof_C_MStatsruntime.skipPCruntime.skipPleaseUseCallersFramesruntime.sliceErrorruntime.slicebytetostringruntime.slicerunetostringruntime.spanClass.noscanruntime.spanClass.sizeclassruntime.spanOfruntime.spanOfUncheckedruntime.stackLargeruntime.stackallocruntime.stackcache_clearruntime.stackcacherefillruntime.stackcachereleaseruntime.stackcheckruntime.stackfreeruntime.stackinitruntime.stacklog2runtime.stackmapdataruntime.stackpoolruntime.stackpoolallocruntime.stackpoolfreeruntime.stackpoolmuruntime.startNanoruntime.startTheWorldruntime.startTheWorldWithSemaruntime.startlockedmruntime.startmruntime.startpanicruntime.startpanic_mruntime.starttimeruntime.staticbytesruntime.statictmp_0runtime.statictmp_1runtime.statictmp_10runtime.statictmp_11runtime.statictmp_12runtime.statictmp_13runtime.statictmp_14runtime.statictmp_15runtime.statictmp_17runtime.statictmp_18runtime.statictmp_2runtime.statictmp_21runtime.statictmp_22runtime.statictmp_23runtime.statictmp_26runtime.statictmp_27runtime.statictmp_28runtime.statictmp_29runtime.statictmp_3runtime.statictmp_30runtime.statictmp_31runtime.statictmp_32runtime.statictmp_33runtime.statictmp_34runtime.statictmp_35runtime.statictmp_38runtime.statictmp_39runtime.statictmp_4runtime.statictmp_40runtime.statictmp_41runtime.statictmp_42runtime.statictmp_43runtime.statictmp_44runtime.statictmp_45runtime.statictmp_6runtime.statictmp_7runtime.statictmp_8runtime.statictmp_9runtime.stealOrderruntime.stepruntime.stkbucketruntime.stopTheWorldruntime.stopTheWorldWithSemaruntime.stoplockedmruntime.stopmruntime.strequalruntime.strhashruntime.stringDataOnStackruntime.stringStructOfruntime.stringtoslicebyteruntime.stringtosliceruneruntime.subtract1runtime.subtractbruntime.support_aesruntime.support_avxruntime.support_avx2runtime.support_bmi1runtime.support_bmi2runtime.support_ermsruntime.support_osxsaveruntime.support_popcntruntime.support_sse2runtime.support_sse41runtime.support_sse42runtime.support_ssse3runtime.sweepruntime.sweeponeruntime.symtabruntime.syncadjustsudogsruntime.sysAllocruntime.sysFaultruntime.sysFreeruntime.sysMapruntime.sysReserveruntime.sysUnusedruntime.sysUsedruntime.sysargsruntime.sysctlruntime.sysmonruntime.systemstackruntime.systemstackPCruntime.systemstack_switchruntime.systemstack_switchPCruntime.testAtomic64runtime.test_x64runtime.test_z64runtime.testdefersizesruntime.textruntime.textsectionmapruntime.throwruntime.throwinitruntime.ticksruntime.tickspersecondruntime.timedivruntime.timejumpruntime.timerprocruntime.timerprocPCruntime.timersruntime.tooManyOverflowBucketsruntime.topofstackruntime.totaldefersizeruntime.traceruntime.traceAcquireBufferruntime.traceAllocBlockPtr.ptrruntime.traceAppendruntime.traceBufPtr.ptrruntime.traceBufPtrOfruntime.traceEventruntime.traceFlushruntime.traceFrameForPCruntime.traceFullDequeueruntime.traceFullQueueruntime.traceGCDoneruntime.traceGCMarkAssistDoneruntime.traceGCMarkAssistStartruntime.traceGCScanDoneruntime.traceGCScanStartruntime.traceGCStartruntime.traceGCSweepDoneruntime.traceGCSweepSpanruntime.traceGCSweepStartruntime.traceGoCreateruntime.traceGoEndruntime.traceGoParkruntime.traceGoPreemptruntime.traceGoSchedruntime.traceGoStartruntime.traceGoSysBlockruntime.traceGoSysCallruntime.traceGoSysExitruntime.traceGoUnparkruntime.traceGomaxprocsruntime.traceHeapAllocruntime.traceNextGCruntime.traceProcFreeruntime.traceProcStartruntime.traceProcStopruntime.traceReaderruntime.traceReleaseBufferruntime.traceStackIDruntime.traceStackPtr.ptrruntime.traceStringruntime.traceallocruntime.tracealloc.func1runtime.tracebackruntime.traceback1runtime.tracebackCgoContextruntime.traceback_cacheruntime.traceback_envruntime.tracebackdefersruntime.tracebackinitruntime.tracebackothersruntime.tracebacktrapruntime.tracefreeruntime.tracefree.func1runtime.tracegcruntime.tracelockruntime.trygetfullruntime.typeBitsBulkBarrierruntime.typedmemclrruntime.typedmemmoveruntime.typedslicecopyruntime.typedslicecopy.func1runtime.typelinkruntime.typelinksinitruntime.typesruntime.typesEqualruntime.typestringruntime.unblocksigruntime.unimplementedruntime.unlockruntime.unlockOSThreadruntime.unlockextraruntime.unminitruntime.unminitSignalsruntime.unwindmruntime.updatememstatsruntime.urandom_devruntime.useAVXmemmoveruntime.useAeshashruntime.useCheckmarkruntime.usleepruntime.wakefingruntime.wakepruntime.workruntime.worldsemaruntime.writeruntime.writeBarrierruntime.writeErrruntime.writebarrierptrruntime.writebarrierptr.func1runtime.writebarrierptr_prewriteruntime.writebarrierptr_prewrite.func1runtime.writebarrierptr_prewrite1runtime.writebarrierptr_prewrite1.func1runtime.xbucketsruntime.zeroValruntime.zerobaseruntime.zerondrruntime/debug.SetTracebackruntime/debug.initruntime/debug.initdone.runtime/debug.setGCPercentruntime/pprof.(*Profile).Nameruntime/pprof.(*Profile).WriteToruntime/pprof.(*keysByCount).Lenruntime/pprof.(*keysByCount).Lessruntime/pprof.(*keysByCount).Swapruntime/pprof.(*profMap).lookupruntime/pprof.(*profileBuilder).(runtime/pprof.addMapping)-fmruntime/pprof.(*profileBuilder).addCPUDataruntime/pprof.(*profileBuilder).addMappingruntime/pprof.(*profileBuilder).buildruntime/pprof.(*profileBuilder).build.func1runtime/pprof.(*profileBuilder).flushruntime/pprof.(*profileBuilder).locForPCruntime/pprof.(*profileBuilder).locForPC.func1runtime/pprof.(*profileBuilder).pbLabelruntime/pprof.(*profileBuilder).pbLineruntime/pprof.(*profileBuilder).pbMappingruntime/pprof.(*profileBuilder).pbSampleruntime/pprof.(*profileBuilder).pbValueTyperuntime/pprof.(*profileBuilder).readMappingruntime/pprof.(*profileBuilder).stringIndexruntime/pprof.(*protobuf).endMessageruntime/pprof.(*protobuf).int64runtime/pprof.(*protobuf).int64Optruntime/pprof.(*protobuf).int64sruntime/pprof.(*protobuf).lengthruntime/pprof.(*protobuf).startMessageruntime/pprof.(*protobuf).stringruntime/pprof.(*protobuf).stringsruntime/pprof.(*protobuf).uint64runtime/pprof.(*protobuf).uint64Optruntime/pprof.(*protobuf).uint64sruntime/pprof.(*protobuf).varintruntime/pprof.(*runtimeProfile).Lenruntime/pprof.(*runtimeProfile).Stackruntime/pprof.(*stackProfile).Lenruntime/pprof.(*stackProfile).Lessruntime/pprof.(*stackProfile).Stackruntime/pprof.(*stackProfile).Swapruntime/pprof.Lookupruntime/pprof.StartCPUProfileruntime/pprof.StopCPUProfileruntime/pprof.WriteHeapProfileruntime/pprof.blockProfileruntime/pprof.countBlockruntime/pprof.countGoroutineruntime/pprof.countHeapruntime/pprof.countMutexruntime/pprof.countThreadCreateruntime/pprof.cpuruntime/pprof.elfBuildIDruntime/pprof.errBadELFruntime/pprof.errNoBuildIDruntime/pprof.funcPCruntime/pprof.goroutineProfileruntime/pprof.heapProfileruntime/pprof.initruntime/pprof.initdone.runtime/pprof.lockProfilesruntime/pprof.lostProfileEventruntime/pprof.mutexProfileruntime/pprof.newProfileBuilderruntime/pprof.parseProcSelfMapsruntime/pprof.parseProcSelfMaps.func1runtime/pprof.printCountProfileruntime/pprof.printCountProfile.func1runtime/pprof.printStackRecordruntime/pprof.profileWriterruntime/pprof.profilesruntime/pprof.readProfileruntime/pprof.runtimeProfile.Lenruntime/pprof.runtimeProfile.Stackruntime/pprof.runtime_cyclesPerSecondruntime/pprof.scaleHeapSampleruntime/pprof.stackProfile.Lenruntime/pprof.stackProfile.Lessruntime/pprof.stackProfile.Stackruntime/pprof.stackProfile.Swapruntime/pprof.statictmp_10runtime/pprof.statictmp_11runtime/pprof.statictmp_12runtime/pprof.statictmp_13runtime/pprof.statictmp_14runtime/pprof.statictmp_15runtime/pprof.statictmp_16runtime/pprof.statictmp_4runtime/pprof.statictmp_5runtime/pprof.statictmp_6runtime/pprof.statictmp_7runtime/pprof.statictmp_8runtime/pprof.statictmp_9runtime/pprof.threadcreateProfileruntime/pprof.unlockProfilesruntime/pprof.writeBlockruntime/pprof.writeBlock.func1runtime/pprof.writeGoroutineruntime/pprof.writeGoroutineStacksruntime/pprof.writeHeapruntime/pprof.writeHeap.func1runtime/pprof.writeHeapProtoruntime/pprof.writeHeapProto.func1runtime/pprof.writeMutexruntime/pprof.writeMutex.func1runtime/pprof.writeRuntimeProfileruntime/pprof.writeThreadCreateruntime/trace.Startruntime/trace.Start.func1runtime/trace.Stopruntime/trace.initruntime/trace.initdone._rupoly_setg_gcc_shiftssort.(*StringSlice).Lensort.(*StringSlice).Lesssort.(*StringSlice).Swapsort.Searchsort.Slicesort.Sortsort.StringSlice.Lensort.StringSlice.Lesssort.StringSlice.Sortsort.StringSlice.Swapsort.Stringssort.doPivotsort.doPivot_funcsort.heapSortsort.heapSort_funcsort.initsort.initdone.sort.insertionSortsort.insertionSort_funcsort.maxDepthsort.medianOfThreesort.medianOfThree_funcsort.quickSortsort.quickSort_funcsort.siftDownsort.siftDown_funcstrconv.(*NumError).Errorstrconv.(*decimal).Assignstrconv.(*decimal).Roundstrconv.(*decimal).RoundDownstrconv.(*decimal).RoundUpstrconv.(*decimal).RoundedIntegerstrconv.(*decimal).Shiftstrconv.(*decimal).Stringstrconv.(*decimal).floatBitsstrconv.(*decimal).setstrconv.(*extFloat).AssignComputeBoundsstrconv.(*extFloat).AssignDecimalstrconv.(*extFloat).FixedDecimalstrconv.(*extFloat).Multiplystrconv.(*extFloat).Normalizestrconv.(*extFloat).ShortestDecimalstrconv.(*extFloat).floatBitsstrconv.(*extFloat).frexp10strconv.AppendFloatstrconv.AppendQuotestrconv.AppendQuoteRunestrconv.AppendQuoteRuneToASCIIstrconv.AppendQuoteToASCIIstrconv.Atoistrconv.CanBackquotestrconv.ErrRangestrconv.ErrSyntaxstrconv.FormatBoolstrconv.FormatFloatstrconv.FormatIntstrconv.FormatUintstrconv.IsPrintstrconv.Itoastrconv.ParseBoolstrconv.ParseFloatstrconv.ParseIntstrconv.ParseUintstrconv.Quotestrconv.QuoteRunestrconv.QuoteToASCIIstrconv.adjustLastDigitstrconv.adjustLastDigitFixedstrconv.appendEscapedRunestrconv.appendQuotedRuneWithstrconv.appendQuotedWithstrconv.atof32strconv.atof32exactstrconv.atof64strconv.atof64exactstrconv.bigFtoastrconv.bsearch16strconv.bsearch32strconv.digitZerostrconv.equalIgnoreCasestrconv.float32infostrconv.float32pow10strconv.float64infostrconv.float64pow10strconv.fmtBstrconv.fmtEstrconv.fmtFstrconv.formatBitsstrconv.formatDigitsstrconv.frexp10Manystrconv.genericFtoastrconv.initstrconv.initdone.strconv.isGraphicstrconv.isInGraphicListstrconv.isNotPrint16strconv.isNotPrint32strconv.isPrint16strconv.isPrint32strconv.leftShiftstrconv.leftcheatsstrconv.maxstrconv.minstrconv.optimizestrconv.powersOfTenstrconv.powtabstrconv.prefixIsLessThanstrconv.quoteRuneWithstrconv.quoteWithstrconv.rangeErrorstrconv.readFloatstrconv.rightShiftstrconv.roundShorteststrconv.shiftsstrconv.shouldRoundUpstrconv.smallstrconv.smallPowersOfTenstrconv.specialstrconv.statictmp_0strconv.statictmp_1strconv.statictmp_10strconv.statictmp_11strconv.statictmp_12strconv.statictmp_13strconv.statictmp_14strconv.statictmp_15strconv.statictmp_2strconv.statictmp_3strconv.statictmp_4strconv.statictmp_5strconv.statictmp_6strconv.statictmp_7strconv.statictmp_8strconv.statictmp_9strconv.syntaxErrorstrconv.trimstrconv.uint64pow10strings.ContainsRunestrings.Countstrings.HasPrefixstrings.Indexstrings.IndexBytestrings.IndexRunestrings.Joinstrings.LastIndexstrings.LastIndexBytestrings.Splitstrings.TrimFuncstrings.TrimLeftFuncstrings.TrimRightFuncstrings.TrimSpacestrings.countBytestrings.countGenericstrings.explodestrings.genSplitstrings.hashStrstrings.hashStrRevstrings.indexFuncstrings.indexShortStrstrings.initstrings.init.0strings.initdone.strings.lastIndexFuncstrings.shortStringLensync.(*Map).Loadsync.(*Map).LoadOrStoresync.(*Map).Storesync.(*Map).dirtyLockedsync.(*Map).missLockedsync.(*Mutex).Locksync.(*Mutex).Unlocksync.(*Once).Dosync.(*Pool).Getsync.(*Pool).Putsync.(*Pool).getSlowsync.(*Pool).pinsync.(*Pool).pinSlowsync.(*RWMutex).Locksync.(*RWMutex).RLocksync.(*RWMutex).RUnlocksync.(*RWMutex).Unlocksync.(*entry).loadsync.(*entry).storeLockedsync.(*entry).tryExpungeLockedsync.(*entry).tryLoadOrStoresync.(*entry).tryStoresync.(*entry).unexpungeLockedsync.allPoolssync.allPoolsMusync.eventsync.expungedsync.indexLocalsync.initsync.init.0sync.init.1sync.initdone.sync.newEntrysync.poolCleanupsync.runtime_Semacquiresync.runtime_SemacquireMutexsync.runtime_Semreleasesync.runtime_canSpinsync.runtime_doSpinsync.runtime_nanotimesync.runtime_notifyListChecksync.runtime_procPinsync.runtime_procUnpinsync.runtime_registerPoolCleanupsync.statictmp_1sync.statictmp_2sync.statictmp_3sync.throwsync/atomic.(*Value).Loadsync/atomic.(*Value).Storesync/atomic.CompareAndSwapPointersync/atomic.CompareAndSwapUint64sync/atomic.CompareAndSwapUint64.args_stackmapsync/atomic.CompareAndSwapUintptrsync/atomic.CompareAndSwapUintptr.args_stackmapsync/atomic.StorePointersync/atomic.StoreUint32sync/atomic.StoreUint32.args_stackmapsync/atomic.StoreUint64sync/atomic.StoreUint64.args_stackmapsync/atomic.StoreUintptrsync/atomic.StoreUintptr.args_stackmapsync/atomic.runtime_procPinsync/atomic.runtime_procUnpinsync/atomic.statictmp_1sync/atomic.statictmp_2syscall.(*Errno).Errorsyscall.BytePtrFromStringsyscall.ByteSliceFromStringsyscall.Chmodsyscall.Closesyscall.CloseOnExecsyscall.Errno.Errorsyscall.Exitsyscall.ForkLocksyscall.Fstatsyscall.Getdirentriessyscall.Getenvsyscall.Getwdsyscall.Lstatsyscall.Opensyscall.ParseDirentsyscall.Pipesyscall.Preadsyscall.RawSyscallsyscall.RawSyscall.args_stackmapsyscall.Readsyscall.ReadDirentsyscall.Seeksyscall.SetNonblocksyscall.Statsyscall.Stderrsyscall.Stdinsyscall.Stdoutsyscall.Syscallsyscall.Syscall.args_stackmapsyscall.Syscall6syscall.Syscall6.args_stackmapsyscall.Writesyscall._zerosyscall.copyenvsyscall.direntInosyscall.direntNamlensyscall.direntReclensyscall.envsyscall.envLocksyscall.envOncesyscall.envssyscall.errEAGAINsyscall.errEINVALsyscall.errENOENTsyscall.errnoErrsyscall.errorssyscall.fcntlsyscall.getAttrListsyscall.initsyscall.initdone.syscall.itoasyscall.minRoutingSockaddrLensyscall.mmapsyscall.munmapsyscall.pipesyscall.readsyscall.readIntsyscall.readIntLEsyscall.rsaAlignOfsyscall.runtime_envssyscall.statictmp_19syscall.statictmp_2syscall.statictmp_32syscall.statictmp_33syscall.statictmp_35syscall.statictmp_40syscall.statictmp_41syscall.statictmp_42syscall.statictmp_43syscall.uitoasyscall.writetesting.(*B).Nametesting.(*B).ResetTimertesting.(*B).Runtesting.(*B).StartTimertesting.(*B).StopTimertesting.(*B).addtesting.(*B).doBenchtesting.(*B).launchtesting.(*B).launch.func1testing.(*B).nsPerOptesting.(*B).runtesting.(*B).run.func1testing.(*B).run1testing.(*B).run1.func1testing.(*B).run1.func1.1testing.(*B).runNtesting.(*B).trimOutputtesting.(*BenchmarkResult).Stringtesting.(*M).Runtesting.(*M).aftertesting.(*M).beforetesting.(*T).Nametesting.(*T).Runtesting.(*T).reporttesting.(*benchContext).processBenchtesting.(*common).Errorftesting.(*common).Failtesting.(*common).Failedtesting.(*common).Nametesting.(*common).Skippedtesting.(*common).decoratetesting.(*common).flushToParenttesting.(*common).frameSkiptesting.(*common).logtesting.(*common).setRantesting.(*indenter).Writetesting.(*matcher).fullNametesting.(*matcher).uniquetesting.(*testContext).releasetesting.(*testContext).waitParalleltesting.(testDeps).MatchString-fmtesting.BenchmarkResult.AllocedBytesPerOptesting.BenchmarkResult.AllocsPerOptesting.BenchmarkResult.MemStringtesting.BenchmarkResult.NsPerOptesting.BenchmarkResult.Stringtesting.BenchmarkResult.mbPerSectesting.MainStarttesting.benchTimetesting.benchmarkLocktesting.benchmarkMemorytesting.benchmarkNametesting.blockProfiletesting.blockProfileRatetesting.callerNametesting.chattytesting.counttesting.covertesting.coverProfiletesting.coverReporttesting.coverReport.func1testing.cpuListtesting.cpuListStrtesting.cpuProfiletesting.errMaintesting.fmtDurationtesting.haveExamplestesting.indenter.Writetesting.inittesting.initdone.testing.isSpacetesting.labelsOncetesting.listTeststesting.matchtesting.matchBenchmarkstesting.matchListtesting.matchMutextesting.maxtesting.memProfiletesting.memProfileRatetesting.memStatstesting.mintesting.mustBeNiltesting.mutexProfiletesting.mutexProfileFractiontesting.newMatchertesting.newTestContexttesting.outputDirtesting.paralleltesting.parseCpuListtesting.rewritetesting.roundDown10testing.roundUptesting.runBenchmarkstesting.runBenchmarks.func1testing.runExampletesting.runExample.func1testing.runExample.func2testing.runExamplestesting.runTeststesting.runTests.func1testing.runTests.func1.1testing.shorttesting.sortLinestesting.splitRegexptesting.startAlarmtesting.startAlarm.func1testing.statictmp_0testing.statictmp_10testing.statictmp_11testing.statictmp_12testing.statictmp_14testing.statictmp_15testing.statictmp_16testing.statictmp_17testing.statictmp_18testing.statictmp_19testing.statictmp_2testing.statictmp_3testing.statictmp_6testing.statictmp_7testing.statictmp_8testing.statictmp_9testing.stopAlarmtesting.tRunnertesting.tRunner.func1testing.timeouttesting.timertesting.toOutputDirtesting.traceFiletesting/internal/testdeps.(*TestDeps).ImportPathtesting/internal/testdeps.(*TestDeps).MatchStringtesting/internal/testdeps.(*TestDeps).StartCPUProfiletesting/internal/testdeps.(*TestDeps).StopCPUProfiletesting/internal/testdeps.(*TestDeps).WriteHeapProfiletesting/internal/testdeps.(*TestDeps).WriteProfileTotesting/internal/testdeps.ImportPathtesting/internal/testdeps.TestDeps.ImportPathtesting/internal/testdeps.TestDeps.MatchStringtesting/internal/testdeps.TestDeps.StartCPUProfiletesting/internal/testdeps.TestDeps.StopCPUProfiletesting/internal/testdeps.TestDeps.WriteHeapProfiletesting/internal/testdeps.TestDeps.WriteProfileTotesting/internal/testdeps.inittesting/internal/testdeps.initdone.testing/internal/testdeps.matchPattesting/internal/testdeps.matchRetext/tabwriter.(*Writer).Flushtext/tabwriter.(*Writer).Inittext/tabwriter.(*Writer).Writetext/tabwriter.(*Writer).addLinetext/tabwriter.(*Writer).appendtext/tabwriter.(*Writer).endEscapetext/tabwriter.(*Writer).flushtext/tabwriter.(*Writer).formattext/tabwriter.(*Writer).resettext/tabwriter.(*Writer).startEscapetext/tabwriter.(*Writer).terminateCelltext/tabwriter.(*Writer).updateWidthtext/tabwriter.(*Writer).write0text/tabwriter.(*Writer).writeLinestext/tabwriter.(*Writer).writeNtext/tabwriter.(*Writer).writePaddingtext/tabwriter..gobytes.1text/tabwriter..gobytes.2text/tabwriter.NewWritertext/tabwriter.handlePanictext/tabwriter.hbartext/tabwriter.inittext/tabwriter.initdone.text/tabwriter.newlinetext/tabwriter.statictmp_0text/tabwriter.statictmp_1text/tabwriter.statictmp_2text/tabwriter.statictmp_3text/tabwriter.tabstext/tabwriter.vbartime.(*Duration).Stringtime.(*Location).Stringtime.(*Location).firstZoneUsedtime.(*Location).gettime.(*Location).lookuptime.(*Location).lookupFirstZonetime.(*Month).Stringtime.(*Time).Stringtime.(*Time).addSectime.(*Time).nsectime.(*Time).sectime.(*Time).stripMonotime.(*Time).unixSectime.(*Timer).Stoptime.(*Weekday).Stringtime.(*data).big4time.(*data).bytetime.(*data).readtime.(*fileSizeError).Errortime.AfterFunctime.Duration.Nanosecondstime.Duration.Secondstime.Duration.Stringtime.Localtime.Month.Stringtime.Nowtime.ParseDurationtime.Sincetime.Sleeptime.Time.Addtime.Time.Aftertime.Time.AppendFormattime.Time.Beforetime.Time.Equaltime.Time.Formattime.Time.Nanosecondtime.Time.Stringtime.Time.Subtime.Time.Unixtime.Time.UnixNanotime.Time.locabstime.Unixtime.Weekday.Stringtime.absClocktime.absDatetime.absWeekdaytime.appendInttime.atoiErrortime.badDatatime.byteStringtime.closefdtime.daystime.daysBeforetime.errBadtime.errLeadingInttime.errLocationtime.fileSizeError.Errortime.fmtFractime.fmtInttime.formatNanotime.get2time.get4time.goFunctime.inittime.initLocaltime.initdone.time.isDigittime.isLeaptime.isNotExisttime.leadingFractiontime.leadingInttime.loadLocationtime.loadZoneDatatime.loadZoneFiletime.loadZoneZiptime.localLoctime.localOncetime.monthstime.nextStdChunktime.nowtime.opentime.preadntime.readFiletime.runtimeNanotime.startTimertime.startsWithLowerCasetime.statictmp_1time.statictmp_12time.std0xtime.stopTimertime.unitMaptime.unixTimetime.utcLoctime.whentime.zoneDirstype.*type..eq.[106]stringtype..eq.[11]float32type..eq.[11]stringtype..eq.[12]stringtype..eq.[134]struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }type..eq.[14]runtime.dbgVartype..eq.[23]float64type..eq.[251]struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }type..eq.[27]stringtype..eq.[2]interface {}type..eq.[2]runtime.gcSweepBuftype..eq.[2]stringtype..eq.[32]runtime.sigTabTtype..eq.[33]float64type..eq.[3]interface {}type..eq.[3]stringtype..eq.[4]interface {}type..eq.[4]stringtype..eq.[5]interface {}type..eq.[5]stringtype..eq.[61]strconv.leftCheattype..eq.[61]struct { Size uint32; Mallocs uint64; Frees uint64 }type..eq.[67]struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }type..eq.[6]stringtype..eq.[7]interface {}type..eq.[7]stringtype..eq.[87]strconv.extFloattype..eq.[8]runtime/pprof.newFunc.1type..eq.[8]strconv.extFloattype..eq.[9]stringtype..eq.compress/flate.literalNodetype..eq.flag.Flagtype..eq.fmt.fmttype..eq.github.com/go-kit/kit/metrics.Timertype..eq.internal/cpu.x86type..eq.internal/poll.FDtype..eq.os.LinkErrortype..eq.os.PathErrortype..eq.os.SyscallErrortype..eq.os.filetype..eq.os.fileStattype..eq.reflect.Methodtype..eq.reflect.ValueErrortype..eq.reflect.funcTypetype..eq.reflect.funcTypeFixed128type..eq.reflect.funcTypeFixed16type..eq.reflect.funcTypeFixed32type..eq.reflect.funcTypeFixed4type..eq.reflect.funcTypeFixed64type..eq.reflect.funcTypeFixed8type..eq.reflect.uncommonTypetype..eq.regexp.entrytype..eq.regexp.inputReadertype..eq.regexp.jobtype..eq.regexp/syntax.Errortype..eq.runtime.Frametype..eq.runtime.MemStatstype..eq.runtime.TypeAssertionErrortype..eq.runtime._defertype..eq.runtime._functype..eq.runtime._panictype..eq.runtime.bitvectortype..eq.runtime.cpuProfiletype..eq.runtime.dbgVartype..eq.runtime.finblocktype..eq.runtime.forcegcstatetype..eq.runtime.functypetype..eq.runtime.gcControllerStatetype..eq.runtime.gcSweepBuftype..eq.runtime.gcTriggertype..eq.runtime.hchantype..eq.runtime.heapBitstype..eq.runtime.hitertype..eq.runtime.markBitstype..eq.runtime.mcachetype..eq.runtime.mcentraltype..eq.runtime.modulehashtype..eq.runtime.mstatstype..eq.runtime.rwmutextype..eq.runtime.semaRoottype..eq.runtime.sigTabTtype..eq.runtime.specialtype..eq.runtime.stackmaptype..eq.runtime.sudogtype..eq.runtime.sweepdatatype..eq.runtime.sysmonticktype..eq.runtime.traceStacktype..eq.runtime.traceStackTabletype..eq.runtime.treapNodetype..eq.runtime.uncommontypetype..eq.runtime/pprof.newFunc.1type..eq.strconv.NumErrortype..eq.strconv.decimaltype..eq.strconv.extFloattype..eq.strconv.leftCheattype..eq.struct { F uintptr; R testing.testDeps }type..eq.struct { F uintptr; reflect.hash uint32 }type..eq.struct { F uintptr; reflect.name string }type..eq.struct { F uintptr; runtime.buf *[]uint8; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr; runtime.all bool; runtime.n *int }type..eq.struct { F uintptr; runtime.c *runtime.mcache; runtime.spc runtime.spanClass }type..eq.struct { F uintptr; runtime.h *runtime.mheap; runtime.s *runtime.mspan; runtime.acct int32 }type..eq.struct { F uintptr; runtime.newg *runtime.g; runtime.stacksize int32 }type..eq.struct { F uintptr; runtime.preemptible bool }type..eq.struct { F uintptr; runtime.r int32 }type..eq.struct { F uintptr; runtime.s **runtime.mspan; runtime.h *runtime.mheap; runtime.npage uintptr; runtime.spanclass runtime.spanClass; runtime.large bool }type..eq.struct { F uintptr; runtime.s **runtime.mspan; runtime.size *uintptr; runtime.needzero bool; runtime.noscan bool }type..eq.struct { F uintptr; runtime.siz int32; runtime.d **runtime._defer }type..eq.struct { Size uint32; Mallocs uint64; Frees uint64 }type..eq.struct { reflect.b bool; reflect.x interface {} }type..eq.struct { runtime.cycle uint32; runtime.flushed bool }type..eq.struct { runtime.enabled bool; runtime.pad [3]uint8; runtime.needed bool; runtime.cgo bool; runtime.alignme uint64 }type..eq.struct { runtime.full runtime.lfstack; runtime.empty runtime.lfstack; runtime.pad0 [64]uint8; runtime.wbufSpans struct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }; _ uint32; runtime.bytesMarked uint64; runtime.markrootNext uint32; runtime.markrootJobs uint32; runtime.nproc uint32; runtime.tstart int64; runtime.nwait uint32; runtime.ndone uint32; runtime.alldone runtime.note; runtime.helperDrainBlock bool; runtime.nFlushCacheRoots int; runtime.nDataRoots int; runtime.nBSSRoots int; runtime.nSpanRoots int; runtime.nStackRoots int; runtime.markrootDone bool; runtime.startSema uint32; runtime.markDoneSema uint32; runtime.bgMarkReady runtime.note; runtime.bgMarkDone uint32; runtime.mode runtime.gcMode; runtime.userForced bool; runtime.totaltime int64; runtime.initialHeapLive uint64; runtime.assistQueue struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }; runtime.sweepWaiters struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }; runtime.cycles uint32; runtime.stwprocs int32; runtime.maxprocs int32; runtime.tSweepTerm int64; runtime.tMark int64; runtime.tMarkTerm int64; runtime.tEnd int64; runtime.pauseNS int64; runtime.pauseStart int64; runtime.heap0 uint64; runtime.heap1 uint64; runtime.heap2 uint64; runtime.heapGoal uint64 }type..eq.struct { runtime.lock runtime.mutex; runtime.pad uint32; runtime.val uint64 }type..eq.struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }type..eq.struct { runtime.note runtime.note; runtime.mask [1]uint32; runtime.wanted [1]uint32; runtime.ignored [1]uint32; runtime.recv [1]uint32; runtime.state uint32; runtime.inuse bool }type..eq.struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }type..eq.struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }type..eq.struct { sync.Mutex; os.dir string }type..eq.struct { sync.Mutex; runtime/pprof.profiling bool; runtime/pprof.done chan bool }type..eq.sync/atomic.Valuetype..eq.syscall.attrListtype..eq.testing.CoverBlocktype..eq.text/tabwriter.celltype..eq.time.zonetype..eq.time.zoneTranstype..hash.[106]stringtype..hash.[11]float32type..hash.[11]stringtype..hash.[12]stringtype..hash.[134]struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }type..hash.[14]runtime.dbgVartype..hash.[23]float64type..hash.[251]struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }type..hash.[27]stringtype..hash.[2]interface {}type..hash.[2]runtime.gcSweepBuftype..hash.[2]stringtype..hash.[32]runtime.sigTabTtype..hash.[33]float64type..hash.[3]interface {}type..hash.[3]stringtype..hash.[4]interface {}type..hash.[4]stringtype..hash.[5]interface {}type..hash.[5]stringtype..hash.[61]strconv.leftCheattype..hash.[61]struct { Size uint32; Mallocs uint64; Frees uint64 }type..hash.[67]struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }type..hash.[6]stringtype..hash.[7]interface {}type..hash.[7]stringtype..hash.[87]strconv.extFloattype..hash.[8]runtime/pprof.newFunc.1type..hash.[8]strconv.extFloattype..hash.[9]stringtype..hash.compress/flate.literalNodetype..hash.flag.Flagtype..hash.fmt.fmttype..hash.github.com/go-kit/kit/metrics.Timertype..hash.internal/cpu.x86type..hash.internal/poll.FDtype..hash.os.LinkErrortype..hash.os.PathErrortype..hash.os.SyscallErrortype..hash.os.filetype..hash.os.fileStattype..hash.reflect.Methodtype..hash.reflect.ValueErrortype..hash.reflect.funcTypetype..hash.reflect.funcTypeFixed128type..hash.reflect.funcTypeFixed16type..hash.reflect.funcTypeFixed32type..hash.reflect.funcTypeFixed4type..hash.reflect.funcTypeFixed64type..hash.reflect.funcTypeFixed8type..hash.reflect.uncommonTypetype..hash.regexp.entrytype..hash.regexp.inputReadertype..hash.regexp.jobtype..hash.regexp/syntax.Errortype..hash.runtime.Frametype..hash.runtime.MemStatstype..hash.runtime.TypeAssertionErrortype..hash.runtime._defertype..hash.runtime._functype..hash.runtime._panictype..hash.runtime.bitvectortype..hash.runtime.cpuProfiletype..hash.runtime.dbgVartype..hash.runtime.finblocktype..hash.runtime.forcegcstatetype..hash.runtime.functypetype..hash.runtime.gcControllerStatetype..hash.runtime.gcSweepBuftype..hash.runtime.gcTriggertype..hash.runtime.hchantype..hash.runtime.heapBitstype..hash.runtime.hitertype..hash.runtime.markBitstype..hash.runtime.mcachetype..hash.runtime.mcentraltype..hash.runtime.modulehashtype..hash.runtime.mstatstype..hash.runtime.rwmutextype..hash.runtime.semaRoottype..hash.runtime.sigTabTtype..hash.runtime.specialtype..hash.runtime.stackmaptype..hash.runtime.sudogtype..hash.runtime.sweepdatatype..hash.runtime.sysmonticktype..hash.runtime.traceStacktype..hash.runtime.traceStackTabletype..hash.runtime.treapNodetype..hash.runtime.uncommontypetype..hash.runtime/pprof.newFunc.1type..hash.strconv.NumErrortype..hash.strconv.decimaltype..hash.strconv.extFloattype..hash.strconv.leftCheattype..hash.struct { F uintptr; R testing.testDeps }type..hash.struct { F uintptr; reflect.hash uint32 }type..hash.struct { F uintptr; reflect.name string }type..hash.struct { F uintptr; runtime.buf *[]uint8; runtime.gp *runtime.g; runtime.pc uintptr; runtime.sp uintptr; runtime.all bool; runtime.n *int }type..hash.struct { F uintptr; runtime.c *runtime.mcache; runtime.spc runtime.spanClass }type..hash.struct { F uintptr; runtime.h *runtime.mheap; runtime.s *runtime.mspan; runtime.acct int32 }type..hash.struct { F uintptr; runtime.newg *runtime.g; runtime.stacksize int32 }type..hash.struct { F uintptr; runtime.preemptible bool }type..hash.struct { F uintptr; runtime.r int32 }type..hash.struct { F uintptr; runtime.s **runtime.mspan; runtime.h *runtime.mheap; runtime.npage uintptr; runtime.spanclass runtime.spanClass; runtime.large bool }type..hash.struct { F uintptr; runtime.s **runtime.mspan; runtime.size *uintptr; runtime.needzero bool; runtime.noscan bool }type..hash.struct { F uintptr; runtime.siz int32; runtime.d **runtime._defer }type..hash.struct { Size uint32; Mallocs uint64; Frees uint64 }type..hash.struct { reflect.b bool; reflect.x interface {} }type..hash.struct { runtime.cycle uint32; runtime.flushed bool }type..hash.struct { runtime.enabled bool; runtime.pad [3]uint8; runtime.needed bool; runtime.cgo bool; runtime.alignme uint64 }type..hash.struct { runtime.full runtime.lfstack; runtime.empty runtime.lfstack; runtime.pad0 [64]uint8; runtime.wbufSpans struct { runtime.lock runtime.mutex; runtime.free runtime.mSpanList; runtime.busy runtime.mSpanList }; _ uint32; runtime.bytesMarked uint64; runtime.markrootNext uint32; runtime.markrootJobs uint32; runtime.nproc uint32; runtime.tstart int64; runtime.nwait uint32; runtime.ndone uint32; runtime.alldone runtime.note; runtime.helperDrainBlock bool; runtime.nFlushCacheRoots int; runtime.nDataRoots int; runtime.nBSSRoots int; runtime.nSpanRoots int; runtime.nStackRoots int; runtime.markrootDone bool; runtime.startSema uint32; runtime.markDoneSema uint32; runtime.bgMarkReady runtime.note; runtime.bgMarkDone uint32; runtime.mode runtime.gcMode; runtime.userForced bool; runtime.totaltime int64; runtime.initialHeapLive uint64; runtime.assistQueue struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr; runtime.tail runtime.guintptr }; runtime.sweepWaiters struct { runtime.lock runtime.mutex; runtime.head runtime.guintptr }; runtime.cycles uint32; runtime.stwprocs int32; runtime.maxprocs int32; runtime.tSweepTerm int64; runtime.tMark int64; runtime.tMarkTerm int64; runtime.tEnd int64; runtime.pauseNS int64; runtime.pauseStart int64; runtime.heap0 uint64; runtime.heap1 uint64; runtime.heap2 uint64; runtime.heapGoal uint64 }type..hash.struct { runtime.lock runtime.mutex; runtime.pad uint32; runtime.val uint64 }type..hash.struct { runtime.mcentral runtime.mcentral; runtime.pad [8]uint8 }type..hash.struct { runtime.note runtime.note; runtime.mask [1]uint32; runtime.wanted [1]uint32; runtime.ignored [1]uint32; runtime.recv [1]uint32; runtime.state uint32; runtime.inuse bool }type..hash.struct { runtime.root runtime.semaRoot; runtime.pad [40]uint8 }type..hash.struct { runtime.size uint32; runtime.nmalloc uint64; runtime.nfree uint64 }type..hash.struct { sync.Mutex; os.dir string }type..hash.struct { sync.Mutex; runtime/pprof.profiling bool; runtime/pprof.done chan bool }type..hash.sync/atomic.Valuetype..hash.syscall.attrListtype..hash.testing.CoverBlocktype..hash.text/tabwriter.celltype..hash.time.zonetype..hash.time.zoneTransunicode.ASCII_Hex_Digitunicode.Adlamunicode.Ahomunicode.Anatolian_Hieroglyphsunicode.Arabicunicode.Armenianunicode.Avestanunicode.Balineseunicode.Bamumunicode.Bassa_Vahunicode.Batakunicode.Bengaliunicode.Bhaiksukiunicode.Bidi_Controlunicode.Bopomofounicode.Brahmiunicode.Brailleunicode.Bugineseunicode.Buhidunicode.Cunicode.Canadian_Aboriginalunicode.Carianunicode.CaseRangesunicode.Categoriesunicode.Caucasian_Albanianunicode.Ccunicode.Cfunicode.Chakmaunicode.Chamunicode.Cherokeeunicode.Counicode.Commonunicode.Copticunicode.Csunicode.Cuneiformunicode.Cypriotunicode.Cyrillicunicode.Dashunicode.Deprecatedunicode.Deseretunicode.Devanagariunicode.Diacriticunicode.Duployanunicode.Egyptian_Hieroglyphsunicode.Elbasanunicode.Ethiopicunicode.Extenderunicode.FoldCategoryunicode.FoldScriptunicode.Georgianunicode.Glagoliticunicode.Gothicunicode.Granthaunicode.Greekunicode.Gujaratiunicode.Gurmukhiunicode.Hanunicode.Hangulunicode.Hanunoounicode.Hatranunicode.Hebrewunicode.Hex_Digitunicode.Hiraganaunicode.Hyphenunicode.IDS_Binary_Operatorunicode.IDS_Trinary_Operatorunicode.Ideographicunicode.Imperial_Aramaicunicode.Inunicode.Inheritedunicode.Inscriptional_Pahlaviunicode.Inscriptional_Parthianunicode.Isunicode.IsPrintunicode.IsSpaceunicode.Javaneseunicode.Join_Controlunicode.Kaithiunicode.Kannadaunicode.Katakanaunicode.Kayah_Liunicode.Kharoshthiunicode.Khmerunicode.Khojkiunicode.Khudawadiunicode.Lunicode.Laounicode.Latinunicode.Lepchaunicode.Limbuunicode.Linear_Aunicode.Linear_Bunicode.Lisuunicode.Llunicode.Lmunicode.Lounicode.Logical_Order_Exceptionunicode.Ltunicode.Luunicode.Lycianunicode.Lydianunicode.Municode.Mahajaniunicode.Malayalamunicode.Mandaicunicode.Manichaeanunicode.Marchenunicode.Mcunicode.Meunicode.Meetei_Mayekunicode.Mende_Kikakuiunicode.Meroitic_Cursiveunicode.Meroitic_Hieroglyphsunicode.Miaounicode.Mnunicode.Modiunicode.Mongolianunicode.Mrounicode.Multaniunicode.Myanmarunicode.Nunicode.Nabataeanunicode.Ndunicode.New_Tai_Lueunicode.Newaunicode.Nkounicode.Nlunicode.Nounicode.Noncharacter_Code_Pointunicode.Oghamunicode.Ol_Chikiunicode.Old_Hungarianunicode.Old_Italicunicode.Old_North_Arabianunicode.Old_Permicunicode.Old_Persianunicode.Old_South_Arabianunicode.Old_Turkicunicode.Oriyaunicode.Osageunicode.Osmanyaunicode.Other_Alphabeticunicode.Other_Default_Ignorable_Code_Pointunicode.Other_Grapheme_Extendunicode.Other_ID_Continueunicode.Other_ID_Startunicode.Other_Lowercaseunicode.Other_Mathunicode.Other_Uppercaseunicode.Punicode.Pahawh_Hmongunicode.Palmyreneunicode.Pattern_Syntaxunicode.Pattern_White_Spaceunicode.Pau_Cin_Hauunicode.Pcunicode.Pdunicode.Peunicode.Pfunicode.Phags_Paunicode.Phoenicianunicode.Piunicode.Pounicode.Prepended_Concatenation_Markunicode.PrintRangesunicode.Propertiesunicode.Psunicode.Psalter_Pahlaviunicode.Quotation_Markunicode.Radicalunicode.Rejangunicode.Runicunicode.Sunicode.Samaritanunicode.Saurashtraunicode.Scunicode.Scriptsunicode.Sentence_Terminalunicode.Sharadaunicode.Shavianunicode.Siddhamunicode.SignWritingunicode.SimpleFoldunicode.Sinhalaunicode.Skunicode.Smunicode.Sounicode.Soft_Dottedunicode.Sora_Sompengunicode.Sundaneseunicode.Syloti_Nagriunicode.Syriacunicode.Tagalogunicode.Tagbanwaunicode.Tai_Leunicode.Tai_Thamunicode.Tai_Vietunicode.Takriunicode.Tamilunicode.Tangutunicode.Teluguunicode.Terminal_Punctuationunicode.Thaanaunicode.Thaiunicode.Tibetanunicode.Tifinaghunicode.Tirhutaunicode.Tounicode.ToLowerunicode.ToUpperunicode.Ugariticunicode.Unified_Ideographunicode.Vaiunicode.Variation_Selectorunicode.Warang_Citiunicode.White_Spaceunicode.Yiunicode.Zunicode.Zlunicode.Zpunicode.Zsunicode.asciiFoldunicode.caseOrbitunicode.foldCommonunicode.foldGreekunicode.foldInheritedunicode.foldLunicode.foldLlunicode.foldLtunicode.foldLuunicode.foldMunicode.foldMnunicode.initunicode.initdone.unicode.is16unicode.is32unicode.isExcludingLatinunicode.propertiesunicode.statictmp_1unicode.statictmp_10unicode.statictmp_100unicode.statictmp_101unicode.statictmp_102unicode.statictmp_103unicode.statictmp_104unicode.statictmp_105unicode.statictmp_106unicode.statictmp_107unicode.statictmp_108unicode.statictmp_109unicode.statictmp_11unicode.statictmp_110unicode.statictmp_111unicode.statictmp_112unicode.statictmp_113unicode.statictmp_114unicode.statictmp_115unicode.statictmp_116unicode.statictmp_117unicode.statictmp_118unicode.statictmp_119unicode.statictmp_12unicode.statictmp_120unicode.statictmp_121unicode.statictmp_122unicode.statictmp_123unicode.statictmp_124unicode.statictmp_125unicode.statictmp_126unicode.statictmp_127unicode.statictmp_128unicode.statictmp_129unicode.statictmp_13unicode.statictmp_130unicode.statictmp_131unicode.statictmp_132unicode.statictmp_133unicode.statictmp_134unicode.statictmp_135unicode.statictmp_136unicode.statictmp_137unicode.statictmp_138unicode.statictmp_139unicode.statictmp_14unicode.statictmp_140unicode.statictmp_141unicode.statictmp_142unicode.statictmp_143unicode.statictmp_144unicode.statictmp_145unicode.statictmp_146unicode.statictmp_147unicode.statictmp_148unicode.statictmp_149unicode.statictmp_15unicode.statictmp_150unicode.statictmp_151unicode.statictmp_152unicode.statictmp_153unicode.statictmp_154unicode.statictmp_155unicode.statictmp_156unicode.statictmp_157unicode.statictmp_158unicode.statictmp_159unicode.statictmp_16unicode.statictmp_160unicode.statictmp_161unicode.statictmp_162unicode.statictmp_163unicode.statictmp_164unicode.statictmp_165unicode.statictmp_166unicode.statictmp_167unicode.statictmp_168unicode.statictmp_169unicode.statictmp_17unicode.statictmp_170unicode.statictmp_171unicode.statictmp_172unicode.statictmp_173unicode.statictmp_174unicode.statictmp_175unicode.statictmp_176unicode.statictmp_177unicode.statictmp_178unicode.statictmp_179unicode.statictmp_180unicode.statictmp_181unicode.statictmp_182unicode.statictmp_183unicode.statictmp_184unicode.statictmp_185unicode.statictmp_186unicode.statictmp_187unicode.statictmp_188unicode.statictmp_189unicode.statictmp_19unicode.statictmp_190unicode.statictmp_191unicode.statictmp_192unicode.statictmp_193unicode.statictmp_194unicode.statictmp_195unicode.statictmp_196unicode.statictmp_197unicode.statictmp_198unicode.statictmp_199unicode.statictmp_2unicode.statictmp_20unicode.statictmp_200unicode.statictmp_201unicode.statictmp_202unicode.statictmp_203unicode.statictmp_204unicode.statictmp_205unicode.statictmp_206unicode.statictmp_207unicode.statictmp_208unicode.statictmp_209unicode.statictmp_21unicode.statictmp_210unicode.statictmp_211unicode.statictmp_212unicode.statictmp_213unicode.statictmp_214unicode.statictmp_215unicode.statictmp_216unicode.statictmp_217unicode.statictmp_218unicode.statictmp_219unicode.statictmp_22unicode.statictmp_220unicode.statictmp_221unicode.statictmp_222unicode.statictmp_223unicode.statictmp_224unicode.statictmp_225unicode.statictmp_226unicode.statictmp_227unicode.statictmp_228unicode.statictmp_229unicode.statictmp_23unicode.statictmp_230unicode.statictmp_231unicode.statictmp_232unicode.statictmp_233unicode.statictmp_234unicode.statictmp_235unicode.statictmp_236unicode.statictmp_237unicode.statictmp_238unicode.statictmp_239unicode.statictmp_24unicode.statictmp_240unicode.statictmp_241unicode.statictmp_242unicode.statictmp_243unicode.statictmp_244unicode.statictmp_245unicode.statictmp_246unicode.statictmp_247unicode.statictmp_248unicode.statictmp_249unicode.statictmp_25unicode.statictmp_250unicode.statictmp_251unicode.statictmp_252unicode.statictmp_253unicode.statictmp_254unicode.statictmp_255unicode.statictmp_256unicode.statictmp_257unicode.statictmp_258unicode.statictmp_259unicode.statictmp_26unicode.statictmp_260unicode.statictmp_261unicode.statictmp_262unicode.statictmp_263unicode.statictmp_264unicode.statictmp_265unicode.statictmp_266unicode.statictmp_267unicode.statictmp_268unicode.statictmp_269unicode.statictmp_27unicode.statictmp_270unicode.statictmp_271unicode.statictmp_272unicode.statictmp_273unicode.statictmp_274unicode.statictmp_275unicode.statictmp_276unicode.statictmp_277unicode.statictmp_278unicode.statictmp_279unicode.statictmp_28unicode.statictmp_280unicode.statictmp_281unicode.statictmp_282unicode.statictmp_283unicode.statictmp_284unicode.statictmp_285unicode.statictmp_286unicode.statictmp_287unicode.statictmp_288unicode.statictmp_289unicode.statictmp_29unicode.statictmp_290unicode.statictmp_291unicode.statictmp_292unicode.statictmp_293unicode.statictmp_294unicode.statictmp_295unicode.statictmp_296unicode.statictmp_297unicode.statictmp_298unicode.statictmp_299unicode.statictmp_3unicode.statictmp_30unicode.statictmp_300unicode.statictmp_301unicode.statictmp_302unicode.statictmp_303unicode.statictmp_304unicode.statictmp_305unicode.statictmp_306unicode.statictmp_307unicode.statictmp_308unicode.statictmp_309unicode.statictmp_31unicode.statictmp_310unicode.statictmp_311unicode.statictmp_312unicode.statictmp_313unicode.statictmp_314unicode.statictmp_315unicode.statictmp_316unicode.statictmp_317unicode.statictmp_318unicode.statictmp_319unicode.statictmp_32unicode.statictmp_320unicode.statictmp_321unicode.statictmp_322unicode.statictmp_323unicode.statictmp_324unicode.statictmp_325unicode.statictmp_326unicode.statictmp_327unicode.statictmp_328unicode.statictmp_329unicode.statictmp_33unicode.statictmp_330unicode.statictmp_331unicode.statictmp_332unicode.statictmp_333unicode.statictmp_334unicode.statictmp_335unicode.statictmp_336unicode.statictmp_337unicode.statictmp_338unicode.statictmp_339unicode.statictmp_34unicode.statictmp_340unicode.statictmp_341unicode.statictmp_342unicode.statictmp_343unicode.statictmp_344unicode.statictmp_345unicode.statictmp_346unicode.statictmp_347unicode.statictmp_348unicode.statictmp_349unicode.statictmp_35unicode.statictmp_350unicode.statictmp_351unicode.statictmp_352unicode.statictmp_353unicode.statictmp_354unicode.statictmp_355unicode.statictmp_356unicode.statictmp_357unicode.statictmp_358unicode.statictmp_359unicode.statictmp_36unicode.statictmp_360unicode.statictmp_361unicode.statictmp_362unicode.statictmp_363unicode.statictmp_364unicode.statictmp_365unicode.statictmp_366unicode.statictmp_367unicode.statictmp_368unicode.statictmp_369unicode.statictmp_37unicode.statictmp_370unicode.statictmp_371unicode.statictmp_372unicode.statictmp_373unicode.statictmp_374unicode.statictmp_375unicode.statictmp_376unicode.statictmp_377unicode.statictmp_378unicode.statictmp_379unicode.statictmp_38unicode.statictmp_380unicode.statictmp_381unicode.statictmp_382unicode.statictmp_383unicode.statictmp_384unicode.statictmp_385unicode.statictmp_386unicode.statictmp_387unicode.statictmp_388unicode.statictmp_389unicode.statictmp_39unicode.statictmp_390unicode.statictmp_391unicode.statictmp_392unicode.statictmp_393unicode.statictmp_394unicode.statictmp_395unicode.statictmp_396unicode.statictmp_397unicode.statictmp_398unicode.statictmp_399unicode.statictmp_4unicode.statictmp_40unicode.statictmp_400unicode.statictmp_401unicode.statictmp_402unicode.statictmp_403unicode.statictmp_404unicode.statictmp_405unicode.statictmp_406unicode.statictmp_407unicode.statictmp_408unicode.statictmp_409unicode.statictmp_41unicode.statictmp_410unicode.statictmp_411unicode.statictmp_412unicode.statictmp_413unicode.statictmp_414unicode.statictmp_415unicode.statictmp_416unicode.statictmp_417unicode.statictmp_418unicode.statictmp_419unicode.statictmp_42unicode.statictmp_420unicode.statictmp_421unicode.statictmp_422unicode.statictmp_423unicode.statictmp_424unicode.statictmp_425unicode.statictmp_426unicode.statictmp_427unicode.statictmp_428unicode.statictmp_429unicode.statictmp_43unicode.statictmp_430unicode.statictmp_431unicode.statictmp_432unicode.statictmp_433unicode.statictmp_434unicode.statictmp_435unicode.statictmp_436unicode.statictmp_437unicode.statictmp_438unicode.statictmp_439unicode.statictmp_44unicode.statictmp_440unicode.statictmp_441unicode.statictmp_442unicode.statictmp_443unicode.statictmp_444unicode.statictmp_445unicode.statictmp_446unicode.statictmp_447unicode.statictmp_448unicode.statictmp_449unicode.statictmp_45unicode.statictmp_450unicode.statictmp_451unicode.statictmp_452unicode.statictmp_453unicode.statictmp_454unicode.statictmp_455unicode.statictmp_456unicode.statictmp_457unicode.statictmp_458unicode.statictmp_459unicode.statictmp_46unicode.statictmp_460unicode.statictmp_461unicode.statictmp_462unicode.statictmp_463unicode.statictmp_464unicode.statictmp_465unicode.statictmp_466unicode.statictmp_467unicode.statictmp_468unicode.statictmp_469unicode.statictmp_47unicode.statictmp_470unicode.statictmp_471unicode.statictmp_472unicode.statictmp_473unicode.statictmp_474unicode.statictmp_475unicode.statictmp_476unicode.statictmp_477unicode.statictmp_478unicode.statictmp_479unicode.statictmp_48unicode.statictmp_480unicode.statictmp_481unicode.statictmp_482unicode.statictmp_483unicode.statictmp_484unicode.statictmp_485unicode.statictmp_486unicode.statictmp_487unicode.statictmp_488unicode.statictmp_489unicode.statictmp_49unicode.statictmp_490unicode.statictmp_491unicode.statictmp_492unicode.statictmp_493unicode.statictmp_494unicode.statictmp_495unicode.statictmp_496unicode.statictmp_497unicode.statictmp_498unicode.statictmp_499unicode.statictmp_5unicode.statictmp_50unicode.statictmp_500unicode.statictmp_501unicode.statictmp_502unicode.statictmp_503unicode.statictmp_504unicode.statictmp_505unicode.statictmp_506unicode.statictmp_507unicode.statictmp_508unicode.statictmp_509unicode.statictmp_51unicode.statictmp_510unicode.statictmp_511unicode.statictmp_512unicode.statictmp_513unicode.statictmp_514unicode.statictmp_515unicode.statictmp_516unicode.statictmp_517unicode.statictmp_518unicode.statictmp_519unicode.statictmp_52unicode.statictmp_520unicode.statictmp_521unicode.statictmp_522unicode.statictmp_523unicode.statictmp_524unicode.statictmp_525unicode.statictmp_526unicode.statictmp_527unicode.statictmp_528unicode.statictmp_529unicode.statictmp_53unicode.statictmp_530unicode.statictmp_531unicode.statictmp_532unicode.statictmp_533unicode.statictmp_534unicode.statictmp_535unicode.statictmp_536unicode.statictmp_537unicode.statictmp_538unicode.statictmp_539unicode.statictmp_54unicode.statictmp_540unicode.statictmp_541unicode.statictmp_542unicode.statictmp_543unicode.statictmp_544unicode.statictmp_545unicode.statictmp_546unicode.statictmp_547unicode.statictmp_548unicode.statictmp_549unicode.statictmp_55unicode.statictmp_550unicode.statictmp_56unicode.statictmp_57unicode.statictmp_58unicode.statictmp_59unicode.statictmp_6unicode.statictmp_60unicode.statictmp_61unicode.statictmp_62unicode.statictmp_63unicode.statictmp_64unicode.statictmp_65unicode.statictmp_66unicode.statictmp_67unicode.statictmp_68unicode.statictmp_69unicode.statictmp_7unicode.statictmp_70unicode.statictmp_71unicode.statictmp_72unicode.statictmp_73unicode.statictmp_74unicode.statictmp_75unicode.statictmp_76unicode.statictmp_77unicode.statictmp_78unicode.statictmp_79unicode.statictmp_8unicode.statictmp_80unicode.statictmp_81unicode.statictmp_82unicode.statictmp_83unicode.statictmp_84unicode.statictmp_85unicode.statictmp_86unicode.statictmp_87unicode.statictmp_88unicode.statictmp_89unicode.statictmp_9unicode.statictmp_90unicode.statictmp_91unicode.statictmp_92unicode.statictmp_93unicode.statictmp_94unicode.statictmp_95unicode.statictmp_96unicode.statictmp_97unicode.statictmp_98unicode.statictmp_99unicode.tounicode/utf8.DecodeLastRuneunicode/utf8.DecodeLastRuneInStringunicode/utf8.DecodeRuneunicode/utf8.DecodeRuneInStringunicode/utf8.EncodeRuneunicode/utf8.RuneCountunicode/utf8.RuneCountInStringunicode/utf8.RuneLenunicode/utf8.RuneStartunicode/utf8.ValidRuneunicode/utf8.acceptRangesunicode/utf8.first_maingolang-github-go-kit-kit-0.6.0/metrics/discard/000077500000000000000000000000001316471211400213005ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/discard/discard.go000066400000000000000000000020501316471211400232350ustar00rootroot00000000000000// Package discard provides a no-op metrics backend. package discard import "github.com/go-kit/kit/metrics" type counter struct{} // NewCounter returns a new no-op counter. func NewCounter() metrics.Counter { return counter{} } // With implements Counter. func (c counter) With(labelValues ...string) metrics.Counter { return c } // Add implements Counter. func (c counter) Add(delta float64) {} type gauge struct{} // NewGauge returns a new no-op gauge. func NewGauge() metrics.Gauge { return gauge{} } // With implements Gauge. func (g gauge) With(labelValues ...string) metrics.Gauge { return g } // Set implements Gauge. func (g gauge) Set(value float64) {} // Add implements metrics.Gauge. func (g gauge) Add(delta float64) {} type histogram struct{} // NewHistogram returns a new no-op histogram. func NewHistogram() metrics.Histogram { return histogram{} } // With implements Histogram. func (h histogram) With(labelValues ...string) metrics.Histogram { return h } // Observe implements histogram. func (h histogram) Observe(value float64) {} golang-github-go-kit-kit-0.6.0/metrics/doc.go000066400000000000000000000111041316471211400207600ustar00rootroot00000000000000// Package metrics provides a framework for application instrumentation. It's // primarily designed to help you get started with good and robust // instrumentation, and to help you migrate from a less-capable system like // Graphite to a more-capable system like Prometheus. If your organization has // already standardized on an instrumentation system like Prometheus, and has no // plans to change, it may make sense to use that system's instrumentation // library directly. // // This package provides three core metric abstractions (Counter, Gauge, and // Histogram) and implementations for almost all common instrumentation // backends. Each metric has an observation method (Add, Set, or Observe, // respectively) used to record values, and a With method to "scope" the // observation by various parameters. For example, you might have a Histogram to // record request durations, parameterized by the method that's being called. // // var requestDuration metrics.Histogram // // ... // requestDuration.With("method", "MyMethod").Observe(time.Since(begin)) // // This allows a single high-level metrics object (requestDuration) to work with // many code paths somewhat dynamically. The concept of With is fully supported // in some backends like Prometheus, and not supported in other backends like // Graphite. So, With may be a no-op, depending on the concrete implementation // you choose. Please check the implementation to know for sure. For // implementations that don't provide With, it's necessary to fully parameterize // each metric in the metric name, e.g. // // // Statsd // c := statsd.NewCounter("request_duration_MyMethod_200") // c.Add(1) // // // Prometheus // c := prometheus.NewCounter(stdprometheus.CounterOpts{ // Name: "request_duration", // ... // }, []string{"method", "status_code"}) // c.With("method", "MyMethod", "status_code", strconv.Itoa(code)).Add(1) // // Usage // // Metrics are dependencies, and should be passed to the components that need // them in the same way you'd construct and pass a database handle, or reference // to another component. Metrics should *not* be created in the global scope. // Instead, instantiate metrics in your func main, using whichever concrete // implementation is appropriate for your organization. // // latency := prometheus.NewSummaryFrom(stdprometheus.SummaryOpts{ // Namespace: "myteam", // Subsystem: "foosvc", // Name: "request_latency_seconds", // Help: "Incoming request latency in seconds.", // }, []string{"method", "status_code"}) // // Write your components to take the metrics they will use as parameters to // their constructors. Use the interface types, not the concrete types. That is, // // // NewAPI takes metrics.Histogram, not *prometheus.Summary // func NewAPI(s Store, logger log.Logger, latency metrics.Histogram) *API { // // ... // } // // func (a *API) ServeFoo(w http.ResponseWriter, r *http.Request) { // begin := time.Now() // // ... // a.latency.Observe(time.Since(begin).Seconds()) // } // // Finally, pass the metrics as dependencies when building your object graph. // This should happen in func main, not in the global scope. // // api := NewAPI(store, logger, latency) // http.ListenAndServe("/", api) // // Note that metrics are "write-only" interfaces. // // Implementation details // // All metrics are safe for concurrent use. Considerable design influence has // been taken from https://github.com/codahale/metrics and // https://prometheus.io. // // Each telemetry system has different semantics for label values, push vs. // pull, support for histograms, etc. These properties influence the design of // their respective packages. This table attempts to summarize the key points of // distinction. // // SYSTEM DIM COUNTERS GAUGES HISTOGRAMS // dogstatsd n batch, push-aggregate batch, push-aggregate native, batch, push-each // statsd 1 batch, push-aggregate batch, push-aggregate native, batch, push-each // graphite 1 batch, push-aggregate batch, push-aggregate synthetic, batch, push-aggregate // expvar 1 atomic atomic synthetic, batch, in-place expose // influx n custom custom custom // prometheus n native native native // pcp 1 native native native // cloudwatch n batch push-aggregate batch push-aggregate synthetic, batch, push-aggregate // package metrics golang-github-go-kit-kit-0.6.0/metrics/dogstatsd/000077500000000000000000000000001316471211400216635ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/dogstatsd/dogstatsd.go000066400000000000000000000247251316471211400242200ustar00rootroot00000000000000// Package dogstatsd provides a DogStatsD backend for package metrics. It's very // similar to StatsD, but supports arbitrary tags per-metric, which map to Go // kit's label values. So, while label values are no-ops in StatsD, they are // supported here. For more details, see the documentation at // http://docs.datadoghq.com/guides/dogstatsd/. // // This package batches observations and emits them on some schedule to the // remote server. This is useful even if you connect to your DogStatsD server // over UDP. Emitting one network packet per observation can quickly overwhelm // even the fastest internal network. package dogstatsd import ( "fmt" "io" "strings" "sync" "sync/atomic" "time" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/generic" "github.com/go-kit/kit/metrics/internal/lv" "github.com/go-kit/kit/metrics/internal/ratemap" "github.com/go-kit/kit/util/conn" ) // Dogstatsd receives metrics observations and forwards them to a DogStatsD // server. Create a Dogstatsd object, use it to create metrics, and pass those // metrics as dependencies to the components that will use them. // // All metrics are buffered until WriteTo is called. Counters and gauges are // aggregated into a single observation per timeseries per write. Timings and // histograms are buffered but not aggregated. // // To regularly report metrics to an io.Writer, use the WriteLoop helper method. // To send to a DogStatsD server, use the SendLoop helper method. type Dogstatsd struct { mtx sync.RWMutex prefix string rates *ratemap.RateMap counters *lv.Space gauges map[string]*gaugeNode timings *lv.Space histograms *lv.Space logger log.Logger lvs lv.LabelValues } // New returns a Dogstatsd object that may be used to create metrics. Prefix is // applied to all created metrics. Callers must ensure that regular calls to // WriteTo are performed, either manually or with one of the helper methods. func New(prefix string, logger log.Logger, lvs ...string) *Dogstatsd { if len(lvs)%2 != 0 { panic("odd number of LabelValues; programmer error!") } return &Dogstatsd{ prefix: prefix, rates: ratemap.New(), counters: lv.NewSpace(), gauges: map[string]*gaugeNode{}, timings: lv.NewSpace(), histograms: lv.NewSpace(), logger: logger, lvs: lvs, } } // NewCounter returns a counter, sending observations to this Dogstatsd object. func (d *Dogstatsd) NewCounter(name string, sampleRate float64) *Counter { d.rates.Set(name, sampleRate) return &Counter{ name: name, obs: d.counters.Observe, } } // NewGauge returns a gauge, sending observations to this Dogstatsd object. func (d *Dogstatsd) NewGauge(name string) *Gauge { d.mtx.Lock() n, ok := d.gauges[name] if !ok { n = &gaugeNode{gauge: &Gauge{g: generic.NewGauge(name), ddog: d}} d.gauges[name] = n } d.mtx.Unlock() return n.gauge } // NewTiming returns a histogram whose observations are interpreted as // millisecond durations, and are forwarded to this Dogstatsd object. func (d *Dogstatsd) NewTiming(name string, sampleRate float64) *Timing { d.rates.Set(name, sampleRate) return &Timing{ name: name, obs: d.timings.Observe, } } // NewHistogram returns a histogram whose observations are of an unspecified // unit, and are forwarded to this Dogstatsd object. func (d *Dogstatsd) NewHistogram(name string, sampleRate float64) *Histogram { d.rates.Set(name, sampleRate) return &Histogram{ name: name, obs: d.histograms.Observe, } } // WriteLoop is a helper method that invokes WriteTo to the passed writer every // time the passed channel fires. This method blocks until the channel is // closed, so clients probably want to run it in its own goroutine. For typical // usage, create a time.Ticker and pass its C channel to this method. func (d *Dogstatsd) WriteLoop(c <-chan time.Time, w io.Writer) { for range c { if _, err := d.WriteTo(w); err != nil { d.logger.Log("during", "WriteTo", "err", err) } } } // SendLoop is a helper method that wraps WriteLoop, passing a managed // connection to the network and address. Like WriteLoop, this method blocks // until the channel is closed, so clients probably want to start it in its own // goroutine. For typical usage, create a time.Ticker and pass its C channel to // this method. func (d *Dogstatsd) SendLoop(c <-chan time.Time, network, address string) { d.WriteLoop(c, conn.NewDefaultManager(network, address, d.logger)) } // WriteTo flushes the buffered content of the metrics to the writer, in // DogStatsD format. WriteTo abides best-effort semantics, so observations are // lost if there is a problem with the write. Clients should be sure to call // WriteTo regularly, ideally through the WriteLoop or SendLoop helper methods. func (d *Dogstatsd) WriteTo(w io.Writer) (count int64, err error) { var n int d.counters.Reset().Walk(func(name string, lvs lv.LabelValues, values []float64) bool { n, err = fmt.Fprintf(w, "%s%s:%f|c%s%s\n", d.prefix, name, sum(values), sampling(d.rates.Get(name)), d.tagValues(lvs)) if err != nil { return false } count += int64(n) return true }) if err != nil { return count, err } d.mtx.RLock() for _, root := range d.gauges { root.walk(func(name string, lvs lv.LabelValues, value float64) bool { n, err = fmt.Fprintf(w, "%s%s:%f|g%s\n", d.prefix, name, value, d.tagValues(lvs)) if err != nil { return false } count += int64(n) return true }) } d.mtx.RUnlock() d.timings.Reset().Walk(func(name string, lvs lv.LabelValues, values []float64) bool { sampleRate := d.rates.Get(name) for _, value := range values { n, err = fmt.Fprintf(w, "%s%s:%f|ms%s%s\n", d.prefix, name, value, sampling(sampleRate), d.tagValues(lvs)) if err != nil { return false } count += int64(n) } return true }) if err != nil { return count, err } d.histograms.Reset().Walk(func(name string, lvs lv.LabelValues, values []float64) bool { sampleRate := d.rates.Get(name) for _, value := range values { n, err = fmt.Fprintf(w, "%s%s:%f|h%s%s\n", d.prefix, name, value, sampling(sampleRate), d.tagValues(lvs)) if err != nil { return false } count += int64(n) } return true }) if err != nil { return count, err } return count, err } func sum(a []float64) float64 { var v float64 for _, f := range a { v += f } return v } func last(a []float64) float64 { return a[len(a)-1] } func sampling(r float64) string { var sv string if r < 1.0 { sv = fmt.Sprintf("|@%f", r) } return sv } func (d *Dogstatsd) tagValues(labelValues []string) string { if len(labelValues) == 0 && len(d.lvs) == 0 { return "" } if len(labelValues)%2 != 0 { panic("tagValues received a labelValues with an odd number of strings") } pairs := make([]string, 0, (len(d.lvs)+len(labelValues))/2) for i := 0; i < len(d.lvs); i += 2 { pairs = append(pairs, d.lvs[i]+":"+d.lvs[i+1]) } for i := 0; i < len(labelValues); i += 2 { pairs = append(pairs, labelValues[i]+":"+labelValues[i+1]) } return "|#" + strings.Join(pairs, ",") } type observeFunc func(name string, lvs lv.LabelValues, value float64) // Counter is a DogStatsD counter. Observations are forwarded to a Dogstatsd // object, and aggregated (summed) per timeseries. type Counter struct { name string lvs lv.LabelValues obs observeFunc } // With implements metrics.Counter. func (c *Counter) With(labelValues ...string) metrics.Counter { return &Counter{ name: c.name, lvs: c.lvs.With(labelValues...), obs: c.obs, } } // Add implements metrics.Counter. func (c *Counter) Add(delta float64) { c.obs(c.name, c.lvs, delta) } // Gauge is a DogStatsD gauge. Observations are forwarded to a Dogstatsd // object, and aggregated (the last observation selected) per timeseries. type Gauge struct { g *generic.Gauge ddog *Dogstatsd set int32 } // With implements metrics.Gauge. func (g *Gauge) With(labelValues ...string) metrics.Gauge { g.ddog.mtx.RLock() node := g.ddog.gauges[g.g.Name] g.ddog.mtx.RUnlock() ga := &Gauge{g: g.g.With(labelValues...).(*generic.Gauge), ddog: g.ddog} return node.addGauge(ga, ga.g.LabelValues()) } // Set implements metrics.Gauge. func (g *Gauge) Set(value float64) { g.g.Set(value) g.touch() } // Add implements metrics.Gauge. func (g *Gauge) Add(delta float64) { g.g.Add(delta) g.touch() } // Timing is a DogStatsD timing, or metrics.Histogram. Observations are // forwarded to a Dogstatsd object, and collected (but not aggregated) per // timeseries. type Timing struct { name string lvs lv.LabelValues obs observeFunc } // With implements metrics.Timing. func (t *Timing) With(labelValues ...string) metrics.Histogram { return &Timing{ name: t.name, lvs: t.lvs.With(labelValues...), obs: t.obs, } } // Observe implements metrics.Histogram. Value is interpreted as milliseconds. func (t *Timing) Observe(value float64) { t.obs(t.name, t.lvs, value) } // Histogram is a DogStatsD histrogram. Observations are forwarded to a // Dogstatsd object, and collected (but not aggregated) per timeseries. type Histogram struct { name string lvs lv.LabelValues obs observeFunc } // With implements metrics.Histogram. func (h *Histogram) With(labelValues ...string) metrics.Histogram { return &Histogram{ name: h.name, lvs: h.lvs.With(labelValues...), obs: h.obs, } } // Observe implements metrics.Histogram. func (h *Histogram) Observe(value float64) { h.obs(h.name, h.lvs, value) } type pair struct{ label, value string } type gaugeNode struct { mtx sync.RWMutex gauge *Gauge children map[pair]*gaugeNode } func (n *gaugeNode) addGauge(g *Gauge, lvs lv.LabelValues) *Gauge { n.mtx.Lock() defer n.mtx.Unlock() if len(lvs) == 0 { if n.gauge == nil { n.gauge = g } return n.gauge } if len(lvs) < 2 { panic("too few LabelValues; programmer error!") } head, tail := pair{lvs[0], lvs[1]}, lvs[2:] if n.children == nil { n.children = map[pair]*gaugeNode{} } child, ok := n.children[head] if !ok { child = &gaugeNode{} n.children[head] = child } return child.addGauge(g, tail) } func (n *gaugeNode) walk(fn func(string, lv.LabelValues, float64) bool) bool { n.mtx.RLock() defer n.mtx.RUnlock() if n.gauge != nil { value, ok := n.gauge.read() if ok && !fn(n.gauge.g.Name, n.gauge.g.LabelValues(), value) { return false } } for _, child := range n.children { if !child.walk(fn) { return false } } return true } func (g *Gauge) touch() { atomic.StoreInt32(&(g.set), 1) } func (g *Gauge) read() (float64, bool) { set := atomic.SwapInt32(&(g.set), 0) return g.g.Value(), set != 0 } golang-github-go-kit-kit-0.6.0/metrics/dogstatsd/dogstatsd_test.go000066400000000000000000000060231316471211400252460ustar00rootroot00000000000000package dogstatsd import ( "testing" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics/teststat" ) func TestCounter(t *testing.T) { prefix, name := "abc.", "def" label, value := "label", "value" regex := `^` + prefix + name + `:([0-9\.]+)\|c\|#` + label + `:` + value + `$` d := New(prefix, log.NewNopLogger()) counter := d.NewCounter(name, 1.0).With(label, value) valuef := teststat.SumLines(d, regex) if err := teststat.TestCounter(counter, valuef); err != nil { t.Fatal(err) } } func TestCounterSampled(t *testing.T) { // This will involve multiplying the observed sum by the inverse of the // sample rate and checking against the expected value within some // tolerance. t.Skip("TODO") } func TestGauge(t *testing.T) { prefix, name := "ghi.", "jkl" label, value := "xyz", "abc" regex := `^` + prefix + name + `:([0-9\.]+)\|g\|#hostname:foohost,` + label + `:` + value + `$` d := New(prefix, log.NewNopLogger(), "hostname", "foohost") gauge := d.NewGauge(name).With(label, value) valuef := teststat.LastLine(d, regex) if err := teststat.TestGauge(gauge, valuef); err != nil { t.Fatal(err) } } // DogStatsD histograms just emit all observations. So, we collect them into // a generic histogram, and run the statistics test on that. func TestHistogram(t *testing.T) { prefix, name := "dogstatsd.", "histogram_test" label, value := "abc", "def" regex := `^` + prefix + name + `:([0-9\.]+)\|h\|#` + label + `:` + value + `$` d := New(prefix, log.NewNopLogger()) histogram := d.NewHistogram(name, 1.0).With(label, value) quantiles := teststat.Quantiles(d, regex, 50) // no |@0.X if err := teststat.TestHistogram(histogram, quantiles, 0.01); err != nil { t.Fatal(err) } } func TestHistogramSampled(t *testing.T) { prefix, name := "dogstatsd.", "sampled_histogram_test" label, value := "foo", "bar" regex := `^` + prefix + name + `:([0-9\.]+)\|h\|@0\.01[0]*\|#` + label + `:` + value + `$` d := New(prefix, log.NewNopLogger()) histogram := d.NewHistogram(name, 0.01).With(label, value) quantiles := teststat.Quantiles(d, regex, 50) if err := teststat.TestHistogram(histogram, quantiles, 0.02); err != nil { t.Fatal(err) } } func TestTiming(t *testing.T) { prefix, name := "dogstatsd.", "timing_test" label, value := "wiggle", "bottom" regex := `^` + prefix + name + `:([0-9\.]+)\|ms\|#` + label + `:` + value + `$` d := New(prefix, log.NewNopLogger()) histogram := d.NewTiming(name, 1.0).With(label, value) quantiles := teststat.Quantiles(d, regex, 50) // no |@0.X if err := teststat.TestHistogram(histogram, quantiles, 0.01); err != nil { t.Fatal(err) } } func TestTimingSampled(t *testing.T) { prefix, name := "dogstatsd.", "sampled_timing_test" label, value := "internal", "external" regex := `^` + prefix + name + `:([0-9\.]+)\|ms\|@0.03[0]*\|#` + label + `:` + value + `$` d := New(prefix, log.NewNopLogger()) histogram := d.NewTiming(name, 0.03).With(label, value) quantiles := teststat.Quantiles(d, regex, 50) if err := teststat.TestHistogram(histogram, quantiles, 0.02); err != nil { t.Fatal(err) } } golang-github-go-kit-kit-0.6.0/metrics/expvar/000077500000000000000000000000001316471211400211745ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/expvar/expvar.go000066400000000000000000000050401316471211400230270ustar00rootroot00000000000000// Package expvar provides expvar backends for metrics. // Label values are not supported. package expvar import ( "expvar" "sync" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/generic" ) // Counter implements the counter metric with an expvar float. // Label values are not supported. type Counter struct { f *expvar.Float } // NewCounter creates an expvar Float with the given name, and returns an object // that implements the Counter interface. func NewCounter(name string) *Counter { return &Counter{ f: expvar.NewFloat(name), } } // With is a no-op. func (c *Counter) With(labelValues ...string) metrics.Counter { return c } // Add implements Counter. func (c *Counter) Add(delta float64) { c.f.Add(delta) } // Gauge implements the gauge metric with an expvar float. // Label values are not supported. type Gauge struct { f *expvar.Float } // NewGauge creates an expvar Float with the given name, and returns an object // that implements the Gauge interface. func NewGauge(name string) *Gauge { return &Gauge{ f: expvar.NewFloat(name), } } // With is a no-op. func (g *Gauge) With(labelValues ...string) metrics.Gauge { return g } // Set implements Gauge. func (g *Gauge) Set(value float64) { g.f.Set(value) } // Add implements metrics.Gauge. func (g *Gauge) Add(delta float64) { g.f.Add(delta) } // Histogram implements the histogram metric with a combination of the generic // Histogram object and several expvar Floats, one for each of the 50th, 90th, // 95th, and 99th quantiles of observed values, with the quantile attached to // the name as a suffix. Label values are not supported. type Histogram struct { mtx sync.Mutex h *generic.Histogram p50 *expvar.Float p90 *expvar.Float p95 *expvar.Float p99 *expvar.Float } // NewHistogram returns a Histogram object with the given name and number of // buckets in the underlying histogram object. 50 is a good default number of // buckets. func NewHistogram(name string, buckets int) *Histogram { return &Histogram{ h: generic.NewHistogram(name, buckets), p50: expvar.NewFloat(name + ".p50"), p90: expvar.NewFloat(name + ".p90"), p95: expvar.NewFloat(name + ".p95"), p99: expvar.NewFloat(name + ".p99"), } } // With is a no-op. func (h *Histogram) With(labelValues ...string) metrics.Histogram { return h } // Observe implements Histogram. func (h *Histogram) Observe(value float64) { h.mtx.Lock() defer h.mtx.Unlock() h.h.Observe(value) h.p50.Set(h.h.Quantile(0.50)) h.p90.Set(h.h.Quantile(0.90)) h.p95.Set(h.h.Quantile(0.95)) h.p99.Set(h.h.Quantile(0.99)) } golang-github-go-kit-kit-0.6.0/metrics/expvar/expvar_test.go000066400000000000000000000023151316471211400240700ustar00rootroot00000000000000package expvar import ( "strconv" "testing" "github.com/go-kit/kit/metrics/teststat" ) func TestCounter(t *testing.T) { counter := NewCounter("expvar_counter").With("label values", "not supported").(*Counter) value := func() float64 { f, _ := strconv.ParseFloat(counter.f.String(), 64); return f } if err := teststat.TestCounter(counter, value); err != nil { t.Fatal(err) } } func TestGauge(t *testing.T) { gauge := NewGauge("expvar_gauge").With("label values", "not supported").(*Gauge) value := func() float64 { f, _ := strconv.ParseFloat(gauge.f.String(), 64); return f } if err := teststat.TestGauge(gauge, value); err != nil { t.Fatal(err) } } func TestHistogram(t *testing.T) { histogram := NewHistogram("expvar_histogram", 50).With("label values", "not supported").(*Histogram) quantiles := func() (float64, float64, float64, float64) { p50, _ := strconv.ParseFloat(histogram.p50.String(), 64) p90, _ := strconv.ParseFloat(histogram.p90.String(), 64) p95, _ := strconv.ParseFloat(histogram.p95.String(), 64) p99, _ := strconv.ParseFloat(histogram.p99.String(), 64) return p50, p90, p95, p99 } if err := teststat.TestHistogram(histogram, quantiles, 0.01); err != nil { t.Fatal(err) } } golang-github-go-kit-kit-0.6.0/metrics/generic/000077500000000000000000000000001316471211400213035ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/generic/generic.go000066400000000000000000000133101316471211400232440ustar00rootroot00000000000000// Package generic implements generic versions of each of the metric types. They // can be embedded by other implementations, and converted to specific formats // as necessary. package generic import ( "fmt" "io" "math" "sync" "sync/atomic" "github.com/VividCortex/gohistogram" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/internal/lv" ) // Counter is an in-memory implementation of a Counter. type Counter struct { Name string lvs lv.LabelValues bits uint64 } // NewCounter returns a new, usable Counter. func NewCounter(name string) *Counter { return &Counter{ Name: name, } } // With implements Counter. func (c *Counter) With(labelValues ...string) metrics.Counter { return &Counter{ Name: c.Name, bits: atomic.LoadUint64(&c.bits), lvs: c.lvs.With(labelValues...), } } // Add implements Counter. func (c *Counter) Add(delta float64) { for { var ( old = atomic.LoadUint64(&c.bits) newf = math.Float64frombits(old) + delta new = math.Float64bits(newf) ) if atomic.CompareAndSwapUint64(&c.bits, old, new) { break } } } // Value returns the current value of the counter. func (c *Counter) Value() float64 { return math.Float64frombits(atomic.LoadUint64(&c.bits)) } // ValueReset returns the current value of the counter, and resets it to zero. // This is useful for metrics backends whose counter aggregations expect deltas, // like Graphite. func (c *Counter) ValueReset() float64 { for { var ( old = atomic.LoadUint64(&c.bits) newf = 0.0 new = math.Float64bits(newf) ) if atomic.CompareAndSwapUint64(&c.bits, old, new) { return math.Float64frombits(old) } } } // LabelValues returns the set of label values attached to the counter. func (c *Counter) LabelValues() []string { return c.lvs } // Gauge is an in-memory implementation of a Gauge. type Gauge struct { Name string lvs lv.LabelValues bits uint64 } // NewGauge returns a new, usable Gauge. func NewGauge(name string) *Gauge { return &Gauge{ Name: name, } } // With implements Gauge. func (g *Gauge) With(labelValues ...string) metrics.Gauge { return &Gauge{ Name: g.Name, bits: atomic.LoadUint64(&g.bits), lvs: g.lvs.With(labelValues...), } } // Set implements Gauge. func (g *Gauge) Set(value float64) { atomic.StoreUint64(&g.bits, math.Float64bits(value)) } // Add implements metrics.Gauge. func (g *Gauge) Add(delta float64) { for { var ( old = atomic.LoadUint64(&g.bits) newf = math.Float64frombits(old) + delta new = math.Float64bits(newf) ) if atomic.CompareAndSwapUint64(&g.bits, old, new) { break } } } // Value returns the current value of the gauge. func (g *Gauge) Value() float64 { return math.Float64frombits(atomic.LoadUint64(&g.bits)) } // LabelValues returns the set of label values attached to the gauge. func (g *Gauge) LabelValues() []string { return g.lvs } // Histogram is an in-memory implementation of a streaming histogram, based on // VividCortex/gohistogram. It dynamically computes quantiles, so it's not // suitable for aggregation. type Histogram struct { Name string lvs lv.LabelValues h *safeHistogram } // NewHistogram returns a numeric histogram based on VividCortex/gohistogram. A // good default value for buckets is 50. func NewHistogram(name string, buckets int) *Histogram { return &Histogram{ Name: name, h: &safeHistogram{Histogram: gohistogram.NewHistogram(buckets)}, } } // With implements Histogram. func (h *Histogram) With(labelValues ...string) metrics.Histogram { return &Histogram{ Name: h.Name, lvs: h.lvs.With(labelValues...), h: h.h, } } // Observe implements Histogram. func (h *Histogram) Observe(value float64) { h.h.Lock() defer h.h.Unlock() h.h.Add(value) } // Quantile returns the value of the quantile q, 0.0 < q < 1.0. func (h *Histogram) Quantile(q float64) float64 { h.h.RLock() defer h.h.RUnlock() return h.h.Quantile(q) } // LabelValues returns the set of label values attached to the histogram. func (h *Histogram) LabelValues() []string { return h.lvs } // Print writes a string representation of the histogram to the passed writer. // Useful for printing to a terminal. func (h *Histogram) Print(w io.Writer) { h.h.RLock() defer h.h.RUnlock() fmt.Fprintf(w, h.h.String()) } // safeHistogram exists as gohistogram.Histogram is not goroutine-safe. type safeHistogram struct { sync.RWMutex gohistogram.Histogram } // Bucket is a range in a histogram which aggregates observations. type Bucket struct { From, To, Count int64 } // Quantile is a pair of a quantile (0..100) and its observed maximum value. type Quantile struct { Quantile int // 0..100 Value int64 } // SimpleHistogram is an in-memory implementation of a Histogram. It only tracks // an approximate moving average, so is likely too naïve for many use cases. type SimpleHistogram struct { mtx sync.RWMutex lvs lv.LabelValues avg float64 n uint64 } // NewSimpleHistogram returns a SimpleHistogram, ready for observations. func NewSimpleHistogram() *SimpleHistogram { return &SimpleHistogram{} } // With implements Histogram. func (h *SimpleHistogram) With(labelValues ...string) metrics.Histogram { return &SimpleHistogram{ lvs: h.lvs.With(labelValues...), avg: h.avg, n: h.n, } } // Observe implements Histogram. func (h *SimpleHistogram) Observe(value float64) { h.mtx.Lock() defer h.mtx.Unlock() h.n++ h.avg -= h.avg / float64(h.n) h.avg += value / float64(h.n) } // ApproximateMovingAverage returns the approximate moving average of observations. func (h *SimpleHistogram) ApproximateMovingAverage() float64 { h.mtx.RLock() defer h.mtx.RUnlock() return h.avg } // LabelValues returns the set of label values attached to the histogram. func (h *SimpleHistogram) LabelValues() []string { return h.lvs } golang-github-go-kit-kit-0.6.0/metrics/generic/generic_test.go000066400000000000000000000056251316471211400243150ustar00rootroot00000000000000package generic_test // This is package generic_test in order to get around an import cycle: this // package imports teststat to do its testing, but package teststat imports // generic to use its Histogram in the Quantiles helper function. import ( "math" "math/rand" "sync" "testing" "github.com/go-kit/kit/metrics/generic" "github.com/go-kit/kit/metrics/teststat" ) func TestCounter(t *testing.T) { name := "my_counter" counter := generic.NewCounter(name).With("label", "counter").(*generic.Counter) if want, have := name, counter.Name; want != have { t.Errorf("Name: want %q, have %q", want, have) } value := func() float64 { return counter.Value() } if err := teststat.TestCounter(counter, value); err != nil { t.Fatal(err) } } func TestValueReset(t *testing.T) { counter := generic.NewCounter("test_value_reset") counter.Add(123) counter.Add(456) counter.Add(789) if want, have := float64(123+456+789), counter.ValueReset(); want != have { t.Errorf("want %f, have %f", want, have) } if want, have := float64(0), counter.Value(); want != have { t.Errorf("want %f, have %f", want, have) } } func TestGauge(t *testing.T) { name := "my_gauge" gauge := generic.NewGauge(name).With("label", "gauge").(*generic.Gauge) if want, have := name, gauge.Name; want != have { t.Errorf("Name: want %q, have %q", want, have) } value := func() float64 { return gauge.Value() } if err := teststat.TestGauge(gauge, value); err != nil { t.Fatal(err) } } func TestHistogram(t *testing.T) { name := "my_histogram" histogram := generic.NewHistogram(name, 50).With("label", "histogram").(*generic.Histogram) if want, have := name, histogram.Name; want != have { t.Errorf("Name: want %q, have %q", want, have) } quantiles := func() (float64, float64, float64, float64) { return histogram.Quantile(0.50), histogram.Quantile(0.90), histogram.Quantile(0.95), histogram.Quantile(0.99) } if err := teststat.TestHistogram(histogram, quantiles, 0.01); err != nil { t.Fatal(err) } } func TestIssue424(t *testing.T) { var ( histogram = generic.NewHistogram("dont_panic", 50) concurrency = 100 operations = 1000 wg sync.WaitGroup ) wg.Add(concurrency) for i := 0; i < concurrency; i++ { go func() { defer wg.Done() for j := 0; j < operations; j++ { histogram.Observe(float64(j)) histogram.Observe(histogram.Quantile(0.5)) } }() } wg.Wait() } func TestSimpleHistogram(t *testing.T) { histogram := generic.NewSimpleHistogram().With("label", "simple_histogram").(*generic.SimpleHistogram) var ( sum int count = 1234 // not too big ) for i := 0; i < count; i++ { value := rand.Intn(1000) sum += value histogram.Observe(float64(value)) } var ( want = float64(sum) / float64(count) have = histogram.ApproximateMovingAverage() tolerance = 0.001 // real real slim ) if math.Abs(want-have)/want > tolerance { t.Errorf("want %f, have %f", want, have) } } golang-github-go-kit-kit-0.6.0/metrics/graphite/000077500000000000000000000000001316471211400214725ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/graphite/graphite.go000066400000000000000000000140651316471211400236320ustar00rootroot00000000000000// Package graphite provides a Graphite backend for metrics. Metrics are batched // and emitted in the plaintext protocol. For more information, see // http://graphite.readthedocs.io/en/latest/feeding-carbon.html#the-plaintext-protocol // // Graphite does not have a native understanding of metric parameterization, so // label values not supported. Use distinct metrics for each unique combination // of label values. package graphite import ( "fmt" "io" "sync" "time" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/generic" "github.com/go-kit/kit/util/conn" ) // Graphite receives metrics observations and forwards them to a Graphite server. // Create a Graphite object, use it to create metrics, and pass those metrics as // dependencies to the components that will use them. // // All metrics are buffered until WriteTo is called. Counters and gauges are // aggregated into a single observation per timeseries per write. Histograms are // exploded into per-quantile gauges and reported once per write. // // To regularly report metrics to an io.Writer, use the WriteLoop helper method. // To send to a Graphite server, use the SendLoop helper method. type Graphite struct { mtx sync.RWMutex prefix string counters map[string]*Counter gauges map[string]*Gauge histograms map[string]*Histogram logger log.Logger } // New returns a Graphite object that may be used to create metrics. Prefix is // applied to all created metrics. Callers must ensure that regular calls to // WriteTo are performed, either manually or with one of the helper methods. func New(prefix string, logger log.Logger) *Graphite { return &Graphite{ prefix: prefix, counters: map[string]*Counter{}, gauges: map[string]*Gauge{}, histograms: map[string]*Histogram{}, logger: logger, } } // NewCounter returns a counter. Observations are aggregated and emitted once // per write invocation. func (g *Graphite) NewCounter(name string) *Counter { c := NewCounter(g.prefix + name) g.mtx.Lock() g.counters[g.prefix+name] = c g.mtx.Unlock() return c } // NewGauge returns a gauge. Observations are aggregated and emitted once per // write invocation. func (g *Graphite) NewGauge(name string) *Gauge { ga := NewGauge(g.prefix + name) g.mtx.Lock() g.gauges[g.prefix+name] = ga g.mtx.Unlock() return ga } // NewHistogram returns a histogram. Observations are aggregated and emitted as // per-quantile gauges, once per write invocation. 50 is a good default value // for buckets. func (g *Graphite) NewHistogram(name string, buckets int) *Histogram { h := NewHistogram(g.prefix+name, buckets) g.mtx.Lock() g.histograms[g.prefix+name] = h g.mtx.Unlock() return h } // WriteLoop is a helper method that invokes WriteTo to the passed writer every // time the passed channel fires. This method blocks until the channel is // closed, so clients probably want to run it in its own goroutine. For typical // usage, create a time.Ticker and pass its C channel to this method. func (g *Graphite) WriteLoop(c <-chan time.Time, w io.Writer) { for range c { if _, err := g.WriteTo(w); err != nil { g.logger.Log("during", "WriteTo", "err", err) } } } // SendLoop is a helper method that wraps WriteLoop, passing a managed // connection to the network and address. Like WriteLoop, this method blocks // until the channel is closed, so clients probably want to start it in its own // goroutine. For typical usage, create a time.Ticker and pass its C channel to // this method. func (g *Graphite) SendLoop(c <-chan time.Time, network, address string) { g.WriteLoop(c, conn.NewDefaultManager(network, address, g.logger)) } // WriteTo flushes the buffered content of the metrics to the writer, in // Graphite plaintext format. WriteTo abides best-effort semantics, so // observations are lost if there is a problem with the write. Clients should be // sure to call WriteTo regularly, ideally through the WriteLoop or SendLoop // helper methods. func (g *Graphite) WriteTo(w io.Writer) (count int64, err error) { g.mtx.RLock() defer g.mtx.RUnlock() now := time.Now().Unix() for name, c := range g.counters { n, err := fmt.Fprintf(w, "%s %f %d\n", name, c.c.ValueReset(), now) if err != nil { return count, err } count += int64(n) } for name, ga := range g.gauges { n, err := fmt.Fprintf(w, "%s %f %d\n", name, ga.g.Value(), now) if err != nil { return count, err } count += int64(n) } for name, h := range g.histograms { for _, p := range []struct { s string f float64 }{ {"50", 0.50}, {"90", 0.90}, {"95", 0.95}, {"99", 0.99}, } { n, err := fmt.Fprintf(w, "%s.p%s %f %d\n", name, p.s, h.h.Quantile(p.f), now) if err != nil { return count, err } count += int64(n) } } return count, err } // Counter is a Graphite counter metric. type Counter struct { c *generic.Counter } // NewCounter returns a new usable counter metric. func NewCounter(name string) *Counter { return &Counter{generic.NewCounter(name)} } // With is a no-op. func (c *Counter) With(...string) metrics.Counter { return c } // Add implements counter. func (c *Counter) Add(delta float64) { c.c.Add(delta) } // Gauge is a Graphite gauge metric. type Gauge struct { g *generic.Gauge } // NewGauge returns a new usable Gauge metric. func NewGauge(name string) *Gauge { return &Gauge{generic.NewGauge(name)} } // With is a no-op. func (g *Gauge) With(...string) metrics.Gauge { return g } // Set implements gauge. func (g *Gauge) Set(value float64) { g.g.Set(value) } // Add implements metrics.Gauge. func (g *Gauge) Add(delta float64) { g.g.Add(delta) } // Histogram is a Graphite histogram metric. Observations are bucketed into // per-quantile gauges. type Histogram struct { h *generic.Histogram } // NewHistogram returns a new usable Histogram metric. func NewHistogram(name string, buckets int) *Histogram { return &Histogram{generic.NewHistogram(name, buckets)} } // With is a no-op. func (h *Histogram) With(...string) metrics.Histogram { return h } // Observe implements histogram. func (h *Histogram) Observe(value float64) { h.h.Observe(value) } golang-github-go-kit-kit-0.6.0/metrics/graphite/graphite_test.go000066400000000000000000000040521316471211400246640ustar00rootroot00000000000000package graphite import ( "bytes" "regexp" "strconv" "testing" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics/teststat" ) func TestCounter(t *testing.T) { prefix, name := "abc.", "def" label, value := "label", "value" // ignored for Graphite regex := `^` + prefix + name + ` ([0-9\.]+) [0-9]+$` g := New(prefix, log.NewNopLogger()) counter := g.NewCounter(name).With(label, value) valuef := teststat.SumLines(g, regex) if err := teststat.TestCounter(counter, valuef); err != nil { t.Fatal(err) } } func TestGauge(t *testing.T) { prefix, name := "ghi.", "jkl" label, value := "xyz", "abc" // ignored for Graphite regex := `^` + prefix + name + ` ([0-9\.]+) [0-9]+$` g := New(prefix, log.NewNopLogger()) gauge := g.NewGauge(name).With(label, value) valuef := teststat.LastLine(g, regex) if err := teststat.TestGauge(gauge, valuef); err != nil { t.Fatal(err) } } func TestHistogram(t *testing.T) { // The histogram test is actually like 4 gauge tests. prefix, name := "graphite.", "histogram_test" label, value := "abc", "def" // ignored for Graphite re50 := regexp.MustCompile(prefix + name + `.p50 ([0-9\.]+) [0-9]+`) re90 := regexp.MustCompile(prefix + name + `.p90 ([0-9\.]+) [0-9]+`) re95 := regexp.MustCompile(prefix + name + `.p95 ([0-9\.]+) [0-9]+`) re99 := regexp.MustCompile(prefix + name + `.p99 ([0-9\.]+) [0-9]+`) g := New(prefix, log.NewNopLogger()) histogram := g.NewHistogram(name, 50).With(label, value) quantiles := func() (float64, float64, float64, float64) { var buf bytes.Buffer g.WriteTo(&buf) match50 := re50.FindStringSubmatch(buf.String()) p50, _ := strconv.ParseFloat(match50[1], 64) match90 := re90.FindStringSubmatch(buf.String()) p90, _ := strconv.ParseFloat(match90[1], 64) match95 := re95.FindStringSubmatch(buf.String()) p95, _ := strconv.ParseFloat(match95[1], 64) match99 := re99.FindStringSubmatch(buf.String()) p99, _ := strconv.ParseFloat(match99[1], 64) return p50, p90, p95, p99 } if err := teststat.TestHistogram(histogram, quantiles, 0.01); err != nil { t.Fatal(err) } } golang-github-go-kit-kit-0.6.0/metrics/influx/000077500000000000000000000000001316471211400211745ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/influx/example_test.go000066400000000000000000000060311316471211400242150ustar00rootroot00000000000000package influx import ( "fmt" "regexp" influxdb "github.com/influxdata/influxdb/client/v2" "github.com/go-kit/kit/log" ) func ExampleCounter() { in := New(map[string]string{"a": "b"}, influxdb.BatchPointsConfig{}, log.NewNopLogger()) counter := in.NewCounter("influx_counter") counter.Add(10) counter.With("error", "true").Add(1) counter.With("error", "false").Add(2) counter.Add(50) client := &bufWriter{} in.WriteTo(client) expectedLines := []string{ `(influx_counter,a=b count=60) [0-9]{19}`, `(influx_counter,a=b,error=true count=1) [0-9]{19}`, `(influx_counter,a=b,error=false count=2) [0-9]{19}`, } if err := extractAndPrintMessage(expectedLines, client.buf.String()); err != nil { fmt.Println(err.Error()) } // Output: // influx_counter,a=b count=60 // influx_counter,a=b,error=true count=1 // influx_counter,a=b,error=false count=2 } func ExampleGauge() { in := New(map[string]string{"a": "b"}, influxdb.BatchPointsConfig{}, log.NewNopLogger()) gauge := in.NewGauge("influx_gauge") gauge.Set(10) gauge.With("error", "true").Set(2) gauge.With("error", "true").Set(1) gauge.With("error", "false").Set(2) gauge.Set(50) gauge.With("test", "true").Set(1) gauge.With("test", "true").Add(1) client := &bufWriter{} in.WriteTo(client) expectedLines := []string{ `(influx_gauge,a=b,test=true value=2) [0-9]{19}`, `(influx_gauge,a=b value=50) [0-9]{19}`, `(influx_gauge,a=b,error=true value=1) [0-9]{19}`, `(influx_gauge,a=b,error=false value=2) [0-9]{19}`, } if err := extractAndPrintMessage(expectedLines, client.buf.String()); err != nil { fmt.Println(err.Error()) } // Output: // influx_gauge,a=b,test=true value=2 // influx_gauge,a=b value=50 // influx_gauge,a=b,error=true value=1 // influx_gauge,a=b,error=false value=2 } func ExampleHistogram() { in := New(map[string]string{"foo": "alpha"}, influxdb.BatchPointsConfig{}, log.NewNopLogger()) histogram := in.NewHistogram("influx_histogram") histogram.Observe(float64(10)) histogram.With("error", "true").Observe(float64(1)) histogram.With("error", "false").Observe(float64(2)) histogram.Observe(float64(50)) client := &bufWriter{} in.WriteTo(client) expectedLines := []string{ `(influx_histogram,foo=alpha p50=10,p90=50,p95=50,p99=50) [0-9]{19}`, `(influx_histogram,error=true,foo=alpha p50=1,p90=1,p95=1,p99=1) [0-9]{19}`, `(influx_histogram,error=false,foo=alpha p50=2,p90=2,p95=2,p99=2) [0-9]{19}`, } if err := extractAndPrintMessage(expectedLines, client.buf.String()); err != nil { fmt.Println(err.Error()) } // Output: // influx_histogram,foo=alpha p50=10,p90=50,p95=50,p99=50 // influx_histogram,error=true,foo=alpha p50=1,p90=1,p95=1,p99=1 // influx_histogram,error=false,foo=alpha p50=2,p90=2,p95=2,p99=2 } func extractAndPrintMessage(expected []string, msg string) error { for _, pattern := range expected { re := regexp.MustCompile(pattern) match := re.FindStringSubmatch(msg) if len(match) != 2 { return fmt.Errorf("Pattern not found! {%s} [%s]: %v\n", pattern, msg, match) } fmt.Println(match[1]) } return nil } golang-github-go-kit-kit-0.6.0/metrics/influx/influx.go000066400000000000000000000164201316471211400230330ustar00rootroot00000000000000// Package influx provides an InfluxDB implementation for metrics. The model is // similar to other push-based instrumentation systems. Observations are // aggregated locally and emitted to the Influx server on regular intervals. package influx import ( "time" influxdb "github.com/influxdata/influxdb/client/v2" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/generic" "github.com/go-kit/kit/metrics/internal/lv" ) // Influx is a store for metrics that will be emitted to an Influx database. // // Influx is a general purpose time-series database, and has no native concepts // of counters, gauges, or histograms. Counters are modeled as a timeseries with // one data point per flush, with a "count" field that reflects all adds since // the last flush. Gauges are modeled as a timeseries with one data point per // flush, with a "value" field that reflects the current state of the gauge. // Histograms are modeled as a timeseries with one data point per combination of tags, // with a set of quantile fields that reflects the p50, p90, p95 & p99. // // Influx tags are attached to the Influx object, can be given to each // metric at construction and can be updated anytime via With function. Influx fields // are mapped to Go kit label values directly by this collector. Actual metric // values are provided as fields with specific names depending on the metric. // // All observations are collected in memory locally, and flushed on demand. type Influx struct { counters *lv.Space gauges *lv.Space histograms *lv.Space tags map[string]string conf influxdb.BatchPointsConfig logger log.Logger } // New returns an Influx, ready to create metrics and collect observations. Tags // are applied to all metrics created from this object. The BatchPointsConfig is // used during flushing. func New(tags map[string]string, conf influxdb.BatchPointsConfig, logger log.Logger) *Influx { return &Influx{ counters: lv.NewSpace(), gauges: lv.NewSpace(), histograms: lv.NewSpace(), tags: tags, conf: conf, logger: logger, } } // NewCounter returns an Influx counter. func (in *Influx) NewCounter(name string) *Counter { return &Counter{ name: name, obs: in.counters.Observe, } } // NewGauge returns an Influx gauge. func (in *Influx) NewGauge(name string) *Gauge { return &Gauge{ name: name, obs: in.gauges.Observe, add: in.gauges.Add, } } // NewHistogram returns an Influx histogram. func (in *Influx) NewHistogram(name string) *Histogram { return &Histogram{ name: name, obs: in.histograms.Observe, } } // BatchPointsWriter captures a subset of the influxdb.Client methods necessary // for emitting metrics observations. type BatchPointsWriter interface { Write(influxdb.BatchPoints) error } // WriteLoop is a helper method that invokes WriteTo to the passed writer every // time the passed channel fires. This method blocks until the channel is // closed, so clients probably want to run it in its own goroutine. For typical // usage, create a time.Ticker and pass its C channel to this method. func (in *Influx) WriteLoop(c <-chan time.Time, w BatchPointsWriter) { for range c { if err := in.WriteTo(w); err != nil { in.logger.Log("during", "WriteTo", "err", err) } } } // WriteTo flushes the buffered content of the metrics to the writer, in an // Influx BatchPoints format. WriteTo abides best-effort semantics, so // observations are lost if there is a problem with the write. Clients should be // sure to call WriteTo regularly, ideally through the WriteLoop helper method. func (in *Influx) WriteTo(w BatchPointsWriter) (err error) { bp, err := influxdb.NewBatchPoints(in.conf) if err != nil { return err } now := time.Now() in.counters.Reset().Walk(func(name string, lvs lv.LabelValues, values []float64) bool { tags := mergeTags(in.tags, lvs) var p *influxdb.Point fields := map[string]interface{}{"count": sum(values)} p, err = influxdb.NewPoint(name, tags, fields, now) if err != nil { return false } bp.AddPoint(p) return true }) if err != nil { return err } in.gauges.Reset().Walk(func(name string, lvs lv.LabelValues, values []float64) bool { tags := mergeTags(in.tags, lvs) var p *influxdb.Point fields := map[string]interface{}{"value": last(values)} p, err = influxdb.NewPoint(name, tags, fields, now) if err != nil { return false } bp.AddPoint(p) return true }) if err != nil { return err } in.histograms.Reset().Walk(func(name string, lvs lv.LabelValues, values []float64) bool { histogram := generic.NewHistogram(name, 50) tags := mergeTags(in.tags, lvs) var p *influxdb.Point for _, v := range values { histogram.Observe(v) } fields := map[string]interface{}{ "p50": histogram.Quantile(0.50), "p90": histogram.Quantile(0.90), "p95": histogram.Quantile(0.95), "p99": histogram.Quantile(0.99), } p, err = influxdb.NewPoint(name, tags, fields, now) if err != nil { return false } bp.AddPoint(p) return true }) if err != nil { return err } return w.Write(bp) } func mergeTags(tags map[string]string, labelValues []string) map[string]string { if len(labelValues)%2 != 0 { panic("mergeTags received a labelValues with an odd number of strings") } ret := make(map[string]string, len(tags)+len(labelValues)/2) for k, v := range tags { ret[k] = v } for i := 0; i < len(labelValues); i += 2 { ret[labelValues[i]] = labelValues[i+1] } return ret } func sum(a []float64) float64 { var v float64 for _, f := range a { v += f } return v } func last(a []float64) float64 { return a[len(a)-1] } type observeFunc func(name string, lvs lv.LabelValues, value float64) // Counter is an Influx counter. Observations are forwarded to an Influx // object, and aggregated (summed) per timeseries. type Counter struct { name string lvs lv.LabelValues obs observeFunc } // With implements metrics.Counter. func (c *Counter) With(labelValues ...string) metrics.Counter { return &Counter{ name: c.name, lvs: c.lvs.With(labelValues...), obs: c.obs, } } // Add implements metrics.Counter. func (c *Counter) Add(delta float64) { c.obs(c.name, c.lvs, delta) } // Gauge is an Influx gauge. Observations are forwarded to a Dogstatsd // object, and aggregated (the last observation selected) per timeseries. type Gauge struct { name string lvs lv.LabelValues obs observeFunc add observeFunc } // With implements metrics.Gauge. func (g *Gauge) With(labelValues ...string) metrics.Gauge { return &Gauge{ name: g.name, lvs: g.lvs.With(labelValues...), obs: g.obs, add: g.add, } } // Set implements metrics.Gauge. func (g *Gauge) Set(value float64) { g.obs(g.name, g.lvs, value) } // Add implements metrics.Gauge. func (g *Gauge) Add(delta float64) { g.add(g.name, g.lvs, delta) } // Histogram is an Influx histrogram. Observations are aggregated into a // generic.Histogram and emitted as per-quantile gauges to the Influx server. type Histogram struct { name string lvs lv.LabelValues obs observeFunc } // With implements metrics.Histogram. func (h *Histogram) With(labelValues ...string) metrics.Histogram { return &Histogram{ name: h.name, lvs: h.lvs.With(labelValues...), obs: h.obs, } } // Observe implements metrics.Histogram. func (h *Histogram) Observe(value float64) { h.obs(h.name, h.lvs, value) } golang-github-go-kit-kit-0.6.0/metrics/influx/influx_test.go000066400000000000000000000071021316471211400240670ustar00rootroot00000000000000package influx import ( "bytes" "fmt" "regexp" "strconv" "strings" "testing" influxdb "github.com/influxdata/influxdb/client/v2" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics/teststat" ) func TestCounter(t *testing.T) { in := New(map[string]string{"a": "b"}, influxdb.BatchPointsConfig{}, log.NewNopLogger()) re := regexp.MustCompile(`influx_counter,a=b count=([0-9\.]+) [0-9]+`) // reverse-engineered :\ counter := in.NewCounter("influx_counter") value := func() float64 { client := &bufWriter{} in.WriteTo(client) match := re.FindStringSubmatch(client.buf.String()) f, _ := strconv.ParseFloat(match[1], 64) return f } if err := teststat.TestCounter(counter, value); err != nil { t.Fatal(err) } } func TestGauge(t *testing.T) { in := New(map[string]string{"foo": "alpha"}, influxdb.BatchPointsConfig{}, log.NewNopLogger()) re := regexp.MustCompile(`influx_gauge,foo=alpha value=([0-9\.]+) [0-9]+`) gauge := in.NewGauge("influx_gauge") value := func() float64 { client := &bufWriter{} in.WriteTo(client) match := re.FindStringSubmatch(client.buf.String()) f, _ := strconv.ParseFloat(match[1], 64) return f } if err := teststat.TestGauge(gauge, value); err != nil { t.Fatal(err) } } func TestHistogram(t *testing.T) { in := New(map[string]string{"foo": "alpha"}, influxdb.BatchPointsConfig{}, log.NewNopLogger()) re := regexp.MustCompile(`influx_histogram,bar=beta,foo=alpha p50=([0-9\.]+),p90=([0-9\.]+),p95=([0-9\.]+),p99=([0-9\.]+) [0-9]+`) histogram := in.NewHistogram("influx_histogram").With("bar", "beta") quantiles := func() (float64, float64, float64, float64) { w := &bufWriter{} in.WriteTo(w) match := re.FindStringSubmatch(w.buf.String()) if len(match) != 5 { t.Errorf("These are not the quantiles you're looking for: %v\n", match) } var result [4]float64 for i, q := range match[1:] { result[i], _ = strconv.ParseFloat(q, 64) } return result[0], result[1], result[2], result[3] } if err := teststat.TestHistogram(histogram, quantiles, 0.01); err != nil { t.Fatal(err) } } func TestHistogramLabels(t *testing.T) { in := New(map[string]string{}, influxdb.BatchPointsConfig{}, log.NewNopLogger()) h := in.NewHistogram("foo") h.Observe(123) h.With("abc", "xyz").Observe(456) w := &bufWriter{} if err := in.WriteTo(w); err != nil { t.Fatal(err) } if want, have := 2, len(strings.Split(strings.TrimSpace(w.buf.String()), "\n")); want != have { t.Errorf("want %d, have %d", want, have) } } func TestIssue404(t *testing.T) { in := New(map[string]string{}, influxdb.BatchPointsConfig{}, log.NewNopLogger()) counterOne := in.NewCounter("influx_counter_one").With("a", "b") counterOne.Add(123) counterTwo := in.NewCounter("influx_counter_two").With("c", "d") counterTwo.Add(456) w := &bufWriter{} in.WriteTo(w) lines := strings.Split(strings.TrimSpace(w.buf.String()), "\n") if want, have := 2, len(lines); want != have { t.Fatalf("want %d, have %d", want, have) } for _, line := range lines { if strings.HasPrefix(line, "influx_counter_one") { if !strings.HasPrefix(line, "influx_counter_one,a=b count=123 ") { t.Errorf("invalid influx_counter_one: %s", line) } } else if strings.HasPrefix(line, "influx_counter_two") { if !strings.HasPrefix(line, "influx_counter_two,c=d count=456 ") { t.Errorf("invalid influx_counter_two: %s", line) } } else { t.Errorf("unexpected line: %s", line) } } } type bufWriter struct { buf bytes.Buffer } func (w *bufWriter) Write(bp influxdb.BatchPoints) error { for _, p := range bp.Points() { fmt.Fprintf(&w.buf, p.String()+"\n") } return nil } golang-github-go-kit-kit-0.6.0/metrics/internal/000077500000000000000000000000001316471211400215035ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/internal/lv/000077500000000000000000000000001316471211400221245ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/internal/lv/labelvalues.go000066400000000000000000000007351316471211400247570ustar00rootroot00000000000000package lv // LabelValues is a type alias that provides validation on its With method. // Metrics may include it as a member to help them satisfy With semantics and // save some code duplication. type LabelValues []string // With validates the input, and returns a new aggregate labelValues. func (lvs LabelValues) With(labelValues ...string) LabelValues { if len(labelValues)%2 != 0 { labelValues = append(labelValues, "unknown") } return append(lvs, labelValues...) } golang-github-go-kit-kit-0.6.0/metrics/internal/lv/labelvalues_test.go000066400000000000000000000011511316471211400260070ustar00rootroot00000000000000package lv import ( "strings" "testing" ) func TestWith(t *testing.T) { var a LabelValues b := a.With("a", "1") c := a.With("b", "2", "c", "3") if want, have := "", strings.Join(a, ""); want != have { t.Errorf("With appears to mutate the original LabelValues: want %q, have %q", want, have) } if want, have := "a1", strings.Join(b, ""); want != have { t.Errorf("With does not appear to return the right thing: want %q, have %q", want, have) } if want, have := "b2c3", strings.Join(c, ""); want != have { t.Errorf("With does not appear to return the right thing: want %q, have %q", want, have) } } golang-github-go-kit-kit-0.6.0/metrics/internal/lv/space.go000066400000000000000000000071371316471211400235560ustar00rootroot00000000000000package lv import "sync" // NewSpace returns an N-dimensional vector space. func NewSpace() *Space { return &Space{} } // Space represents an N-dimensional vector space. Each name and unique label // value pair establishes a new dimension and point within that dimension. Order // matters, i.e. [a=1 b=2] identifies a different timeseries than [b=2 a=1]. type Space struct { mtx sync.RWMutex nodes map[string]*node } // Observe locates the time series identified by the name and label values in // the vector space, and appends the value to the list of observations. func (s *Space) Observe(name string, lvs LabelValues, value float64) { s.nodeFor(name).observe(lvs, value) } // Add locates the time series identified by the name and label values in // the vector space, and appends the delta to the last value in the list of // observations. func (s *Space) Add(name string, lvs LabelValues, delta float64) { s.nodeFor(name).add(lvs, delta) } // Walk traverses the vector space and invokes fn for each non-empty time series // which is encountered. Return false to abort the traversal. func (s *Space) Walk(fn func(name string, lvs LabelValues, observations []float64) bool) { s.mtx.RLock() defer s.mtx.RUnlock() for name, node := range s.nodes { f := func(lvs LabelValues, observations []float64) bool { return fn(name, lvs, observations) } if !node.walk(LabelValues{}, f) { return } } } // Reset empties the current space and returns a new Space with the old // contents. Reset a Space to get an immutable copy suitable for walking. func (s *Space) Reset() *Space { s.mtx.Lock() defer s.mtx.Unlock() n := NewSpace() n.nodes, s.nodes = s.nodes, n.nodes return n } func (s *Space) nodeFor(name string) *node { s.mtx.Lock() defer s.mtx.Unlock() if s.nodes == nil { s.nodes = map[string]*node{} } n, ok := s.nodes[name] if !ok { n = &node{} s.nodes[name] = n } return n } // node exists at a specific point in the N-dimensional vector space of all // possible label values. The node collects observations and has child nodes // with greater specificity. type node struct { mtx sync.RWMutex observations []float64 children map[pair]*node } type pair struct{ label, value string } func (n *node) observe(lvs LabelValues, value float64) { n.mtx.Lock() defer n.mtx.Unlock() if len(lvs) == 0 { n.observations = append(n.observations, value) return } if len(lvs) < 2 { panic("too few LabelValues; programmer error!") } head, tail := pair{lvs[0], lvs[1]}, lvs[2:] if n.children == nil { n.children = map[pair]*node{} } child, ok := n.children[head] if !ok { child = &node{} n.children[head] = child } child.observe(tail, value) } func (n *node) add(lvs LabelValues, delta float64) { n.mtx.Lock() defer n.mtx.Unlock() if len(lvs) == 0 { var value float64 if len(n.observations) > 0 { value = last(n.observations) + delta } else { value = delta } n.observations = append(n.observations, value) return } if len(lvs) < 2 { panic("too few LabelValues; programmer error!") } head, tail := pair{lvs[0], lvs[1]}, lvs[2:] if n.children == nil { n.children = map[pair]*node{} } child, ok := n.children[head] if !ok { child = &node{} n.children[head] = child } child.add(tail, delta) } func (n *node) walk(lvs LabelValues, fn func(LabelValues, []float64) bool) bool { n.mtx.RLock() defer n.mtx.RUnlock() if len(n.observations) > 0 && !fn(lvs, n.observations) { return false } for p, child := range n.children { if !child.walk(append(lvs, p.label, p.value), fn) { return false } } return true } func last(a []float64) float64 { return a[len(a)-1] } golang-github-go-kit-kit-0.6.0/metrics/internal/lv/space_test.go000066400000000000000000000044001316471211400246030ustar00rootroot00000000000000package lv import ( "strings" "testing" ) func TestSpaceWalkAbort(t *testing.T) { s := NewSpace() s.Observe("a", LabelValues{"a", "b"}, 1) s.Observe("a", LabelValues{"c", "d"}, 2) s.Observe("a", LabelValues{"e", "f"}, 4) s.Observe("a", LabelValues{"g", "h"}, 8) s.Observe("b", LabelValues{"a", "b"}, 16) s.Observe("b", LabelValues{"c", "d"}, 32) s.Observe("b", LabelValues{"e", "f"}, 64) s.Observe("b", LabelValues{"g", "h"}, 128) var count int s.Walk(func(name string, lvs LabelValues, obs []float64) bool { count++ return false }) if want, have := 1, count; want != have { t.Errorf("want %d, have %d", want, have) } } func TestSpaceWalkSums(t *testing.T) { s := NewSpace() s.Observe("metric_one", LabelValues{}, 1) s.Observe("metric_one", LabelValues{}, 2) s.Observe("metric_one", LabelValues{"a", "1", "b", "2"}, 4) s.Observe("metric_one", LabelValues{"a", "1", "b", "2"}, 8) s.Observe("metric_one", LabelValues{}, 16) s.Observe("metric_one", LabelValues{"a", "1", "b", "3"}, 32) s.Observe("metric_two", LabelValues{}, 64) s.Observe("metric_two", LabelValues{}, 128) s.Observe("metric_two", LabelValues{"a", "1", "b", "2"}, 256) have := map[string]float64{} s.Walk(func(name string, lvs LabelValues, obs []float64) bool { //t.Logf("%s %v => %v", name, lvs, obs) have[name+" ["+strings.Join(lvs, "")+"]"] += sum(obs) return true }) want := map[string]float64{ "metric_one []": 1 + 2 + 16, "metric_one [a1b2]": 4 + 8, "metric_one [a1b3]": 32, "metric_two []": 64 + 128, "metric_two [a1b2]": 256, } for keystr, wantsum := range want { if havesum := have[keystr]; wantsum != havesum { t.Errorf("%q: want %.1f, have %.1f", keystr, wantsum, havesum) } delete(want, keystr) delete(have, keystr) } for keystr, havesum := range have { t.Errorf("%q: unexpected observations recorded: %.1f", keystr, havesum) } } func TestSpaceWalkSkipsEmptyDimensions(t *testing.T) { s := NewSpace() s.Observe("foo", LabelValues{"bar", "1", "baz", "2"}, 123) var count int s.Walk(func(name string, lvs LabelValues, obs []float64) bool { count++ return true }) if want, have := 1, count; want != have { t.Errorf("want %d, have %d", want, have) } } func sum(a []float64) (v float64) { for _, f := range a { v += f } return } golang-github-go-kit-kit-0.6.0/metrics/internal/ratemap/000077500000000000000000000000001316471211400231345ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/internal/ratemap/ratemap.go000066400000000000000000000017611316471211400251210ustar00rootroot00000000000000// Package ratemap implements a goroutine-safe map of string to float64. It can // be embedded in implementations whose metrics support fixed sample rates, so // that an additional parameter doesn't have to be tracked through the e.g. // lv.Space object. package ratemap import "sync" // RateMap is a simple goroutine-safe map of string to float64. type RateMap struct { mtx sync.RWMutex m map[string]float64 } // New returns a new RateMap. func New() *RateMap { return &RateMap{ m: map[string]float64{}, } } // Set writes the given name/rate pair to the map. // Set is safe for concurrent access by multiple goroutines. func (m *RateMap) Set(name string, rate float64) { m.mtx.Lock() defer m.mtx.Unlock() m.m[name] = rate } // Get retrieves the rate for the given name, or 1.0 if none is set. // Get is safe for concurrent access by multiple goroutines. func (m *RateMap) Get(name string) float64 { m.mtx.RLock() defer m.mtx.RUnlock() f, ok := m.m[name] if !ok { f = 1.0 } return f } golang-github-go-kit-kit-0.6.0/metrics/metrics.go000066400000000000000000000014611316471211400216660ustar00rootroot00000000000000package metrics // Counter describes a metric that accumulates values monotonically. // An example of a counter is the number of received HTTP requests. type Counter interface { With(labelValues ...string) Counter Add(delta float64) } // Gauge describes a metric that takes specific values over time. // An example of a gauge is the current depth of a job queue. type Gauge interface { With(labelValues ...string) Gauge Set(value float64) Add(delta float64) } // Histogram describes a metric that takes repeated observations of the same // kind of thing, and produces a statistical summary of those observations, // typically expressed as quantiles or buckets. An example of a histogram is // HTTP request latencies. type Histogram interface { With(labelValues ...string) Histogram Observe(value float64) } golang-github-go-kit-kit-0.6.0/metrics/multi/000077500000000000000000000000001316471211400210215ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/multi/multi.go000066400000000000000000000041701316471211400225040ustar00rootroot00000000000000// Package multi provides adapters that send observations to multiple metrics // simultaneously. This is useful if your service needs to emit to multiple // instrumentation systems at the same time, for example if your organization is // transitioning from one system to another. package multi import "github.com/go-kit/kit/metrics" // Counter collects multiple individual counters and treats them as a unit. type Counter []metrics.Counter // NewCounter returns a multi-counter, wrapping the passed counters. func NewCounter(c ...metrics.Counter) Counter { return Counter(c) } // Add implements counter. func (c Counter) Add(delta float64) { for _, counter := range c { counter.Add(delta) } } // With implements counter. func (c Counter) With(labelValues ...string) metrics.Counter { next := make(Counter, len(c)) for i := range c { next[i] = c[i].With(labelValues...) } return next } // Gauge collects multiple individual gauges and treats them as a unit. type Gauge []metrics.Gauge // NewGauge returns a multi-gauge, wrapping the passed gauges. func NewGauge(g ...metrics.Gauge) Gauge { return Gauge(g) } // Set implements Gauge. func (g Gauge) Set(value float64) { for _, gauge := range g { gauge.Set(value) } } // With implements gauge. func (g Gauge) With(labelValues ...string) metrics.Gauge { next := make(Gauge, len(g)) for i := range g { next[i] = g[i].With(labelValues...) } return next } // Add implements metrics.Gauge. func (g Gauge) Add(delta float64) { for _, gauge := range g { gauge.Add(delta) } } // Histogram collects multiple individual histograms and treats them as a unit. type Histogram []metrics.Histogram // NewHistogram returns a multi-histogram, wrapping the passed histograms. func NewHistogram(h ...metrics.Histogram) Histogram { return Histogram(h) } // Observe implements Histogram. func (h Histogram) Observe(value float64) { for _, histogram := range h { histogram.Observe(value) } } // With implements histogram. func (h Histogram) With(labelValues ...string) metrics.Histogram { next := make(Histogram, len(h)) for i := range h { next[i] = h[i].With(labelValues...) } return next } golang-github-go-kit-kit-0.6.0/metrics/multi/multi_test.go000066400000000000000000000042071316471211400235440ustar00rootroot00000000000000package multi import ( "fmt" "testing" "github.com/go-kit/kit/metrics" ) func TestMultiCounter(t *testing.T) { c1 := &mockCounter{} c2 := &mockCounter{} c3 := &mockCounter{} mc := NewCounter(c1, c2, c3) mc.Add(123) mc.Add(456) want := "[123 456]" for i, m := range []fmt.Stringer{c1, c2, c3} { if have := m.String(); want != have { t.Errorf("c%d: want %q, have %q", i+1, want, have) } } } func TestMultiGauge(t *testing.T) { g1 := &mockGauge{} g2 := &mockGauge{} g3 := &mockGauge{} mg := NewGauge(g1, g2, g3) mg.Set(9) mg.Set(8) mg.Set(7) mg.Add(3) want := "[9 8 7 10]" for i, m := range []fmt.Stringer{g1, g2, g3} { if have := m.String(); want != have { t.Errorf("g%d: want %q, have %q", i+1, want, have) } } } func TestMultiHistogram(t *testing.T) { h1 := &mockHistogram{} h2 := &mockHistogram{} h3 := &mockHistogram{} mh := NewHistogram(h1, h2, h3) mh.Observe(1) mh.Observe(2) mh.Observe(4) mh.Observe(8) want := "[1 2 4 8]" for i, m := range []fmt.Stringer{h1, h2, h3} { if have := m.String(); want != have { t.Errorf("g%d: want %q, have %q", i+1, want, have) } } } type mockCounter struct { obs []float64 } func (c *mockCounter) Add(delta float64) { c.obs = append(c.obs, delta) } func (c *mockCounter) With(...string) metrics.Counter { return c } func (c *mockCounter) String() string { return fmt.Sprintf("%v", c.obs) } type mockGauge struct { obs []float64 } func (g *mockGauge) Set(value float64) { g.obs = append(g.obs, value) } func (g *mockGauge) With(...string) metrics.Gauge { return g } func (g *mockGauge) String() string { return fmt.Sprintf("%v", g.obs) } func (g *mockGauge) Add(delta float64) { var value float64 if len(g.obs) > 0 { value = g.obs[len(g.obs)-1] + delta } else { value = delta } g.obs = append(g.obs, value) } type mockHistogram struct { obs []float64 } func (h *mockHistogram) Observe(value float64) { h.obs = append(h.obs, value) } func (h *mockHistogram) With(...string) metrics.Histogram { return h } func (h *mockHistogram) String() string { return fmt.Sprintf("%v", h.obs) } golang-github-go-kit-kit-0.6.0/metrics/pcp/000077500000000000000000000000001316471211400204515ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/pcp/pcp.go000066400000000000000000000077501316471211400215730ustar00rootroot00000000000000package pcp import ( "github.com/performancecopilot/speed" "github.com/go-kit/kit/metrics" ) // Reporter encapsulates a speed client. type Reporter struct { c *speed.PCPClient } // NewReporter creates a new Reporter instance. The first parameter is the // application name and is used to create the speed client. Hence it should be a // valid speed parameter name and should not contain spaces or the path // separator for your operating system. func NewReporter(appname string) (*Reporter, error) { c, err := speed.NewPCPClient(appname) if err != nil { return nil, err } return &Reporter{c}, nil } // Start starts the underlying speed client so it can start reporting registered // metrics to your PCP installation. func (r *Reporter) Start() { r.c.MustStart() } // Stop stops the underlying speed client so it can stop reporting registered // metrics to your PCP installation. func (r *Reporter) Stop() { r.c.MustStop() } // Counter implements metrics.Counter via a single dimensional speed.Counter. type Counter struct { c speed.Counter } // NewCounter creates a new Counter. This requires a name parameter and can // optionally take a couple of description strings, that are used to create the // underlying speed.Counter and are reported by PCP. func (r *Reporter) NewCounter(name string, desc ...string) (*Counter, error) { c, err := speed.NewPCPCounter(0, name, desc...) if err != nil { return nil, err } r.c.MustRegister(c) return &Counter{c}, nil } // With is a no-op. func (c *Counter) With(labelValues ...string) metrics.Counter { return c } // Add increments Counter. speed.Counters only take int64, so delta is converted // to int64 before observation. func (c *Counter) Add(delta float64) { c.c.Inc(int64(delta)) } // Gauge implements metrics.Gauge via a single dimensional speed.Gauge. type Gauge struct { g speed.Gauge } // NewGauge creates a new Gauge. This requires a name parameter and can // optionally take a couple of description strings, that are used to create the // underlying speed.Gauge and are reported by PCP. func (r *Reporter) NewGauge(name string, desc ...string) (*Gauge, error) { g, err := speed.NewPCPGauge(0, name, desc...) if err != nil { return nil, err } r.c.MustRegister(g) return &Gauge{g}, nil } // With is a no-op. func (g *Gauge) With(labelValues ...string) metrics.Gauge { return g } // Set sets the value of the gauge. func (g *Gauge) Set(value float64) { g.g.Set(value) } // Add adds a value to the gauge. func (g *Gauge) Add(delta float64) { g.g.Inc(delta) } // Histogram wraps a speed Histogram. type Histogram struct { h speed.Histogram } // NewHistogram creates a new Histogram. The minimum observeable value is 0. The // maximum observeable value is 3600000000 (3.6e9). // // The required parameters are a metric name, the minimum and maximum observable // values, and a metric unit for the units of the observed values. // // Optionally, it can also take a couple of description strings. func (r *Reporter) NewHistogram(name string, min, max int64, unit speed.MetricUnit, desc ...string) (*Histogram, error) { h, err := speed.NewPCPHistogram(name, min, max, 5, unit, desc...) if err != nil { return nil, err } r.c.MustRegister(h) return &Histogram{h}, nil } // With is a no-op. func (h *Histogram) With(labelValues ...string) metrics.Histogram { return h } // Observe observes a value. // // This converts float64 value to int64 before observation, as the Histogram in // speed is backed using codahale/hdrhistogram, which only observes int64 // values. Additionally, the value is interpreted in the metric unit used to // construct the histogram. func (h *Histogram) Observe(value float64) { h.h.MustRecord(int64(value)) } // Mean returns the mean of the values observed so far by the Histogram. func (h *Histogram) Mean() float64 { return h.h.Mean() } // Percentile returns a percentile value for the given percentile // between 0 and 100 for all values observed by the histogram. func (h *Histogram) Percentile(p float64) int64 { return h.h.Percentile(p) } golang-github-go-kit-kit-0.6.0/metrics/pcp/pcp_test.go000066400000000000000000000030511316471211400226200ustar00rootroot00000000000000package pcp import ( "testing" "github.com/performancecopilot/speed" "github.com/go-kit/kit/metrics/teststat" ) func TestCounter(t *testing.T) { r, err := NewReporter("test_counter") if err != nil { t.Fatal(err) } counter, err := r.NewCounter("speed_counter") if err != nil { t.Fatal(err) } counter = counter.With("label values", "not supported").(*Counter) value := func() float64 { f := counter.c.Val(); return float64(f) } if err := teststat.TestCounter(counter, value); err != nil { t.Fatal(err) } } func TestGauge(t *testing.T) { r, err := NewReporter("test_gauge") if err != nil { t.Fatal(err) } gauge, err := r.NewGauge("speed_gauge") if err != nil { t.Fatal(err) } gauge = gauge.With("label values", "not supported").(*Gauge) value := func() float64 { f := gauge.g.Val(); return f } if err := teststat.TestGauge(gauge, value); err != nil { t.Fatal(err) } } func TestHistogram(t *testing.T) { r, err := NewReporter("test_histogram") if err != nil { t.Fatal(err) } histogram, err := r.NewHistogram("speed_histogram", 0, 3600000000, speed.OneUnit) if err != nil { t.Fatal(err) } histogram = histogram.With("label values", "not supported").(*Histogram) quantiles := func() (float64, float64, float64, float64) { p50 := float64(histogram.Percentile(50)) p90 := float64(histogram.Percentile(90)) p95 := float64(histogram.Percentile(95)) p99 := float64(histogram.Percentile(99)) return p50, p90, p95, p99 } if err := teststat.TestHistogram(histogram, quantiles, 0.01); err != nil { t.Fatal(err) } } golang-github-go-kit-kit-0.6.0/metrics/prometheus/000077500000000000000000000000001316471211400220625ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/prometheus/prometheus.go000066400000000000000000000106711316471211400246110ustar00rootroot00000000000000// Package prometheus provides Prometheus implementations for metrics. // Individual metrics are mapped to their Prometheus counterparts, and // (depending on the constructor used) may be automatically registered in the // global Prometheus metrics registry. package prometheus import ( "github.com/prometheus/client_golang/prometheus" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/internal/lv" ) // Counter implements Counter, via a Prometheus CounterVec. type Counter struct { cv *prometheus.CounterVec lvs lv.LabelValues } // NewCounterFrom constructs and registers a Prometheus CounterVec, // and returns a usable Counter object. func NewCounterFrom(opts prometheus.CounterOpts, labelNames []string) *Counter { cv := prometheus.NewCounterVec(opts, labelNames) prometheus.MustRegister(cv) return NewCounter(cv) } // NewCounter wraps the CounterVec and returns a usable Counter object. func NewCounter(cv *prometheus.CounterVec) *Counter { return &Counter{ cv: cv, } } // With implements Counter. func (c *Counter) With(labelValues ...string) metrics.Counter { return &Counter{ cv: c.cv, lvs: c.lvs.With(labelValues...), } } // Add implements Counter. func (c *Counter) Add(delta float64) { c.cv.With(makeLabels(c.lvs...)).Add(delta) } // Gauge implements Gauge, via a Prometheus GaugeVec. type Gauge struct { gv *prometheus.GaugeVec lvs lv.LabelValues } // NewGaugeFrom construts and registers a Prometheus GaugeVec, // and returns a usable Gauge object. func NewGaugeFrom(opts prometheus.GaugeOpts, labelNames []string) *Gauge { gv := prometheus.NewGaugeVec(opts, labelNames) prometheus.MustRegister(gv) return NewGauge(gv) } // NewGauge wraps the GaugeVec and returns a usable Gauge object. func NewGauge(gv *prometheus.GaugeVec) *Gauge { return &Gauge{ gv: gv, } } // With implements Gauge. func (g *Gauge) With(labelValues ...string) metrics.Gauge { return &Gauge{ gv: g.gv, lvs: g.lvs.With(labelValues...), } } // Set implements Gauge. func (g *Gauge) Set(value float64) { g.gv.With(makeLabels(g.lvs...)).Set(value) } // Add is supported by Prometheus GaugeVecs. func (g *Gauge) Add(delta float64) { g.gv.With(makeLabels(g.lvs...)).Add(delta) } // Summary implements Histogram, via a Prometheus SummaryVec. The difference // between a Summary and a Histogram is that Summaries don't require predefined // quantile buckets, but cannot be statistically aggregated. type Summary struct { sv *prometheus.SummaryVec lvs lv.LabelValues } // NewSummaryFrom constructs and registers a Prometheus SummaryVec, // and returns a usable Summary object. func NewSummaryFrom(opts prometheus.SummaryOpts, labelNames []string) *Summary { sv := prometheus.NewSummaryVec(opts, labelNames) prometheus.MustRegister(sv) return NewSummary(sv) } // NewSummary wraps the SummaryVec and returns a usable Summary object. func NewSummary(sv *prometheus.SummaryVec) *Summary { return &Summary{ sv: sv, } } // With implements Histogram. func (s *Summary) With(labelValues ...string) metrics.Histogram { return &Summary{ sv: s.sv, lvs: s.lvs.With(labelValues...), } } // Observe implements Histogram. func (s *Summary) Observe(value float64) { s.sv.With(makeLabels(s.lvs...)).Observe(value) } // Histogram implements Histogram via a Prometheus HistogramVec. The difference // between a Histogram and a Summary is that Histograms require predefined // quantile buckets, and can be statistically aggregated. type Histogram struct { hv *prometheus.HistogramVec lvs lv.LabelValues } // NewHistogramFrom constructs and registers a Prometheus HistogramVec, // and returns a usable Histogram object. func NewHistogramFrom(opts prometheus.HistogramOpts, labelNames []string) *Histogram { hv := prometheus.NewHistogramVec(opts, labelNames) prometheus.MustRegister(hv) return NewHistogram(hv) } // NewHistogram wraps the HistogramVec and returns a usable Histogram object. func NewHistogram(hv *prometheus.HistogramVec) *Histogram { return &Histogram{ hv: hv, } } // With implements Histogram. func (h *Histogram) With(labelValues ...string) metrics.Histogram { return &Histogram{ hv: h.hv, lvs: h.lvs.With(labelValues...), } } // Observe implements Histogram. func (h *Histogram) Observe(value float64) { h.hv.With(makeLabels(h.lvs...)).Observe(value) } func makeLabels(labelValues ...string) prometheus.Labels { labels := prometheus.Labels{} for i := 0; i < len(labelValues); i += 2 { labels[labelValues[i]] = labelValues[i+1] } return labels } golang-github-go-kit-kit-0.6.0/metrics/prometheus/prometheus_test.go000066400000000000000000000145261316471211400256530ustar00rootroot00000000000000package prometheus import ( "io/ioutil" "math" "math/rand" "net/http" "net/http/httptest" "reflect" "regexp" "strconv" "strings" "testing" stdprometheus "github.com/prometheus/client_golang/prometheus" "github.com/go-kit/kit/metrics/teststat" ) func TestCounter(t *testing.T) { s := httptest.NewServer(stdprometheus.UninstrumentedHandler()) defer s.Close() scrape := func() string { resp, _ := http.Get(s.URL) buf, _ := ioutil.ReadAll(resp.Body) return string(buf) } namespace, subsystem, name := "ns", "ss", "foo" re := regexp.MustCompile(namespace + `_` + subsystem + `_` + name + `{alpha="alpha-value",beta="beta-value"} ([0-9\.]+)`) counter := NewCounterFrom(stdprometheus.CounterOpts{ Namespace: namespace, Subsystem: subsystem, Name: name, Help: "This is the help string.", }, []string{"alpha", "beta"}).With("beta", "beta-value", "alpha", "alpha-value") // order shouldn't matter value := func() float64 { matches := re.FindStringSubmatch(scrape()) f, _ := strconv.ParseFloat(matches[1], 64) return f } if err := teststat.TestCounter(counter, value); err != nil { t.Fatal(err) } } func TestGauge(t *testing.T) { s := httptest.NewServer(stdprometheus.UninstrumentedHandler()) defer s.Close() scrape := func() string { resp, _ := http.Get(s.URL) buf, _ := ioutil.ReadAll(resp.Body) return string(buf) } namespace, subsystem, name := "aaa", "bbb", "ccc" re := regexp.MustCompile(namespace + `_` + subsystem + `_` + name + `{foo="bar"} ([0-9\.]+)`) gauge := NewGaugeFrom(stdprometheus.GaugeOpts{ Namespace: namespace, Subsystem: subsystem, Name: name, Help: "This is a different help string.", }, []string{"foo"}).With("foo", "bar") value := func() float64 { matches := re.FindStringSubmatch(scrape()) f, _ := strconv.ParseFloat(matches[1], 64) return f } if err := teststat.TestGauge(gauge, value); err != nil { t.Fatal(err) } } func TestSummary(t *testing.T) { s := httptest.NewServer(stdprometheus.UninstrumentedHandler()) defer s.Close() scrape := func() string { resp, _ := http.Get(s.URL) buf, _ := ioutil.ReadAll(resp.Body) return string(buf) } namespace, subsystem, name := "test", "prometheus", "summary" re50 := regexp.MustCompile(namespace + `_` + subsystem + `_` + name + `{a="a",b="b",quantile="0.5"} ([0-9\.]+)`) re90 := regexp.MustCompile(namespace + `_` + subsystem + `_` + name + `{a="a",b="b",quantile="0.9"} ([0-9\.]+)`) re99 := regexp.MustCompile(namespace + `_` + subsystem + `_` + name + `{a="a",b="b",quantile="0.99"} ([0-9\.]+)`) summary := NewSummaryFrom(stdprometheus.SummaryOpts{ Namespace: namespace, Subsystem: subsystem, Name: name, Help: "This is the help string for the summary.", }, []string{"a", "b"}).With("b", "b").With("a", "a") quantiles := func() (float64, float64, float64, float64) { buf := scrape() match50 := re50.FindStringSubmatch(buf) p50, _ := strconv.ParseFloat(match50[1], 64) match90 := re90.FindStringSubmatch(buf) p90, _ := strconv.ParseFloat(match90[1], 64) match99 := re99.FindStringSubmatch(buf) p99, _ := strconv.ParseFloat(match99[1], 64) p95 := p90 + ((p99 - p90) / 2) // Prometheus, y u no p95??? :< #yolo return p50, p90, p95, p99 } if err := teststat.TestHistogram(summary, quantiles, 0.01); err != nil { t.Fatal(err) } } func TestHistogram(t *testing.T) { // Prometheus reports histograms as a count of observations that fell into // each predefined bucket, with the bucket value representing a global upper // limit. That is, the count monotonically increases over the buckets. This // requires a different strategy to test. s := httptest.NewServer(stdprometheus.UninstrumentedHandler()) defer s.Close() scrape := func() string { resp, _ := http.Get(s.URL) buf, _ := ioutil.ReadAll(resp.Body) return string(buf) } namespace, subsystem, name := "test", "prometheus", "histogram" re := regexp.MustCompile(namespace + `_` + subsystem + `_` + name + `_bucket{x="1",le="([0-9]+|\+Inf)"} ([0-9\.]+)`) numStdev := 3 bucketMin := (teststat.Mean - (numStdev * teststat.Stdev)) bucketMax := (teststat.Mean + (numStdev * teststat.Stdev)) if bucketMin < 0 { bucketMin = 0 } bucketCount := 10 bucketDelta := (bucketMax - bucketMin) / bucketCount buckets := []float64{} for i := bucketMin; i <= bucketMax; i += bucketDelta { buckets = append(buckets, float64(i)) } histogram := NewHistogramFrom(stdprometheus.HistogramOpts{ Namespace: namespace, Subsystem: subsystem, Name: name, Help: "This is the help string for the histogram.", Buckets: buckets, }, []string{"x"}).With("x", "1") // Can't TestHistogram, because Prometheus Histograms don't dynamically // compute quantiles. Instead, they fill up buckets. So, let's populate the // histogram kind of manually. teststat.PopulateNormalHistogram(histogram, rand.Int()) // Then, we use ExpectedObservationsLessThan to validate. for _, line := range strings.Split(scrape(), "\n") { match := re.FindStringSubmatch(line) if match == nil { continue } bucket, _ := strconv.ParseInt(match[1], 10, 64) have, _ := strconv.ParseInt(match[2], 10, 64) want := teststat.ExpectedObservationsLessThan(bucket) if match[1] == "+Inf" { want = int64(teststat.Count) // special case } // Unfortunately, we observe experimentally that Prometheus is quite // imprecise at the extremes. I'm setting a very high tolerance for now. // It would be great to dig in and figure out whether that's a problem // with my Expected calculation, or in Prometheus. tolerance := 0.25 if delta := math.Abs(float64(want) - float64(have)); (delta / float64(want)) > tolerance { t.Errorf("Bucket %d: want %d, have %d (%.1f%%)", bucket, want, have, (100.0 * delta / float64(want))) } } } func TestInconsistentLabelCardinality(t *testing.T) { defer func() { x := recover() if x == nil { t.Fatal("expected panic, got none") } err, ok := x.(error) if !ok { t.Fatalf("expected error, got %s", reflect.TypeOf(x)) } if want, have := "inconsistent label cardinality", err.Error(); want != have { t.Fatalf("want %q, have %q", want, have) } }() NewCounterFrom(stdprometheus.CounterOpts{ Namespace: "test", Subsystem: "inconsistent_label_cardinality", Name: "foobar", Help: "This is the help string for the metric.", }, []string{"a", "b"}).With( "a", "1", "b", "2", "c", "KABOOM!", ).Add(123) } golang-github-go-kit-kit-0.6.0/metrics/provider/000077500000000000000000000000001316471211400215215ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/provider/discard.go000066400000000000000000000013511316471211400234610ustar00rootroot00000000000000package provider import ( "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/discard" ) type discardProvider struct{} // NewDiscardProvider returns a provider that produces no-op metrics via the // discarding backend. func NewDiscardProvider() Provider { return discardProvider{} } // NewCounter implements Provider. func (discardProvider) NewCounter(string) metrics.Counter { return discard.NewCounter() } // NewGauge implements Provider. func (discardProvider) NewGauge(string) metrics.Gauge { return discard.NewGauge() } // NewHistogram implements Provider. func (discardProvider) NewHistogram(string, int) metrics.Histogram { return discard.NewHistogram() } // Stop implements Provider. func (discardProvider) Stop() {} golang-github-go-kit-kit-0.6.0/metrics/provider/dogstatsd.go000066400000000000000000000024071316471211400240470ustar00rootroot00000000000000package provider import ( "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/dogstatsd" ) type dogstatsdProvider struct { d *dogstatsd.Dogstatsd stop func() } // NewDogstatsdProvider wraps the given Dogstatsd object and stop func and // returns a Provider that produces Dogstatsd metrics. A typical stop function // would be ticker.Stop from the ticker passed to the SendLoop helper method. func NewDogstatsdProvider(d *dogstatsd.Dogstatsd, stop func()) Provider { return &dogstatsdProvider{ d: d, stop: stop, } } // NewCounter implements Provider, returning a new Dogstatsd Counter with a // sample rate of 1.0. func (p *dogstatsdProvider) NewCounter(name string) metrics.Counter { return p.d.NewCounter(name, 1.0) } // NewGauge implements Provider. func (p *dogstatsdProvider) NewGauge(name string) metrics.Gauge { return p.d.NewGauge(name) } // NewHistogram implements Provider, returning a new Dogstatsd Histogram (note: // not a Timing) with a sample rate of 1.0. The buckets argument is ignored. func (p *dogstatsdProvider) NewHistogram(name string, _ int) metrics.Histogram { return p.d.NewHistogram(name, 1.0) } // Stop implements Provider, invoking the stop function passed at construction. func (p *dogstatsdProvider) Stop() { p.stop() } golang-github-go-kit-kit-0.6.0/metrics/provider/expvar.go000066400000000000000000000014101316471211400233510ustar00rootroot00000000000000package provider import ( "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/expvar" ) type expvarProvider struct{} // NewExpvarProvider returns a Provider that produces expvar metrics. func NewExpvarProvider() Provider { return expvarProvider{} } // NewCounter implements Provider. func (p expvarProvider) NewCounter(name string) metrics.Counter { return expvar.NewCounter(name) } // NewGauge implements Provider. func (p expvarProvider) NewGauge(name string) metrics.Gauge { return expvar.NewGauge(name) } // NewHistogram implements Provider. func (p expvarProvider) NewHistogram(name string, buckets int) metrics.Histogram { return expvar.NewHistogram(name, buckets) } // Stop implements Provider, but is a no-op. func (p expvarProvider) Stop() {} golang-github-go-kit-kit-0.6.0/metrics/provider/graphite.go000066400000000000000000000021051316471211400236510ustar00rootroot00000000000000package provider import ( "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/graphite" ) type graphiteProvider struct { g *graphite.Graphite stop func() } // NewGraphiteProvider wraps the given Graphite object and stop func and returns // a Provider that produces Graphite metrics. A typical stop function would be // ticker.Stop from the ticker passed to the SendLoop helper method. func NewGraphiteProvider(g *graphite.Graphite, stop func()) Provider { return &graphiteProvider{ g: g, stop: stop, } } // NewCounter implements Provider. func (p *graphiteProvider) NewCounter(name string) metrics.Counter { return p.g.NewCounter(name) } // NewGauge implements Provider. func (p *graphiteProvider) NewGauge(name string) metrics.Gauge { return p.g.NewGauge(name) } // NewHistogram implements Provider. func (p *graphiteProvider) NewHistogram(name string, buckets int) metrics.Histogram { return p.g.NewHistogram(name, buckets) } // Stop implements Provider, invoking the stop function passed at construction. func (p *graphiteProvider) Stop() { p.stop() } golang-github-go-kit-kit-0.6.0/metrics/provider/influx.go000066400000000000000000000020471316471211400233600ustar00rootroot00000000000000package provider import ( "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/influx" ) type influxProvider struct { in *influx.Influx stop func() } // NewInfluxProvider takes the given Influx object and stop func, and returns // a Provider that produces Influx metrics. func NewInfluxProvider(in *influx.Influx, stop func()) Provider { return &influxProvider{ in: in, stop: stop, } } // NewCounter implements Provider. Per-metric tags are not supported. func (p *influxProvider) NewCounter(name string) metrics.Counter { return p.in.NewCounter(name) } // NewGauge implements Provider. Per-metric tags are not supported. func (p *influxProvider) NewGauge(name string) metrics.Gauge { return p.in.NewGauge(name) } // NewHistogram implements Provider. Per-metric tags are not supported. func (p *influxProvider) NewHistogram(name string, buckets int) metrics.Histogram { return p.in.NewHistogram(name) } // Stop implements Provider, invoking the stop function passed at construction. func (p *influxProvider) Stop() { p.stop() } golang-github-go-kit-kit-0.6.0/metrics/provider/prometheus.go000066400000000000000000000040531316471211400242450ustar00rootroot00000000000000package provider import ( stdprometheus "github.com/prometheus/client_golang/prometheus" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/prometheus" ) type prometheusProvider struct { namespace string subsystem string } // NewPrometheusProvider returns a Provider that produces Prometheus metrics. // Namespace and subsystem are applied to all produced metrics. func NewPrometheusProvider(namespace, subsystem string) Provider { return &prometheusProvider{ namespace: namespace, subsystem: subsystem, } } // NewCounter implements Provider via prometheus.NewCounterFrom, i.e. the // counter is registered. The metric's namespace and subsystem are taken from // the Provider. Help is set to the name of the metric, and no const label names // are set. func (p *prometheusProvider) NewCounter(name string) metrics.Counter { return prometheus.NewCounterFrom(stdprometheus.CounterOpts{ Namespace: p.namespace, Subsystem: p.subsystem, Name: name, Help: name, }, []string{}) } // NewGauge implements Provider via prometheus.NewGaugeFrom, i.e. the gauge is // registered. The metric's namespace and subsystem are taken from the Provider. // Help is set to the name of the metric, and no const label names are set. func (p *prometheusProvider) NewGauge(name string) metrics.Gauge { return prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{ Namespace: p.namespace, Subsystem: p.subsystem, Name: name, Help: name, }, []string{}) } // NewGauge implements Provider via prometheus.NewSummaryFrom, i.e. the summary // is registered. The metric's namespace and subsystem are taken from the // Provider. Help is set to the name of the metric, and no const label names are // set. Buckets are ignored. func (p *prometheusProvider) NewHistogram(name string, _ int) metrics.Histogram { return prometheus.NewSummaryFrom(stdprometheus.SummaryOpts{ Namespace: p.namespace, Subsystem: p.subsystem, Name: name, Help: name, }, []string{}) } // Stop implements Provider, but is a no-op. func (p *prometheusProvider) Stop() {} golang-github-go-kit-kit-0.6.0/metrics/provider/provider.go000066400000000000000000000030321316471211400237000ustar00rootroot00000000000000// Package provider provides a factory-like abstraction for metrics backends. // This package is provided specifically for the needs of the NY Times framework // Gizmo. Most normal Go kit users shouldn't need to use it. // // Normally, if your microservice needs to support different metrics backends, // you can simply do different construction based on a flag. For example, // // var latency metrics.Histogram // var requests metrics.Counter // switch *metricsBackend { // case "prometheus": // latency = prometheus.NewSummaryVec(...) // requests = prometheus.NewCounterVec(...) // case "statsd": // s := statsd.New(...) // t := time.NewTicker(5*time.Second) // go s.SendLoop(t.C, "tcp", "statsd.local:8125") // latency = s.NewHistogram(...) // requests = s.NewCounter(...) // default: // log.Fatal("unsupported metrics backend %q", *metricsBackend) // } // package provider import ( "github.com/go-kit/kit/metrics" ) // Provider abstracts over constructors and lifecycle management functions for // each supported metrics backend. It should only be used by those who need to // swap out implementations dynamically. // // This is primarily useful for intermediating frameworks, and is likely // unnecessary for most Go kit services. See the package-level doc comment for // more typical usage instructions. type Provider interface { NewCounter(name string) metrics.Counter NewGauge(name string) metrics.Gauge NewHistogram(name string, buckets int) metrics.Histogram Stop() } golang-github-go-kit-kit-0.6.0/metrics/provider/statsd.go000066400000000000000000000022541316471211400233550ustar00rootroot00000000000000package provider import ( "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/statsd" ) type statsdProvider struct { s *statsd.Statsd stop func() } // NewStatsdProvider wraps the given Statsd object and stop func and returns a // Provider that produces Statsd metrics. A typical stop function would be // ticker.Stop from the ticker passed to the SendLoop helper method. func NewStatsdProvider(s *statsd.Statsd, stop func()) Provider { return &statsdProvider{ s: s, stop: stop, } } // NewCounter implements Provider. func (p *statsdProvider) NewCounter(name string) metrics.Counter { return p.s.NewCounter(name, 1.0) } // NewGauge implements Provider. func (p *statsdProvider) NewGauge(name string) metrics.Gauge { return p.s.NewGauge(name) } // NewHistogram implements Provider, returning a StatsD Timing that accepts // observations in milliseconds. The sample rate is fixed at 1.0. The bucket // parameter is ignored. func (p *statsdProvider) NewHistogram(name string, _ int) metrics.Histogram { return p.s.NewTiming(name, 1.0) } // Stop implements Provider, invoking the stop function passed at construction. func (p *statsdProvider) Stop() { p.stop() } golang-github-go-kit-kit-0.6.0/metrics/statsd/000077500000000000000000000000001316471211400211715ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/statsd/statsd.go000066400000000000000000000154651316471211400230350ustar00rootroot00000000000000// Package statsd provides a StatsD backend for package metrics. StatsD has no // concept of arbitrary key-value tagging, so label values are not supported, // and With is a no-op on all metrics. // // This package batches observations and emits them on some schedule to the // remote server. This is useful even if you connect to your StatsD server over // UDP. Emitting one network packet per observation can quickly overwhelm even // the fastest internal network. package statsd import ( "fmt" "io" "time" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/internal/lv" "github.com/go-kit/kit/metrics/internal/ratemap" "github.com/go-kit/kit/util/conn" ) // Statsd receives metrics observations and forwards them to a StatsD server. // Create a Statsd object, use it to create metrics, and pass those metrics as // dependencies to the components that will use them. // // All metrics are buffered until WriteTo is called. Counters and gauges are // aggregated into a single observation per timeseries per write. Timings are // buffered but not aggregated. // // To regularly report metrics to an io.Writer, use the WriteLoop helper method. // To send to a StatsD server, use the SendLoop helper method. type Statsd struct { prefix string rates *ratemap.RateMap // The observations are collected in an N-dimensional vector space, even // though they only take advantage of a single dimension (name). This is an // implementation detail born purely from convenience. It would be more // accurate to collect them in a map[string][]float64, but we already have // this nice data structure and helper methods. counters *lv.Space gauges *lv.Space timings *lv.Space logger log.Logger } // New returns a Statsd object that may be used to create metrics. Prefix is // applied to all created metrics. Callers must ensure that regular calls to // WriteTo are performed, either manually or with one of the helper methods. func New(prefix string, logger log.Logger) *Statsd { return &Statsd{ prefix: prefix, rates: ratemap.New(), counters: lv.NewSpace(), gauges: lv.NewSpace(), timings: lv.NewSpace(), logger: logger, } } // NewCounter returns a counter, sending observations to this Statsd object. func (s *Statsd) NewCounter(name string, sampleRate float64) *Counter { s.rates.Set(s.prefix+name, sampleRate) return &Counter{ name: s.prefix + name, obs: s.counters.Observe, } } // NewGauge returns a gauge, sending observations to this Statsd object. func (s *Statsd) NewGauge(name string) *Gauge { return &Gauge{ name: s.prefix + name, obs: s.gauges.Observe, add: s.gauges.Add, } } // NewTiming returns a histogram whose observations are interpreted as // millisecond durations, and are forwarded to this Statsd object. func (s *Statsd) NewTiming(name string, sampleRate float64) *Timing { s.rates.Set(s.prefix+name, sampleRate) return &Timing{ name: s.prefix + name, obs: s.timings.Observe, } } // WriteLoop is a helper method that invokes WriteTo to the passed writer every // time the passed channel fires. This method blocks until the channel is // closed, so clients probably want to run it in its own goroutine. For typical // usage, create a time.Ticker and pass its C channel to this method. func (s *Statsd) WriteLoop(c <-chan time.Time, w io.Writer) { for range c { if _, err := s.WriteTo(w); err != nil { s.logger.Log("during", "WriteTo", "err", err) } } } // SendLoop is a helper method that wraps WriteLoop, passing a managed // connection to the network and address. Like WriteLoop, this method blocks // until the channel is closed, so clients probably want to start it in its own // goroutine. For typical usage, create a time.Ticker and pass its C channel to // this method. func (s *Statsd) SendLoop(c <-chan time.Time, network, address string) { s.WriteLoop(c, conn.NewDefaultManager(network, address, s.logger)) } // WriteTo flushes the buffered content of the metrics to the writer, in // StatsD format. WriteTo abides best-effort semantics, so observations are // lost if there is a problem with the write. Clients should be sure to call // WriteTo regularly, ideally through the WriteLoop or SendLoop helper methods. func (s *Statsd) WriteTo(w io.Writer) (count int64, err error) { var n int s.counters.Reset().Walk(func(name string, _ lv.LabelValues, values []float64) bool { n, err = fmt.Fprintf(w, "%s:%f|c%s\n", name, sum(values), sampling(s.rates.Get(name))) if err != nil { return false } count += int64(n) return true }) if err != nil { return count, err } s.gauges.Reset().Walk(func(name string, _ lv.LabelValues, values []float64) bool { n, err = fmt.Fprintf(w, "%s:%f|g\n", name, last(values)) if err != nil { return false } count += int64(n) return true }) if err != nil { return count, err } s.timings.Reset().Walk(func(name string, _ lv.LabelValues, values []float64) bool { sampleRate := s.rates.Get(name) for _, value := range values { n, err = fmt.Fprintf(w, "%s:%f|ms%s\n", name, value, sampling(sampleRate)) if err != nil { return false } count += int64(n) } return true }) if err != nil { return count, err } return count, err } func sum(a []float64) float64 { var v float64 for _, f := range a { v += f } return v } func last(a []float64) float64 { return a[len(a)-1] } func sampling(r float64) string { var sv string if r < 1.0 { sv = fmt.Sprintf("|@%f", r) } return sv } type observeFunc func(name string, lvs lv.LabelValues, value float64) // Counter is a StatsD counter. Observations are forwarded to a Statsd object, // and aggregated (summed) per timeseries. type Counter struct { name string obs observeFunc } // With is a no-op. func (c *Counter) With(...string) metrics.Counter { return c } // Add implements metrics.Counter. func (c *Counter) Add(delta float64) { c.obs(c.name, lv.LabelValues{}, delta) } // Gauge is a StatsD gauge. Observations are forwarded to a Statsd object, and // aggregated (the last observation selected) per timeseries. type Gauge struct { name string obs observeFunc add observeFunc } // With is a no-op. func (g *Gauge) With(...string) metrics.Gauge { return g } // Set implements metrics.Gauge. func (g *Gauge) Set(value float64) { g.obs(g.name, lv.LabelValues{}, value) } // Add implements metrics.Gauge. func (g *Gauge) Add(delta float64) { g.add(g.name, lv.LabelValues{}, delta) } // Timing is a StatsD timing, or metrics.Histogram. Observations are // forwarded to a Statsd object, and collected (but not aggregated) per // timeseries. type Timing struct { name string obs observeFunc } // With is a no-op. func (t *Timing) With(...string) metrics.Histogram { return t } // Observe implements metrics.Histogram. Value is interpreted as milliseconds. func (t *Timing) Observe(value float64) { t.obs(t.name, lv.LabelValues{}, value) } golang-github-go-kit-kit-0.6.0/metrics/statsd/statsd_test.go000066400000000000000000000037511316471211400240670ustar00rootroot00000000000000package statsd import ( "testing" "github.com/go-kit/kit/log" "github.com/go-kit/kit/metrics/teststat" ) func TestCounter(t *testing.T) { prefix, name := "abc.", "def" label, value := "label", "value" // ignored regex := `^` + prefix + name + `:([0-9\.]+)\|c$` s := New(prefix, log.NewNopLogger()) counter := s.NewCounter(name, 1.0).With(label, value) valuef := teststat.SumLines(s, regex) if err := teststat.TestCounter(counter, valuef); err != nil { t.Fatal(err) } } func TestCounterSampled(t *testing.T) { // This will involve multiplying the observed sum by the inverse of the // sample rate and checking against the expected value within some // tolerance. t.Skip("TODO") } func TestGauge(t *testing.T) { prefix, name := "ghi.", "jkl" label, value := "xyz", "abc" // ignored regex := `^` + prefix + name + `:([0-9\.]+)\|g$` s := New(prefix, log.NewNopLogger()) gauge := s.NewGauge(name).With(label, value) valuef := teststat.LastLine(s, regex) if err := teststat.TestGauge(gauge, valuef); err != nil { t.Fatal(err) } } // StatsD timings just emit all observations. So, we collect them into a generic // histogram, and run the statistics test on that. func TestTiming(t *testing.T) { prefix, name := "statsd.", "timing_test" label, value := "abc", "def" // ignored regex := `^` + prefix + name + `:([0-9\.]+)\|ms$` s := New(prefix, log.NewNopLogger()) timing := s.NewTiming(name, 1.0).With(label, value) quantiles := teststat.Quantiles(s, regex, 50) // no |@0.X if err := teststat.TestHistogram(timing, quantiles, 0.01); err != nil { t.Fatal(err) } } func TestTimingSampled(t *testing.T) { prefix, name := "statsd.", "sampled_timing_test" label, value := "foo", "bar" // ignored regex := `^` + prefix + name + `:([0-9\.]+)\|ms\|@0\.01[0]*$` s := New(prefix, log.NewNopLogger()) timing := s.NewTiming(name, 0.01).With(label, value) quantiles := teststat.Quantiles(s, regex, 50) if err := teststat.TestHistogram(timing, quantiles, 0.02); err != nil { t.Fatal(err) } } golang-github-go-kit-kit-0.6.0/metrics/teststat/000077500000000000000000000000001316471211400215425ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/metrics/teststat/buffers.go000066400000000000000000000035641316471211400235350ustar00rootroot00000000000000package teststat import ( "bufio" "bytes" "io" "regexp" "strconv" "github.com/go-kit/kit/metrics/generic" ) // SumLines expects a regex whose first capture group can be parsed as a // float64. It will dump the WriterTo and parse each line, expecting to find a // match. It returns the sum of all captured floats. func SumLines(w io.WriterTo, regex string) func() float64 { return func() float64 { sum, _ := stats(w, regex, nil) return sum } } // LastLine expects a regex whose first capture group can be parsed as a // float64. It will dump the WriterTo and parse each line, expecting to find a // match. It returns the final captured float. func LastLine(w io.WriterTo, regex string) func() float64 { return func() float64 { _, final := stats(w, regex, nil) return final } } // Quantiles expects a regex whose first capture group can be parsed as a // float64. It will dump the WriterTo and parse each line, expecting to find a // match. It observes all captured floats into a generic.Histogram with the // given number of buckets, and returns the 50th, 90th, 95th, and 99th quantiles // from that histogram. func Quantiles(w io.WriterTo, regex string, buckets int) func() (float64, float64, float64, float64) { return func() (float64, float64, float64, float64) { h := generic.NewHistogram("quantile-test", buckets) stats(w, regex, h) return h.Quantile(0.50), h.Quantile(0.90), h.Quantile(0.95), h.Quantile(0.99) } } func stats(w io.WriterTo, regex string, h *generic.Histogram) (sum, final float64) { re := regexp.MustCompile(regex) buf := &bytes.Buffer{} w.WriteTo(buf) //fmt.Fprintf(os.Stderr, "%s\n", buf.String()) s := bufio.NewScanner(buf) for s.Scan() { match := re.FindStringSubmatch(s.Text()) f, err := strconv.ParseFloat(match[1], 64) if err != nil { panic(err) } sum += f final = f if h != nil { h.Observe(f) } } return sum, final } golang-github-go-kit-kit-0.6.0/metrics/teststat/populate.go000066400000000000000000000041451316471211400237260ustar00rootroot00000000000000package teststat import ( "math" "math/rand" "github.com/go-kit/kit/metrics" ) // PopulateNormalHistogram makes a series of normal random observations into the // histogram. The number of observations is determined by Count. The randomness // is determined by Mean, Stdev, and the seed parameter. // // This is a low-level function, exported only for metrics that don't perform // dynamic quantile computation, like a Prometheus Histogram (c.f. Summary). In // most cases, you don't need to use this function, and can use TestHistogram // instead. func PopulateNormalHistogram(h metrics.Histogram, seed int) { r := rand.New(rand.NewSource(int64(seed))) for i := 0; i < Count; i++ { sample := r.NormFloat64()*float64(Stdev) + float64(Mean) if sample < 0 { sample = 0 } h.Observe(sample) } } func normalQuantiles() (p50, p90, p95, p99 float64) { return nvq(50), nvq(90), nvq(95), nvq(99) } func nvq(quantile int) float64 { // https://en.wikipedia.org/wiki/Normal_distribution#Quantile_function return float64(Mean) + float64(Stdev)*math.Sqrt2*erfinv(2*(float64(quantile)/100)-1) } func erfinv(y float64) float64 { // https://stackoverflow.com/questions/5971830/need-code-for-inverse-error-function if y < -1.0 || y > 1.0 { panic("invalid input") } var ( a = [4]float64{0.886226899, -1.645349621, 0.914624893, -0.140543331} b = [4]float64{-2.118377725, 1.442710462, -0.329097515, 0.012229801} c = [4]float64{-1.970840454, -1.624906493, 3.429567803, 1.641345311} d = [2]float64{3.543889200, 1.637067800} ) const y0 = 0.7 var x, z float64 if math.Abs(y) == 1.0 { x = -y * math.Log(0.0) } else if y < -y0 { z = math.Sqrt(-math.Log((1.0 + y) / 2.0)) x = -(((c[3]*z+c[2])*z+c[1])*z + c[0]) / ((d[1]*z+d[0])*z + 1.0) } else { if y < y0 { z = y * y x = y * (((a[3]*z+a[2])*z+a[1])*z + a[0]) / ((((b[3]*z+b[3])*z+b[1])*z+b[0])*z + 1.0) } else { z = math.Sqrt(-math.Log((1.0 - y) / 2.0)) x = (((c[3]*z+c[2])*z+c[1])*z + c[0]) / ((d[1]*z+d[0])*z + 1.0) } x = x - (math.Erf(x)-y)/(2.0/math.SqrtPi*math.Exp(-x*x)) x = x - (math.Erf(x)-y)/(2.0/math.SqrtPi*math.Exp(-x*x)) } return x } golang-github-go-kit-kit-0.6.0/metrics/teststat/teststat.go000066400000000000000000000063141316471211400237500ustar00rootroot00000000000000// Package teststat provides helpers for testing metrics backends. package teststat import ( "errors" "fmt" "math" "math/rand" "strings" "github.com/go-kit/kit/metrics" ) // TestCounter puts some deltas through the counter, and then calls the value // func to check that the counter has the correct final value. func TestCounter(counter metrics.Counter, value func() float64) error { want := FillCounter(counter) if have := value(); want != have { return fmt.Errorf("want %f, have %f", want, have) } return nil } // FillCounter puts some deltas through the counter and returns the total value. func FillCounter(counter metrics.Counter) float64 { a := rand.Perm(100) n := rand.Intn(len(a)) var want float64 for i := 0; i < n; i++ { f := float64(a[i]) counter.Add(f) want += f } return want } // TestGauge puts some values through the gauge, and then calls the value func // to check that the gauge has the correct final value. func TestGauge(gauge metrics.Gauge, value func() float64) error { a := rand.Perm(100) n := rand.Intn(len(a)) var want float64 for i := 0; i < n; i++ { f := float64(a[i]) gauge.Set(f) want = f } for i := 0; i < n; i++ { f := float64(a[i]) gauge.Add(f) want += f } if have := value(); want != have { return fmt.Errorf("want %f, have %f", want, have) } return nil } // TestHistogram puts some observations through the histogram, and then calls // the quantiles func to checks that the histogram has computed the correct // quantiles within some tolerance func TestHistogram(histogram metrics.Histogram, quantiles func() (p50, p90, p95, p99 float64), tolerance float64) error { PopulateNormalHistogram(histogram, rand.Int()) want50, want90, want95, want99 := normalQuantiles() have50, have90, have95, have99 := quantiles() var errs []string if want, have := want50, have50; !cmp(want, have, tolerance) { errs = append(errs, fmt.Sprintf("p50: want %f, have %f", want, have)) } if want, have := want90, have90; !cmp(want, have, tolerance) { errs = append(errs, fmt.Sprintf("p90: want %f, have %f", want, have)) } if want, have := want95, have95; !cmp(want, have, tolerance) { errs = append(errs, fmt.Sprintf("p95: want %f, have %f", want, have)) } if want, have := want99, have99; !cmp(want, have, tolerance) { errs = append(errs, fmt.Sprintf("p99: want %f, have %f", want, have)) } if len(errs) > 0 { return errors.New(strings.Join(errs, "; ")) } return nil } var ( // Count is the number of observations. Count = 12345 // Mean is the center of the normal distribution of observations. Mean = 500 // Stdev of the normal distribution of observations. Stdev = 25 ) // ExpectedObservationsLessThan returns the number of observations that should // have a value less than or equal to the given value, given a normal // distribution of observations described by Count, Mean, and Stdev. func ExpectedObservationsLessThan(bucket int64) int64 { // https://code.google.com/p/gostat/source/browse/stat/normal.go cdf := ((1.0 / 2.0) * (1 + math.Erf((float64(bucket)-float64(Mean))/(float64(Stdev)*math.Sqrt2)))) return int64(cdf * float64(Count)) } func cmp(want, have, tol float64) bool { if (math.Abs(want-have) / want) > tol { return false } return true } golang-github-go-kit-kit-0.6.0/metrics/timer.go000066400000000000000000000015001316471211400213320ustar00rootroot00000000000000package metrics import "time" // Timer acts as a stopwatch, sending observations to a wrapped histogram. // It's a bit of helpful syntax sugar for h.Observe(time.Since(x)). type Timer struct { h Histogram t time.Time u time.Duration } // NewTimer wraps the given histogram and records the current time. func NewTimer(h Histogram) *Timer { return &Timer{ h: h, t: time.Now(), u: time.Second, } } // ObserveDuration captures the number of seconds since the timer was // constructed, and forwards that observation to the histogram. func (t *Timer) ObserveDuration() { d := float64(time.Since(t.t).Nanoseconds()) / float64(t.u) if d < 0 { d = 0 } t.h.Observe(d) } // Unit sets the unit of the float64 emitted by the timer. // By default, the timer emits seconds. func (t *Timer) Unit(u time.Duration) { t.u = u } golang-github-go-kit-kit-0.6.0/metrics/timer_test.go000066400000000000000000000025631316471211400224030ustar00rootroot00000000000000package metrics_test import ( "math" "testing" "time" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/generic" ) func TestTimerFast(t *testing.T) { h := generic.NewSimpleHistogram() metrics.NewTimer(h).ObserveDuration() tolerance := 0.050 if want, have := 0.000, h.ApproximateMovingAverage(); math.Abs(want-have) > tolerance { t.Errorf("want %.3f, have %.3f", want, have) } } func TestTimerSlow(t *testing.T) { h := generic.NewSimpleHistogram() timer := metrics.NewTimer(h) time.Sleep(250 * time.Millisecond) timer.ObserveDuration() tolerance := 0.050 if want, have := 0.250, h.ApproximateMovingAverage(); math.Abs(want-have) > tolerance { t.Errorf("want %.3f, have %.3f", want, have) } } func TestTimerUnit(t *testing.T) { for _, tc := range []struct { name string unit time.Duration tolerance float64 want float64 }{ {"Seconds", time.Second, 0.010, 0.100}, {"Milliseconds", time.Millisecond, 10, 100}, {"Nanoseconds", time.Nanosecond, 10000000, 100000000}, } { t.Run(tc.name, func(t *testing.T) { h := generic.NewSimpleHistogram() timer := metrics.NewTimer(h) time.Sleep(100 * time.Millisecond) timer.Unit(tc.unit) timer.ObserveDuration() if want, have := tc.want, h.ApproximateMovingAverage(); math.Abs(want-have) > tc.tolerance { t.Errorf("want %.3f, have %.3f", want, have) } }) } } golang-github-go-kit-kit-0.6.0/ratelimit/000077500000000000000000000000001316471211400202135ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/ratelimit/token_bucket.go000066400000000000000000000067601316471211400232300ustar00rootroot00000000000000package ratelimit import ( "context" "errors" "time" "github.com/juju/ratelimit" "github.com/go-kit/kit/endpoint" ) // ErrLimited is returned in the request path when the rate limiter is // triggered and the request is rejected. var ErrLimited = errors.New("rate limit exceeded") // NewTokenBucketLimiter returns an endpoint.Middleware that acts as a rate // limiter based on a token-bucket algorithm. Requests that would exceed the // maximum request rate are simply rejected with an error. func NewTokenBucketLimiter(tb *ratelimit.Bucket) endpoint.Middleware { return NewErroringLimiter(NewAllower(tb)) } // NewTokenBucketThrottler returns an endpoint.Middleware that acts as a // request throttler based on a token-bucket algorithm. Requests that would // exceed the maximum request rate are delayed. // The parameterized function "_" is kept for backwards-compatiblity of // the API, but it is no longer used for anything. You may pass it nil. func NewTokenBucketThrottler(tb *ratelimit.Bucket, _ func(time.Duration)) endpoint.Middleware { return NewDelayingLimiter(NewWaiter(tb)) } // Allower dictates whether or not a request is acceptable to run. // The Limiter from "golang.org/x/time/rate" already implements this interface, // one is able to use that in NewErroringLimiter without any modifications. type Allower interface { Allow() bool } // NewErroringLimiter returns an endpoint.Middleware that acts as a rate // limiter. Requests that would exceed the // maximum request rate are simply rejected with an error. func NewErroringLimiter(limit Allower) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { if !limit.Allow() { return nil, ErrLimited } return next(ctx, request) } } } // Waiter dictates how long a request must be delayed. // The Limiter from "golang.org/x/time/rate" already implements this interface, // one is able to use that in NewDelayingLimiter without any modifications. type Waiter interface { Wait(ctx context.Context) error } // NewDelayingLimiter returns an endpoint.Middleware that acts as a // request throttler. Requests that would // exceed the maximum request rate are delayed via the Waiter function func NewDelayingLimiter(limit Waiter) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { if err := limit.Wait(ctx); err != nil { return nil, err } return next(ctx, request) } } } // AllowerFunc is an adapter that lets a function operate as if // it implements Allower type AllowerFunc func() bool // Allow makes the adapter implement Allower func (f AllowerFunc) Allow() bool { return f() } // NewAllower turns an existing ratelimit.Bucket into an API-compatible form func NewAllower(tb *ratelimit.Bucket) Allower { return AllowerFunc(func() bool { return (tb.TakeAvailable(1) != 0) }) } // WaiterFunc is an adapter that lets a function operate as if // it implements Waiter type WaiterFunc func(ctx context.Context) error // Wait makes the adapter implement Waiter func (f WaiterFunc) Wait(ctx context.Context) error { return f(ctx) } // NewWaiter turns an existing ratelimit.Bucket into an API-compatible form func NewWaiter(tb *ratelimit.Bucket) Waiter { return WaiterFunc(func(ctx context.Context) error { dur := tb.Take(1) select { case <-ctx.Done(): return ctx.Err() case <-time.After(dur): // happy path } return nil }) } golang-github-go-kit-kit-0.6.0/ratelimit/token_bucket_test.go000066400000000000000000000031331316471211400242560ustar00rootroot00000000000000package ratelimit_test import ( "context" "strings" "testing" "time" jujuratelimit "github.com/juju/ratelimit" "golang.org/x/time/rate" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/ratelimit" ) var nopEndpoint = func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil } func TestTokenBucketLimiter(t *testing.T) { tb := jujuratelimit.NewBucket(time.Minute, 1) testSuccessThenFailure( t, ratelimit.NewTokenBucketLimiter(tb)(nopEndpoint), ratelimit.ErrLimited.Error()) } func TestTokenBucketThrottler(t *testing.T) { tb := jujuratelimit.NewBucket(time.Minute, 1) testSuccessThenFailure( t, ratelimit.NewTokenBucketThrottler(tb, nil)(nopEndpoint), "context deadline exceeded") } func TestXRateErroring(t *testing.T) { limit := rate.NewLimiter(rate.Every(time.Minute), 1) testSuccessThenFailure( t, ratelimit.NewErroringLimiter(limit)(nopEndpoint), ratelimit.ErrLimited.Error()) } func TestXRateDelaying(t *testing.T) { limit := rate.NewLimiter(rate.Every(time.Minute), 1) testSuccessThenFailure( t, ratelimit.NewDelayingLimiter(limit)(nopEndpoint), "exceed context deadline") } func testSuccessThenFailure(t *testing.T, e endpoint.Endpoint, failContains string) { ctx, cxl := context.WithTimeout(context.Background(), 500*time.Millisecond) defer cxl() // First request should succeed. if _, err := e(ctx, struct{}{}); err != nil { t.Errorf("unexpected: %v\n", err) } // Next request should fail. if _, err := e(ctx, struct{}{}); !strings.Contains(err.Error(), failContains) { t.Errorf("expected `%s`: %v\n", failContains, err) } } golang-github-go-kit-kit-0.6.0/sd/000077500000000000000000000000001316471211400166275ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/sd/benchmark_test.go000066400000000000000000000011341316471211400221460ustar00rootroot00000000000000package sd import ( "io" "testing" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" ) func BenchmarkEndpoints(b *testing.B) { var ( ca = make(closer) cb = make(closer) cmap = map[string]io.Closer{"a": ca, "b": cb} factory = func(instance string) (endpoint.Endpoint, io.Closer, error) { return endpoint.Nop, cmap[instance], nil } c = newEndpointCache(factory, log.NewNopLogger(), endpointerOptions{}) ) b.ReportAllocs() c.Update(Event{Instances: []string{"a", "b"}}) b.RunParallel(func(pb *testing.PB) { for pb.Next() { c.Endpoints() } }) } golang-github-go-kit-kit-0.6.0/sd/consul/000077500000000000000000000000001316471211400201325ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/sd/consul/client.go000066400000000000000000000022231316471211400217360ustar00rootroot00000000000000package consul import ( consul "github.com/hashicorp/consul/api" ) // Client is a wrapper around the Consul API. type Client interface { // Register a service with the local agent. Register(r *consul.AgentServiceRegistration) error // Deregister a service with the local agent. Deregister(r *consul.AgentServiceRegistration) error // Service Service(service, tag string, passingOnly bool, queryOpts *consul.QueryOptions) ([]*consul.ServiceEntry, *consul.QueryMeta, error) } type client struct { consul *consul.Client } // NewClient returns an implementation of the Client interface, wrapping a // concrete Consul client. func NewClient(c *consul.Client) Client { return &client{consul: c} } func (c *client) Register(r *consul.AgentServiceRegistration) error { return c.consul.Agent().ServiceRegister(r) } func (c *client) Deregister(r *consul.AgentServiceRegistration) error { return c.consul.Agent().ServiceDeregister(r.ID) } func (c *client) Service(service, tag string, passingOnly bool, queryOpts *consul.QueryOptions) ([]*consul.ServiceEntry, *consul.QueryMeta, error) { return c.consul.Health().Service(service, tag, passingOnly, queryOpts) } golang-github-go-kit-kit-0.6.0/sd/consul/client_test.go000066400000000000000000000065451316471211400230100ustar00rootroot00000000000000package consul import ( "context" "errors" "io" "reflect" "testing" stdconsul "github.com/hashicorp/consul/api" "github.com/go-kit/kit/endpoint" ) func TestClientRegistration(t *testing.T) { c := newTestClient(nil) services, _, err := c.Service(testRegistration.Name, "", true, &stdconsul.QueryOptions{}) if err != nil { t.Error(err) } if want, have := 0, len(services); want != have { t.Errorf("want %d, have %d", want, have) } if err := c.Register(testRegistration); err != nil { t.Error(err) } if err := c.Register(testRegistration); err == nil { t.Errorf("want error, have %v", err) } services, _, err = c.Service(testRegistration.Name, "", true, &stdconsul.QueryOptions{}) if err != nil { t.Error(err) } if want, have := 1, len(services); want != have { t.Errorf("want %d, have %d", want, have) } if err := c.Deregister(testRegistration); err != nil { t.Error(err) } if err := c.Deregister(testRegistration); err == nil { t.Errorf("want error, have %v", err) } services, _, err = c.Service(testRegistration.Name, "", true, &stdconsul.QueryOptions{}) if err != nil { t.Error(err) } if want, have := 0, len(services); want != have { t.Errorf("want %d, have %d", want, have) } } type testClient struct { entries []*stdconsul.ServiceEntry } func newTestClient(entries []*stdconsul.ServiceEntry) *testClient { return &testClient{ entries: entries, } } var _ Client = &testClient{} func (c *testClient) Service(service, tag string, _ bool, opts *stdconsul.QueryOptions) ([]*stdconsul.ServiceEntry, *stdconsul.QueryMeta, error) { var results []*stdconsul.ServiceEntry for _, entry := range c.entries { if entry.Service.Service != service { continue } if tag != "" { tagMap := map[string]struct{}{} for _, t := range entry.Service.Tags { tagMap[t] = struct{}{} } if _, ok := tagMap[tag]; !ok { continue } } results = append(results, entry) } return results, &stdconsul.QueryMeta{}, nil } func (c *testClient) Register(r *stdconsul.AgentServiceRegistration) error { toAdd := registration2entry(r) for _, entry := range c.entries { if reflect.DeepEqual(*entry, *toAdd) { return errors.New("duplicate") } } c.entries = append(c.entries, toAdd) return nil } func (c *testClient) Deregister(r *stdconsul.AgentServiceRegistration) error { toDelete := registration2entry(r) var newEntries []*stdconsul.ServiceEntry for _, entry := range c.entries { if reflect.DeepEqual(*entry, *toDelete) { continue } newEntries = append(newEntries, entry) } if len(newEntries) == len(c.entries) { return errors.New("not found") } c.entries = newEntries return nil } func registration2entry(r *stdconsul.AgentServiceRegistration) *stdconsul.ServiceEntry { return &stdconsul.ServiceEntry{ Node: &stdconsul.Node{ Node: "some-node", Address: r.Address, }, Service: &stdconsul.AgentService{ ID: r.ID, Service: r.Name, Tags: r.Tags, Port: r.Port, Address: r.Address, }, // Checks ignored } } func testFactory(instance string) (endpoint.Endpoint, io.Closer, error) { return func(context.Context, interface{}) (interface{}, error) { return instance, nil }, nil, nil } var testRegistration = &stdconsul.AgentServiceRegistration{ ID: "my-id", Name: "my-name", Tags: []string{"my-tag-1", "my-tag-2"}, Port: 12345, Address: "my-address", } golang-github-go-kit-kit-0.6.0/sd/consul/doc.go000066400000000000000000000001361316471211400212260ustar00rootroot00000000000000// Package consul provides Instancer and Registrar implementations for Consul. package consul golang-github-go-kit-kit-0.6.0/sd/consul/instancer.go000066400000000000000000000074211316471211400224530ustar00rootroot00000000000000package consul import ( "fmt" "io" consul "github.com/hashicorp/consul/api" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" "github.com/go-kit/kit/sd/internal/instance" ) const defaultIndex = 0 // Instancer yields instances for a service in Consul. type Instancer struct { cache *instance.Cache client Client logger log.Logger service string tags []string passingOnly bool quitc chan struct{} } // NewInstancer returns a Consul instancer that publishes instances for the // requested service. It only returns instances for which all of the passed tags // are present. func NewInstancer(client Client, logger log.Logger, service string, tags []string, passingOnly bool) *Instancer { s := &Instancer{ cache: instance.NewCache(), client: client, logger: log.With(logger, "service", service, "tags", fmt.Sprint(tags)), service: service, tags: tags, passingOnly: passingOnly, quitc: make(chan struct{}), } instances, index, err := s.getInstances(defaultIndex, nil) if err == nil { s.logger.Log("instances", len(instances)) } else { s.logger.Log("err", err) } s.cache.Update(sd.Event{Instances: instances, Err: err}) go s.loop(index) return s } // Stop terminates the instancer. func (s *Instancer) Stop() { close(s.quitc) } func (s *Instancer) loop(lastIndex uint64) { var ( instances []string err error ) for { instances, lastIndex, err = s.getInstances(lastIndex, s.quitc) switch { case err == io.EOF: return // stopped via quitc case err != nil: s.logger.Log("err", err) s.cache.Update(sd.Event{Err: err}) default: s.cache.Update(sd.Event{Instances: instances}) } } } func (s *Instancer) getInstances(lastIndex uint64, interruptc chan struct{}) ([]string, uint64, error) { tag := "" if len(s.tags) > 0 { tag = s.tags[0] } // Consul doesn't support more than one tag in its service query method. // https://github.com/hashicorp/consul/issues/294 // Hashi suggest prepared queries, but they don't support blocking. // https://www.consul.io/docs/agent/http/query.html#execute // If we want blocking for efficiency, we must filter tags manually. type response struct { instances []string index uint64 } var ( errc = make(chan error, 1) resc = make(chan response, 1) ) go func() { entries, meta, err := s.client.Service(s.service, tag, s.passingOnly, &consul.QueryOptions{ WaitIndex: lastIndex, }) if err != nil { errc <- err return } if len(s.tags) > 1 { entries = filterEntries(entries, s.tags[1:]...) } resc <- response{ instances: makeInstances(entries), index: meta.LastIndex, } }() select { case err := <-errc: return nil, 0, err case res := <-resc: return res.instances, res.index, nil case <-interruptc: return nil, 0, io.EOF } } // Register implements Instancer. func (s *Instancer) Register(ch chan<- sd.Event) { s.cache.Register(ch) } // Deregister implements Instancer. func (s *Instancer) Deregister(ch chan<- sd.Event) { s.cache.Deregister(ch) } func filterEntries(entries []*consul.ServiceEntry, tags ...string) []*consul.ServiceEntry { var es []*consul.ServiceEntry ENTRIES: for _, entry := range entries { ts := make(map[string]struct{}, len(entry.Service.Tags)) for _, tag := range entry.Service.Tags { ts[tag] = struct{}{} } for _, tag := range tags { if _, ok := ts[tag]; !ok { continue ENTRIES } } es = append(es, entry) } return es } func makeInstances(entries []*consul.ServiceEntry) []string { instances := make([]string, len(entries)) for i, entry := range entries { addr := entry.Node.Address if entry.Service.Address != "" { addr = entry.Service.Address } instances[i] = fmt.Sprintf("%s:%d", addr, entry.Service.Port) } return instances } golang-github-go-kit-kit-0.6.0/sd/consul/instancer_test.go000066400000000000000000000051151316471211400235100ustar00rootroot00000000000000package consul import ( "context" "testing" consul "github.com/hashicorp/consul/api" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" ) var _ sd.Instancer = (*Instancer)(nil) // API check var consulState = []*consul.ServiceEntry{ { Node: &consul.Node{ Address: "10.0.0.0", Node: "app00.local", }, Service: &consul.AgentService{ ID: "search-api-0", Port: 8000, Service: "search", Tags: []string{ "api", "v1", }, }, }, { Node: &consul.Node{ Address: "10.0.0.1", Node: "app01.local", }, Service: &consul.AgentService{ ID: "search-api-1", Port: 8001, Service: "search", Tags: []string{ "api", "v2", }, }, }, { Node: &consul.Node{ Address: "10.0.0.1", Node: "app01.local", }, Service: &consul.AgentService{ Address: "10.0.0.10", ID: "search-db-0", Port: 9000, Service: "search", Tags: []string{ "db", }, }, }, } func TestInstancer(t *testing.T) { var ( logger = log.NewNopLogger() client = newTestClient(consulState) ) s := NewInstancer(client, logger, "search", []string{"api"}, true) defer s.Stop() state := s.cache.State() if want, have := 2, len(state.Instances); want != have { t.Errorf("want %d, have %d", want, have) } } func TestInstancerNoService(t *testing.T) { var ( logger = log.NewNopLogger() client = newTestClient(consulState) ) s := NewInstancer(client, logger, "feed", []string{}, true) defer s.Stop() state := s.cache.State() if want, have := 0, len(state.Instances); want != have { t.Fatalf("want %d, have %d", want, have) } } func TestInstancerWithTags(t *testing.T) { var ( logger = log.NewNopLogger() client = newTestClient(consulState) ) s := NewInstancer(client, logger, "search", []string{"api", "v2"}, true) defer s.Stop() state := s.cache.State() if want, have := 1, len(state.Instances); want != have { t.Fatalf("want %d, have %d", want, have) } } func TestInstancerAddressOverride(t *testing.T) { s := NewInstancer(newTestClient(consulState), log.NewNopLogger(), "search", []string{"db"}, true) defer s.Stop() state := s.cache.State() if want, have := 1, len(state.Instances); want != have { t.Fatalf("want %d, have %d", want, have) } endpoint, closer, err := testFactory(state.Instances[0]) if err != nil { t.Fatal(err) } if closer != nil { defer closer.Close() } response, err := endpoint(context.Background(), struct{}{}) if err != nil { t.Fatal(err) } if want, have := "10.0.0.10:9000", response.(string); want != have { t.Errorf("want %q, have %q", want, have) } } golang-github-go-kit-kit-0.6.0/sd/consul/integration_test.go000066400000000000000000000036561316471211400240550ustar00rootroot00000000000000// +build integration package consul import ( "io" "os" "testing" "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" stdconsul "github.com/hashicorp/consul/api" ) func TestIntegration(t *testing.T) { consulAddr := os.Getenv("CONSUL_ADDR") if consulAddr == "" { t.Fatal("CONSUL_ADDR is not set") } stdClient, err := stdconsul.NewClient(&stdconsul.Config{ Address: consulAddr, }) if err != nil { t.Fatal(err) } client := NewClient(stdClient) logger := log.NewLogfmtLogger(os.Stderr) // Produce a fake service registration. r := &stdconsul.AgentServiceRegistration{ ID: "my-service-ID", Name: "my-service-name", Tags: []string{"alpha", "beta"}, Port: 12345, Address: "my-address", EnableTagOverride: false, // skipping check(s) } // Build an Instancer on r.Name + r.Tags. factory := func(instance string) (endpoint.Endpoint, io.Closer, error) { t.Logf("factory invoked for %q", instance) return endpoint.Nop, nil, nil } instancer := NewInstancer( client, log.With(logger, "component", "instancer"), r.Name, r.Tags, true, ) endpointer := sd.NewEndpointer( instancer, factory, log.With(logger, "component", "endpointer"), ) time.Sleep(time.Second) // Before we publish, we should have no endpoints. endpoints, err := endpointer.Endpoints() if err != nil { t.Error(err) } if want, have := 0, len(endpoints); want != have { t.Errorf("want %d, have %d", want, have) } // Build a registrar for r. registrar := NewRegistrar(client, r, log.With(logger, "component", "registrar")) registrar.Register() defer registrar.Deregister() time.Sleep(time.Second) // Now we should have one active endpoints. endpoints, err = endpointer.Endpoints() if err != nil { t.Error(err) } if want, have := 1, len(endpoints); want != have { t.Errorf("want %d, have %d", want, have) } } golang-github-go-kit-kit-0.6.0/sd/consul/registrar.go000066400000000000000000000021361316471211400224650ustar00rootroot00000000000000package consul import ( "fmt" stdconsul "github.com/hashicorp/consul/api" "github.com/go-kit/kit/log" ) // Registrar registers service instance liveness information to Consul. type Registrar struct { client Client registration *stdconsul.AgentServiceRegistration logger log.Logger } // NewRegistrar returns a Consul Registrar acting on the provided catalog // registration. func NewRegistrar(client Client, r *stdconsul.AgentServiceRegistration, logger log.Logger) *Registrar { return &Registrar{ client: client, registration: r, logger: log.With(logger, "service", r.Name, "tags", fmt.Sprint(r.Tags), "address", r.Address), } } // Register implements sd.Registrar interface. func (p *Registrar) Register() { if err := p.client.Register(p.registration); err != nil { p.logger.Log("err", err) } else { p.logger.Log("action", "register") } } // Deregister implements sd.Registrar interface. func (p *Registrar) Deregister() { if err := p.client.Deregister(p.registration); err != nil { p.logger.Log("err", err) } else { p.logger.Log("action", "deregister") } } golang-github-go-kit-kit-0.6.0/sd/consul/registrar_test.go000066400000000000000000000011441316471211400235220ustar00rootroot00000000000000package consul import ( "testing" stdconsul "github.com/hashicorp/consul/api" "github.com/go-kit/kit/log" ) func TestRegistrar(t *testing.T) { client := newTestClient([]*stdconsul.ServiceEntry{}) p := NewRegistrar(client, testRegistration, log.NewNopLogger()) if want, have := 0, len(client.entries); want != have { t.Errorf("want %d, have %d", want, have) } p.Register() if want, have := 1, len(client.entries); want != have { t.Errorf("want %d, have %d", want, have) } p.Deregister() if want, have := 0, len(client.entries); want != have { t.Errorf("want %d, have %d", want, have) } } golang-github-go-kit-kit-0.6.0/sd/dnssrv/000077500000000000000000000000001316471211400201465ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/sd/dnssrv/doc.go000066400000000000000000000001331316471211400212370ustar00rootroot00000000000000// Package dnssrv provides an Instancer implementation for DNS SRV records. package dnssrv golang-github-go-kit-kit-0.6.0/sd/dnssrv/instancer.go000066400000000000000000000044331316471211400224670ustar00rootroot00000000000000package dnssrv import ( "fmt" "net" "time" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" "github.com/go-kit/kit/sd/internal/instance" ) // Instancer yields instances from the named DNS SRV record. The name is // resolved on a fixed schedule. Priorities and weights are ignored. type Instancer struct { cache *instance.Cache name string logger log.Logger quit chan struct{} } // NewInstancer returns a DNS SRV instancer. func NewInstancer( name string, ttl time.Duration, logger log.Logger, ) *Instancer { return NewInstancerDetailed(name, time.NewTicker(ttl), net.LookupSRV, logger) } // NewInstancerDetailed is the same as NewInstancer, but allows users to // provide an explicit lookup refresh ticker instead of a TTL, and specify the // lookup function instead of using net.LookupSRV. func NewInstancerDetailed( name string, refresh *time.Ticker, lookup Lookup, logger log.Logger, ) *Instancer { p := &Instancer{ cache: instance.NewCache(), name: name, logger: logger, quit: make(chan struct{}), } instances, err := p.resolve(lookup) if err == nil { logger.Log("name", name, "instances", len(instances)) } else { logger.Log("name", name, "err", err) } p.cache.Update(sd.Event{Instances: instances, Err: err}) go p.loop(refresh, lookup) return p } // Stop terminates the Instancer. func (p *Instancer) Stop() { close(p.quit) } func (p *Instancer) loop(t *time.Ticker, lookup Lookup) { defer t.Stop() for { select { case <-t.C: instances, err := p.resolve(lookup) if err != nil { p.logger.Log("name", p.name, "err", err) p.cache.Update(sd.Event{Err: err}) continue // don't replace potentially-good with bad } p.cache.Update(sd.Event{Instances: instances}) case <-p.quit: return } } } func (p *Instancer) resolve(lookup Lookup) ([]string, error) { _, addrs, err := lookup("", "", p.name) if err != nil { return nil, err } instances := make([]string, len(addrs)) for i, addr := range addrs { instances[i] = net.JoinHostPort(addr.Target, fmt.Sprint(addr.Port)) } return instances, nil } // Register implements Instancer. func (s *Instancer) Register(ch chan<- sd.Event) { s.cache.Register(ch) } // Deregister implements Instancer. func (s *Instancer) Deregister(ch chan<- sd.Event) { s.cache.Deregister(ch) } golang-github-go-kit-kit-0.6.0/sd/dnssrv/instancer_test.go000066400000000000000000000034411316471211400235240ustar00rootroot00000000000000package dnssrv import ( "net" "sync/atomic" "testing" "time" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" ) var _ sd.Instancer = (*Instancer)(nil) // API check func TestRefresh(t *testing.T) { name := "some.service.internal" ticker := time.NewTicker(time.Second) ticker.Stop() tickc := make(chan time.Time) ticker.C = tickc var lookups uint64 records := []*net.SRV{} lookup := func(service, proto, name string) (string, []*net.SRV, error) { t.Logf("lookup(%q, %q, %q)", service, proto, name) atomic.AddUint64(&lookups, 1) return "cname", records, nil } instancer := NewInstancerDetailed(name, ticker, lookup, log.NewNopLogger()) defer instancer.Stop() // First lookup, empty state := instancer.cache.State() if state.Err != nil { t.Error(state.Err) } if want, have := 0, len(state.Instances); want != have { t.Errorf("want %d, have %d", want, have) } if want, have := uint64(1), atomic.LoadUint64(&lookups); want != have { t.Errorf("want %d, have %d", want, have) } // Load some records and lookup again records = []*net.SRV{ {Target: "1.0.0.1", Port: 1001}, {Target: "1.0.0.2", Port: 1002}, {Target: "1.0.0.3", Port: 1003}, } tickc <- time.Now() // There is a race condition where the instancer.State call below // invokes the cache before it is updated by the tick above. // TODO(pb): solve by running the read through the loop goroutine. time.Sleep(100 * time.Millisecond) state = instancer.cache.State() if state.Err != nil { t.Error(state.Err) } if want, have := 3, len(state.Instances); want != have { t.Errorf("want %d, have %d", want, have) } if want, have := uint64(2), atomic.LoadUint64(&lookups); want != have { t.Errorf("want %d, have %d", want, have) } } type nopCloser struct{} func (nopCloser) Close() error { return nil } golang-github-go-kit-kit-0.6.0/sd/dnssrv/lookup.go000066400000000000000000000003651316471211400220120ustar00rootroot00000000000000package dnssrv import "net" // Lookup is a function that resolves a DNS SRV record to multiple addresses. // It has the same signature as net.LookupSRV. type Lookup func(service, proto, name string) (cname string, addrs []*net.SRV, err error) golang-github-go-kit-kit-0.6.0/sd/doc.go000066400000000000000000000006131316471211400177230ustar00rootroot00000000000000// Package sd provides utilities related to service discovery. That includes the // client-side loadbalancer pattern, where a microservice subscribes to a // service discovery system in order to reach remote instances; as well as the // registrator pattern, where a microservice registers itself in a service // discovery system. Implementations are provided for most common systems. package sd golang-github-go-kit-kit-0.6.0/sd/endpoint_cache.go000066400000000000000000000075101316471211400221240ustar00rootroot00000000000000package sd import ( "io" "sort" "sync" "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" ) // endpointCache collects the most recent set of instances from a service discovery // system, creates endpoints for them using a factory function, and makes // them available to consumers. type endpointCache struct { options endpointerOptions mtx sync.RWMutex factory Factory cache map[string]endpointCloser err error endpoints []endpoint.Endpoint logger log.Logger invalidateDeadline time.Time timeNow func() time.Time } type endpointCloser struct { endpoint.Endpoint io.Closer } // newEndpointCache returns a new, empty endpointCache. func newEndpointCache(factory Factory, logger log.Logger, options endpointerOptions) *endpointCache { return &endpointCache{ options: options, factory: factory, cache: map[string]endpointCloser{}, logger: logger, timeNow: time.Now, } } // Update should be invoked by clients with a complete set of current instance // strings whenever that set changes. The cache manufactures new endpoints via // the factory, closes old endpoints when they disappear, and persists existing // endpoints if they survive through an update. func (c *endpointCache) Update(event Event) { c.mtx.Lock() defer c.mtx.Unlock() // Happy path. if event.Err == nil { c.updateCache(event.Instances) c.err = nil return } // Sad path. Something's gone wrong in sd. c.logger.Log("err", event.Err) if !c.options.invalidateOnError { return // keep returning the last known endpoints on error } if c.err != nil { return // already in the error state, do nothing & keep original error } c.err = event.Err // set new deadline to invalidate Endpoints unless non-error Event is received c.invalidateDeadline = c.timeNow().Add(c.options.invalidateTimeout) return } func (c *endpointCache) updateCache(instances []string) { // Deterministic order (for later). sort.Strings(instances) // Produce the current set of services. cache := make(map[string]endpointCloser, len(instances)) for _, instance := range instances { // If it already exists, just copy it over. if sc, ok := c.cache[instance]; ok { cache[instance] = sc delete(c.cache, instance) continue } // If it doesn't exist, create it. service, closer, err := c.factory(instance) if err != nil { c.logger.Log("instance", instance, "err", err) continue } cache[instance] = endpointCloser{service, closer} } // Close any leftover endpoints. for _, sc := range c.cache { if sc.Closer != nil { sc.Closer.Close() } } // Populate the slice of endpoints. endpoints := make([]endpoint.Endpoint, 0, len(cache)) for _, instance := range instances { // A bad factory may mean an instance is not present. if _, ok := cache[instance]; !ok { continue } endpoints = append(endpoints, cache[instance].Endpoint) } // Swap and trigger GC for old copies. c.endpoints = endpoints c.cache = cache } // Endpoints yields the current set of (presumably identical) endpoints, ordered // lexicographically by the corresponding instance string. func (c *endpointCache) Endpoints() ([]endpoint.Endpoint, error) { // in the steady state we're going to have many goroutines calling Endpoints() // concurrently, so to minimize contention we use a shared R-lock. c.mtx.RLock() if c.err == nil || c.timeNow().Before(c.invalidateDeadline) { defer c.mtx.RUnlock() return c.endpoints, nil } c.mtx.RUnlock() // in case of an error, switch to an exclusive lock. c.mtx.Lock() defer c.mtx.Unlock() // re-check condition due to a race between RUnlock() and Lock(). if c.err == nil || c.timeNow().Before(c.invalidateDeadline) { return c.endpoints, nil } c.updateCache(nil) // close any remaining active endpoints return nil, c.err } golang-github-go-kit-kit-0.6.0/sd/endpoint_cache_test.go000066400000000000000000000111651316471211400231640ustar00rootroot00000000000000package sd import ( "errors" "io" "testing" "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" ) func TestEndpointCache(t *testing.T) { var ( ca = make(closer) cb = make(closer) c = map[string]io.Closer{"a": ca, "b": cb} f = func(instance string) (endpoint.Endpoint, io.Closer, error) { return endpoint.Nop, c[instance], nil } cache = newEndpointCache(f, log.NewNopLogger(), endpointerOptions{}) ) // Populate cache.Update(Event{Instances: []string{"a", "b"}}) select { case <-ca: t.Errorf("endpoint a closed, not good") case <-cb: t.Errorf("endpoint b closed, not good") case <-time.After(time.Millisecond): t.Logf("no closures yet, good") } assertEndpointsLen(t, cache, 2) // Duplicate, should be no-op cache.Update(Event{Instances: []string{"a", "b"}}) select { case <-ca: t.Errorf("endpoint a closed, not good") case <-cb: t.Errorf("endpoint b closed, not good") case <-time.After(time.Millisecond): t.Logf("no closures yet, good") } assertEndpointsLen(t, cache, 2) // Error, should continue returning old endpoints cache.Update(Event{Err: errors.New("sd error")}) select { case <-ca: t.Errorf("endpoint a closed, not good") case <-cb: t.Errorf("endpoint b closed, not good") case <-time.After(time.Millisecond): t.Logf("no closures yet, good") } assertEndpointsLen(t, cache, 2) // Delete b go cache.Update(Event{Instances: []string{"a"}}) select { case <-ca: t.Errorf("endpoint a closed, not good") case <-cb: t.Logf("endpoint b closed, good") case <-time.After(time.Second): t.Errorf("didn't close the deleted instance in time") } assertEndpointsLen(t, cache, 1) // Delete a go cache.Update(Event{Instances: []string{}}) select { // case <-cb: will succeed, as it's closed case <-ca: t.Logf("endpoint a closed, good") case <-time.After(time.Second): t.Errorf("didn't close the deleted instance in time") } assertEndpointsLen(t, cache, 0) } func TestEndpointCacheErrorAndTimeout(t *testing.T) { var ( ca = make(closer) cb = make(closer) c = map[string]io.Closer{"a": ca, "b": cb} f = func(instance string) (endpoint.Endpoint, io.Closer, error) { return endpoint.Nop, c[instance], nil } timeOut = 100 * time.Millisecond cache = newEndpointCache(f, log.NewNopLogger(), endpointerOptions{ invalidateOnError: true, invalidateTimeout: timeOut, }) ) timeNow := time.Now() cache.timeNow = func() time.Time { return timeNow } // Populate cache.Update(Event{Instances: []string{"a"}}) select { case <-ca: t.Errorf("endpoint a closed, not good") case <-time.After(time.Millisecond): t.Logf("no closures yet, good") } assertEndpointsLen(t, cache, 1) // Send error, keep time still. cache.Update(Event{Err: errors.New("sd error")}) select { case <-ca: t.Errorf("endpoint a closed, not good") case <-time.After(time.Millisecond): t.Logf("no closures yet, good") } assertEndpointsLen(t, cache, 1) // Move the time, but less than the timeout timeNow = timeNow.Add(timeOut / 2) assertEndpointsLen(t, cache, 1) select { case <-ca: t.Errorf("endpoint a closed, not good") case <-time.After(time.Millisecond): t.Logf("no closures yet, good") } // Move the time past the timeout timeNow = timeNow.Add(timeOut) assertEndpointsError(t, cache, "sd error") select { case <-ca: t.Logf("endpoint a closed, good") case <-time.After(time.Millisecond): t.Errorf("didn't close the deleted instance in time") } // Send another error cache.Update(Event{Err: errors.New("another sd error")}) assertEndpointsError(t, cache, "sd error") // expect original error } func TestBadFactory(t *testing.T) { cache := newEndpointCache(func(string) (endpoint.Endpoint, io.Closer, error) { return nil, nil, errors.New("bad factory") }, log.NewNopLogger(), endpointerOptions{}) cache.Update(Event{Instances: []string{"foo:1234", "bar:5678"}}) assertEndpointsLen(t, cache, 0) } func assertEndpointsLen(t *testing.T, cache *endpointCache, l int) { endpoints, err := cache.Endpoints() if err != nil { t.Errorf("unexpected error %v", err) return } if want, have := l, len(endpoints); want != have { t.Errorf("want %d, have %d", want, have) } } func assertEndpointsError(t *testing.T, cache *endpointCache, wantErr string) { endpoints, err := cache.Endpoints() if err == nil { t.Errorf("expecting error, not good") return } if want, have := wantErr, err.Error(); want != have { t.Errorf("want %s, have %s", want, have) return } if want, have := 0, len(endpoints); want != have { t.Errorf("want %d, have %d", want, have) } } type closer chan struct{} func (c closer) Close() error { close(c); return nil } golang-github-go-kit-kit-0.6.0/sd/endpointer.go000066400000000000000000000056511316471211400213340ustar00rootroot00000000000000package sd import ( "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" ) // Endpointer listens to a service discovery system and yields a set of // identical endpoints on demand. An error indicates a problem with connectivity // to the service discovery system, or within the system itself; an Endpointer // may yield no endpoints without error. type Endpointer interface { Endpoints() ([]endpoint.Endpoint, error) } // FixedEndpointer yields a fixed set of endpoints. type FixedEndpointer []endpoint.Endpoint // Endpoints implements Endpointer. func (s FixedEndpointer) Endpoints() ([]endpoint.Endpoint, error) { return s, nil } // NewEndpointer creates an Endpointer that subscribes to updates from Instancer src // and uses factory f to create Endpoints. If src notifies of an error, the Endpointer // keeps returning previously created Endpoints assuming they are still good, unless // this behavior is disabled via InvalidateOnError option. func NewEndpointer(src Instancer, f Factory, logger log.Logger, options ...EndpointerOption) *DefaultEndpointer { opts := endpointerOptions{} for _, opt := range options { opt(&opts) } se := &DefaultEndpointer{ cache: newEndpointCache(f, logger, opts), instancer: src, ch: make(chan Event), } go se.receive() src.Register(se.ch) return se } // EndpointerOption allows control of endpointCache behavior. type EndpointerOption func(*endpointerOptions) // InvalidateOnError returns EndpointerOption that controls how the Endpointer // behaves when then Instancer publishes an Event containing an error. // Without this option the Endpointer continues returning the last known // endpoints. With this option, the Endpointer continues returning the last // known endpoints until the timeout elapses, then closes all active endpoints // and starts returning an error. Once the Instancer sends a new update with // valid resource instances, the normal operation is resumed. func InvalidateOnError(timeout time.Duration) EndpointerOption { return func(opts *endpointerOptions) { opts.invalidateOnError = true opts.invalidateTimeout = timeout } } type endpointerOptions struct { invalidateOnError bool invalidateTimeout time.Duration } // DefaultEndpointer implements an Endpointer interface. // When created with NewEndpointer function, it automatically registers // as a subscriber to events from the Instances and maintains a list // of active Endpoints. type DefaultEndpointer struct { cache *endpointCache instancer Instancer ch chan Event } func (de *DefaultEndpointer) receive() { for event := range de.ch { de.cache.Update(event) } } // Close deregisters DefaultEndpointer from the Instancer and stops the internal go-routine. func (de *DefaultEndpointer) Close() { de.instancer.Deregister(de.ch) close(de.ch) } // Endpoints implements Endpointer. func (de *DefaultEndpointer) Endpoints() ([]endpoint.Endpoint, error) { return de.cache.Endpoints() } golang-github-go-kit-kit-0.6.0/sd/endpointer_test.go000066400000000000000000000041451316471211400223700ustar00rootroot00000000000000package sd_test import ( "io" "testing" "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" "github.com/go-kit/kit/sd/internal/instance" ) func TestDefaultEndpointer(t *testing.T) { var ( ca = make(closer) cb = make(closer) c = map[string]io.Closer{"a": ca, "b": cb} f = func(instance string) (endpoint.Endpoint, io.Closer, error) { return endpoint.Nop, c[instance], nil } instancer = &mockInstancer{instance.NewCache()} ) // set initial state instancer.Update(sd.Event{Instances: []string{"a", "b"}}) endpointer := sd.NewEndpointer(instancer, f, log.NewNopLogger(), sd.InvalidateOnError(time.Minute)) var ( endpoints []endpoint.Endpoint err error ) if !within(time.Second, func() bool { endpoints, err = endpointer.Endpoints() return err == nil && len(endpoints) == 2 }) { t.Errorf("wanted 2 endpoints, got %d (%v)", len(endpoints), err) } instancer.Update(sd.Event{Instances: []string{}}) select { case <-ca: t.Logf("endpoint a closed, good") case <-time.After(time.Millisecond): t.Errorf("didn't close the deleted instance in time") } select { case <-cb: t.Logf("endpoint b closed, good") case <-time.After(time.Millisecond): t.Errorf("didn't close the deleted instance in time") } if endpoints, err := endpointer.Endpoints(); err != nil { t.Errorf("unepected error %v", err) } else if want, have := 0, len(endpoints); want != have { t.Errorf("want %d, have %d", want, have) } endpointer.Close() instancer.Update(sd.Event{Instances: []string{"a"}}) // TODO verify that on Close the endpointer fully disconnects from the instancer. // Unfortunately, because we use instance.Cache, this test cannot be in the sd package, // and therefore does not have access to the endpointer's private members. } type mockInstancer struct{ *instance.Cache } type closer chan struct{} func (c closer) Close() error { close(c); return nil } func within(d time.Duration, f func() bool) bool { deadline := time.Now().Add(d) for time.Now().Before(deadline) { if f() { return true } time.Sleep(d / 10) } return false } golang-github-go-kit-kit-0.6.0/sd/etcd/000077500000000000000000000000001316471211400175465ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/sd/etcd/client.go000066400000000000000000000115641316471211400213620ustar00rootroot00000000000000package etcd import ( "context" "crypto/tls" "crypto/x509" "errors" "io/ioutil" "net" "net/http" "time" etcd "github.com/coreos/etcd/client" ) var ( // ErrNoKey indicates a client method needs a key but receives none. ErrNoKey = errors.New("no key provided") // ErrNoValue indicates a client method needs a value but receives none. ErrNoValue = errors.New("no value provided") ) // Client is a wrapper around the etcd client. type Client interface { // GetEntries queries the given prefix in etcd and returns a slice // containing the values of all keys found, recursively, underneath that // prefix. GetEntries(prefix string) ([]string, error) // WatchPrefix watches the given prefix in etcd for changes. When a change // is detected, it will signal on the passed channel. Clients are expected // to call GetEntries to update themselves with the latest set of complete // values. WatchPrefix will always send an initial sentinel value on the // channel after establishing the watch, to ensure that clients always // receive the latest set of values. WatchPrefix will block until the // context passed to the NewClient constructor is terminated. WatchPrefix(prefix string, ch chan struct{}) // Register a service with etcd. Register(s Service) error // Deregister a service with etcd. Deregister(s Service) error } type client struct { keysAPI etcd.KeysAPI ctx context.Context } // ClientOptions defines options for the etcd client. All values are optional. // If any duration is not specified, a default of 3 seconds will be used. type ClientOptions struct { Cert string Key string CACert string DialTimeout time.Duration DialKeepAlive time.Duration HeaderTimeoutPerRequest time.Duration } // NewClient returns Client with a connection to the named machines. It will // return an error if a connection to the cluster cannot be made. The parameter // machines needs to be a full URL with schemas. e.g. "http://localhost:2379" // will work, but "localhost:2379" will not. func NewClient(ctx context.Context, machines []string, options ClientOptions) (Client, error) { if options.DialTimeout == 0 { options.DialTimeout = 3 * time.Second } if options.DialKeepAlive == 0 { options.DialKeepAlive = 3 * time.Second } if options.HeaderTimeoutPerRequest == 0 { options.HeaderTimeoutPerRequest = 3 * time.Second } transport := etcd.DefaultTransport if options.Cert != "" && options.Key != "" { tlsCert, err := tls.LoadX509KeyPair(options.Cert, options.Key) if err != nil { return nil, err } caCertCt, err := ioutil.ReadFile(options.CACert) if err != nil { return nil, err } caCertPool := x509.NewCertPool() caCertPool.AppendCertsFromPEM(caCertCt) transport = &http.Transport{ TLSClientConfig: &tls.Config{ Certificates: []tls.Certificate{tlsCert}, RootCAs: caCertPool, }, Dial: func(network, address string) (net.Conn, error) { return (&net.Dialer{ Timeout: options.DialTimeout, KeepAlive: options.DialKeepAlive, }).Dial(network, address) }, } } ce, err := etcd.New(etcd.Config{ Endpoints: machines, Transport: transport, HeaderTimeoutPerRequest: options.HeaderTimeoutPerRequest, }) if err != nil { return nil, err } return &client{ keysAPI: etcd.NewKeysAPI(ce), ctx: ctx, }, nil } // GetEntries implements the etcd Client interface. func (c *client) GetEntries(key string) ([]string, error) { resp, err := c.keysAPI.Get(c.ctx, key, &etcd.GetOptions{Recursive: true}) if err != nil { return nil, err } // Special case. Note that it's possible that len(resp.Node.Nodes) == 0 and // resp.Node.Value is also empty, in which case the key is empty and we // should not return any entries. if len(resp.Node.Nodes) == 0 && resp.Node.Value != "" { return []string{resp.Node.Value}, nil } entries := make([]string, len(resp.Node.Nodes)) for i, node := range resp.Node.Nodes { entries[i] = node.Value } return entries, nil } // WatchPrefix implements the etcd Client interface. func (c *client) WatchPrefix(prefix string, ch chan struct{}) { watch := c.keysAPI.Watcher(prefix, &etcd.WatcherOptions{AfterIndex: 0, Recursive: true}) ch <- struct{}{} // make sure caller invokes GetEntries for { if _, err := watch.Next(c.ctx); err != nil { return } ch <- struct{}{} } } func (c *client) Register(s Service) error { if s.Key == "" { return ErrNoKey } if s.Value == "" { return ErrNoValue } var err error if s.TTL != nil { _, err = c.keysAPI.Set(c.ctx, s.Key, s.Value, &etcd.SetOptions{ PrevExist: etcd.PrevIgnore, TTL: s.TTL.ttl, }) } else { _, err = c.keysAPI.Create(c.ctx, s.Key, s.Value) } return err } func (c *client) Deregister(s Service) error { if s.Key == "" { return ErrNoKey } _, err := c.keysAPI.Delete(c.ctx, s.Key, s.DeleteOptions) return err } golang-github-go-kit-kit-0.6.0/sd/etcd/client_test.go000066400000000000000000000203621316471211400224150ustar00rootroot00000000000000package etcd import ( "errors" "reflect" "testing" "time" "golang.org/x/net/context" etcd "github.com/coreos/etcd/client" ) func TestNewClient(t *testing.T) { client, err := NewClient( context.Background(), []string{"http://irrelevant:12345"}, ClientOptions{ DialTimeout: 2 * time.Second, DialKeepAlive: 2 * time.Second, HeaderTimeoutPerRequest: 2 * time.Second, }, ) if err != nil { t.Fatalf("unexpected error creating client: %v", err) } if client == nil { t.Fatal("expected new Client, got nil") } } // NewClient should fail when providing invalid or missing endpoints. func TestOptions(t *testing.T) { a, err := NewClient( context.Background(), []string{}, ClientOptions{ Cert: "", Key: "", CACert: "", DialTimeout: 2 * time.Second, DialKeepAlive: 2 * time.Second, HeaderTimeoutPerRequest: 2 * time.Second, }, ) if err == nil { t.Errorf("expected error: %v", err) } if a != nil { t.Fatalf("expected client to be nil on failure") } _, err = NewClient( context.Background(), []string{"http://irrelevant:12345"}, ClientOptions{ Cert: "blank.crt", Key: "blank.key", CACert: "blank.CACert", DialTimeout: 2 * time.Second, DialKeepAlive: 2 * time.Second, HeaderTimeoutPerRequest: 2 * time.Second, }, ) if err == nil { t.Errorf("expected error: %v", err) } } // Mocks of the underlying etcd.KeysAPI interface that is called by the methods we want to test // fakeKeysAPI implements etcd.KeysAPI, event and err are channels used to emulate // an etcd event or error, getres will be returned when etcd.KeysAPI.Get is called. type fakeKeysAPI struct { event chan bool err chan bool getres *getResult } type getResult struct { resp *etcd.Response err error } // Get return the content of getres or nil, nil func (fka *fakeKeysAPI) Get(ctx context.Context, key string, opts *etcd.GetOptions) (*etcd.Response, error) { if fka.getres == nil { return nil, nil } return fka.getres.resp, fka.getres.err } // Set is not used in the tests func (fka *fakeKeysAPI) Set(ctx context.Context, key, value string, opts *etcd.SetOptions) (*etcd.Response, error) { return nil, nil } // Delete is not used in the tests func (fka *fakeKeysAPI) Delete(ctx context.Context, key string, opts *etcd.DeleteOptions) (*etcd.Response, error) { return nil, nil } // Create is not used in the tests func (fka *fakeKeysAPI) Create(ctx context.Context, key, value string) (*etcd.Response, error) { return nil, nil } // CreateInOrder is not used in the tests func (fka *fakeKeysAPI) CreateInOrder(ctx context.Context, dir, value string, opts *etcd.CreateInOrderOptions) (*etcd.Response, error) { return nil, nil } // Update is not used in the tests func (fka *fakeKeysAPI) Update(ctx context.Context, key, value string) (*etcd.Response, error) { return nil, nil } // Watcher return a fakeWatcher that will forward event and error received on the channels func (fka *fakeKeysAPI) Watcher(key string, opts *etcd.WatcherOptions) etcd.Watcher { return &fakeWatcher{fka.event, fka.err} } // fakeWatcher implements etcd.Watcher type fakeWatcher struct { event chan bool err chan bool } // Next blocks until an etcd event or error is emulated. // When an event occurs it just return nil response and error. // When an error occur it return a non nil error. func (fw *fakeWatcher) Next(context.Context) (*etcd.Response, error) { for { select { case <-fw.event: return nil, nil case <-fw.err: return nil, errors.New("error from underlying etcd watcher") default: } } } // newFakeClient return a new etcd.Client built on top of the mocked interfaces func newFakeClient(event, err chan bool, getres *getResult) Client { return &client{ keysAPI: &fakeKeysAPI{event, err, getres}, ctx: context.Background(), } } // Register should fail when the provided service has an empty key or value func TestRegisterClient(t *testing.T) { client := newFakeClient(nil, nil, nil) err := client.Register(Service{Key: "", Value: "value", DeleteOptions: nil}) if want, have := ErrNoKey, err; want != have { t.Fatalf("want %v, have %v", want, have) } err = client.Register(Service{Key: "key", Value: "", DeleteOptions: nil}) if want, have := ErrNoValue, err; want != have { t.Fatalf("want %v, have %v", want, have) } err = client.Register(Service{Key: "key", Value: "value", DeleteOptions: nil}) if err != nil { t.Fatal(err) } } // Deregister should fail if the input service has an empty key func TestDeregisterClient(t *testing.T) { client := newFakeClient(nil, nil, nil) err := client.Deregister(Service{Key: "", Value: "value", DeleteOptions: nil}) if want, have := ErrNoKey, err; want != have { t.Fatalf("want %v, have %v", want, have) } err = client.Deregister(Service{Key: "key", Value: "", DeleteOptions: nil}) if err != nil { t.Fatal(err) } } // WatchPrefix notify the caller by writing on the channel if an etcd event occurs // or return in case of an underlying error func TestWatchPrefix(t *testing.T) { err := make(chan bool) event := make(chan bool) watchPrefixReturned := make(chan bool, 1) client := newFakeClient(event, err, nil) ch := make(chan struct{}) go func() { client.WatchPrefix("prefix", ch) // block until an etcd event or error occurs watchPrefixReturned <- true }() // WatchPrefix force the caller to read once from the channel before actually // sending notification, emulate that first read. <-ch // Emulate an etcd event event <- true if want, have := struct{}{}, <-ch; want != have { t.Fatalf("want %v, have %v", want, have) } // Emulate an error, WatchPrefix should return err <- true select { case <-watchPrefixReturned: break case <-time.After(1 * time.Second): t.Fatal("WatchPrefix not returning on errors") } } var errKeyAPI = errors.New("emulate error returned by KeysAPI.Get") // table of test cases for method GetEntries var getEntriesTestTable = []struct { input getResult // value returned by the underlying etcd.KeysAPI.Get resp []string // response expected in output of GetEntries err error //error expected in output of GetEntries }{ // test case: an error is returned by etcd.KeysAPI.Get {getResult{nil, errKeyAPI}, nil, errKeyAPI}, // test case: return a single leaf node, with an empty value {getResult{&etcd.Response{ Action: "get", Node: &etcd.Node{ Key: "nodekey", Dir: false, Value: "", Nodes: nil, CreatedIndex: 0, ModifiedIndex: 0, Expiration: nil, TTL: 0, }, PrevNode: nil, Index: 0, }, nil}, []string{}, nil}, // test case: return a single leaf node, with a value {getResult{&etcd.Response{ Action: "get", Node: &etcd.Node{ Key: "nodekey", Dir: false, Value: "nodevalue", Nodes: nil, CreatedIndex: 0, ModifiedIndex: 0, Expiration: nil, TTL: 0, }, PrevNode: nil, Index: 0, }, nil}, []string{"nodevalue"}, nil}, // test case: return a node with two childs {getResult{&etcd.Response{ Action: "get", Node: &etcd.Node{ Key: "nodekey", Dir: true, Value: "nodevalue", Nodes: []*etcd.Node{ { Key: "childnode1", Dir: false, Value: "childvalue1", Nodes: nil, CreatedIndex: 0, ModifiedIndex: 0, Expiration: nil, TTL: 0, }, { Key: "childnode2", Dir: false, Value: "childvalue2", Nodes: nil, CreatedIndex: 0, ModifiedIndex: 0, Expiration: nil, TTL: 0, }, }, CreatedIndex: 0, ModifiedIndex: 0, Expiration: nil, TTL: 0, }, PrevNode: nil, Index: 0, }, nil}, []string{"childvalue1", "childvalue2"}, nil}, } func TestGetEntries(t *testing.T) { for _, et := range getEntriesTestTable { client := newFakeClient(nil, nil, &et.input) resp, err := client.GetEntries("prefix") if want, have := et.resp, resp; !reflect.DeepEqual(want, have) { t.Fatalf("want %v, have %v", want, have) } if want, have := et.err, err; want != have { t.Fatalf("want %v, have %v", want, have) } } } golang-github-go-kit-kit-0.6.0/sd/etcd/doc.go000066400000000000000000000003611316471211400206420ustar00rootroot00000000000000// Package etcd provides an Instancer and Registrar implementation for etcd. If // you use etcd as your service discovery system, this package will help you // implement the registration and client-side load balancing patterns. package etcd golang-github-go-kit-kit-0.6.0/sd/etcd/example_test.go000066400000000000000000000041721316471211400225730ustar00rootroot00000000000000package etcd import ( "context" "io" "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" "github.com/go-kit/kit/sd/lb" ) func Example() { // Let's say this is a service that means to register itself. // First, we will set up some context. var ( etcdServer = "http://10.0.0.1:2379" // don't forget schema and port! prefix = "/services/foosvc/" // known at compile time instance = "1.2.3.4:8080" // taken from runtime or platform, somehow key = prefix + instance // should be globally unique value = "http://" + instance // based on our transport ctx = context.Background() ) // Build the client. client, err := NewClient(ctx, []string{etcdServer}, ClientOptions{}) if err != nil { panic(err) } // Build the registrar. registrar := NewRegistrar(client, Service{ Key: key, Value: value, }, log.NewNopLogger()) // Register our instance. registrar.Register() // At the end of our service lifecycle, for example at the end of func main, // we should make sure to deregister ourselves. This is important! Don't // accidentally skip this step by invoking a log.Fatal or os.Exit in the // interim, which bypasses the defer stack. defer registrar.Deregister() // It's likely that we'll also want to connect to other services and call // their methods. We can build an Instancer to listen for changes from etcd, // create Endpointer, wrap it with a load-balancer to pick a single // endpoint, and finally wrap it with a retry strategy to get something that // can be used as an endpoint directly. barPrefix := "/services/barsvc" logger := log.NewNopLogger() instancer, err := NewInstancer(client, barPrefix, logger) if err != nil { panic(err) } endpointer := sd.NewEndpointer(instancer, barFactory, logger) balancer := lb.NewRoundRobin(endpointer) retry := lb.Retry(3, 3*time.Second, balancer) // And now retry can be used like any other endpoint. req := struct{}{} if _, err = retry(ctx, req); err != nil { panic(err) } } func barFactory(string) (endpoint.Endpoint, io.Closer, error) { return endpoint.Nop, nil, nil } golang-github-go-kit-kit-0.6.0/sd/etcd/instancer.go000066400000000000000000000033211316471211400220620ustar00rootroot00000000000000package etcd import ( "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" "github.com/go-kit/kit/sd/internal/instance" ) // Instancer yields instances stored in a certain etcd keyspace. Any kind of // change in that keyspace is watched and will update the Instancer's Instancers. type Instancer struct { cache *instance.Cache client Client prefix string logger log.Logger quitc chan struct{} } // NewInstancer returns an etcd instancer. It will start watching the given // prefix for changes, and update the subscribers. func NewInstancer(c Client, prefix string, logger log.Logger) (*Instancer, error) { s := &Instancer{ client: c, prefix: prefix, cache: instance.NewCache(), logger: logger, quitc: make(chan struct{}), } instances, err := s.client.GetEntries(s.prefix) if err == nil { logger.Log("prefix", s.prefix, "instances", len(instances)) } else { logger.Log("prefix", s.prefix, "err", err) } s.cache.Update(sd.Event{Instances: instances, Err: err}) go s.loop() return s, nil } func (s *Instancer) loop() { ch := make(chan struct{}) go s.client.WatchPrefix(s.prefix, ch) for { select { case <-ch: instances, err := s.client.GetEntries(s.prefix) if err != nil { s.logger.Log("msg", "failed to retrieve entries", "err", err) s.cache.Update(sd.Event{Err: err}) continue } s.cache.Update(sd.Event{Instances: instances}) case <-s.quitc: return } } } // Stop terminates the Instancer. func (s *Instancer) Stop() { close(s.quitc) } // Register implements Instancer. func (s *Instancer) Register(ch chan<- sd.Event) { s.cache.Register(ch) } // Deregister implements Instancer. func (s *Instancer) Deregister(ch chan<- sd.Event) { s.cache.Deregister(ch) } golang-github-go-kit-kit-0.6.0/sd/etcd/instancer_test.go000066400000000000000000000024711316471211400231260ustar00rootroot00000000000000package etcd import ( "errors" "testing" stdetcd "github.com/coreos/etcd/client" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" ) var _ sd.Instancer = (*Instancer)(nil) // API check var ( node = &stdetcd.Node{ Key: "/foo", Nodes: []*stdetcd.Node{ {Key: "/foo/1", Value: "1:1"}, {Key: "/foo/2", Value: "1:2"}, }, } fakeResponse = &stdetcd.Response{ Node: node, } ) var _ sd.Instancer = &Instancer{} // API check func TestInstancer(t *testing.T) { client := &fakeClient{ responses: map[string]*stdetcd.Response{"/foo": fakeResponse}, } s, err := NewInstancer(client, "/foo", log.NewNopLogger()) if err != nil { t.Fatal(err) } defer s.Stop() if state := s.cache.State(); state.Err != nil { t.Fatal(state.Err) } } type fakeClient struct { responses map[string]*stdetcd.Response } func (c *fakeClient) GetEntries(prefix string) ([]string, error) { response, ok := c.responses[prefix] if !ok { return nil, errors.New("key not exist") } entries := make([]string, len(response.Node.Nodes)) for i, node := range response.Node.Nodes { entries[i] = node.Value } return entries, nil } func (c *fakeClient) WatchPrefix(prefix string, ch chan struct{}) {} func (c *fakeClient) Register(Service) error { return nil } func (c *fakeClient) Deregister(Service) error { return nil } golang-github-go-kit-kit-0.6.0/sd/etcd/integration_test.go000066400000000000000000000063701316471211400234650ustar00rootroot00000000000000// +build integration package etcd import ( "context" "io" "os" "testing" "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" ) // Package sd/etcd provides a wrapper around the etcd key/value store. This // example assumes the user has an instance of etcd installed and running // locally on port 2379. func TestIntegration(t *testing.T) { addr := os.Getenv("ETCD_ADDR") if addr == "" { t.Skip("ETCD_ADDR not set; skipping integration test") } var ( prefix = "/services/foosvc/" // known at compile time instance = "1.2.3.4:8080" // taken from runtime or platform, somehow key = prefix + instance value = "http://" + instance // based on our transport ) client, err := NewClient(context.Background(), []string{addr}, ClientOptions{ DialTimeout: 2 * time.Second, DialKeepAlive: 2 * time.Second, HeaderTimeoutPerRequest: 2 * time.Second, }) if err != nil { t.Fatalf("NewClient(%q): %v", addr, err) } // Verify test data is initially empty. entries, err := client.GetEntries(key) if err == nil { t.Fatalf("GetEntries(%q): expected error, got none", key) } t.Logf("GetEntries(%q): %v (OK)", key, err) // Instantiate a new Registrar, passing in test data. registrar := NewRegistrar(client, Service{ Key: key, Value: value, }, log.With(log.NewLogfmtLogger(os.Stderr), "component", "registrar")) // Register our instance. registrar.Register() t.Logf("Registered") // Retrieve entries from etcd manually. entries, err = client.GetEntries(key) if err != nil { t.Fatalf("client.GetEntries(%q): %v", key, err) } if want, have := 1, len(entries); want != have { t.Fatalf("client.GetEntries(%q): want %d, have %d", key, want, have) } if want, have := value, entries[0]; want != have { t.Fatalf("want %q, have %q", want, have) } instancer, err := NewInstancer( client, prefix, log.With(log.NewLogfmtLogger(os.Stderr), "component", "instancer"), ) if err != nil { t.Fatalf("NewInstancer: %v", err) } endpointer := sd.NewEndpointer( instancer, func(string) (endpoint.Endpoint, io.Closer, error) { return endpoint.Nop, nil, nil }, log.With(log.NewLogfmtLogger(os.Stderr), "component", "instancer"), ) t.Logf("Constructed Endpointer OK") if !within(time.Second, func() bool { endpoints, err := endpointer.Endpoints() return err == nil && len(endpoints) == 1 }) { t.Fatalf("Endpointer didn't see Register in time") } t.Logf("Endpointer saw Register OK") // Deregister first instance of test data. registrar.Deregister() t.Logf("Deregistered") // Check it was deregistered. if !within(time.Second, func() bool { endpoints, err := endpointer.Endpoints() t.Logf("Checking Deregister: len(endpoints) = %d, err = %v", len(endpoints), err) return err == nil && len(endpoints) == 0 }) { t.Fatalf("Endpointer didn't see Deregister in time") } // Verify test data no longer exists in etcd. _, err = client.GetEntries(key) if err == nil { t.Fatalf("GetEntries(%q): expected error, got none", key) } t.Logf("GetEntries(%q): %v (OK)", key, err) } func within(d time.Duration, f func() bool) bool { deadline := time.Now().Add(d) for time.Now().Before(deadline) { if f() { return true } time.Sleep(d / 10) } return false } golang-github-go-kit-kit-0.6.0/sd/etcd/registrar.go000066400000000000000000000060661316471211400221070ustar00rootroot00000000000000package etcd import ( "sync" "time" etcd "github.com/coreos/etcd/client" "github.com/go-kit/kit/log" ) const minHeartBeatTime = 500 * time.Millisecond // Registrar registers service instance liveness information to etcd. type Registrar struct { client Client service Service logger log.Logger quitmtx sync.Mutex quit chan struct{} } // Service holds the instance identifying data you want to publish to etcd. Key // must be unique, and value is the string returned to subscribers, typically // called the "instance" string in other parts of package sd. type Service struct { Key string // unique key, e.g. "/service/foobar/1.2.3.4:8080" Value string // returned to subscribers, e.g. "http://1.2.3.4:8080" TTL *TTLOption DeleteOptions *etcd.DeleteOptions } // TTLOption allow setting a key with a TTL. This option will be used by a loop // goroutine which regularly refreshes the lease of the key. type TTLOption struct { heartbeat time.Duration // e.g. time.Second * 3 ttl time.Duration // e.g. time.Second * 10 } // NewTTLOption returns a TTLOption that contains proper TTL settings. Heartbeat // is used to refresh the lease of the key periodically; its value should be at // least 500ms. TTL defines the lease of the key; its value should be // significantly greater than heartbeat. // // Good default values might be 3s heartbeat, 10s TTL. func NewTTLOption(heartbeat, ttl time.Duration) *TTLOption { if heartbeat <= minHeartBeatTime { heartbeat = minHeartBeatTime } if ttl <= heartbeat { ttl = 3 * heartbeat } return &TTLOption{ heartbeat: heartbeat, ttl: ttl, } } // NewRegistrar returns a etcd Registrar acting on the provided catalog // registration (service). func NewRegistrar(client Client, service Service, logger log.Logger) *Registrar { return &Registrar{ client: client, service: service, logger: log.With(logger, "key", service.Key, "value", service.Value), } } // Register implements the sd.Registrar interface. Call it when you want your // service to be registered in etcd, typically at startup. func (r *Registrar) Register() { if err := r.client.Register(r.service); err != nil { r.logger.Log("err", err) } else { r.logger.Log("action", "register") } if r.service.TTL != nil { go r.loop() } } func (r *Registrar) loop() { r.quitmtx.Lock() if r.quit != nil { return // already running } r.quit = make(chan struct{}) r.quitmtx.Unlock() tick := time.NewTicker(r.service.TTL.heartbeat) defer tick.Stop() for { select { case <-tick.C: if err := r.client.Register(r.service); err != nil { r.logger.Log("err", err) } case <-r.quit: return } } } // Deregister implements the sd.Registrar interface. Call it when you want your // service to be deregistered from etcd, typically just prior to shutdown. func (r *Registrar) Deregister() { if err := r.client.Deregister(r.service); err != nil { r.logger.Log("err", err) } else { r.logger.Log("action", "deregister") } r.quitmtx.Lock() defer r.quitmtx.Unlock() if r.quit != nil { close(r.quit) r.quit = nil } } golang-github-go-kit-kit-0.6.0/sd/etcd/registrar_test.go000066400000000000000000000056151316471211400231450ustar00rootroot00000000000000package etcd import ( "bytes" "errors" "testing" "github.com/go-kit/kit/log" ) // testClient is a basic implementation of Client type testClient struct { registerRes error // value returned when Register or Deregister is called } func (tc *testClient) GetEntries(prefix string) ([]string, error) { return nil, nil } func (tc *testClient) WatchPrefix(prefix string, ch chan struct{}) { return } func (tc *testClient) Register(s Service) error { return tc.registerRes } func (tc *testClient) Deregister(s Service) error { return tc.registerRes } // default service used to build registrar in our tests var testService = Service{"testKey", "testValue", nil, nil} // NewRegistar should return a registar with a logger using the service key and value func TestNewRegistar(t *testing.T) { c := Client(&testClient{nil}) buf := &bytes.Buffer{} logger := log.NewLogfmtLogger(buf) r := NewRegistrar( c, testService, logger, ) if err := r.logger.Log("msg", "message"); err != nil { t.Fatal(err) } if want, have := "key=testKey value=testValue msg=message\n", buf.String(); want != have { t.Errorf("\nwant: %shave: %s", want, have) } } // Register log the error returned by the client or log the successful registration action // table of test cases for method Register var registerTestTable = []struct { registerRes error // value returned by the client on calls to Register log string // expected log by the registrar }{ // test case: an error is returned by the client {errors.New("regError"), "key=testKey value=testValue err=regError\n"}, // test case: registration successful {nil, "key=testKey value=testValue action=register\n"}, } func TestRegister(t *testing.T) { for _, tc := range registerTestTable { c := Client(&testClient{tc.registerRes}) buf := &bytes.Buffer{} logger := log.NewLogfmtLogger(buf) r := NewRegistrar( c, testService, logger, ) r.Register() if want, have := tc.log, buf.String(); want != have { t.Fatalf("want %v, have %v", want, have) } } } // Deregister log the error returned by the client or log the successful deregistration action // table of test cases for method Deregister var deregisterTestTable = []struct { deregisterRes error // value returned by the client on calls to Deregister log string // expected log by the registrar }{ // test case: an error is returned by the client {errors.New("deregError"), "key=testKey value=testValue err=deregError\n"}, // test case: deregistration successful {nil, "key=testKey value=testValue action=deregister\n"}, } func TestDeregister(t *testing.T) { for _, tc := range deregisterTestTable { c := Client(&testClient{tc.deregisterRes}) buf := &bytes.Buffer{} logger := log.NewLogfmtLogger(buf) r := NewRegistrar( c, testService, logger, ) r.Deregister() if want, have := tc.log, buf.String(); want != have { t.Fatalf("want %v, have %v", want, have) } } } golang-github-go-kit-kit-0.6.0/sd/eureka/000077500000000000000000000000001316471211400201035ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/sd/eureka/doc.go000066400000000000000000000001531316471211400211760ustar00rootroot00000000000000// Package eureka provides Instancer and Registrar implementations for Netflix OSS's Eureka package eureka golang-github-go-kit-kit-0.6.0/sd/eureka/instancer.go000066400000000000000000000046321316471211400224250ustar00rootroot00000000000000package eureka import ( "fmt" "github.com/hudl/fargo" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" "github.com/go-kit/kit/sd/internal/instance" ) // Instancer yields instances stored in the Eureka registry for the given app. // Changes in that app are watched and will update the subscribers. type Instancer struct { cache *instance.Cache conn fargoConnection app string logger log.Logger quitc chan chan struct{} } // NewInstancer returns a Eureka Instancer. It will start watching the given // app string for changes, and update the subscribers accordingly. func NewInstancer(conn fargoConnection, app string, logger log.Logger) *Instancer { logger = log.With(logger, "app", app) s := &Instancer{ cache: instance.NewCache(), conn: conn, app: app, logger: logger, quitc: make(chan chan struct{}), } done := make(chan struct{}) updates := conn.ScheduleAppUpdates(app, true, done) s.consume(<-updates) go s.loop(updates, done) return s } // Stop terminates the Instancer. func (s *Instancer) Stop() { q := make(chan struct{}) s.quitc <- q <-q s.quitc = nil } func (s *Instancer) consume(update fargo.AppUpdate) { if update.Err != nil { s.logger.Log("during", "Update", "err", update.Err) s.cache.Update(sd.Event{Err: update.Err}) return } instances := convertFargoAppToInstances(update.App) s.logger.Log("instances", len(instances)) s.cache.Update(sd.Event{Instances: instances}) } func (s *Instancer) loop(updates <-chan fargo.AppUpdate, done chan<- struct{}) { defer close(done) for { select { case update := <-updates: s.consume(update) case q := <-s.quitc: close(q) return } } } func (s *Instancer) getInstances() ([]string, error) { app, err := s.conn.GetApp(s.app) if err != nil { return nil, err } return convertFargoAppToInstances(app), nil } func convertFargoAppToInstances(app *fargo.Application) []string { instances := make([]string, len(app.Instances)) for i, inst := range app.Instances { instances[i] = fmt.Sprintf("%s:%d", inst.IPAddr, inst.Port) } return instances } // Register implements Instancer. func (s *Instancer) Register(ch chan<- sd.Event) { s.cache.Register(ch) } // Deregister implements Instancer. func (s *Instancer) Deregister(ch chan<- sd.Event) { s.cache.Deregister(ch) } // state returns the current state of instance.Cache, only for testing func (s *Instancer) state() sd.Event { return s.cache.State() } golang-github-go-kit-kit-0.6.0/sd/eureka/instancer_test.go000066400000000000000000000043051316471211400234610ustar00rootroot00000000000000package eureka import ( "testing" "time" "github.com/hudl/fargo" "github.com/go-kit/kit/sd" ) var _ sd.Instancer = (*Instancer)(nil) // API check func TestInstancer(t *testing.T) { connection := &testConnection{ instances: []*fargo.Instance{instanceTest1, instanceTest2}, errApplication: nil, } instancer := NewInstancer(connection, appNameTest, loggerTest) defer instancer.Stop() state := instancer.state() if state.Err != nil { t.Fatal(state.Err) } if want, have := 2, len(state.Instances); want != have { t.Errorf("want %d, have %d", want, have) } } func TestInstancerReceivesUpdates(t *testing.T) { connection := &testConnection{ instances: []*fargo.Instance{instanceTest1}, errApplication: nil, } instancer := NewInstancer(connection, appNameTest, loggerTest) defer instancer.Stop() verifyCount := func(want int) (have int, converged bool) { const maxPollAttempts = 5 const delayPerAttempt = 200 * time.Millisecond for i := 1; ; i++ { state := instancer.state() if have := len(state.Instances); want == have { return have, true } else if i == maxPollAttempts { return have, false } time.Sleep(delayPerAttempt) } } if have, converged := verifyCount(1); !converged { t.Fatalf("initial: want %d, have %d", 1, have) } if err := connection.RegisterInstance(instanceTest2); err != nil { t.Fatalf("failed to register an instance: %v", err) } if have, converged := verifyCount(2); !converged { t.Fatalf("after registration: want %d, have %d", 2, have) } if err := connection.DeregisterInstance(instanceTest1); err != nil { t.Fatalf("failed to unregister an instance: %v", err) } if have, converged := verifyCount(1); !converged { t.Fatalf("after deregistration: want %d, have %d", 1, have) } } func TestBadInstancerScheduleUpdates(t *testing.T) { connection := &testConnection{ instances: []*fargo.Instance{instanceTest1}, errApplication: errTest, } instancer := NewInstancer(connection, appNameTest, loggerTest) defer instancer.Stop() state := instancer.state() if state.Err == nil { t.Fatal("expecting error") } if want, have := 0, len(state.Instances); want != have { t.Errorf("want %d, have %d", want, have) } } golang-github-go-kit-kit-0.6.0/sd/eureka/integration_test.go000066400000000000000000000052231316471211400240160ustar00rootroot00000000000000// +build integration package eureka import ( "os" "testing" "time" "github.com/hudl/fargo" "github.com/go-kit/kit/log" ) // Package sd/eureka provides a wrapper around the Netflix Eureka service // registry by way of the Fargo library. This test assumes the user has an // instance of Eureka available at the address in the environment variable. // Example `${EUREKA_ADDR}` format: http://localhost:8761/eureka // // NOTE: when starting a Eureka server for integration testing, ensure // the response cache interval is reduced to one second. This can be // achieved with the following Java argument: // `-Deureka.server.responseCacheUpdateIntervalMs=1000` func TestIntegration(t *testing.T) { eurekaAddr := os.Getenv("EUREKA_ADDR") if eurekaAddr == "" { t.Skip("EUREKA_ADDR is not set") } logger := log.NewLogfmtLogger(os.Stderr) logger = log.With(logger, "ts", log.DefaultTimestamp) var fargoConfig fargo.Config // Target Eureka server(s). fargoConfig.Eureka.ServiceUrls = []string{eurekaAddr} // How often the subscriber should poll for updates. fargoConfig.Eureka.PollIntervalSeconds = 1 // Create a Fargo connection and a Eureka registrar. fargoConnection := fargo.NewConnFromConfig(fargoConfig) registrar1 := NewRegistrar(&fargoConnection, instanceTest1, log.With(logger, "component", "registrar1")) // Register one instance. registrar1.Register() defer registrar1.Deregister() // Build a Eureka instancer. instancer := NewInstancer( &fargoConnection, appNameTest, log.With(logger, "component", "instancer"), ) defer instancer.Stop() // checks every 100ms (fr up to 10s) for the expected number of instances to be reported waitForInstances := func(count int) { for t := 0; t < 100; t++ { state := instancer.state() if len(state.Instances) == count { return } time.Sleep(100 * time.Millisecond) } state := instancer.state() if state.Err != nil { t.Error(state.Err) } if want, have := 1, len(state.Instances); want != have { t.Errorf("want %d, have %d", want, have) } } // We should have one instance immediately after subscriber instantiation. waitForInstances(1) // Register a second instance registrar2 := NewRegistrar(&fargoConnection, instanceTest2, log.With(logger, "component", "registrar2")) registrar2.Register() defer registrar2.Deregister() // In case of exceptional circumstances. // This should be enough time for a scheduled update assuming Eureka is // configured with the properties mentioned in the function comments. waitForInstances(2) // Deregister the second instance. registrar2.Deregister() // Wait for another scheduled update. // And then there was one. waitForInstances(1) } golang-github-go-kit-kit-0.6.0/sd/eureka/registrar.go000066400000000000000000000066251316471211400224450ustar00rootroot00000000000000package eureka import ( "fmt" "net/http" "sync" "time" "github.com/hudl/fargo" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" ) // Matches official Netflix Java client default. const defaultRenewalInterval = 30 * time.Second // The methods of fargo.Connection used in this package. type fargoConnection interface { RegisterInstance(instance *fargo.Instance) error DeregisterInstance(instance *fargo.Instance) error ReregisterInstance(instance *fargo.Instance) error HeartBeatInstance(instance *fargo.Instance) error ScheduleAppUpdates(name string, await bool, done <-chan struct{}) <-chan fargo.AppUpdate GetApp(name string) (*fargo.Application, error) } type fargoUnsuccessfulHTTPResponse struct { statusCode int messagePrefix string } func (u *fargoUnsuccessfulHTTPResponse) Error() string { return fmt.Sprintf("err=%s code=%d", u.messagePrefix, u.statusCode) } // Registrar maintains service instance liveness information in Eureka. type Registrar struct { conn fargoConnection instance *fargo.Instance logger log.Logger quitc chan chan struct{} sync.Mutex } var _ sd.Registrar = (*Registrar)(nil) // NewRegistrar returns an Eureka Registrar acting on behalf of the provided // Fargo connection and instance. See the integration test for usage examples. func NewRegistrar(conn fargoConnection, instance *fargo.Instance, logger log.Logger) *Registrar { return &Registrar{ conn: conn, instance: instance, logger: log.With(logger, "service", instance.App, "address", fmt.Sprintf("%s:%d", instance.IPAddr, instance.Port)), } } // Register implements sd.Registrar. func (r *Registrar) Register() { r.Lock() defer r.Unlock() if r.quitc != nil { return // Already in the registration loop. } if err := r.conn.RegisterInstance(r.instance); err != nil { r.logger.Log("during", "Register", "err", err) } r.quitc = make(chan chan struct{}) go r.loop() } // Deregister implements sd.Registrar. func (r *Registrar) Deregister() { r.Lock() defer r.Unlock() if r.quitc == nil { return // Already deregistered. } q := make(chan struct{}) r.quitc <- q <-q r.quitc = nil } func (r *Registrar) loop() { var renewalInterval time.Duration if r.instance.LeaseInfo.RenewalIntervalInSecs > 0 { renewalInterval = time.Duration(r.instance.LeaseInfo.RenewalIntervalInSecs) * time.Second } else { renewalInterval = defaultRenewalInterval } ticker := time.NewTicker(renewalInterval) defer ticker.Stop() for { select { case <-ticker.C: if err := r.heartbeat(); err != nil { r.logger.Log("during", "heartbeat", "err", err) } case q := <-r.quitc: if err := r.conn.DeregisterInstance(r.instance); err != nil { r.logger.Log("during", "Deregister", "err", err) } close(q) return } } } func httpResponseStatusCode(err error) (code int, present bool) { if code, ok := fargo.HTTPResponseStatusCode(err); ok { return code, true } // Allow injection of errors for testing. if u, ok := err.(*fargoUnsuccessfulHTTPResponse); ok { return u.statusCode, true } return 0, false } func isNotFound(err error) bool { code, ok := httpResponseStatusCode(err) return ok && code == http.StatusNotFound } func (r *Registrar) heartbeat() error { err := r.conn.HeartBeatInstance(r.instance) if err == nil { return nil } if isNotFound(err) { // Instance expired (e.g. network partition). Re-register. return r.conn.ReregisterInstance(r.instance) } return err } golang-github-go-kit-kit-0.6.0/sd/eureka/registrar_test.go000066400000000000000000000050231316471211400234730ustar00rootroot00000000000000package eureka import ( "testing" "time" ) func TestRegistrar(t *testing.T) { connection := &testConnection{ errHeartbeat: errTest, } registrar1 := NewRegistrar(connection, instanceTest1, loggerTest) registrar2 := NewRegistrar(connection, instanceTest2, loggerTest) // Not registered. registrar1.Deregister() if want, have := 0, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } // Register. registrar1.Register() if want, have := 1, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } registrar2.Register() if want, have := 2, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } // Deregister. registrar1.Deregister() if want, have := 1, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } // Already registered. registrar1.Register() if want, have := 2, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } registrar1.Register() if want, have := 2, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } // Wait for a heartbeat failure. time.Sleep(1010 * time.Millisecond) if want, have := 2, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } registrar1.Deregister() if want, have := 1, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } } func TestBadRegister(t *testing.T) { connection := &testConnection{ errRegister: errTest, } registrar := NewRegistrar(connection, instanceTest1, loggerTest) registrar.Register() if want, have := 0, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } } func TestBadDeregister(t *testing.T) { connection := &testConnection{ errDeregister: errTest, } registrar := NewRegistrar(connection, instanceTest1, loggerTest) registrar.Register() if want, have := 1, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } registrar.Deregister() if want, have := 1, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } } func TestExpiredInstance(t *testing.T) { connection := &testConnection{ errHeartbeat: errNotFound, } registrar := NewRegistrar(connection, instanceTest1, loggerTest) registrar.Register() // Wait for a heartbeat failure. time.Sleep(1010 * time.Millisecond) if want, have := 1, len(connection.instances); want != have { t.Errorf("want %d, have %d", want, have) } } golang-github-go-kit-kit-0.6.0/sd/eureka/util_test.go000066400000000000000000000074041316471211400224530ustar00rootroot00000000000000package eureka import ( "errors" "fmt" "reflect" "sync" "time" "github.com/go-kit/kit/log" "github.com/hudl/fargo" ) type testConnection struct { mu sync.RWMutex instances []*fargo.Instance errApplication error errHeartbeat error errRegister error errDeregister error } var ( errTest = errors.New("kaboom") errNotFound = &fargoUnsuccessfulHTTPResponse{statusCode: 404, messagePrefix: "not found"} loggerTest = log.NewNopLogger() appNameTest = "go-kit" instanceTest1 = &fargo.Instance{ HostName: "serveregistrar1.acme.org", Port: 8080, App: appNameTest, IPAddr: "192.168.0.1", VipAddress: "192.168.0.1", SecureVipAddress: "192.168.0.1", HealthCheckUrl: "http://serveregistrar1.acme.org:8080/healthz", StatusPageUrl: "http://serveregistrar1.acme.org:8080/status", HomePageUrl: "http://serveregistrar1.acme.org:8080/", Status: fargo.UP, DataCenterInfo: fargo.DataCenterInfo{Name: fargo.MyOwn}, LeaseInfo: fargo.LeaseInfo{RenewalIntervalInSecs: 1}, } instanceTest2 = &fargo.Instance{ HostName: "serveregistrar2.acme.org", Port: 8080, App: appNameTest, IPAddr: "192.168.0.2", VipAddress: "192.168.0.2", SecureVipAddress: "192.168.0.2", HealthCheckUrl: "http://serveregistrar2.acme.org:8080/healthz", StatusPageUrl: "http://serveregistrar2.acme.org:8080/status", HomePageUrl: "http://serveregistrar2.acme.org:8080/", Status: fargo.UP, DataCenterInfo: fargo.DataCenterInfo{Name: fargo.MyOwn}, } ) var _ fargoConnection = (*testConnection)(nil) func (c *testConnection) RegisterInstance(i *fargo.Instance) error { if c.errRegister != nil { return c.errRegister } c.mu.Lock() defer c.mu.Unlock() for _, instance := range c.instances { if reflect.DeepEqual(*instance, *i) { return errors.New("already registered") } } c.instances = append(c.instances, i) return nil } func (c *testConnection) HeartBeatInstance(i *fargo.Instance) error { return c.errHeartbeat } func (c *testConnection) DeregisterInstance(i *fargo.Instance) error { if c.errDeregister != nil { return c.errDeregister } c.mu.Lock() defer c.mu.Unlock() remaining := make([]*fargo.Instance, 0, len(c.instances)) for _, instance := range c.instances { if reflect.DeepEqual(*instance, *i) { continue } remaining = append(remaining, instance) } if len(remaining) == len(c.instances) { return errors.New("not registered") } c.instances = remaining return nil } func (c *testConnection) ReregisterInstance(ins *fargo.Instance) error { return nil } func (c *testConnection) instancesForApplication(name string) []*fargo.Instance { c.mu.RLock() defer c.mu.RUnlock() instances := make([]*fargo.Instance, 0, len(c.instances)) for _, i := range c.instances { if i.App == name { instances = append(instances, i) } } return instances } func (c *testConnection) GetApp(name string) (*fargo.Application, error) { if err := c.errApplication; err != nil { return nil, err } instances := c.instancesForApplication(name) if len(instances) == 0 { return nil, fmt.Errorf("Application not found for name=%s", name) } return &fargo.Application{Name: name, Instances: instances}, nil } func (c *testConnection) ScheduleAppUpdates(name string, await bool, done <-chan struct{}) <-chan fargo.AppUpdate { updatec := make(chan fargo.AppUpdate, 1) send := func() { app, err := c.GetApp(name) select { case updatec <- fargo.AppUpdate{App: app, Err: err}: default: } } if await { send() } go func() { ticker := time.NewTicker(100 * time.Millisecond) for { select { case <-ticker.C: send() case <-done: ticker.Stop() return } } }() return updatec } golang-github-go-kit-kit-0.6.0/sd/factory.go000066400000000000000000000011511316471211400206230ustar00rootroot00000000000000package sd import ( "io" "github.com/go-kit/kit/endpoint" ) // Factory is a function that converts an instance string (e.g. host:port) to a // specific endpoint. Instances that provide multiple endpoints require multiple // factories. A factory also returns an io.Closer that's invoked when the // instance goes away and needs to be cleaned up. Factories may return nil // closers. // // Users are expected to provide their own factory functions that assume // specific transports, or can deduce transports by parsing the instance string. type Factory func(instance string) (endpoint.Endpoint, io.Closer, error) golang-github-go-kit-kit-0.6.0/sd/instancer.go000066400000000000000000000030721316471211400211460ustar00rootroot00000000000000package sd // Event represents a push notification generated from the underlying service discovery // implementation. It contains either a full set of available resource instances, or // an error indicating some issue with obtaining information from discovery backend. // Examples of errors may include loosing connection to the discovery backend, or // trying to look up resource instances using an incorrectly formatted key. // After receiving an Event with an error the listenter should treat previously discovered // resource instances as stale (although it may choose to continue using them). // If the Instancer is able to restore connection to the discovery backend it must push // another Event with the current set of resource instances. type Event struct { Instances []string Err error } // Instancer listens to a service discovery system and notifies registered // observers of changes in the resource instances. Every event sent to the channels // contains a complete set of instances known to the Instancer. That complete set is // sent immediately upon registering the channel, and on any future updates from // discovery system. type Instancer interface { Register(chan<- Event) Deregister(chan<- Event) Stop() } // FixedInstancer yields a fixed set of instances. type FixedInstancer []string // Register implements Instancer. func (d FixedInstancer) Register(ch chan<- Event) { ch <- Event{Instances: d} } // Deregister implements Instancer. func (d FixedInstancer) Deregister(ch chan<- Event) {} // Stop implements Instancer. func (d FixedInstancer) Stop() {} golang-github-go-kit-kit-0.6.0/sd/internal/000077500000000000000000000000001316471211400204435ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/sd/internal/instance/000077500000000000000000000000001316471211400222475ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/sd/internal/instance/cache.go000066400000000000000000000032461316471211400236460ustar00rootroot00000000000000package instance import ( "reflect" "sort" "sync" "github.com/go-kit/kit/sd" ) // Cache keeps track of resource instances provided to it via Update method // and implements the Instancer interface type Cache struct { mtx sync.RWMutex state sd.Event reg registry } // NewCache creates a new Cache. func NewCache() *Cache { return &Cache{ reg: registry{}, } } // Update receives new instances from service discovery, stores them internally, // and notifies all registered listeners. func (c *Cache) Update(event sd.Event) { c.mtx.Lock() defer c.mtx.Unlock() sort.Strings(event.Instances) if reflect.DeepEqual(c.state, event) { return // no need to broadcast the same instances } c.state = event c.reg.broadcast(event) } // State returns the current state of discovery (instances or error) as sd.Event func (c *Cache) State() sd.Event { c.mtx.RLock() defer c.mtx.RUnlock() return c.state } // Stop implements Instancer. Since the cache is just a plain-old store of data, // Stop is a no-op. func (c *Cache) Stop() {} // Register implements Instancer. func (c *Cache) Register(ch chan<- sd.Event) { c.mtx.Lock() defer c.mtx.Unlock() c.reg.register(ch) // always push the current state to new channels ch <- c.state } // Deregister implements Instancer. func (c *Cache) Deregister(ch chan<- sd.Event) { c.mtx.Lock() defer c.mtx.Unlock() c.reg.deregister(ch) } // registry is not goroutine-safe. type registry map[chan<- sd.Event]struct{} func (r registry) broadcast(event sd.Event) { for c := range r { c <- event } } func (r registry) register(c chan<- sd.Event) { r[c] = struct{}{} } func (r registry) deregister(c chan<- sd.Event) { delete(r, c) } golang-github-go-kit-kit-0.6.0/sd/internal/instance/cache_test.go000066400000000000000000000040651316471211400247050ustar00rootroot00000000000000package instance import ( "reflect" "testing" "time" "github.com/go-kit/kit/sd" ) var _ sd.Instancer = (*Cache)(nil) // API check // The test verifies the following: // registering causes initial notification of the current state // instances are sorted // different update causes new notification // identical notifications cause no updates // no updates after de-registering func TestCache(t *testing.T) { e1 := sd.Event{Instances: []string{"y", "x"}} // not sorted e2 := sd.Event{Instances: []string{"c", "a", "b"}} cache := NewCache() if want, have := 0, len(cache.State().Instances); want != have { t.Fatalf("want %v instances, have %v", want, have) } cache.Update(e1) // sets initial state if want, have := 2, len(cache.State().Instances); want != have { t.Fatalf("want %v instances, have %v", want, have) } r1 := make(chan sd.Event) go cache.Register(r1) expectUpdate(t, r1, []string{"x", "y"}) go cache.Update(e2) // different set expectUpdate(t, r1, []string{"a", "b", "c"}) cache.Deregister(r1) close(r1) } func expectUpdate(t *testing.T, r chan sd.Event, expect []string) { select { case e := <-r: if want, have := expect, e.Instances; !reflect.DeepEqual(want, have) { t.Fatalf("want: %v, have: %v", want, have) } case <-time.After(time.Second): t.Fatalf("did not receive expected update %v", expect) } } func TestRegistry(t *testing.T) { reg := make(registry) c1 := make(chan sd.Event, 1) c2 := make(chan sd.Event, 1) reg.register(c1) reg.register(c2) // validate that both channels receive the update reg.broadcast(sd.Event{Instances: []string{"x", "y"}}) if want, have := []string{"x", "y"}, (<-c1).Instances; !reflect.DeepEqual(want, have) { t.Fatalf("want: %v, have: %v", want, have) } if want, have := []string{"x", "y"}, (<-c2).Instances; !reflect.DeepEqual(want, have) { t.Fatalf("want: %v, have: %v", want, have) } reg.deregister(c1) reg.deregister(c2) close(c1) close(c2) // if deregister didn't work, broadcast would panic on closed channels reg.broadcast(sd.Event{Instances: []string{"x", "y"}}) } golang-github-go-kit-kit-0.6.0/sd/lb/000077500000000000000000000000001316471211400172245ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/sd/lb/balancer.go000066400000000000000000000005071316471211400213240ustar00rootroot00000000000000package lb import ( "errors" "github.com/go-kit/kit/endpoint" ) // Balancer yields endpoints according to some heuristic. type Balancer interface { Endpoint() (endpoint.Endpoint, error) } // ErrNoEndpoints is returned when no qualifying endpoints are available. var ErrNoEndpoints = errors.New("no endpoints available") golang-github-go-kit-kit-0.6.0/sd/lb/doc.go000066400000000000000000000003641316471211400203230ustar00rootroot00000000000000// Package lb implements the client-side load balancer pattern. When combined // with a service discovery system of record, it enables a more decentralized // architecture, removing the need for separate load balancers like HAProxy. package lb golang-github-go-kit-kit-0.6.0/sd/lb/random.go000066400000000000000000000011121316471211400210260ustar00rootroot00000000000000package lb import ( "math/rand" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/sd" ) // NewRandom returns a load balancer that selects services randomly. func NewRandom(s sd.Endpointer, seed int64) Balancer { return &random{ s: s, r: rand.New(rand.NewSource(seed)), } } type random struct { s sd.Endpointer r *rand.Rand } func (r *random) Endpoint() (endpoint.Endpoint, error) { endpoints, err := r.s.Endpoints() if err != nil { return nil, err } if len(endpoints) <= 0 { return nil, ErrNoEndpoints } return endpoints[r.r.Intn(len(endpoints))], nil } golang-github-go-kit-kit-0.6.0/sd/lb/random_test.go000066400000000000000000000022461316471211400220760ustar00rootroot00000000000000package lb import ( "context" "math" "testing" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/sd" ) func TestRandom(t *testing.T) { var ( n = 7 endpoints = make([]endpoint.Endpoint, n) counts = make([]int, n) seed = int64(12345) iterations = 1000000 want = iterations / n tolerance = want / 100 // 1% ) for i := 0; i < n; i++ { i0 := i endpoints[i] = func(context.Context, interface{}) (interface{}, error) { counts[i0]++; return struct{}{}, nil } } endpointer := sd.FixedEndpointer(endpoints) balancer := NewRandom(endpointer, seed) for i := 0; i < iterations; i++ { endpoint, _ := balancer.Endpoint() endpoint(context.Background(), struct{}{}) } for i, have := range counts { delta := int(math.Abs(float64(want - have))) if delta > tolerance { t.Errorf("%d: want %d, have %d, delta %d > %d tolerance", i, want, have, delta, tolerance) } } } func TestRandomNoEndpoints(t *testing.T) { endpointer := sd.FixedEndpointer{} balancer := NewRandom(endpointer, 1415926) _, err := balancer.Endpoint() if want, have := ErrNoEndpoints, err; want != have { t.Errorf("want %v, have %v", want, have) } } golang-github-go-kit-kit-0.6.0/sd/lb/retry.go000066400000000000000000000066321316471211400207270ustar00rootroot00000000000000package lb import ( "context" "fmt" "strings" "time" "github.com/go-kit/kit/endpoint" ) // RetryError is an error wrapper that is used by the retry mechanism. All // errors returned by the retry mechanism via its endpoint will be RetryErrors. type RetryError struct { RawErrors []error // all errors encountered from endpoints directly Final error // the final, terminating error } func (e RetryError) Error() string { var suffix string if len(e.RawErrors) > 1 { a := make([]string, len(e.RawErrors)-1) for i := 0; i < len(e.RawErrors)-1; i++ { // last one is Final a[i] = e.RawErrors[i].Error() } suffix = fmt.Sprintf(" (previously: %s)", strings.Join(a, "; ")) } return fmt.Sprintf("%v%s", e.Final, suffix) } // Callback is a function that is given the current attempt count and the error // received from the underlying endpoint. It should return whether the Retry // function should continue trying to get a working endpoint, and a custom error // if desired. The error message may be nil, but a true/false is always // expected. In all cases, if the replacement error is supplied, the received // error will be replaced in the calling context. type Callback func(n int, received error) (keepTrying bool, replacement error) // Retry wraps a service load balancer and returns an endpoint oriented load // balancer for the specified service method. Requests to the endpoint will be // automatically load balanced via the load balancer. Requests that return // errors will be retried until they succeed, up to max times, or until the // timeout is elapsed, whichever comes first. func Retry(max int, timeout time.Duration, b Balancer) endpoint.Endpoint { return RetryWithCallback(timeout, b, maxRetries(max)) } func maxRetries(max int) Callback { return func(n int, err error) (keepTrying bool, replacement error) { return n < max, nil } } func alwaysRetry(int, error) (keepTrying bool, replacement error) { return true, nil } // RetryWithCallback wraps a service load balancer and returns an endpoint // oriented load balancer for the specified service method. Requests to the // endpoint will be automatically load balanced via the load balancer. Requests // that return errors will be retried until they succeed, up to max times, until // the callback returns false, or until the timeout is elapsed, whichever comes // first. func RetryWithCallback(timeout time.Duration, b Balancer, cb Callback) endpoint.Endpoint { if cb == nil { cb = alwaysRetry } if b == nil { panic("nil Balancer") } return func(ctx context.Context, request interface{}) (response interface{}, err error) { var ( newctx, cancel = context.WithTimeout(ctx, timeout) responses = make(chan interface{}, 1) errs = make(chan error, 1) final RetryError ) defer cancel() for i := 1; ; i++ { go func() { e, err := b.Endpoint() if err != nil { errs <- err return } response, err := e(newctx, request) if err != nil { errs <- err return } responses <- response }() select { case <-newctx.Done(): return nil, newctx.Err() case response := <-responses: return response, nil case err := <-errs: final.RawErrors = append(final.RawErrors, err) keepTrying, replacement := cb(i, err) if replacement != nil { err = replacement } if !keepTrying { final.Final = err return nil, final } continue } } } } golang-github-go-kit-kit-0.6.0/sd/lb/retry_test.go000066400000000000000000000107611316471211400217640ustar00rootroot00000000000000package lb_test import ( "context" "errors" "testing" "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/sd" "github.com/go-kit/kit/sd/lb" ) func TestRetryMaxTotalFail(t *testing.T) { var ( endpoints = sd.FixedEndpointer{} // no endpoints rr = lb.NewRoundRobin(endpoints) retry = lb.Retry(999, time.Second, rr) // lots of retries ctx = context.Background() ) if _, err := retry(ctx, struct{}{}); err == nil { t.Errorf("expected error, got none") // should fail } } func TestRetryMaxPartialFail(t *testing.T) { var ( endpoints = []endpoint.Endpoint{ func(context.Context, interface{}) (interface{}, error) { return nil, errors.New("error one") }, func(context.Context, interface{}) (interface{}, error) { return nil, errors.New("error two") }, func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil /* OK */ }, } endpointer = sd.FixedEndpointer{ 0: endpoints[0], 1: endpoints[1], 2: endpoints[2], } retries = len(endpoints) - 1 // not quite enough retries rr = lb.NewRoundRobin(endpointer) ctx = context.Background() ) if _, err := lb.Retry(retries, time.Second, rr)(ctx, struct{}{}); err == nil { t.Errorf("expected error two, got none") } } func TestRetryMaxSuccess(t *testing.T) { var ( endpoints = []endpoint.Endpoint{ func(context.Context, interface{}) (interface{}, error) { return nil, errors.New("error one") }, func(context.Context, interface{}) (interface{}, error) { return nil, errors.New("error two") }, func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil /* OK */ }, } endpointer = sd.FixedEndpointer{ 0: endpoints[0], 1: endpoints[1], 2: endpoints[2], } retries = len(endpoints) // exactly enough retries rr = lb.NewRoundRobin(endpointer) ctx = context.Background() ) if _, err := lb.Retry(retries, time.Second, rr)(ctx, struct{}{}); err != nil { t.Error(err) } } func TestRetryTimeout(t *testing.T) { var ( step = make(chan struct{}) e = func(context.Context, interface{}) (interface{}, error) { <-step; return struct{}{}, nil } timeout = time.Millisecond retry = lb.Retry(999, timeout, lb.NewRoundRobin(sd.FixedEndpointer{0: e})) errs = make(chan error, 1) invoke = func() { _, err := retry(context.Background(), struct{}{}); errs <- err } ) go func() { step <- struct{}{} }() // queue up a flush of the endpoint invoke() // invoke the endpoint and trigger the flush if err := <-errs; err != nil { // that should succeed t.Error(err) } go func() { time.Sleep(10 * timeout); step <- struct{}{} }() // a delayed flush invoke() // invoke the endpoint if err := <-errs; err != context.DeadlineExceeded { // that should not succeed t.Errorf("wanted %v, got none", context.DeadlineExceeded) } } func TestAbortEarlyCustomMessage(t *testing.T) { var ( myErr = errors.New("aborting early") cb = func(int, error) (bool, error) { return false, myErr } endpoints = sd.FixedEndpointer{} // no endpoints rr = lb.NewRoundRobin(endpoints) retry = lb.RetryWithCallback(time.Second, rr, cb) // lots of retries ctx = context.Background() ) _, err := retry(ctx, struct{}{}) if want, have := myErr, err.(lb.RetryError).Final; want != have { t.Errorf("want %v, have %v", want, have) } } func TestErrorPassedUnchangedToCallback(t *testing.T) { var ( myErr = errors.New("my custom error") cb = func(_ int, err error) (bool, error) { if want, have := myErr, err; want != have { t.Errorf("want %v, have %v", want, have) } return false, nil } endpoint = func(ctx context.Context, request interface{}) (interface{}, error) { return nil, myErr } endpoints = sd.FixedEndpointer{endpoint} // no endpoints rr = lb.NewRoundRobin(endpoints) retry = lb.RetryWithCallback(time.Second, rr, cb) // lots of retries ctx = context.Background() ) _, err := retry(ctx, struct{}{}) if want, have := myErr, err.(lb.RetryError).Final; want != have { t.Errorf("want %v, have %v", want, have) } } func TestHandleNilCallback(t *testing.T) { var ( endpointer = sd.FixedEndpointer{ func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil /* OK */ }, } rr = lb.NewRoundRobin(endpointer) ctx = context.Background() ) retry := lb.RetryWithCallback(time.Second, rr, nil) if _, err := retry(ctx, struct{}{}); err != nil { t.Error(err) } } golang-github-go-kit-kit-0.6.0/sd/lb/round_robin.go000066400000000000000000000011571316471211400220770ustar00rootroot00000000000000package lb import ( "sync/atomic" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/sd" ) // NewRoundRobin returns a load balancer that returns services in sequence. func NewRoundRobin(s sd.Endpointer) Balancer { return &roundRobin{ s: s, c: 0, } } type roundRobin struct { s sd.Endpointer c uint64 } func (rr *roundRobin) Endpoint() (endpoint.Endpoint, error) { endpoints, err := rr.s.Endpoints() if err != nil { return nil, err } if len(endpoints) <= 0 { return nil, ErrNoEndpoints } old := atomic.AddUint64(&rr.c, 1) - 1 idx := old % uint64(len(endpoints)) return endpoints[idx], nil } golang-github-go-kit-kit-0.6.0/sd/lb/round_robin_test.go000066400000000000000000000035341316471211400231370ustar00rootroot00000000000000package lb import ( "context" "reflect" "sync" "sync/atomic" "testing" "time" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/sd" ) func TestRoundRobin(t *testing.T) { var ( counts = []int{0, 0, 0} endpoints = []endpoint.Endpoint{ func(context.Context, interface{}) (interface{}, error) { counts[0]++; return struct{}{}, nil }, func(context.Context, interface{}) (interface{}, error) { counts[1]++; return struct{}{}, nil }, func(context.Context, interface{}) (interface{}, error) { counts[2]++; return struct{}{}, nil }, } ) endpointer := sd.FixedEndpointer(endpoints) balancer := NewRoundRobin(endpointer) for i, want := range [][]int{ {1, 0, 0}, {1, 1, 0}, {1, 1, 1}, {2, 1, 1}, {2, 2, 1}, {2, 2, 2}, {3, 2, 2}, } { endpoint, err := balancer.Endpoint() if err != nil { t.Fatal(err) } endpoint(context.Background(), struct{}{}) if have := counts; !reflect.DeepEqual(want, have) { t.Fatalf("%d: want %v, have %v", i, want, have) } } } func TestRoundRobinNoEndpoints(t *testing.T) { endpointer := sd.FixedEndpointer{} balancer := NewRoundRobin(endpointer) _, err := balancer.Endpoint() if want, have := ErrNoEndpoints, err; want != have { t.Errorf("want %v, have %v", want, have) } } func TestRoundRobinNoRace(t *testing.T) { balancer := NewRoundRobin(sd.FixedEndpointer([]endpoint.Endpoint{ endpoint.Nop, endpoint.Nop, endpoint.Nop, endpoint.Nop, endpoint.Nop, })) var ( n = 100 done = make(chan struct{}) wg sync.WaitGroup count uint64 ) wg.Add(n) for i := 0; i < n; i++ { go func() { defer wg.Done() for { select { case <-done: return default: _, _ = balancer.Endpoint() atomic.AddUint64(&count, 1) } } }() } time.Sleep(time.Second) close(done) wg.Wait() t.Logf("made %d calls", atomic.LoadUint64(&count)) } golang-github-go-kit-kit-0.6.0/sd/registrar.go000066400000000000000000000007751316471211400211710ustar00rootroot00000000000000package sd // Registrar registers instance information to a service discovery system when // an instance becomes alive and healthy, and deregisters that information when // the service becomes unhealthy or goes away. // // Registrar implementations exist for various service discovery systems. Note // that identifying instance information (e.g. host:port) must be given via the // concrete constructor; this interface merely signals lifecycle changes. type Registrar interface { Register() Deregister() } golang-github-go-kit-kit-0.6.0/sd/zk/000077500000000000000000000000001316471211400172535ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/sd/zk/client.go000066400000000000000000000165231316471211400210670ustar00rootroot00000000000000package zk import ( "errors" "net" "strings" "time" "github.com/samuel/go-zookeeper/zk" "github.com/go-kit/kit/log" ) // DefaultACL is the default ACL to use for creating znodes. var ( DefaultACL = zk.WorldACL(zk.PermAll) ErrInvalidCredentials = errors.New("invalid credentials provided") ErrClientClosed = errors.New("client service closed") ErrNotRegistered = errors.New("not registered") ErrNodeNotFound = errors.New("node not found") ) const ( // DefaultConnectTimeout is the default timeout to establish a connection to // a ZooKeeper node. DefaultConnectTimeout = 2 * time.Second // DefaultSessionTimeout is the default timeout to keep the current // ZooKeeper session alive during a temporary disconnect. DefaultSessionTimeout = 5 * time.Second ) // Client is a wrapper around a lower level ZooKeeper client implementation. type Client interface { // GetEntries should query the provided path in ZooKeeper, place a watch on // it and retrieve data from its current child nodes. GetEntries(path string) ([]string, <-chan zk.Event, error) // CreateParentNodes should try to create the path in case it does not exist // yet on ZooKeeper. CreateParentNodes(path string) error // Register a service with ZooKeeper. Register(s *Service) error // Deregister a service with ZooKeeper. Deregister(s *Service) error // Stop should properly shutdown the client implementation Stop() } type clientConfig struct { logger log.Logger acl []zk.ACL credentials []byte connectTimeout time.Duration sessionTimeout time.Duration rootNodePayload [][]byte eventHandler func(zk.Event) } // Option functions enable friendly APIs. type Option func(*clientConfig) error type client struct { *zk.Conn clientConfig active bool quit chan struct{} } // ACL returns an Option specifying a non-default ACL for creating parent nodes. func ACL(acl []zk.ACL) Option { return func(c *clientConfig) error { c.acl = acl return nil } } // Credentials returns an Option specifying a user/password combination which // the client will use to authenticate itself with. func Credentials(user, pass string) Option { return func(c *clientConfig) error { if user == "" || pass == "" { return ErrInvalidCredentials } c.credentials = []byte(user + ":" + pass) return nil } } // ConnectTimeout returns an Option specifying a non-default connection timeout // when we try to establish a connection to a ZooKeeper server. func ConnectTimeout(t time.Duration) Option { return func(c *clientConfig) error { if t.Seconds() < 1 { return errors.New("invalid connect timeout (minimum value is 1 second)") } c.connectTimeout = t return nil } } // SessionTimeout returns an Option specifying a non-default session timeout. func SessionTimeout(t time.Duration) Option { return func(c *clientConfig) error { if t.Seconds() < 1 { return errors.New("invalid session timeout (minimum value is 1 second)") } c.sessionTimeout = t return nil } } // Payload returns an Option specifying non-default data values for each znode // created by CreateParentNodes. func Payload(payload [][]byte) Option { return func(c *clientConfig) error { c.rootNodePayload = payload return nil } } // EventHandler returns an Option specifying a callback function to handle // incoming zk.Event payloads (ZooKeeper connection events). func EventHandler(handler func(zk.Event)) Option { return func(c *clientConfig) error { c.eventHandler = handler return nil } } // NewClient returns a ZooKeeper client with a connection to the server cluster. // It will return an error if the server cluster cannot be resolved. func NewClient(servers []string, logger log.Logger, options ...Option) (Client, error) { defaultEventHandler := func(event zk.Event) { logger.Log("eventtype", event.Type.String(), "server", event.Server, "state", event.State.String(), "err", event.Err) } config := clientConfig{ acl: DefaultACL, connectTimeout: DefaultConnectTimeout, sessionTimeout: DefaultSessionTimeout, eventHandler: defaultEventHandler, logger: logger, } for _, option := range options { if err := option(&config); err != nil { return nil, err } } // dialer overrides the default ZooKeeper library Dialer so we can configure // the connectTimeout. The current library has a hardcoded value of 1 second // and there are reports of race conditions, due to slow DNS resolvers and // other network latency issues. dialer := func(network, address string, _ time.Duration) (net.Conn, error) { return net.DialTimeout(network, address, config.connectTimeout) } conn, eventc, err := zk.Connect(servers, config.sessionTimeout, withLogger(logger), zk.WithDialer(dialer)) if err != nil { return nil, err } if len(config.credentials) > 0 { err = conn.AddAuth("digest", config.credentials) if err != nil { return nil, err } } c := &client{conn, config, true, make(chan struct{})} // Start listening for incoming Event payloads and callback the set // eventHandler. go func() { for { select { case event := <-eventc: config.eventHandler(event) case <-c.quit: return } } }() return c, nil } // CreateParentNodes implements the ZooKeeper Client interface. func (c *client) CreateParentNodes(path string) error { if !c.active { return ErrClientClosed } if path[0] != '/' { return zk.ErrInvalidPath } payload := []byte("") pathString := "" pathNodes := strings.Split(path, "/") for i := 1; i < len(pathNodes); i++ { if i <= len(c.rootNodePayload) { payload = c.rootNodePayload[i-1] } else { payload = []byte("") } pathString += "/" + pathNodes[i] _, err := c.Create(pathString, payload, 0, c.acl) // not being able to create the node because it exists or not having // sufficient rights is not an issue. It is ok for the node to already // exist and/or us to only have read rights if err != nil && err != zk.ErrNodeExists && err != zk.ErrNoAuth { return err } } return nil } // GetEntries implements the ZooKeeper Client interface. func (c *client) GetEntries(path string) ([]string, <-chan zk.Event, error) { // retrieve list of child nodes for given path and add watch to path znodes, _, eventc, err := c.ChildrenW(path) if err != nil { return nil, eventc, err } var resp []string for _, znode := range znodes { // retrieve payload for child znode and add to response array if data, _, err := c.Get(path + "/" + znode); err == nil { resp = append(resp, string(data)) } } return resp, eventc, nil } // Register implements the ZooKeeper Client interface. func (c *client) Register(s *Service) error { if s.Path[len(s.Path)-1] != '/' { s.Path += "/" } path := s.Path + s.Name if err := c.CreateParentNodes(path); err != nil { return err } node, err := c.CreateProtectedEphemeralSequential(path, s.Data, c.acl) if err != nil { return err } s.node = node return nil } // Deregister implements the ZooKeeper Client interface. func (c *client) Deregister(s *Service) error { if s.node == "" { return ErrNotRegistered } path := s.Path + s.Name found, stat, err := c.Exists(path) if err != nil { return err } if !found { return ErrNodeNotFound } if err := c.Delete(path, stat.Version); err != nil { return err } return nil } // Stop implements the ZooKeeper Client interface. func (c *client) Stop() { c.active = false close(c.quit) c.Close() } golang-github-go-kit-kit-0.6.0/sd/zk/client_test.go000066400000000000000000000075461316471211400221330ustar00rootroot00000000000000package zk import ( "bytes" "testing" "time" stdzk "github.com/samuel/go-zookeeper/zk" "github.com/go-kit/kit/log" ) func TestNewClient(t *testing.T) { var ( acl = stdzk.WorldACL(stdzk.PermRead) connectTimeout = 3 * time.Second sessionTimeout = 20 * time.Second payload = [][]byte{[]byte("Payload"), []byte("Test")} ) c, err := NewClient( []string{"FailThisInvalidHost!!!"}, log.NewNopLogger(), ) if err == nil { t.Errorf("expected error, got nil") } hasFired := false calledEventHandler := make(chan struct{}) eventHandler := func(event stdzk.Event) { if !hasFired { // test is successful if this function has fired at least once hasFired = true close(calledEventHandler) } } c, err = NewClient( []string{"localhost"}, log.NewNopLogger(), ACL(acl), ConnectTimeout(connectTimeout), SessionTimeout(sessionTimeout), Payload(payload), EventHandler(eventHandler), ) if err != nil { t.Fatal(err) } defer c.Stop() clientImpl, ok := c.(*client) if !ok { t.Fatal("retrieved incorrect Client implementation") } if want, have := acl, clientImpl.acl; want[0] != have[0] { t.Errorf("want %+v, have %+v", want, have) } if want, have := connectTimeout, clientImpl.connectTimeout; want != have { t.Errorf("want %d, have %d", want, have) } if want, have := sessionTimeout, clientImpl.sessionTimeout; want != have { t.Errorf("want %d, have %d", want, have) } if want, have := payload, clientImpl.rootNodePayload; bytes.Compare(want[0], have[0]) != 0 || bytes.Compare(want[1], have[1]) != 0 { t.Errorf("want %s, have %s", want, have) } select { case <-calledEventHandler: case <-time.After(100 * time.Millisecond): t.Errorf("event handler never called") } } func TestOptions(t *testing.T) { _, err := NewClient([]string{"localhost"}, log.NewNopLogger(), Credentials("valid", "credentials")) if err != nil && err != stdzk.ErrNoServer { t.Errorf("unexpected error: %v", err) } _, err = NewClient([]string{"localhost"}, log.NewNopLogger(), Credentials("nopass", "")) if want, have := err, ErrInvalidCredentials; want != have { t.Errorf("want %v, have %v", want, have) } _, err = NewClient([]string{"localhost"}, log.NewNopLogger(), ConnectTimeout(0)) if err == nil { t.Errorf("expected connect timeout error") } _, err = NewClient([]string{"localhost"}, log.NewNopLogger(), SessionTimeout(0)) if err == nil { t.Errorf("expected connect timeout error") } } func TestCreateParentNodes(t *testing.T) { payload := [][]byte{[]byte("Payload"), []byte("Test")} c, err := NewClient([]string{"localhost:65500"}, log.NewNopLogger()) if err != nil { t.Errorf("unexpected error: %v", err) } if c == nil { t.Fatal("expected new Client, got nil") } s, err := NewInstancer(c, "/validpath", log.NewNopLogger()) if err != stdzk.ErrNoServer { t.Errorf("unexpected error: %v", err) } if s != nil { t.Error("expected failed new Instancer") } s, err = NewInstancer(c, "invalidpath", log.NewNopLogger()) if err != stdzk.ErrInvalidPath { t.Errorf("unexpected error: %v", err) } _, _, err = c.GetEntries("/validpath") if err != stdzk.ErrNoServer { t.Errorf("unexpected error: %v", err) } c.Stop() err = c.CreateParentNodes("/validpath") if err != ErrClientClosed { t.Errorf("unexpected error: %v", err) } s, err = NewInstancer(c, "/validpath", log.NewNopLogger()) if err != ErrClientClosed { t.Errorf("unexpected error: %v", err) } if s != nil { t.Error("expected failed new Instancer") } c, err = NewClient([]string{"localhost:65500"}, log.NewNopLogger(), Payload(payload)) if err != nil { t.Errorf("unexpected error: %v", err) } if c == nil { t.Fatal("expected new Client, got nil") } s, err = NewInstancer(c, "/validpath", log.NewNopLogger()) if err != stdzk.ErrNoServer { t.Errorf("unexpected error: %v", err) } if s != nil { t.Error("expected failed new Instancer") } } golang-github-go-kit-kit-0.6.0/sd/zk/doc.go000066400000000000000000000001311316471211400203420ustar00rootroot00000000000000// Package zk provides Instancer and Registrar implementations for ZooKeeper. package zk golang-github-go-kit-kit-0.6.0/sd/zk/instancer.go000066400000000000000000000045171316471211400215770ustar00rootroot00000000000000package zk import ( "github.com/samuel/go-zookeeper/zk" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" "github.com/go-kit/kit/sd/internal/instance" ) // Instancer yield instances stored in a certain ZooKeeper path. Any kind of // change in that path is watched and will update the subscribers. type Instancer struct { cache *instance.Cache client Client path string logger log.Logger quitc chan struct{} } // NewInstancer returns a ZooKeeper Instancer. ZooKeeper will start watching // the given path for changes and update the Instancer endpoints. func NewInstancer(c Client, path string, logger log.Logger) (*Instancer, error) { s := &Instancer{ cache: instance.NewCache(), client: c, path: path, logger: logger, quitc: make(chan struct{}), } err := s.client.CreateParentNodes(s.path) if err != nil { return nil, err } instances, eventc, err := s.client.GetEntries(s.path) if err != nil { logger.Log("path", s.path, "msg", "failed to retrieve entries", "err", err) // other implementations continue here, but we exit because we don't know if eventc is valid return nil, err } logger.Log("path", s.path, "instances", len(instances)) s.cache.Update(sd.Event{Instances: instances}) go s.loop(eventc) return s, nil } func (s *Instancer) loop(eventc <-chan zk.Event) { var ( instances []string err error ) for { select { case <-eventc: // We received a path update notification. Call GetEntries to // retrieve child node data, and set a new watch, as ZK watches are // one-time triggers. instances, eventc, err = s.client.GetEntries(s.path) if err != nil { s.logger.Log("path", s.path, "msg", "failed to retrieve entries", "err", err) s.cache.Update(sd.Event{Err: err}) continue } s.logger.Log("path", s.path, "instances", len(instances)) s.cache.Update(sd.Event{Instances: instances}) case <-s.quitc: return } } } // Stop terminates the Instancer. func (s *Instancer) Stop() { close(s.quitc) } // Register implements Instancer. func (s *Instancer) Register(ch chan<- sd.Event) { s.cache.Register(ch) } // Deregister implements Instancer. func (s *Instancer) Deregister(ch chan<- sd.Event) { s.cache.Deregister(ch) } // state returns the current state of instance.Cache, only for testing func (s *Instancer) state() sd.Event { return s.cache.State() } golang-github-go-kit-kit-0.6.0/sd/zk/instancer_test.go000066400000000000000000000056611316471211400226370ustar00rootroot00000000000000package zk import ( "testing" "time" "github.com/go-kit/kit/sd" ) var _ sd.Instancer = (*Instancer)(nil) // API check func TestInstancer(t *testing.T) { client := newFakeClient() instancer, err := NewInstancer(client, path, logger) if err != nil { t.Fatalf("failed to create new Instancer: %v", err) } defer instancer.Stop() endpointer := sd.NewEndpointer(instancer, newFactory(""), logger) if _, err := endpointer.Endpoints(); err != nil { t.Fatal(err) } } func TestBadFactory(t *testing.T) { client := newFakeClient() instancer, err := NewInstancer(client, path, logger) if err != nil { t.Fatalf("failed to create new Instancer: %v", err) } defer instancer.Stop() endpointer := sd.NewEndpointer(instancer, newFactory("kaboom"), logger) // instance1 came online client.AddService(path+"/instance1", "kaboom") // instance2 came online client.AddService(path+"/instance2", "zookeeper_node_data") if err = asyncTest(100*time.Millisecond, 1, endpointer); err != nil { t.Error(err) } } func TestServiceUpdate(t *testing.T) { client := newFakeClient() instancer, err := NewInstancer(client, path, logger) if err != nil { t.Fatalf("failed to create new Instancer: %v", err) } defer instancer.Stop() endpointer := sd.NewEndpointer(instancer, newFactory(""), logger) endpoints, err := endpointer.Endpoints() if err != nil { t.Fatal(err) } if want, have := 0, len(endpoints); want != have { t.Errorf("want %d, have %d", want, have) } // instance1 came online client.AddService(path+"/instance1", "zookeeper_node_data1") // instance2 came online client.AddService(path+"/instance2", "zookeeper_node_data2") // we should have 2 instances if err = asyncTest(100*time.Millisecond, 2, endpointer); err != nil { t.Error(err) } // TODO(pb): this bit is flaky // //// watch triggers an error... //client.SendErrorOnWatch() // //// test if error was consumed //if err = client.ErrorIsConsumedWithin(100 * time.Millisecond); err != nil { // t.Error(err) //} // instance3 came online client.AddService(path+"/instance3", "zookeeper_node_data3") // we should have 3 instances if err = asyncTest(100*time.Millisecond, 3, endpointer); err != nil { t.Error(err) } // instance1 goes offline client.RemoveService(path + "/instance1") // instance2 goes offline client.RemoveService(path + "/instance2") // we should have 1 instance if err = asyncTest(100*time.Millisecond, 1, endpointer); err != nil { t.Error(err) } } func TestBadInstancerCreate(t *testing.T) { client := newFakeClient() client.SendErrorOnWatch() instancer, err := NewInstancer(client, path, logger) if err == nil { t.Error("expected error on new Instancer") } if instancer != nil { t.Error("expected Instancer not to be created") } instancer, err = NewInstancer(client, "BadPath", logger) if err == nil { t.Error("expected error on new Instancer") } if instancer != nil { t.Error("expected Instancer not to be created") } } golang-github-go-kit-kit-0.6.0/sd/zk/integration_test.go000066400000000000000000000105101316471211400231610ustar00rootroot00000000000000// +build integration package zk import ( "bytes" "log" "os" "testing" "time" stdzk "github.com/samuel/go-zookeeper/zk" ) var ( host []string ) func TestMain(m *testing.M) { zkAddr := os.Getenv("ZK_ADDR") if zkAddr == "" { log.Fatal("ZK_ADDR is not set") } host = []string{zkAddr} } func TestCreateParentNodesOnServer(t *testing.T) { payload := [][]byte{[]byte("Payload"), []byte("Test")} c1, err := NewClient(host, logger, Payload(payload)) if err != nil { t.Fatalf("Connect returned error: %v", err) } if c1 == nil { t.Fatal("Expected pointer to client, got nil") } defer c1.Stop() instancer, err := NewInstancer(c1, path, logger) if err != nil { t.Fatalf("Unable to create Subscriber: %v", err) } defer instancer.Stop() state := instancer.state() if state.Err != nil { t.Fatal(err) } if want, have := 0, len(state.Instances); want != have { t.Errorf("want %d, have %d", want, have) } c2, err := NewClient(host, logger) if err != nil { t.Fatalf("Connect returned error: %v", err) } defer c2.Stop() data, _, err := c2.(*client).Get(path) if err != nil { t.Fatal(err) } // test Client implementation of CreateParentNodes. It should have created // our payload if bytes.Compare(data, payload[1]) != 0 { t.Errorf("want %s, have %s", payload[1], data) } } func TestCreateBadParentNodesOnServer(t *testing.T) { c, _ := NewClient(host, logger) defer c.Stop() _, err := NewInstancer(c, "invalid/path", logger) if want, have := stdzk.ErrInvalidPath, err; want != have { t.Errorf("want %v, have %v", want, have) } } func TestCredentials1(t *testing.T) { acl := stdzk.DigestACL(stdzk.PermAll, "user", "secret") c, _ := NewClient(host, logger, ACL(acl), Credentials("user", "secret")) defer c.Stop() _, err := NewInstancer(c, "/acl-issue-test", logger) if err != nil { t.Fatal(err) } } func TestCredentials2(t *testing.T) { acl := stdzk.DigestACL(stdzk.PermAll, "user", "secret") c, _ := NewClient(host, logger, ACL(acl)) defer c.Stop() _, err := NewInstancer(c, "/acl-issue-test", logger) if err != stdzk.ErrNoAuth { t.Errorf("want %v, have %v", stdzk.ErrNoAuth, err) } } func TestConnection(t *testing.T) { c, _ := NewClient(host, logger) c.Stop() _, err := NewInstancer(c, "/acl-issue-test", logger) if err != ErrClientClosed { t.Errorf("want %v, have %v", ErrClientClosed, err) } } func TestGetEntriesOnServer(t *testing.T) { var instancePayload = "10.0.3.204:8002" c1, err := NewClient(host, logger) if err != nil { t.Fatalf("Connect returned error: %v", err) } defer c1.Stop() c2, err := NewClient(host, logger) s, err := NewInstancer(c2, path, logger) if err != nil { t.Fatal(err) } defer c2.Stop() instance1 := &Service{ Path: path, Name: "instance1", Data: []byte(instancePayload), } if err = c2.Register(instance1); err != nil { t.Fatalf("Unable to create test ephemeral znode 1: %+v", err) } instance2 := &Service{ Path: path, Name: "instance2", Data: []byte(instancePayload), } if err = c2.Register(instance2); err != nil { t.Fatalf("Unable to create test ephemeral znode 2: %+v", err) } time.Sleep(50 * time.Millisecond) state := s.state() if state.Err != nil { t.Fatal(state.Err) } if want, have := 2, len(state.Instances); want != have { t.Errorf("want %d, have %d", want, have) } } func TestGetEntriesPayloadOnServer(t *testing.T) { c, err := NewClient(host, logger) if err != nil { t.Fatalf("Connect returned error: %v", err) } _, eventc, err := c.GetEntries(path) if err != nil { t.Fatal(err) } instance3 := Service{ Path: path, Name: "instance3", Data: []byte("just some payload"), } registrar := NewRegistrar(c, instance3, logger) registrar.Register() select { case event := <-eventc: if want, have := stdzk.EventNodeChildrenChanged.String(), event.Type.String(); want != have { t.Errorf("want %s, have %s", want, have) } case <-time.After(100 * time.Millisecond): t.Errorf("expected incoming watch event, timeout occurred") } _, eventc, err = c.GetEntries(path) if err != nil { t.Fatal(err) } registrar.Deregister() select { case event := <-eventc: if want, have := stdzk.EventNodeChildrenChanged.String(), event.Type.String(); want != have { t.Errorf("want %s, have %s", want, have) } case <-time.After(100 * time.Millisecond): t.Errorf("expected incoming watch event, timeout occurred") } } golang-github-go-kit-kit-0.6.0/sd/zk/logwrapper.go000066400000000000000000000011741316471211400217670ustar00rootroot00000000000000package zk import ( "fmt" "github.com/samuel/go-zookeeper/zk" "github.com/go-kit/kit/log" ) // wrapLogger wraps a Go kit logger so we can use it as the logging service for // the ZooKeeper library, which expects a Printf method to be available. type wrapLogger struct { log.Logger } func (logger wrapLogger) Printf(format string, args ...interface{}) { logger.Log("msg", fmt.Sprintf(format, args...)) } // withLogger replaces the ZooKeeper library's default logging service with our // own Go kit logger. func withLogger(logger log.Logger) func(c *zk.Conn) { return func(c *zk.Conn) { c.SetLogger(wrapLogger{logger}) } } golang-github-go-kit-kit-0.6.0/sd/zk/registrar.go000066400000000000000000000026041316471211400216060ustar00rootroot00000000000000package zk import "github.com/go-kit/kit/log" // Registrar registers service instance liveness information to ZooKeeper. type Registrar struct { client Client service Service logger log.Logger } // Service holds the root path, service name and instance identifying data you // want to publish to ZooKeeper. type Service struct { Path string // discovery namespace, example: /myorganization/myplatform/ Name string // service name, example: addscv Data []byte // instance data to store for discovery, example: 10.0.2.10:80 node string // Client will record the ephemeral node name so we can deregister } // NewRegistrar returns a ZooKeeper Registrar acting on the provided catalog // registration. func NewRegistrar(client Client, service Service, logger log.Logger) *Registrar { return &Registrar{ client: client, service: service, logger: log.With(logger, "service", service.Name, "path", service.Path, "data", string(service.Data), ), } } // Register implements sd.Registrar interface. func (r *Registrar) Register() { if err := r.client.Register(&r.service); err != nil { r.logger.Log("err", err) } else { r.logger.Log("action", "register") } } // Deregister implements sd.Registrar interface. func (r *Registrar) Deregister() { if err := r.client.Deregister(&r.service); err != nil { r.logger.Log("err", err) } else { r.logger.Log("action", "deregister") } } golang-github-go-kit-kit-0.6.0/sd/zk/util_test.go000066400000000000000000000052121316471211400216160ustar00rootroot00000000000000package zk import ( "context" "errors" "fmt" "io" "sync" "time" "github.com/samuel/go-zookeeper/zk" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" "github.com/go-kit/kit/sd" ) var ( path = "/gokit.test/service.name" e = func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil } logger = log.NewNopLogger() ) type fakeClient struct { mtx sync.Mutex ch chan zk.Event responses map[string]string result bool } func newFakeClient() *fakeClient { return &fakeClient{ ch: make(chan zk.Event, 1), responses: make(map[string]string), result: true, } } func (c *fakeClient) CreateParentNodes(path string) error { if path == "BadPath" { return errors.New("dummy error") } return nil } func (c *fakeClient) GetEntries(path string) ([]string, <-chan zk.Event, error) { c.mtx.Lock() defer c.mtx.Unlock() if c.result == false { c.result = true return []string{}, c.ch, errors.New("dummy error") } responses := []string{} for _, data := range c.responses { responses = append(responses, data) } return responses, c.ch, nil } func (c *fakeClient) AddService(node, data string) { c.mtx.Lock() defer c.mtx.Unlock() c.responses[node] = data c.ch <- zk.Event{} } func (c *fakeClient) RemoveService(node string) { c.mtx.Lock() defer c.mtx.Unlock() delete(c.responses, node) c.ch <- zk.Event{} } func (c *fakeClient) Register(s *Service) error { return nil } func (c *fakeClient) Deregister(s *Service) error { return nil } func (c *fakeClient) SendErrorOnWatch() { c.mtx.Lock() defer c.mtx.Unlock() c.result = false c.ch <- zk.Event{} } func (c *fakeClient) ErrorIsConsumedWithin(timeout time.Duration) error { t := time.After(timeout) for { select { case <-t: return fmt.Errorf("expected error not consumed after timeout %s", timeout) default: c.mtx.Lock() if c.result == false { c.mtx.Unlock() return nil } c.mtx.Unlock() } } } func (c *fakeClient) Stop() {} func newFactory(fakeError string) sd.Factory { return func(instance string) (endpoint.Endpoint, io.Closer, error) { if fakeError == instance { return nil, nil, errors.New(fakeError) } return endpoint.Nop, nil, nil } } func asyncTest(timeout time.Duration, want int, s sd.Endpointer) (err error) { var endpoints []endpoint.Endpoint have := -1 // want can never be <0 t := time.After(timeout) for { select { case <-t: return fmt.Errorf("want %d, have %d (timeout %s)", want, have, timeout.String()) default: endpoints, err = s.Endpoints() have = len(endpoints) if err != nil || want == have { return } time.Sleep(timeout / 10) } } } golang-github-go-kit-kit-0.6.0/tracing/000077500000000000000000000000001316471211400176505ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/tracing/README.md000066400000000000000000000044441316471211400211350ustar00rootroot00000000000000# package tracing `package tracing` provides [Dapper][]-style request tracing to services. ## Rationale Request tracing is a fundamental building block for large distributed applications. It's instrumental in understanding request flows, identifying hot spots, and diagnosing errors. All microservice infrastructures will benefit from request tracing; sufficiently large infrastructures will require it. ## OpenTracing Go kit builds on top of the [OpenTracing] API and uses the [opentracing-go] package to provide tracing middlewares for its servers and clients. Currently `kit/transport/http` and `kit/transport/grpc` transports are supported. Since [OpenTracing] is an upcoming standard API, Go kit should support a multitude of tracing backends. If a Tracer implementation in Go for your back-end exists, it should work out of the box. The following tracing back-ends are known to work with Go kit through the OpenTracing interface and are highlighted in the [addsvc] example. ### LightStep [LightStep] support is available through their standard Go package [lightstep-tracer-go]. ### AppDash [Appdash] support is available straight from their system repository in the [appdash/opentracing] directory. ### Zipkin [Zipkin] support is now available from the [zipkin-go-opentracing] package which can be found at the [Open Zipkin GitHub] page. This means our old custom `tracing/zipkin` package is now deprecated. In the `kit/tracing/zipkin` directory you can still find the `docker-compose` script to bootstrap a Zipkin development environment and a [README] detailing how to transition from the old package to the new. [Dapper]: http://research.google.com/pubs/pub36356.html [addsvc]:https://github.com/go-kit/kit/tree/master/examples/addsvc [README]: https://github.com/go-kit/kit/blob/master/tracing/zipkin/README.md [OpenTracing]: http://opentracing.io [opentracing-go]: https://github.com/opentracing/opentracing-go [Zipkin]: http://zipkin.io/ [Open Zipkin GitHub]: https://github.com/openzipkin [zipkin-go-opentracing]: https://github.com/openzipkin/zipkin-go-opentracing [Appdash]: https://github.com/sourcegraph/appdash [appdash/opentracing]: https://github.com/sourcegraph/appdash/tree/master/opentracing [LightStep]: http://lightstep.com/ [lightstep-tracer-go]: https://github.com/lightstep/lightstep-tracer-go golang-github-go-kit-kit-0.6.0/tracing/doc.go000066400000000000000000000007031316471211400207440ustar00rootroot00000000000000// Package tracing provides helpers and bindings for distributed tracing. // // As your infrastructure grows, it becomes important to be able to trace a // request, as it travels through multiple services and back to the user. // Package tracing provides endpoints and transport helpers and middlewares to // capture and emit request-scoped information. We use the excellent OpenTracing // project to bind to concrete tracing systems. package tracing golang-github-go-kit-kit-0.6.0/tracing/opentracing/000077500000000000000000000000001316471211400221615ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/tracing/opentracing/doc.go000066400000000000000000000003771316471211400232640ustar00rootroot00000000000000// Package opentracing provides Go kit integration to the OpenTracing project. // OpenTracing implements a general purpose interface that microservices can // program against, and which adapts to all major distributed tracing systems. package opentracing golang-github-go-kit-kit-0.6.0/tracing/opentracing/endpoint.go000066400000000000000000000034731316471211400243370ustar00rootroot00000000000000package opentracing import ( "context" "github.com/opentracing/opentracing-go" otext "github.com/opentracing/opentracing-go/ext" "github.com/go-kit/kit/endpoint" ) // TraceServer returns a Middleware that wraps the `next` Endpoint in an // OpenTracing Span called `operationName`. // // If `ctx` already has a Span, it is re-used and the operation name is // overwritten. If `ctx` does not yet have a Span, one is created here. func TraceServer(tracer opentracing.Tracer, operationName string) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { serverSpan := opentracing.SpanFromContext(ctx) if serverSpan == nil { // All we can do is create a new root span. serverSpan = tracer.StartSpan(operationName) } else { serverSpan.SetOperationName(operationName) } defer serverSpan.Finish() otext.SpanKindRPCServer.Set(serverSpan) ctx = opentracing.ContextWithSpan(ctx, serverSpan) return next(ctx, request) } } } // TraceClient returns a Middleware that wraps the `next` Endpoint in an // OpenTracing Span called `operationName`. func TraceClient(tracer opentracing.Tracer, operationName string) endpoint.Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { var clientSpan opentracing.Span if parentSpan := opentracing.SpanFromContext(ctx); parentSpan != nil { clientSpan = tracer.StartSpan( operationName, opentracing.ChildOf(parentSpan.Context()), ) } else { clientSpan = tracer.StartSpan(operationName) } defer clientSpan.Finish() otext.SpanKindRPCClient.Set(clientSpan) ctx = opentracing.ContextWithSpan(ctx, clientSpan) return next(ctx, request) } } } golang-github-go-kit-kit-0.6.0/tracing/opentracing/endpoint_test.go000066400000000000000000000070441316471211400253740ustar00rootroot00000000000000package opentracing_test import ( "context" "testing" "github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go/mocktracer" "github.com/go-kit/kit/endpoint" kitot "github.com/go-kit/kit/tracing/opentracing" ) func TestTraceServer(t *testing.T) { tracer := mocktracer.New() // Initialize the ctx with a nameless Span. contextSpan := tracer.StartSpan("").(*mocktracer.MockSpan) ctx := opentracing.ContextWithSpan(context.Background(), contextSpan) tracedEndpoint := kitot.TraceServer(tracer, "testOp")(endpoint.Nop) if _, err := tracedEndpoint(ctx, struct{}{}); err != nil { t.Fatal(err) } finishedSpans := tracer.FinishedSpans() if want, have := 1, len(finishedSpans); want != have { t.Fatalf("Want %v span(s), found %v", want, have) } // Test that the op name is updated endpointSpan := finishedSpans[0] if want, have := "testOp", endpointSpan.OperationName; want != have { t.Fatalf("Want %q, have %q", want, have) } contextContext := contextSpan.Context().(mocktracer.MockSpanContext) endpointContext := endpointSpan.Context().(mocktracer.MockSpanContext) // ...and that the ID is unmodified. if want, have := contextContext.SpanID, endpointContext.SpanID; want != have { t.Errorf("Want SpanID %q, have %q", want, have) } } func TestTraceServerNoContextSpan(t *testing.T) { tracer := mocktracer.New() // Empty/background context. tracedEndpoint := kitot.TraceServer(tracer, "testOp")(endpoint.Nop) if _, err := tracedEndpoint(context.Background(), struct{}{}); err != nil { t.Fatal(err) } // tracedEndpoint created a new Span. finishedSpans := tracer.FinishedSpans() if want, have := 1, len(finishedSpans); want != have { t.Fatalf("Want %v span(s), found %v", want, have) } endpointSpan := finishedSpans[0] if want, have := "testOp", endpointSpan.OperationName; want != have { t.Fatalf("Want %q, have %q", want, have) } } func TestTraceClient(t *testing.T) { tracer := mocktracer.New() // Initialize the ctx with a parent Span. parentSpan := tracer.StartSpan("parent").(*mocktracer.MockSpan) defer parentSpan.Finish() ctx := opentracing.ContextWithSpan(context.Background(), parentSpan) tracedEndpoint := kitot.TraceClient(tracer, "testOp")(endpoint.Nop) if _, err := tracedEndpoint(ctx, struct{}{}); err != nil { t.Fatal(err) } // tracedEndpoint created a new Span. finishedSpans := tracer.FinishedSpans() if want, have := 1, len(finishedSpans); want != have { t.Fatalf("Want %v span(s), found %v", want, have) } endpointSpan := finishedSpans[0] if want, have := "testOp", endpointSpan.OperationName; want != have { t.Fatalf("Want %q, have %q", want, have) } parentContext := parentSpan.Context().(mocktracer.MockSpanContext) endpointContext := parentSpan.Context().(mocktracer.MockSpanContext) // ... and that the parent ID is set appropriately. if want, have := parentContext.SpanID, endpointContext.SpanID; want != have { t.Errorf("Want ParentID %q, have %q", want, have) } } func TestTraceClientNoContextSpan(t *testing.T) { tracer := mocktracer.New() // Empty/background context. tracedEndpoint := kitot.TraceClient(tracer, "testOp")(endpoint.Nop) if _, err := tracedEndpoint(context.Background(), struct{}{}); err != nil { t.Fatal(err) } // tracedEndpoint created a new Span. finishedSpans := tracer.FinishedSpans() if want, have := 1, len(finishedSpans); want != have { t.Fatalf("Want %v span(s), found %v", want, have) } endpointSpan := finishedSpans[0] if want, have := "testOp", endpointSpan.OperationName; want != have { t.Fatalf("Want %q, have %q", want, have) } } golang-github-go-kit-kit-0.6.0/tracing/opentracing/grpc.go000066400000000000000000000044761316471211400234560ustar00rootroot00000000000000package opentracing import ( "context" "encoding/base64" "strings" "github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go/ext" "google.golang.org/grpc/metadata" "github.com/go-kit/kit/log" ) // ContextToGRPC returns a grpc RequestFunc that injects an OpenTracing Span // found in `ctx` into the grpc Metadata. If no such Span can be found, the // RequestFunc is a noop. func ContextToGRPC(tracer opentracing.Tracer, logger log.Logger) func(ctx context.Context, md *metadata.MD) context.Context { return func(ctx context.Context, md *metadata.MD) context.Context { if span := opentracing.SpanFromContext(ctx); span != nil { // There's nothing we can do with an error here. if err := tracer.Inject(span.Context(), opentracing.TextMap, metadataReaderWriter{md}); err != nil { logger.Log("err", err) } } return ctx } } // GRPCToContext returns a grpc RequestFunc that tries to join with an // OpenTracing trace found in `req` and starts a new Span called // `operationName` accordingly. If no trace could be found in `req`, the Span // will be a trace root. The Span is incorporated in the returned Context and // can be retrieved with opentracing.SpanFromContext(ctx). func GRPCToContext(tracer opentracing.Tracer, operationName string, logger log.Logger) func(ctx context.Context, md metadata.MD) context.Context { return func(ctx context.Context, md metadata.MD) context.Context { var span opentracing.Span wireContext, err := tracer.Extract(opentracing.TextMap, metadataReaderWriter{&md}) if err != nil && err != opentracing.ErrSpanContextNotFound { logger.Log("err", err) } span = tracer.StartSpan(operationName, ext.RPCServerOption(wireContext)) return opentracing.ContextWithSpan(ctx, span) } } // A type that conforms to opentracing.TextMapReader and // opentracing.TextMapWriter. type metadataReaderWriter struct { *metadata.MD } func (w metadataReaderWriter) Set(key, val string) { key = strings.ToLower(key) if strings.HasSuffix(key, "-bin") { val = string(base64.StdEncoding.EncodeToString([]byte(val))) } (*w.MD)[key] = append((*w.MD)[key], val) } func (w metadataReaderWriter) ForeachKey(handler func(key, val string) error) error { for k, vals := range *w.MD { for _, v := range vals { if err := handler(k, v); err != nil { return err } } } return nil } golang-github-go-kit-kit-0.6.0/tracing/opentracing/grpc_test.go000066400000000000000000000041161316471211400245040ustar00rootroot00000000000000package opentracing_test import ( "context" "testing" "github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go/mocktracer" "google.golang.org/grpc/metadata" "github.com/go-kit/kit/log" kitot "github.com/go-kit/kit/tracing/opentracing" ) func TestTraceGRPCRequestRoundtrip(t *testing.T) { logger := log.NewNopLogger() tracer := mocktracer.New() // Initialize the ctx with a Span to inject. beforeSpan := tracer.StartSpan("to_inject").(*mocktracer.MockSpan) defer beforeSpan.Finish() beforeSpan.SetBaggageItem("baggage", "check") beforeCtx := opentracing.ContextWithSpan(context.Background(), beforeSpan) toGRPCFunc := kitot.ContextToGRPC(tracer, logger) md := metadata.Pairs() // Call the RequestFunc. afterCtx := toGRPCFunc(beforeCtx, &md) // The Span should not have changed. afterSpan := opentracing.SpanFromContext(afterCtx) if beforeSpan != afterSpan { t.Error("Should not swap in a new span") } // No spans should have finished yet. finishedSpans := tracer.FinishedSpans() if want, have := 0, len(finishedSpans); want != have { t.Errorf("Want %v span(s), found %v", want, have) } // Use GRPCToContext to verify that we can join with the trace given MD. fromGRPCFunc := kitot.GRPCToContext(tracer, "joined", logger) joinCtx := fromGRPCFunc(afterCtx, md) joinedSpan := opentracing.SpanFromContext(joinCtx).(*mocktracer.MockSpan) joinedContext := joinedSpan.Context().(mocktracer.MockSpanContext) beforeContext := beforeSpan.Context().(mocktracer.MockSpanContext) if joinedContext.SpanID == beforeContext.SpanID { t.Error("SpanID should have changed", joinedContext.SpanID, beforeContext.SpanID) } // Check that the parent/child relationship is as expected for the joined span. if want, have := beforeContext.SpanID, joinedSpan.ParentID; want != have { t.Errorf("Want ParentID %q, have %q", want, have) } if want, have := "joined", joinedSpan.OperationName; want != have { t.Errorf("Want %q, have %q", want, have) } if want, have := "check", joinedSpan.BaggageItem("baggage"); want != have { t.Errorf("Want %q, have %q", want, have) } } golang-github-go-kit-kit-0.6.0/tracing/opentracing/http.go000066400000000000000000000044641316471211400234770ustar00rootroot00000000000000package opentracing import ( "context" "net" "net/http" "strconv" "github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go/ext" "github.com/go-kit/kit/log" kithttp "github.com/go-kit/kit/transport/http" ) // ContextToHTTP returns an http RequestFunc that injects an OpenTracing Span // found in `ctx` into the http headers. If no such Span can be found, the // RequestFunc is a noop. func ContextToHTTP(tracer opentracing.Tracer, logger log.Logger) kithttp.RequestFunc { return func(ctx context.Context, req *http.Request) context.Context { // Try to find a Span in the Context. if span := opentracing.SpanFromContext(ctx); span != nil { // Add standard OpenTracing tags. ext.HTTPMethod.Set(span, req.Method) ext.HTTPUrl.Set(span, req.URL.String()) host, portString, err := net.SplitHostPort(req.URL.Host) if err == nil { ext.PeerHostname.Set(span, host) if port, err := strconv.Atoi(portString); err != nil { ext.PeerPort.Set(span, uint16(port)) } } else { ext.PeerHostname.Set(span, req.URL.Host) } // There's nothing we can do with any errors here. if err = tracer.Inject( span.Context(), opentracing.TextMap, opentracing.HTTPHeadersCarrier(req.Header), ); err != nil { logger.Log("err", err) } } return ctx } } // HTTPToContext returns an http RequestFunc that tries to join with an // OpenTracing trace found in `req` and starts a new Span called // `operationName` accordingly. If no trace could be found in `req`, the Span // will be a trace root. The Span is incorporated in the returned Context and // can be retrieved with opentracing.SpanFromContext(ctx). func HTTPToContext(tracer opentracing.Tracer, operationName string, logger log.Logger) kithttp.RequestFunc { return func(ctx context.Context, req *http.Request) context.Context { // Try to join to a trace propagated in `req`. var span opentracing.Span wireContext, err := tracer.Extract( opentracing.TextMap, opentracing.HTTPHeadersCarrier(req.Header), ) if err != nil && err != opentracing.ErrSpanContextNotFound { logger.Log("err", err) } span = tracer.StartSpan(operationName, ext.RPCServerOption(wireContext)) ext.HTTPMethod.Set(span, req.Method) ext.HTTPUrl.Set(span, req.URL.String()) return opentracing.ContextWithSpan(ctx, span) } } golang-github-go-kit-kit-0.6.0/tracing/opentracing/http_test.go000066400000000000000000000072511316471211400245330ustar00rootroot00000000000000package opentracing_test import ( "context" "net/http" "reflect" "testing" "github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go/ext" "github.com/opentracing/opentracing-go/mocktracer" "github.com/go-kit/kit/log" kitot "github.com/go-kit/kit/tracing/opentracing" ) func TestTraceHTTPRequestRoundtrip(t *testing.T) { logger := log.NewNopLogger() tracer := mocktracer.New() // Initialize the ctx with a Span to inject. beforeSpan := tracer.StartSpan("to_inject").(*mocktracer.MockSpan) defer beforeSpan.Finish() beforeSpan.SetBaggageItem("baggage", "check") beforeCtx := opentracing.ContextWithSpan(context.Background(), beforeSpan) toHTTPFunc := kitot.ContextToHTTP(tracer, logger) req, _ := http.NewRequest("GET", "http://test.biz/path", nil) // Call the RequestFunc. afterCtx := toHTTPFunc(beforeCtx, req) // The Span should not have changed. afterSpan := opentracing.SpanFromContext(afterCtx) if beforeSpan != afterSpan { t.Error("Should not swap in a new span") } // No spans should have finished yet. finishedSpans := tracer.FinishedSpans() if want, have := 0, len(finishedSpans); want != have { t.Errorf("Want %v span(s), found %v", want, have) } // Use HTTPToContext to verify that we can join with the trace given a req. fromHTTPFunc := kitot.HTTPToContext(tracer, "joined", logger) joinCtx := fromHTTPFunc(afterCtx, req) joinedSpan := opentracing.SpanFromContext(joinCtx).(*mocktracer.MockSpan) joinedContext := joinedSpan.Context().(mocktracer.MockSpanContext) beforeContext := beforeSpan.Context().(mocktracer.MockSpanContext) if joinedContext.SpanID == beforeContext.SpanID { t.Error("SpanID should have changed", joinedContext.SpanID, beforeContext.SpanID) } // Check that the parent/child relationship is as expected for the joined span. if want, have := beforeContext.SpanID, joinedSpan.ParentID; want != have { t.Errorf("Want ParentID %q, have %q", want, have) } if want, have := "joined", joinedSpan.OperationName; want != have { t.Errorf("Want %q, have %q", want, have) } if want, have := "check", joinedSpan.BaggageItem("baggage"); want != have { t.Errorf("Want %q, have %q", want, have) } } func TestContextToHTTPTags(t *testing.T) { tracer := mocktracer.New() span := tracer.StartSpan("to_inject").(*mocktracer.MockSpan) defer span.Finish() ctx := opentracing.ContextWithSpan(context.Background(), span) req, _ := http.NewRequest("GET", "http://test.biz/path", nil) kitot.ContextToHTTP(tracer, log.NewNopLogger())(ctx, req) expectedTags := map[string]interface{}{ string(ext.HTTPMethod): "GET", string(ext.HTTPUrl): "http://test.biz/path", string(ext.PeerHostname): "test.biz", } if !reflect.DeepEqual(expectedTags, span.Tags()) { t.Errorf("Want %q, have %q", expectedTags, span.Tags()) } } func TestHTTPToContextTags(t *testing.T) { tracer := mocktracer.New() parentSpan := tracer.StartSpan("to_extract").(*mocktracer.MockSpan) defer parentSpan.Finish() req, _ := http.NewRequest("GET", "http://test.biz/path", nil) tracer.Inject(parentSpan.Context(), opentracing.TextMap, opentracing.HTTPHeadersCarrier(req.Header)) ctx := kitot.HTTPToContext(tracer, "op", log.NewNopLogger())(context.Background(), req) opentracing.SpanFromContext(ctx).Finish() childSpan := tracer.FinishedSpans()[0] expectedTags := map[string]interface{}{ string(ext.HTTPMethod): "GET", string(ext.HTTPUrl): "http://test.biz/path", string(ext.SpanKind): ext.SpanKindRPCServerEnum, } if !reflect.DeepEqual(expectedTags, childSpan.Tags()) { t.Errorf("Want %q, have %q", expectedTags, childSpan.Tags()) } if want, have := "op", childSpan.OperationName; want != have { t.Errorf("Want %q, have %q", want, have) } } golang-github-go-kit-kit-0.6.0/tracing/zipkin/000077500000000000000000000000001316471211400211545ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/tracing/zipkin/README.md000066400000000000000000000134151316471211400224370ustar00rootroot00000000000000# Zipkin ## Development and Testing Set-up Great efforts have been made to make [Zipkin] easier to test, develop and experiment against. [Zipkin] can now be run from a single Docker container or by running its self-contained executable jar without extensive configuration. In its default configuration you will run Zipkin with a HTTP collector, In memory Span storage backend and web UI on port 9411. Example: ``` docker run -d -p 9411:9411 openzipkin/zipkin ``` [zipkin]: http://zipkin.io Instrumenting your services with Zipkin distributed tracing using the default configuration is now possible with the latest release of [zipkin-go-opentracing] as it includes an HTTP transport for sending spans to the [Zipkin] HTTP Collector. ## Middleware Usage Follow the [addsvc] example to check out how to wire the Zipkin Middleware. The changes should be relatively minor. The [zipkin-go-opentracing] package has support for HTTP, Kafka and Scribe collectors as well as using Go Kit's [Log] package for logging. ### Configuring for the Zipkin HTTP Collector To select the transport for the HTTP Collector, you configure the `Recorder` with the appropriate collector like this: ```go var ( debugMode = false serviceName = "MyService" serviceHostPort = "localhost:8000" zipkinHTTPEndpoint = "localhost:9411" ) collector, err = zipkin.NewHTTPCollector(zipkinHTTPEndpoint) if err != nil { // handle error } tracer, err = zipkin.NewTracer( zipkin.NewRecorder(collector, debugMode, serviceHostPort, serviceName), ... ) ``` ### Span per Node vs. Span per RPC By default Zipkin V1 considers either side of an RPC to have the same identity and differs in that respect from many other tracing systems which consider the caller to be the parent and the receiver to be the child. The OpenTracing specification does not dictate one model over the other, but the Zipkin team is looking into these [single-host-spans] to potentially bring Zipkin more in-line with the other tracing systems. [single-host-spans]: https://github.com/openzipkin/zipkin/issues/963 In case of a `span per node` the receiver will create a child span from the propagated parent span like this: ``` Span per Node propagation and identities CALLER: RECEIVER: --------------------------------- traceId -> traceId spanId (new) spanId -> parentSpanId parentSpanId ``` **Note:** most tracing implementations supporting the `span per node` model therefore do not propagate their `parentSpanID` as its not needed. A typical Zipkin implementation will use the `span per RPC` model and recreate the span identity from the caller on the receiver's end and then annotates its values on top of it. Propagation will happen like this: ``` Span per RPC propagation and identities CALLER: RECEIVER: --------------------------------- traceId -> traceId spanId -> spanId parentSpanId -> parentSpanId ``` The [zipkin-go-opentracing] implementation allows you to choose which model you wish to use. Make sure you select the same model consistently for all your services that are required to communicate with each other or you will have trace propagation issues. If using non OpenTracing / legacy instrumentation, it's probably best to use the `span per RPC call` model. To adhere to the more common tracing philosophy of `span per node`, the Tracer defaults to `span per node`. To set the `span per RPC call` mode start your tracer like this: ```go tracer, err = zipkin.NewTracer( zipkin.NewRecorder(...), zipkin.ClientServerSameSpan(true), ) ``` [zipkin-go-opentracing]: https://github.com/openzipkin/zipkin-go-opentracing [addsvc]:https://github.com/go-kit/kit/tree/master/examples/addsvc [Log]: https://github.com/go-kit/kit/tree/master/log ### Tracing Resources In our legacy implementation we had the `NewChildSpan` method to allow annotation of resources such as databases, caches and other services that do not have server side tracing support. Since OpenTracing has no specific method of dealing with these items explicitely that is compatible with Zipkin's `SA` annotation, the [zipkin-go-opentracing] has implemented support using the OpenTracing Tags system. Here is an example of how one would be able to record a resource span compatible with standard OpenTracing and triggering an `SA` annotation in [zipkin-go-opentracing]: ```go // you need to import the ext package for the Tag helper functions import ( "github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go/ext" ) func (svc *Service) GetMeSomeExamples(ctx context.Context, ...) ([]Examples, error) { // Example of annotating a database query: var ( serviceName = "MySQL" serviceHost = "mysql.example.com" servicePort = uint16(3306) queryLabel = "GetExamplesByParam" query = "select * from example where param = 'value'" ) // retrieve the parent span, if not found create a new trace parentSpan := opentracing.SpanFromContext(ctx) if parentSpan == nil { parentSpan = opentracing.StartSpan(queryLabel) defer parentSpan.Finish() } // create a new span to record the resource interaction span := opentracing.StartChildSpan(parentSpan, queryLabel) // span.kind "resource" triggers SA annotation ext.SpanKind.Set(span, "resource") // this will label the span's service & hostPort (called Endpoint in Zipkin) ext.PeerService.Set(span, serviceName) ext.PeerHostname.Set(span, serviceHost) ext.PeerPort.Set(span, servicePort) // a Tag is the equivalent of a Zipkin Binary Annotation (key:value pair) span.SetTag("query", query) // a LogEvent is the equivalent of a Zipkin Annotation (timestamped) span.LogEvent("query:start") // do the actual query... // let's annotate the end... span.LogEvent("query:end") // we're done with this span. span.Finish() // do other stuff ... } ``` golang-github-go-kit-kit-0.6.0/transport/000077500000000000000000000000001316471211400202555ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/transport/doc.go000066400000000000000000000001211316471211400213430ustar00rootroot00000000000000// Package transport contains bindings to concrete transports. package transport golang-github-go-kit-kit-0.6.0/transport/grpc/000077500000000000000000000000001316471211400212105ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/transport/grpc/README.md000066400000000000000000000040731316471211400224730ustar00rootroot00000000000000# grpc [gRPC](http://www.grpc.io/) is an excellent, modern IDL and transport for microservices. If you're starting a greenfield project, go-kit strongly recommends gRPC as your default transport. One important note is that while gRPC supports streaming requests and replies, go-kit does not. You can still use streams in your service, but their implementation will not be able to take advantage of many go-kit features like middleware. Using gRPC and go-kit together is very simple. First, define your service using protobuf3. This is explained [in gRPC documentation](http://www.grpc.io/docs/#defining-a-service). See [add.proto](https://github.com/go-kit/kit/blob/ec8b02591ee873433565a1ae9d317353412d1d27/examples/addsvc/pb/add.proto) for an example. Make sure the proto definition matches your service's go-kit (interface) definition. Next, get the protoc compiler. You can download pre-compiled binaries from the [protobuf release page](https://github.com/google/protobuf/releases). You will unzip a folder called `protoc3` with a subdirectory `bin` containing an executable. Move that executable somewhere in your `$PATH` and you're good to go! It can also be built from source. ```sh brew install autoconf automake libtool git clone https://github.com/google/protobuf cd protobuf ./autogen.sh ; ./configure ; make ; make install ``` Then, compile your service definition, from .proto to .go. ```sh protoc add.proto --go_out=plugins=grpc:. ``` Finally, write a tiny binding from your service definition to the gRPC definition. It's a simple conversion from one domain to another. See [grpc_binding.go](https://github.com/go-kit/kit/blob/ec8b02591ee873433565a1ae9d317353412d1d27/examples/addsvc/grpc_binding.go) for an example. That's it! The gRPC binding can be bound to a listener and serve normal gRPC requests. And within your service, you can use standard go-kit components and idioms. See [addsvc](https://github.com/go-kit/kit/tree/master/examples/addsvc) for a complete working example with gRPC support. And remember: go-kit services can support multiple transports simultaneously. golang-github-go-kit-kit-0.6.0/transport/grpc/_grpc_test/000077500000000000000000000000001316471211400233415ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/transport/grpc/_grpc_test/client.go000066400000000000000000000020241316471211400251440ustar00rootroot00000000000000package test import ( "context" "google.golang.org/grpc" "github.com/go-kit/kit/endpoint" grpctransport "github.com/go-kit/kit/transport/grpc" "github.com/go-kit/kit/transport/grpc/_grpc_test/pb" ) type clientBinding struct { test endpoint.Endpoint } func (c *clientBinding) Test(ctx context.Context, a string, b int64) (context.Context, string, error) { response, err := c.test(ctx, TestRequest{A: a, B: b}) if err != nil { return nil, "", err } r := response.(*TestResponse) return r.Ctx, r.V, nil } func NewClient(cc *grpc.ClientConn) Service { return &clientBinding{ test: grpctransport.NewClient( cc, "pb.Test", "Test", encodeRequest, decodeResponse, &pb.TestResponse{}, grpctransport.ClientBefore( injectCorrelationID, ), grpctransport.ClientBefore( displayClientRequestHeaders, ), grpctransport.ClientAfter( displayClientResponseHeaders, displayClientResponseTrailers, ), grpctransport.ClientAfter( extractConsumedCorrelationID, ), ).Endpoint(), } } golang-github-go-kit-kit-0.6.0/transport/grpc/_grpc_test/context_metadata.go000066400000000000000000000077711316471211400272300ustar00rootroot00000000000000package test import ( "context" "fmt" "google.golang.org/grpc/metadata" ) type metaContext string const ( correlationID metaContext = "correlation-id" responseHDR metaContext = "my-response-header" responseTRLR metaContext = "my-response-trailer" correlationIDTRLR metaContext = "correlation-id-consumed" ) /* client before functions */ func injectCorrelationID(ctx context.Context, md *metadata.MD) context.Context { if hdr, ok := ctx.Value(correlationID).(string); ok { fmt.Printf("\tClient found correlationID %q in context, set metadata header\n", hdr) (*md)[string(correlationID)] = append((*md)[string(correlationID)], hdr) } return ctx } func displayClientRequestHeaders(ctx context.Context, md *metadata.MD) context.Context { if len(*md) > 0 { fmt.Println("\tClient >> Request Headers:") for key, val := range *md { fmt.Printf("\t\t%s: %s\n", key, val[len(val)-1]) } } return ctx } /* server before functions */ func extractCorrelationID(ctx context.Context, md metadata.MD) context.Context { if hdr, ok := md[string(correlationID)]; ok { cID := hdr[len(hdr)-1] ctx = context.WithValue(ctx, correlationID, cID) fmt.Printf("\tServer received correlationID %q in metadata header, set context\n", cID) } return ctx } func displayServerRequestHeaders(ctx context.Context, md metadata.MD) context.Context { if len(md) > 0 { fmt.Println("\tServer << Request Headers:") for key, val := range md { fmt.Printf("\t\t%s: %s\n", key, val[len(val)-1]) } } return ctx } /* server after functions */ func injectResponseHeader(ctx context.Context, md *metadata.MD, _ *metadata.MD) context.Context { *md = metadata.Join(*md, metadata.Pairs(string(responseHDR), "has-a-value")) return ctx } func displayServerResponseHeaders(ctx context.Context, md *metadata.MD, _ *metadata.MD) context.Context { if len(*md) > 0 { fmt.Println("\tServer >> Response Headers:") for key, val := range *md { fmt.Printf("\t\t%s: %s\n", key, val[len(val)-1]) } } return ctx } func injectResponseTrailer(ctx context.Context, _ *metadata.MD, md *metadata.MD) context.Context { *md = metadata.Join(*md, metadata.Pairs(string(responseTRLR), "has-a-value-too")) return ctx } func injectConsumedCorrelationID(ctx context.Context, _ *metadata.MD, md *metadata.MD) context.Context { if hdr, ok := ctx.Value(correlationID).(string); ok { fmt.Printf("\tServer found correlationID %q in context, set consumed trailer\n", hdr) *md = metadata.Join(*md, metadata.Pairs(string(correlationIDTRLR), hdr)) } return ctx } func displayServerResponseTrailers(ctx context.Context, _ *metadata.MD, md *metadata.MD) context.Context { if len(*md) > 0 { fmt.Println("\tServer >> Response Trailers:") for key, val := range *md { fmt.Printf("\t\t%s: %s\n", key, val[len(val)-1]) } } return ctx } /* client after functions */ func displayClientResponseHeaders(ctx context.Context, md metadata.MD, _ metadata.MD) context.Context { if len(md) > 0 { fmt.Println("\tClient << Response Headers:") for key, val := range md { fmt.Printf("\t\t%s: %s\n", key, val[len(val)-1]) } } return ctx } func displayClientResponseTrailers(ctx context.Context, _ metadata.MD, md metadata.MD) context.Context { if len(md) > 0 { fmt.Println("\tClient << Response Trailers:") for key, val := range md { fmt.Printf("\t\t%s: %s\n", key, val[len(val)-1]) } } return ctx } func extractConsumedCorrelationID(ctx context.Context, _ metadata.MD, md metadata.MD) context.Context { if hdr, ok := md[string(correlationIDTRLR)]; ok { fmt.Printf("\tClient received consumed correlationID %q in metadata trailer, set context\n", hdr[len(hdr)-1]) ctx = context.WithValue(ctx, correlationIDTRLR, hdr[len(hdr)-1]) } return ctx } /* CorrelationID context handlers */ func SetCorrelationID(ctx context.Context, v string) context.Context { return context.WithValue(ctx, correlationID, v) } func GetConsumedCorrelationID(ctx context.Context) string { if trlr, ok := ctx.Value(correlationIDTRLR).(string); ok { return trlr } return "" } golang-github-go-kit-kit-0.6.0/transport/grpc/_grpc_test/pb/000077500000000000000000000000001316471211400237425ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/transport/grpc/_grpc_test/pb/generate.go000066400000000000000000000001041316471211400260560ustar00rootroot00000000000000package pb //go:generate protoc test.proto --go_out=plugins=grpc:. golang-github-go-kit-kit-0.6.0/transport/grpc/_grpc_test/pb/test.pb.go000066400000000000000000000115031316471211400256500ustar00rootroot00000000000000// Code generated by protoc-gen-go. // source: test.proto // DO NOT EDIT! /* Package pb is a generated protocol buffer package. It is generated from these files: test.proto It has these top-level messages: TestRequest TestResponse */ package pb import proto "github.com/golang/protobuf/proto" import fmt "fmt" import math "math" import ( context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package type TestRequest struct { A string `protobuf:"bytes,1,opt,name=a" json:"a,omitempty"` B int64 `protobuf:"varint,2,opt,name=b" json:"b,omitempty"` } func (m *TestRequest) Reset() { *m = TestRequest{} } func (m *TestRequest) String() string { return proto.CompactTextString(m) } func (*TestRequest) ProtoMessage() {} func (*TestRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } func (m *TestRequest) GetA() string { if m != nil { return m.A } return "" } func (m *TestRequest) GetB() int64 { if m != nil { return m.B } return 0 } type TestResponse struct { V string `protobuf:"bytes,1,opt,name=v" json:"v,omitempty"` } func (m *TestResponse) Reset() { *m = TestResponse{} } func (m *TestResponse) String() string { return proto.CompactTextString(m) } func (*TestResponse) ProtoMessage() {} func (*TestResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } func (m *TestResponse) GetV() string { if m != nil { return m.V } return "" } func init() { proto.RegisterType((*TestRequest)(nil), "pb.TestRequest") proto.RegisterType((*TestResponse)(nil), "pb.TestResponse") } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // Client API for Test service type TestClient interface { Test(ctx context.Context, in *TestRequest, opts ...grpc.CallOption) (*TestResponse, error) } type testClient struct { cc *grpc.ClientConn } func NewTestClient(cc *grpc.ClientConn) TestClient { return &testClient{cc} } func (c *testClient) Test(ctx context.Context, in *TestRequest, opts ...grpc.CallOption) (*TestResponse, error) { out := new(TestResponse) err := grpc.Invoke(ctx, "/pb.Test/Test", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } // Server API for Test service type TestServer interface { Test(context.Context, *TestRequest) (*TestResponse, error) } func RegisterTestServer(s *grpc.Server, srv TestServer) { s.RegisterService(&_Test_serviceDesc, srv) } func _Test_Test_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(TestRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TestServer).Test(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pb.Test/Test", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TestServer).Test(ctx, req.(*TestRequest)) } return interceptor(ctx, in, info, handler) } var _Test_serviceDesc = grpc.ServiceDesc{ ServiceName: "pb.Test", HandlerType: (*TestServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Test", Handler: _Test_Test_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "test.proto", } func init() { proto.RegisterFile("test.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ // 129 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x2a, 0x49, 0x2d, 0x2e, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2a, 0x48, 0x52, 0xd2, 0xe4, 0xe2, 0x0e, 0x49, 0x2d, 0x2e, 0x09, 0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x11, 0xe2, 0xe1, 0x62, 0x4c, 0x94, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x62, 0x4c, 0x04, 0xf1, 0x92, 0x24, 0x98, 0x14, 0x18, 0x35, 0x98, 0x83, 0x18, 0x93, 0x94, 0x64, 0xb8, 0x78, 0x20, 0x4a, 0x8b, 0x0b, 0xf2, 0xf3, 0x8a, 0x53, 0x41, 0xb2, 0x65, 0x30, 0xb5, 0x65, 0x46, 0xc6, 0x5c, 0x2c, 0x20, 0x59, 0x21, 0x6d, 0x28, 0xcd, 0xaf, 0x57, 0x90, 0xa4, 0x87, 0x64, 0xb4, 0x94, 0x00, 0x42, 0x00, 0x62, 0x80, 0x12, 0x43, 0x12, 0x1b, 0xd8, 0x21, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x49, 0xfc, 0xd8, 0xf1, 0x96, 0x00, 0x00, 0x00, } golang-github-go-kit-kit-0.6.0/transport/grpc/_grpc_test/pb/test.proto000066400000000000000000000003071316471211400260060ustar00rootroot00000000000000syntax = "proto3"; package pb; service Test { rpc Test (TestRequest) returns (TestResponse) {} } message TestRequest { string a = 1; int64 b = 2; } message TestResponse { string v = 1; } golang-github-go-kit-kit-0.6.0/transport/grpc/_grpc_test/request_response.go000066400000000000000000000013011316471211400272710ustar00rootroot00000000000000package test import ( "context" "github.com/go-kit/kit/transport/grpc/_grpc_test/pb" ) func encodeRequest(ctx context.Context, req interface{}) (interface{}, error) { r := req.(TestRequest) return &pb.TestRequest{A: r.A, B: r.B}, nil } func decodeRequest(ctx context.Context, req interface{}) (interface{}, error) { r := req.(*pb.TestRequest) return TestRequest{A: r.A, B: r.B}, nil } func encodeResponse(ctx context.Context, resp interface{}) (interface{}, error) { r := resp.(*TestResponse) return &pb.TestResponse{V: r.V}, nil } func decodeResponse(ctx context.Context, resp interface{}) (interface{}, error) { r := resp.(*pb.TestResponse) return &TestResponse{V: r.V, Ctx: ctx}, nil } golang-github-go-kit-kit-0.6.0/transport/grpc/_grpc_test/server.go000066400000000000000000000030151316471211400251750ustar00rootroot00000000000000package test import ( "context" "fmt" oldcontext "golang.org/x/net/context" "github.com/go-kit/kit/endpoint" grpctransport "github.com/go-kit/kit/transport/grpc" "github.com/go-kit/kit/transport/grpc/_grpc_test/pb" ) type service struct{} func (service) Test(ctx context.Context, a string, b int64) (context.Context, string, error) { return nil, fmt.Sprintf("%s = %d", a, b), nil } func NewService() Service { return service{} } func makeTestEndpoint(svc Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(TestRequest) newCtx, v, err := svc.Test(ctx, req.A, req.B) return &TestResponse{ V: v, Ctx: newCtx, }, err } } type serverBinding struct { test grpctransport.Handler } func (b *serverBinding) Test(ctx oldcontext.Context, req *pb.TestRequest) (*pb.TestResponse, error) { _, response, err := b.test.ServeGRPC(ctx, req) if err != nil { return nil, err } return response.(*pb.TestResponse), nil } func NewBinding(svc Service) *serverBinding { return &serverBinding{ test: grpctransport.NewServer( makeTestEndpoint(svc), decodeRequest, encodeResponse, grpctransport.ServerBefore( extractCorrelationID, ), grpctransport.ServerBefore( displayServerRequestHeaders, ), grpctransport.ServerAfter( injectResponseHeader, injectResponseTrailer, injectConsumedCorrelationID, ), grpctransport.ServerAfter( displayServerResponseHeaders, displayServerResponseTrailers, ), ), } } golang-github-go-kit-kit-0.6.0/transport/grpc/_grpc_test/service.go000066400000000000000000000003711316471211400253310ustar00rootroot00000000000000package test import "context" type Service interface { Test(ctx context.Context, a string, b int64) (context.Context, string, error) } type TestRequest struct { A string B int64 } type TestResponse struct { Ctx context.Context V string } golang-github-go-kit-kit-0.6.0/transport/grpc/client.go000066400000000000000000000057271316471211400230300ustar00rootroot00000000000000package grpc import ( "context" "fmt" "reflect" "google.golang.org/grpc" "google.golang.org/grpc/metadata" "github.com/go-kit/kit/endpoint" ) // Client wraps a gRPC connection and provides a method that implements // endpoint.Endpoint. type Client struct { client *grpc.ClientConn serviceName string method string enc EncodeRequestFunc dec DecodeResponseFunc grpcReply reflect.Type before []ClientRequestFunc after []ClientResponseFunc } // NewClient constructs a usable Client for a single remote endpoint. // Pass an zero-value protobuf message of the RPC response type as // the grpcReply argument. func NewClient( cc *grpc.ClientConn, serviceName string, method string, enc EncodeRequestFunc, dec DecodeResponseFunc, grpcReply interface{}, options ...ClientOption, ) *Client { c := &Client{ client: cc, method: fmt.Sprintf("/%s/%s", serviceName, method), enc: enc, dec: dec, // We are using reflect.Indirect here to allow both reply structs and // pointers to these reply structs. New consumers of the client should // use structs directly, while existing consumers will not break if they // remain to use pointers to structs. grpcReply: reflect.TypeOf( reflect.Indirect( reflect.ValueOf(grpcReply), ).Interface(), ), before: []ClientRequestFunc{}, after: []ClientResponseFunc{}, } for _, option := range options { option(c) } return c } // ClientOption sets an optional parameter for clients. type ClientOption func(*Client) // ClientBefore sets the RequestFuncs that are applied to the outgoing gRPC // request before it's invoked. func ClientBefore(before ...ClientRequestFunc) ClientOption { return func(c *Client) { c.before = append(c.before, before...) } } // ClientAfter sets the ClientResponseFuncs that are applied to the incoming // gRPC response prior to it being decoded. This is useful for obtaining // response metadata and adding onto the context prior to decoding. func ClientAfter(after ...ClientResponseFunc) ClientOption { return func(c *Client) { c.after = append(c.after, after...) } } // Endpoint returns a usable endpoint that will invoke the gRPC specified by the // client. func (c Client) Endpoint() endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { ctx, cancel := context.WithCancel(ctx) defer cancel() req, err := c.enc(ctx, request) if err != nil { return nil, err } md := &metadata.MD{} for _, f := range c.before { ctx = f(ctx, md) } ctx = metadata.NewOutgoingContext(ctx, *md) var header, trailer metadata.MD grpcReply := reflect.New(c.grpcReply).Interface() if err = grpc.Invoke( ctx, c.method, req, grpcReply, c.client, grpc.Header(&header), grpc.Trailer(&trailer), ); err != nil { return nil, err } for _, f := range c.after { ctx = f(ctx, header, trailer) } response, err := c.dec(ctx, grpcReply) if err != nil { return nil, err } return response, nil } } golang-github-go-kit-kit-0.6.0/transport/grpc/client_test.go000066400000000000000000000023351316471211400240570ustar00rootroot00000000000000package grpc_test import ( "context" "fmt" "net" "testing" "google.golang.org/grpc" test "github.com/go-kit/kit/transport/grpc/_grpc_test" "github.com/go-kit/kit/transport/grpc/_grpc_test/pb" ) const ( hostPort string = "localhost:8002" ) func TestGRPCClient(t *testing.T) { var ( server = grpc.NewServer() service = test.NewService() ) sc, err := net.Listen("tcp", hostPort) if err != nil { t.Fatalf("unable to listen: %+v", err) } defer server.GracefulStop() go func() { pb.RegisterTestServer(server, test.NewBinding(service)) _ = server.Serve(sc) }() cc, err := grpc.Dial(hostPort, grpc.WithInsecure()) if err != nil { t.Fatalf("unable to Dial: %+v", err) } client := test.NewClient(cc) var ( a = "the answer to life the universe and everything" b = int64(42) cID = "request-1" ctx = test.SetCorrelationID(context.Background(), cID) ) responseCTX, v, err := client.Test(ctx, a, b) if err != nil { t.Fatalf("unable to Test: %+v", err) } if want, have := fmt.Sprintf("%s = %d", a, b), v; want != have { t.Fatalf("want %q, have %q", want, have) } if want, have := cID, test.GetConsumedCorrelationID(responseCTX); want != have { t.Fatalf("want %q, have %q", want, have) } } golang-github-go-kit-kit-0.6.0/transport/grpc/doc.go000066400000000000000000000001041316471211400222770ustar00rootroot00000000000000// Package grpc provides a gRPC binding for endpoints. package grpc golang-github-go-kit-kit-0.6.0/transport/grpc/encode_decode.go000066400000000000000000000030321316471211400242750ustar00rootroot00000000000000package grpc import ( "context" ) // DecodeRequestFunc extracts a user-domain request object from a gRPC request. // It's designed to be used in gRPC servers, for server-side endpoints. One // straightforward DecodeRequestFunc could be something that decodes from the // gRPC request message to the concrete request type. type DecodeRequestFunc func(context.Context, interface{}) (request interface{}, err error) // EncodeRequestFunc encodes the passed request object into the gRPC request // object. It's designed to be used in gRPC clients, for client-side endpoints. // One straightforward EncodeRequestFunc could something that encodes the object // directly to the gRPC request message. type EncodeRequestFunc func(context.Context, interface{}) (request interface{}, err error) // EncodeResponseFunc encodes the passed response object to the gRPC response // message. It's designed to be used in gRPC servers, for server-side endpoints. // One straightforward EncodeResponseFunc could be something that encodes the // object directly to the gRPC response message. type EncodeResponseFunc func(context.Context, interface{}) (response interface{}, err error) // DecodeResponseFunc extracts a user-domain response object from a gRPC // response object. It's designed to be used in gRPC clients, for client-side // endpoints. One straightforward DecodeResponseFunc could be something that // decodes from the gRPC response message to the concrete response type. type DecodeResponseFunc func(context.Context, interface{}) (response interface{}, err error) golang-github-go-kit-kit-0.6.0/transport/grpc/request_response_funcs.go000066400000000000000000000053271316471211400263520ustar00rootroot00000000000000package grpc import ( "context" "encoding/base64" "strings" "google.golang.org/grpc/metadata" ) const ( binHdrSuffix = "-bin" ) // ClientRequestFunc may take information from context and use it to construct // metadata headers to be transported to the server. ClientRequestFuncs are // executed after creating the request but prior to sending the gRPC request to // the server. type ClientRequestFunc func(context.Context, *metadata.MD) context.Context // ServerRequestFunc may take information from the received metadata header and // use it to place items in the request scoped context. ServerRequestFuncs are // executed prior to invoking the endpoint. type ServerRequestFunc func(context.Context, metadata.MD) context.Context // ServerResponseFunc may take information from a request context and use it to // manipulate the gRPC response metadata headers and trailers. ResponseFuncs are // only executed in servers, after invoking the endpoint but prior to writing a // response. type ServerResponseFunc func(ctx context.Context, header *metadata.MD, trailer *metadata.MD) context.Context // ClientResponseFunc may take information from a gRPC metadata header and/or // trailer and make the responses available for consumption. ClientResponseFuncs // are only executed in clients, after a request has been made, but prior to it // being decoded. type ClientResponseFunc func(ctx context.Context, header metadata.MD, trailer metadata.MD) context.Context // SetRequestHeader returns a ClientRequestFunc that sets the specified metadata // key-value pair. func SetRequestHeader(key, val string) ClientRequestFunc { return func(ctx context.Context, md *metadata.MD) context.Context { key, val := EncodeKeyValue(key, val) (*md)[key] = append((*md)[key], val) return ctx } } // SetResponseHeader returns a ResponseFunc that sets the specified metadata // key-value pair. func SetResponseHeader(key, val string) ServerResponseFunc { return func(ctx context.Context, md *metadata.MD, _ *metadata.MD) context.Context { key, val := EncodeKeyValue(key, val) (*md)[key] = append((*md)[key], val) return ctx } } // SetResponseTrailer returns a ResponseFunc that sets the specified metadata // key-value pair. func SetResponseTrailer(key, val string) ServerResponseFunc { return func(ctx context.Context, _ *metadata.MD, md *metadata.MD) context.Context { key, val := EncodeKeyValue(key, val) (*md)[key] = append((*md)[key], val) return ctx } } // EncodeKeyValue sanitizes a key-value pair for use in gRPC metadata headers. func EncodeKeyValue(key, val string) (string, string) { key = strings.ToLower(key) if strings.HasSuffix(key, binHdrSuffix) { v := base64.StdEncoding.EncodeToString([]byte(val)) val = string(v) } return key, val } golang-github-go-kit-kit-0.6.0/transport/grpc/server.go000066400000000000000000000062551316471211400230550ustar00rootroot00000000000000package grpc import ( oldcontext "golang.org/x/net/context" "google.golang.org/grpc" "google.golang.org/grpc/metadata" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" ) // Handler which should be called from the gRPC binding of the service // implementation. The incoming request parameter, and returned response // parameter, are both gRPC types, not user-domain. type Handler interface { ServeGRPC(ctx oldcontext.Context, request interface{}) (oldcontext.Context, interface{}, error) } // Server wraps an endpoint and implements grpc.Handler. type Server struct { e endpoint.Endpoint dec DecodeRequestFunc enc EncodeResponseFunc before []ServerRequestFunc after []ServerResponseFunc logger log.Logger } // NewServer constructs a new server, which implements wraps the provided // endpoint and implements the Handler interface. Consumers should write // bindings that adapt the concrete gRPC methods from their compiled protobuf // definitions to individual handlers. Request and response objects are from the // caller business domain, not gRPC request and reply types. func NewServer( e endpoint.Endpoint, dec DecodeRequestFunc, enc EncodeResponseFunc, options ...ServerOption, ) *Server { s := &Server{ e: e, dec: dec, enc: enc, logger: log.NewNopLogger(), } for _, option := range options { option(s) } return s } // ServerOption sets an optional parameter for servers. type ServerOption func(*Server) // ServerBefore functions are executed on the HTTP request object before the // request is decoded. func ServerBefore(before ...ServerRequestFunc) ServerOption { return func(s *Server) { s.before = append(s.before, before...) } } // ServerAfter functions are executed on the HTTP response writer after the // endpoint is invoked, but before anything is written to the client. func ServerAfter(after ...ServerResponseFunc) ServerOption { return func(s *Server) { s.after = append(s.after, after...) } } // ServerErrorLogger is used to log non-terminal errors. By default, no errors // are logged. func ServerErrorLogger(logger log.Logger) ServerOption { return func(s *Server) { s.logger = logger } } // ServeGRPC implements the Handler interface. func (s Server) ServeGRPC(ctx oldcontext.Context, req interface{}) (oldcontext.Context, interface{}, error) { // Retrieve gRPC metadata. md, ok := metadata.FromIncomingContext(ctx) if !ok { md = metadata.MD{} } for _, f := range s.before { ctx = f(ctx, md) } request, err := s.dec(ctx, req) if err != nil { s.logger.Log("err", err) return ctx, nil, err } response, err := s.e(ctx, request) if err != nil { s.logger.Log("err", err) return ctx, nil, err } var mdHeader, mdTrailer metadata.MD for _, f := range s.after { ctx = f(ctx, &mdHeader, &mdTrailer) } grpcResp, err := s.enc(ctx, response) if err != nil { s.logger.Log("err", err) return ctx, nil, err } if len(mdHeader) > 0 { if err = grpc.SendHeader(ctx, mdHeader); err != nil { s.logger.Log("err", err) return ctx, nil, err } } if len(mdTrailer) > 0 { if err = grpc.SetTrailer(ctx, mdTrailer); err != nil { s.logger.Log("err", err) return ctx, nil, err } } return ctx, grpcResp, nil } golang-github-go-kit-kit-0.6.0/transport/http/000077500000000000000000000000001316471211400212345ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/transport/http/client.go000066400000000000000000000121261316471211400230430ustar00rootroot00000000000000package http import ( "bytes" "context" "encoding/json" "encoding/xml" "io/ioutil" "net/http" "net/url" "github.com/go-kit/kit/endpoint" ) // Client wraps a URL and provides a method that implements endpoint.Endpoint. type Client struct { client *http.Client method string tgt *url.URL enc EncodeRequestFunc dec DecodeResponseFunc before []RequestFunc after []ClientResponseFunc finalizer ClientFinalizerFunc bufferedStream bool } // NewClient constructs a usable Client for a single remote method. func NewClient( method string, tgt *url.URL, enc EncodeRequestFunc, dec DecodeResponseFunc, options ...ClientOption, ) *Client { c := &Client{ client: http.DefaultClient, method: method, tgt: tgt, enc: enc, dec: dec, before: []RequestFunc{}, after: []ClientResponseFunc{}, bufferedStream: false, } for _, option := range options { option(c) } return c } // ClientOption sets an optional parameter for clients. type ClientOption func(*Client) // SetClient sets the underlying HTTP client used for requests. // By default, http.DefaultClient is used. func SetClient(client *http.Client) ClientOption { return func(c *Client) { c.client = client } } // ClientBefore sets the RequestFuncs that are applied to the outgoing HTTP // request before it's invoked. func ClientBefore(before ...RequestFunc) ClientOption { return func(c *Client) { c.before = append(c.before, before...) } } // ClientAfter sets the ClientResponseFuncs applied to the incoming HTTP // request prior to it being decoded. This is useful for obtaining anything off // of the response and adding onto the context prior to decoding. func ClientAfter(after ...ClientResponseFunc) ClientOption { return func(c *Client) { c.after = append(c.after, after...) } } // ClientFinalizer is executed at the end of every HTTP request. // By default, no finalizer is registered. func ClientFinalizer(f ClientFinalizerFunc) ClientOption { return func(s *Client) { s.finalizer = f } } // BufferedStream sets whether the Response.Body is left open, allowing it // to be read from later. Useful for transporting a file as a buffered stream. func BufferedStream(buffered bool) ClientOption { return func(c *Client) { c.bufferedStream = buffered } } // Endpoint returns a usable endpoint that invokes the remote endpoint. func (c Client) Endpoint() endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { ctx, cancel := context.WithCancel(ctx) defer cancel() var ( resp *http.Response err error ) if c.finalizer != nil { defer func() { if resp != nil { ctx = context.WithValue(ctx, ContextKeyResponseHeaders, resp.Header) ctx = context.WithValue(ctx, ContextKeyResponseSize, resp.ContentLength) } c.finalizer(ctx, err) }() } req, err := http.NewRequest(c.method, c.tgt.String(), nil) if err != nil { return nil, err } if err = c.enc(ctx, req, request); err != nil { return nil, err } for _, f := range c.before { ctx = f(ctx, req) } resp, err = c.client.Do(req.WithContext(ctx)) if err != nil { return nil, err } if !c.bufferedStream { defer resp.Body.Close() } for _, f := range c.after { ctx = f(ctx, resp) } response, err := c.dec(ctx, resp) if err != nil { return nil, err } return response, nil } } // ClientFinalizerFunc can be used to perform work at the end of a client HTTP // request, after the response is returned. The principal // intended use is for error logging. Additional response parameters are // provided in the context under keys with the ContextKeyResponse prefix. // Note: err may be nil. There maybe also no additional response parameters depending on // when an error occurs. type ClientFinalizerFunc func(ctx context.Context, err error) // EncodeJSONRequest is an EncodeRequestFunc that serializes the request as a // JSON object to the Request body. Many JSON-over-HTTP services can use it as // a sensible default. If the request implements Headerer, the provided headers // will be applied to the request. func EncodeJSONRequest(c context.Context, r *http.Request, request interface{}) error { r.Header.Set("Content-Type", "application/json; charset=utf-8") if headerer, ok := request.(Headerer); ok { for k := range headerer.Headers() { r.Header.Set(k, headerer.Headers().Get(k)) } } var b bytes.Buffer r.Body = ioutil.NopCloser(&b) return json.NewEncoder(&b).Encode(request) } // EncodeXMLRequest is an EncodeRequestFunc that serializes the request as a // XML object to the Request body. If the request implements Headerer, // the provided headers will be applied to the request. func EncodeXMLRequest(c context.Context, r *http.Request, request interface{}) error { r.Header.Set("Content-Type", "text/xml; charset=utf-8") if headerer, ok := request.(Headerer); ok { for k := range headerer.Headers() { r.Header.Set(k, headerer.Headers().Get(k)) } } var b bytes.Buffer r.Body = ioutil.NopCloser(&b) return xml.NewEncoder(&b).Encode(request) } golang-github-go-kit-kit-0.6.0/transport/http/client_test.go000066400000000000000000000150741316471211400241070ustar00rootroot00000000000000package http_test import ( "context" "io" "io/ioutil" "net/http" "net/http/httptest" "net/url" "testing" "time" httptransport "github.com/go-kit/kit/transport/http" ) type TestResponse struct { Body io.ReadCloser String string } func TestHTTPClient(t *testing.T) { var ( testbody = "testbody" encode = func(context.Context, *http.Request, interface{}) error { return nil } decode = func(_ context.Context, r *http.Response) (interface{}, error) { buffer := make([]byte, len(testbody)) r.Body.Read(buffer) return TestResponse{r.Body, string(buffer)}, nil } headers = make(chan string, 1) headerKey = "X-Foo" headerVal = "abcde" afterHeaderKey = "X-The-Dude" afterHeaderVal = "Abides" afterVal = "" afterFunc = func(ctx context.Context, r *http.Response) context.Context { afterVal = r.Header.Get(afterHeaderKey) return ctx } ) server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { headers <- r.Header.Get(headerKey) w.Header().Set(afterHeaderKey, afterHeaderVal) w.WriteHeader(http.StatusOK) w.Write([]byte(testbody)) })) client := httptransport.NewClient( "GET", mustParse(server.URL), encode, decode, httptransport.ClientBefore(httptransport.SetRequestHeader(headerKey, headerVal)), httptransport.ClientAfter(afterFunc), ) res, err := client.Endpoint()(context.Background(), struct{}{}) if err != nil { t.Fatal(err) } var have string select { case have = <-headers: case <-time.After(time.Millisecond): t.Fatalf("timeout waiting for %s", headerKey) } // Check that Request Header was successfully received if want := headerVal; want != have { t.Errorf("want %q, have %q", want, have) } // Check that Response header set from server was received in SetClientAfter if want, have := afterVal, afterHeaderVal; want != have { t.Errorf("want %q, have %q", want, have) } // Check that the response was successfully decoded response, ok := res.(TestResponse) if !ok { t.Fatal("response should be TestResponse") } if want, have := testbody, response.String; want != have { t.Errorf("want %q, have %q", want, have) } // Check that response body was closed b := make([]byte, 1) _, err = response.Body.Read(b) if err == nil { t.Fatal("wanted error, got none") } if doNotWant, have := io.EOF, err; doNotWant == have { t.Errorf("do not want %q, have %q", doNotWant, have) } } func TestHTTPClientBufferedStream(t *testing.T) { var ( testbody = "testbody" encode = func(context.Context, *http.Request, interface{}) error { return nil } decode = func(_ context.Context, r *http.Response) (interface{}, error) { return TestResponse{r.Body, ""}, nil } ) server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) w.Write([]byte(testbody)) })) client := httptransport.NewClient( "GET", mustParse(server.URL), encode, decode, httptransport.BufferedStream(true), ) res, err := client.Endpoint()(context.Background(), struct{}{}) if err != nil { t.Fatal(err) } // Check that the response was successfully decoded response, ok := res.(TestResponse) if !ok { t.Fatal("response should be TestResponse") } // Check that response body was NOT closed b := make([]byte, len(testbody)) _, err = response.Body.Read(b) if want, have := io.EOF, err; have != want { t.Fatalf("want %q, have %q", want, have) } if want, have := testbody, string(b); want != have { t.Errorf("want %q, have %q", want, have) } } func TestClientFinalizer(t *testing.T) { var ( headerKey = "X-Henlo-Lizer" headerVal = "Helllo you stinky lizard" responseBody = "go eat a fly ugly\n" done = make(chan struct{}) encode = func(context.Context, *http.Request, interface{}) error { return nil } decode = func(_ context.Context, r *http.Response) (interface{}, error) { return TestResponse{r.Body, ""}, nil } ) server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set(headerKey, headerVal) w.Write([]byte(responseBody)) })) defer server.Close() client := httptransport.NewClient( "GET", mustParse(server.URL), encode, decode, httptransport.ClientFinalizer(func(ctx context.Context, err error) { responseHeader := ctx.Value(httptransport.ContextKeyResponseHeaders).(http.Header) if want, have := headerVal, responseHeader.Get(headerKey); want != have { t.Errorf("%s: want %q, have %q", headerKey, want, have) } responseSize := ctx.Value(httptransport.ContextKeyResponseSize).(int64) if want, have := int64(len(responseBody)), responseSize; want != have { t.Errorf("response size: want %d, have %d", want, have) } close(done) }), ) _, err := client.Endpoint()(context.Background(), struct{}{}) if err != nil { t.Fatal(err) } select { case <-done: case <-time.After(time.Second): t.Fatal("timeout waiting for finalizer") } } func TestEncodeJSONRequest(t *testing.T) { var header http.Header var body string server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { b, err := ioutil.ReadAll(r.Body) if err != nil && err != io.EOF { t.Fatal(err) } header = r.Header body = string(b) })) defer server.Close() serverURL, err := url.Parse(server.URL) if err != nil { t.Fatal(err) } client := httptransport.NewClient( "POST", serverURL, httptransport.EncodeJSONRequest, func(context.Context, *http.Response) (interface{}, error) { return nil, nil }, ).Endpoint() for _, test := range []struct { value interface{} body string }{ {nil, "null\n"}, {12, "12\n"}, {1.2, "1.2\n"}, {true, "true\n"}, {"test", "\"test\"\n"}, {enhancedRequest{Foo: "foo"}, "{\"foo\":\"foo\"}\n"}, } { if _, err := client(context.Background(), test.value); err != nil { t.Error(err) continue } if body != test.body { t.Errorf("%v: actual %#v, expected %#v", test.value, body, test.body) } } if _, err := client(context.Background(), enhancedRequest{Foo: "foo"}); err != nil { t.Fatal(err) } if _, ok := header["X-Edward"]; !ok { t.Fatalf("X-Edward value: actual %v, expected %v", nil, []string{"Snowden"}) } if v := header.Get("X-Edward"); v != "Snowden" { t.Errorf("X-Edward string: actual %v, expected %v", v, "Snowden") } } func mustParse(s string) *url.URL { u, err := url.Parse(s) if err != nil { panic(err) } return u } type enhancedRequest struct { Foo string `json:"foo"` } func (e enhancedRequest) Headers() http.Header { return http.Header{"X-Edward": []string{"Snowden"}} } golang-github-go-kit-kit-0.6.0/transport/http/doc.go000066400000000000000000000001241316471211400223250ustar00rootroot00000000000000// Package http provides a general purpose HTTP binding for endpoints. package http golang-github-go-kit-kit-0.6.0/transport/http/encode_decode.go000066400000000000000000000030251316471211400243230ustar00rootroot00000000000000package http import ( "context" "net/http" ) // DecodeRequestFunc extracts a user-domain request object from an HTTP // request object. It's designed to be used in HTTP servers, for server-side // endpoints. One straightforward DecodeRequestFunc could be something that // JSON decodes from the request body to the concrete response type. type DecodeRequestFunc func(context.Context, *http.Request) (request interface{}, err error) // EncodeRequestFunc encodes the passed request object into the HTTP request // object. It's designed to be used in HTTP clients, for client-side // endpoints. One straightforward EncodeRequestFunc could something that JSON // encodes the object directly to the request body. type EncodeRequestFunc func(context.Context, *http.Request, interface{}) error // EncodeResponseFunc encodes the passed response object to the HTTP response // writer. It's designed to be used in HTTP servers, for server-side // endpoints. One straightforward EncodeResponseFunc could be something that // JSON encodes the object directly to the response body. type EncodeResponseFunc func(context.Context, http.ResponseWriter, interface{}) error // DecodeResponseFunc extracts a user-domain response object from an HTTP // response object. It's designed to be used in HTTP clients, for client-side // endpoints. One straightforward DecodeResponseFunc could be something that // JSON decodes from the response body to the concrete response type. type DecodeResponseFunc func(context.Context, *http.Response) (response interface{}, err error) golang-github-go-kit-kit-0.6.0/transport/http/example_test.go000066400000000000000000000021231316471211400242530ustar00rootroot00000000000000package http import ( "context" "fmt" "net/http" "net/http/httptest" ) func ExamplePopulateRequestContext() { handler := NewServer( func(ctx context.Context, request interface{}) (response interface{}, err error) { fmt.Println("Method", ctx.Value(ContextKeyRequestMethod).(string)) fmt.Println("RequestPath", ctx.Value(ContextKeyRequestPath).(string)) fmt.Println("RequestURI", ctx.Value(ContextKeyRequestURI).(string)) fmt.Println("X-Request-ID", ctx.Value(ContextKeyRequestXRequestID).(string)) return struct{}{}, nil }, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, func(context.Context, http.ResponseWriter, interface{}) error { return nil }, ServerBefore(PopulateRequestContext), ) server := httptest.NewServer(handler) defer server.Close() req, _ := http.NewRequest("PATCH", fmt.Sprintf("%s/search?q=sympatico", server.URL), nil) req.Header.Set("X-Request-Id", "a1b2c3d4e5") http.DefaultClient.Do(req) // Output: // Method PATCH // RequestPath /search // RequestURI /search?q=sympatico // X-Request-ID a1b2c3d4e5 } golang-github-go-kit-kit-0.6.0/transport/http/request_response_funcs.go000066400000000000000000000122351316471211400263720ustar00rootroot00000000000000package http import ( "context" "net/http" ) // RequestFunc may take information from an HTTP request and put it into a // request context. In Servers, RequestFuncs are executed prior to invoking the // endpoint. In Clients, RequestFuncs are executed after creating the request // but prior to invoking the HTTP client. type RequestFunc func(context.Context, *http.Request) context.Context // ServerResponseFunc may take information from a request context and use it to // manipulate a ResponseWriter. ServerResponseFuncs are only executed in // servers, after invoking the endpoint but prior to writing a response. type ServerResponseFunc func(context.Context, http.ResponseWriter) context.Context // ClientResponseFunc may take information from an HTTP request and make the // response available for consumption. ClientResponseFuncs are only executed in // clients, after a request has been made, but prior to it being decoded. type ClientResponseFunc func(context.Context, *http.Response) context.Context // SetContentType returns a ServerResponseFunc that sets the Content-Type header // to the provided value. func SetContentType(contentType string) ServerResponseFunc { return SetResponseHeader("Content-Type", contentType) } // SetResponseHeader returns a ServerResponseFunc that sets the given header. func SetResponseHeader(key, val string) ServerResponseFunc { return func(ctx context.Context, w http.ResponseWriter) context.Context { w.Header().Set(key, val) return ctx } } // SetRequestHeader returns a RequestFunc that sets the given header. func SetRequestHeader(key, val string) RequestFunc { return func(ctx context.Context, r *http.Request) context.Context { r.Header.Set(key, val) return ctx } } // PopulateRequestContext is a RequestFunc that populates several values into // the context from the HTTP request. Those values may be extracted using the // corresponding ContextKey type in this package. func PopulateRequestContext(ctx context.Context, r *http.Request) context.Context { for k, v := range map[contextKey]string{ ContextKeyRequestMethod: r.Method, ContextKeyRequestURI: r.RequestURI, ContextKeyRequestPath: r.URL.Path, ContextKeyRequestProto: r.Proto, ContextKeyRequestHost: r.Host, ContextKeyRequestRemoteAddr: r.RemoteAddr, ContextKeyRequestXForwardedFor: r.Header.Get("X-Forwarded-For"), ContextKeyRequestXForwardedProto: r.Header.Get("X-Forwarded-Proto"), ContextKeyRequestAuthorization: r.Header.Get("Authorization"), ContextKeyRequestReferer: r.Header.Get("Referer"), ContextKeyRequestUserAgent: r.Header.Get("User-Agent"), ContextKeyRequestXRequestID: r.Header.Get("X-Request-Id"), ContextKeyRequestAccept: r.Header.Get("Accept"), } { ctx = context.WithValue(ctx, k, v) } return ctx } type contextKey int const ( // ContextKeyRequestMethod is populated in the context by // PopulateRequestContext. Its value is r.Method. ContextKeyRequestMethod contextKey = iota // ContextKeyRequestURI is populated in the context by // PopulateRequestContext. Its value is r.RequestURI. ContextKeyRequestURI // ContextKeyRequestPath is populated in the context by // PopulateRequestContext. Its value is r.URL.Path. ContextKeyRequestPath // ContextKeyRequestProto is populated in the context by // PopulateRequestContext. Its value is r.Proto. ContextKeyRequestProto // ContextKeyRequestHost is populated in the context by // PopulateRequestContext. Its value is r.Host. ContextKeyRequestHost // ContextKeyRequestRemoteAddr is populated in the context by // PopulateRequestContext. Its value is r.RemoteAddr. ContextKeyRequestRemoteAddr // ContextKeyRequestXForwardedFor is populated in the context by // PopulateRequestContext. Its value is r.Header.Get("X-Forwarded-For"). ContextKeyRequestXForwardedFor // ContextKeyRequestXForwardedProto is populated in the context by // PopulateRequestContext. Its value is r.Header.Get("X-Forwarded-Proto"). ContextKeyRequestXForwardedProto // ContextKeyRequestAuthorization is populated in the context by // PopulateRequestContext. Its value is r.Header.Get("Authorization"). ContextKeyRequestAuthorization // ContextKeyRequestReferer is populated in the context by // PopulateRequestContext. Its value is r.Header.Get("Referer"). ContextKeyRequestReferer // ContextKeyRequestUserAgent is populated in the context by // PopulateRequestContext. Its value is r.Header.Get("User-Agent"). ContextKeyRequestUserAgent // ContextKeyRequestXRequestID is populated in the context by // PopulateRequestContext. Its value is r.Header.Get("X-Request-Id"). ContextKeyRequestXRequestID // ContextKeyRequestAccept is populated in the context by // PopulateRequestContext. Its value is r.Header.Get("Accept"). ContextKeyRequestAccept // ContextKeyResponseHeaders is populated in the context whenever a // ServerFinalizerFunc is specified. Its value is of type http.Header, and // is captured only once the entire response has been written. ContextKeyResponseHeaders // ContextKeyResponseSize is populated in the context whenever a // ServerFinalizerFunc is specified. Its value is of type int64. ContextKeyResponseSize ) golang-github-go-kit-kit-0.6.0/transport/http/request_response_funcs_test.go000066400000000000000000000013141316471211400274250ustar00rootroot00000000000000package http_test import ( "context" "net/http/httptest" "testing" httptransport "github.com/go-kit/kit/transport/http" ) func TestSetHeader(t *testing.T) { const ( key = "X-Foo" val = "12345" ) r := httptest.NewRecorder() httptransport.SetResponseHeader(key, val)(context.Background(), r) if want, have := val, r.Header().Get(key); want != have { t.Errorf("want %q, have %q", want, have) } } func TestSetContentType(t *testing.T) { const contentType = "application/json" r := httptest.NewRecorder() httptransport.SetContentType(contentType)(context.Background(), r) if want, have := contentType, r.Header().Get("Content-Type"); want != have { t.Errorf("want %q, have %q", want, have) } } golang-github-go-kit-kit-0.6.0/transport/http/server.go000066400000000000000000000161231316471211400230740ustar00rootroot00000000000000package http import ( "context" "encoding/json" "net/http" "github.com/go-kit/kit/endpoint" "github.com/go-kit/kit/log" ) // Server wraps an endpoint and implements http.Handler. type Server struct { e endpoint.Endpoint dec DecodeRequestFunc enc EncodeResponseFunc before []RequestFunc after []ServerResponseFunc errorEncoder ErrorEncoder finalizer ServerFinalizerFunc logger log.Logger } // NewServer constructs a new server, which implements http.Handler and wraps // the provided endpoint. func NewServer( e endpoint.Endpoint, dec DecodeRequestFunc, enc EncodeResponseFunc, options ...ServerOption, ) *Server { s := &Server{ e: e, dec: dec, enc: enc, errorEncoder: DefaultErrorEncoder, logger: log.NewNopLogger(), } for _, option := range options { option(s) } return s } // ServerOption sets an optional parameter for servers. type ServerOption func(*Server) // ServerBefore functions are executed on the HTTP request object before the // request is decoded. func ServerBefore(before ...RequestFunc) ServerOption { return func(s *Server) { s.before = append(s.before, before...) } } // ServerAfter functions are executed on the HTTP response writer after the // endpoint is invoked, but before anything is written to the client. func ServerAfter(after ...ServerResponseFunc) ServerOption { return func(s *Server) { s.after = append(s.after, after...) } } // ServerErrorEncoder is used to encode errors to the http.ResponseWriter // whenever they're encountered in the processing of a request. Clients can // use this to provide custom error formatting and response codes. By default, // errors will be written with the DefaultErrorEncoder. func ServerErrorEncoder(ee ErrorEncoder) ServerOption { return func(s *Server) { s.errorEncoder = ee } } // ServerErrorLogger is used to log non-terminal errors. By default, no errors // are logged. This is intended as a diagnostic measure. Finer-grained control // of error handling, including logging in more detail, should be performed in a // custom ServerErrorEncoder or ServerFinalizer, both of which have access to // the context. func ServerErrorLogger(logger log.Logger) ServerOption { return func(s *Server) { s.logger = logger } } // ServerFinalizer is executed at the end of every HTTP request. // By default, no finalizer is registered. func ServerFinalizer(f ServerFinalizerFunc) ServerOption { return func(s *Server) { s.finalizer = f } } // ServeHTTP implements http.Handler. func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { ctx := r.Context() if s.finalizer != nil { iw := &interceptingWriter{w, http.StatusOK, 0} defer func() { ctx = context.WithValue(ctx, ContextKeyResponseHeaders, iw.Header()) ctx = context.WithValue(ctx, ContextKeyResponseSize, iw.written) s.finalizer(ctx, iw.code, r) }() w = iw } for _, f := range s.before { ctx = f(ctx, r) } request, err := s.dec(ctx, r) if err != nil { s.logger.Log("err", err) s.errorEncoder(ctx, err, w) return } response, err := s.e(ctx, request) if err != nil { s.logger.Log("err", err) s.errorEncoder(ctx, err, w) return } for _, f := range s.after { ctx = f(ctx, w) } if err := s.enc(ctx, w, response); err != nil { s.logger.Log("err", err) s.errorEncoder(ctx, err, w) return } } // ErrorEncoder is responsible for encoding an error to the ResponseWriter. // Users are encouraged to use custom ErrorEncoders to encode HTTP errors to // their clients, and will likely want to pass and check for their own error // types. See the example shipping/handling service. type ErrorEncoder func(ctx context.Context, err error, w http.ResponseWriter) // ServerFinalizerFunc can be used to perform work at the end of an HTTP // request, after the response has been written to the client. The principal // intended use is for request logging. In addition to the response code // provided in the function signature, additional response parameters are // provided in the context under keys with the ContextKeyResponse prefix. type ServerFinalizerFunc func(ctx context.Context, code int, r *http.Request) // EncodeJSONResponse is a EncodeResponseFunc that serializes the response as a // JSON object to the ResponseWriter. Many JSON-over-HTTP services can use it as // a sensible default. If the response implements Headerer, the provided headers // will be applied to the response. If the response implements StatusCoder, the // provided StatusCode will be used instead of 200. func EncodeJSONResponse(_ context.Context, w http.ResponseWriter, response interface{}) error { w.Header().Set("Content-Type", "application/json; charset=utf-8") if headerer, ok := response.(Headerer); ok { for k := range headerer.Headers() { w.Header().Set(k, headerer.Headers().Get(k)) } } code := http.StatusOK if sc, ok := response.(StatusCoder); ok { code = sc.StatusCode() } w.WriteHeader(code) if code == http.StatusNoContent { return nil } return json.NewEncoder(w).Encode(response) } // DefaultErrorEncoder writes the error to the ResponseWriter, by default a // content type of text/plain, a body of the plain text of the error, and a // status code of 500. If the error implements Headerer, the provided headers // will be applied to the response. If the error implements json.Marshaler, and // the marshaling succeeds, a content type of application/json and the JSON // encoded form of the error will be used. If the error implements StatusCoder, // the provided StatusCode will be used instead of 500. func DefaultErrorEncoder(_ context.Context, err error, w http.ResponseWriter) { contentType, body := "text/plain; charset=utf-8", []byte(err.Error()) if marshaler, ok := err.(json.Marshaler); ok { if jsonBody, marshalErr := marshaler.MarshalJSON(); marshalErr == nil { contentType, body = "application/json; charset=utf-8", jsonBody } } w.Header().Set("Content-Type", contentType) if headerer, ok := err.(Headerer); ok { for k := range headerer.Headers() { w.Header().Set(k, headerer.Headers().Get(k)) } } code := http.StatusInternalServerError if sc, ok := err.(StatusCoder); ok { code = sc.StatusCode() } w.WriteHeader(code) w.Write(body) } // StatusCoder is checked by DefaultErrorEncoder. If an error value implements // StatusCoder, the StatusCode will be used when encoding the error. By default, // StatusInternalServerError (500) is used. type StatusCoder interface { StatusCode() int } // Headerer is checked by DefaultErrorEncoder. If an error value implements // Headerer, the provided headers will be applied to the response writer, after // the Content-Type is set. type Headerer interface { Headers() http.Header } type interceptingWriter struct { http.ResponseWriter code int written int64 } // WriteHeader may not be explicitly called, so care must be taken to // initialize w.code to its default value of http.StatusOK. func (w *interceptingWriter) WriteHeader(code int) { w.code = code w.ResponseWriter.WriteHeader(code) } func (w *interceptingWriter) Write(p []byte) (int, error) { n, err := w.ResponseWriter.Write(p) w.written += int64(n) return n, err } golang-github-go-kit-kit-0.6.0/transport/http/server_test.go000066400000000000000000000255571316471211400241460ustar00rootroot00000000000000package http_test import ( "context" "errors" "io/ioutil" "net/http" "net/http/httptest" "strings" "testing" "time" "github.com/go-kit/kit/endpoint" httptransport "github.com/go-kit/kit/transport/http" ) func TestServerBadDecode(t *testing.T) { handler := httptransport.NewServer( func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil }, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, errors.New("dang") }, func(context.Context, http.ResponseWriter, interface{}) error { return nil }, ) server := httptest.NewServer(handler) defer server.Close() resp, _ := http.Get(server.URL) if want, have := http.StatusInternalServerError, resp.StatusCode; want != have { t.Errorf("want %d, have %d", want, have) } } func TestServerBadEndpoint(t *testing.T) { handler := httptransport.NewServer( func(context.Context, interface{}) (interface{}, error) { return struct{}{}, errors.New("dang") }, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, func(context.Context, http.ResponseWriter, interface{}) error { return nil }, ) server := httptest.NewServer(handler) defer server.Close() resp, _ := http.Get(server.URL) if want, have := http.StatusInternalServerError, resp.StatusCode; want != have { t.Errorf("want %d, have %d", want, have) } } func TestServerBadEncode(t *testing.T) { handler := httptransport.NewServer( func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil }, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, func(context.Context, http.ResponseWriter, interface{}) error { return errors.New("dang") }, ) server := httptest.NewServer(handler) defer server.Close() resp, _ := http.Get(server.URL) if want, have := http.StatusInternalServerError, resp.StatusCode; want != have { t.Errorf("want %d, have %d", want, have) } } func TestServerErrorEncoder(t *testing.T) { errTeapot := errors.New("teapot") code := func(err error) int { if err == errTeapot { return http.StatusTeapot } return http.StatusInternalServerError } handler := httptransport.NewServer( func(context.Context, interface{}) (interface{}, error) { return struct{}{}, errTeapot }, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, func(context.Context, http.ResponseWriter, interface{}) error { return nil }, httptransport.ServerErrorEncoder(func(_ context.Context, err error, w http.ResponseWriter) { w.WriteHeader(code(err)) }), ) server := httptest.NewServer(handler) defer server.Close() resp, _ := http.Get(server.URL) if want, have := http.StatusTeapot, resp.StatusCode; want != have { t.Errorf("want %d, have %d", want, have) } } func TestServerHappyPath(t *testing.T) { step, response := testServer(t) step() resp := <-response defer resp.Body.Close() buf, _ := ioutil.ReadAll(resp.Body) if want, have := http.StatusOK, resp.StatusCode; want != have { t.Errorf("want %d, have %d (%s)", want, have, buf) } } func TestMultipleServerBefore(t *testing.T) { var ( headerKey = "X-Henlo-Lizer" headerVal = "Helllo you stinky lizard" statusCode = http.StatusTeapot responseBody = "go eat a fly ugly\n" done = make(chan struct{}) ) handler := httptransport.NewServer( endpoint.Nop, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, func(_ context.Context, w http.ResponseWriter, _ interface{}) error { w.Header().Set(headerKey, headerVal) w.WriteHeader(statusCode) w.Write([]byte(responseBody)) return nil }, httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context { ctx = context.WithValue(ctx, "one", 1) return ctx }), httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context { if _, ok := ctx.Value("one").(int); !ok { t.Error("Value was not set properly when multiple ServerBefores are used") } close(done) return ctx }), ) server := httptest.NewServer(handler) defer server.Close() go http.Get(server.URL) select { case <-done: case <-time.After(time.Second): t.Fatal("timeout waiting for finalizer") } } func TestMultipleServerAfter(t *testing.T) { var ( headerKey = "X-Henlo-Lizer" headerVal = "Helllo you stinky lizard" statusCode = http.StatusTeapot responseBody = "go eat a fly ugly\n" done = make(chan struct{}) ) handler := httptransport.NewServer( endpoint.Nop, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, func(_ context.Context, w http.ResponseWriter, _ interface{}) error { w.Header().Set(headerKey, headerVal) w.WriteHeader(statusCode) w.Write([]byte(responseBody)) return nil }, httptransport.ServerAfter(func(ctx context.Context, w http.ResponseWriter) context.Context { ctx = context.WithValue(ctx, "one", 1) return ctx }), httptransport.ServerAfter(func(ctx context.Context, w http.ResponseWriter) context.Context { if _, ok := ctx.Value("one").(int); !ok { t.Error("Value was not set properly when multiple ServerAfters are used") } close(done) return ctx }), ) server := httptest.NewServer(handler) defer server.Close() go http.Get(server.URL) select { case <-done: case <-time.After(time.Second): t.Fatal("timeout waiting for finalizer") } } func TestServerFinalizer(t *testing.T) { var ( headerKey = "X-Henlo-Lizer" headerVal = "Helllo you stinky lizard" statusCode = http.StatusTeapot responseBody = "go eat a fly ugly\n" done = make(chan struct{}) ) handler := httptransport.NewServer( endpoint.Nop, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, func(_ context.Context, w http.ResponseWriter, _ interface{}) error { w.Header().Set(headerKey, headerVal) w.WriteHeader(statusCode) w.Write([]byte(responseBody)) return nil }, httptransport.ServerFinalizer(func(ctx context.Context, code int, _ *http.Request) { if want, have := statusCode, code; want != have { t.Errorf("StatusCode: want %d, have %d", want, have) } responseHeader := ctx.Value(httptransport.ContextKeyResponseHeaders).(http.Header) if want, have := headerVal, responseHeader.Get(headerKey); want != have { t.Errorf("%s: want %q, have %q", headerKey, want, have) } responseSize := ctx.Value(httptransport.ContextKeyResponseSize).(int64) if want, have := int64(len(responseBody)), responseSize; want != have { t.Errorf("response size: want %d, have %d", want, have) } close(done) }), ) server := httptest.NewServer(handler) defer server.Close() go http.Get(server.URL) select { case <-done: case <-time.After(time.Second): t.Fatal("timeout waiting for finalizer") } } type enhancedResponse struct { Foo string `json:"foo"` } func (e enhancedResponse) StatusCode() int { return http.StatusPaymentRequired } func (e enhancedResponse) Headers() http.Header { return http.Header{"X-Edward": []string{"Snowden"}} } func TestEncodeJSONResponse(t *testing.T) { handler := httptransport.NewServer( func(context.Context, interface{}) (interface{}, error) { return enhancedResponse{Foo: "bar"}, nil }, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, httptransport.EncodeJSONResponse, ) server := httptest.NewServer(handler) defer server.Close() resp, err := http.Get(server.URL) if err != nil { t.Fatal(err) } if want, have := http.StatusPaymentRequired, resp.StatusCode; want != have { t.Errorf("StatusCode: want %d, have %d", want, have) } if want, have := "Snowden", resp.Header.Get("X-Edward"); want != have { t.Errorf("X-Edward: want %q, have %q", want, have) } buf, _ := ioutil.ReadAll(resp.Body) if want, have := `{"foo":"bar"}`, strings.TrimSpace(string(buf)); want != have { t.Errorf("Body: want %s, have %s", want, have) } } type noContentResponse struct{} func (e noContentResponse) StatusCode() int { return http.StatusNoContent } func TestEncodeNoContent(t *testing.T) { handler := httptransport.NewServer( func(context.Context, interface{}) (interface{}, error) { return noContentResponse{}, nil }, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, httptransport.EncodeJSONResponse, ) server := httptest.NewServer(handler) defer server.Close() resp, err := http.Get(server.URL) if err != nil { t.Fatal(err) } if want, have := http.StatusNoContent, resp.StatusCode; want != have { t.Errorf("StatusCode: want %d, have %d", want, have) } buf, _ := ioutil.ReadAll(resp.Body) if want, have := 0, len(buf); want != have { t.Errorf("Body: want no content, have %d bytes", have) } } type enhancedError struct{} func (e enhancedError) Error() string { return "enhanced error" } func (e enhancedError) StatusCode() int { return http.StatusTeapot } func (e enhancedError) MarshalJSON() ([]byte, error) { return []byte(`{"err":"enhanced"}`), nil } func (e enhancedError) Headers() http.Header { return http.Header{"X-Enhanced": []string{"1"}} } func TestEnhancedError(t *testing.T) { handler := httptransport.NewServer( func(context.Context, interface{}) (interface{}, error) { return nil, enhancedError{} }, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, func(_ context.Context, w http.ResponseWriter, _ interface{}) error { return nil }, ) server := httptest.NewServer(handler) defer server.Close() resp, err := http.Get(server.URL) if err != nil { t.Fatal(err) } defer resp.Body.Close() if want, have := http.StatusTeapot, resp.StatusCode; want != have { t.Errorf("StatusCode: want %d, have %d", want, have) } if want, have := "1", resp.Header.Get("X-Enhanced"); want != have { t.Errorf("X-Enhanced: want %q, have %q", want, have) } buf, _ := ioutil.ReadAll(resp.Body) if want, have := `{"err":"enhanced"}`, strings.TrimSpace(string(buf)); want != have { t.Errorf("Body: want %s, have %s", want, have) } } func testServer(t *testing.T) (step func(), resp <-chan *http.Response) { var ( stepch = make(chan bool) endpoint = func(context.Context, interface{}) (interface{}, error) { <-stepch; return struct{}{}, nil } response = make(chan *http.Response) handler = httptransport.NewServer( endpoint, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, func(context.Context, http.ResponseWriter, interface{}) error { return nil }, httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context { return ctx }), httptransport.ServerAfter(func(ctx context.Context, w http.ResponseWriter) context.Context { return ctx }), ) ) go func() { server := httptest.NewServer(handler) defer server.Close() resp, err := http.Get(server.URL) if err != nil { t.Error(err) return } response <- resp }() return func() { stepch <- true }, response } golang-github-go-kit-kit-0.6.0/transport/httprp/000077500000000000000000000000001316471211400215765ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/transport/httprp/doc.go000066400000000000000000000003401316471211400226670ustar00rootroot00000000000000// Package httprp provides an HTTP reverse-proxy transport. HTTP handlers that // need to proxy requests to another HTTP service can do so with this package by // specifying the URL to forward the request to. package httprp golang-github-go-kit-kit-0.6.0/transport/httprp/server.go000066400000000000000000000027141316471211400234370ustar00rootroot00000000000000package httprp import ( "context" "net/http" "net/http/httputil" "net/url" ) // RequestFunc may take information from an HTTP request and put it into a // request context. BeforeFuncs are executed prior to invoking the // endpoint. type RequestFunc func(context.Context, *http.Request) context.Context // Server is a proxying request handler. type Server struct { proxy http.Handler before []RequestFunc errorEncoder func(w http.ResponseWriter, err error) } // NewServer constructs a new server that implements http.Server and will proxy // requests to the given base URL using its scheme, host, and base path. // If the target's path is "/base" and the incoming request was for "/dir", // the target request will be for /base/dir. func NewServer( baseURL *url.URL, options ...ServerOption, ) *Server { s := &Server{ proxy: httputil.NewSingleHostReverseProxy(baseURL), } for _, option := range options { option(s) } return s } // ServerOption sets an optional parameter for servers. type ServerOption func(*Server) // ServerBefore functions are executed on the HTTP request object before the // request is decoded. func ServerBefore(before ...RequestFunc) ServerOption { return func(s *Server) { s.before = append(s.before, before...) } } // ServeHTTP implements http.Handler. func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { ctx := r.Context() for _, f := range s.before { ctx = f(ctx, r) } s.proxy.ServeHTTP(w, r) } golang-github-go-kit-kit-0.6.0/transport/httprp/server_test.go000066400000000000000000000103631316471211400244750ustar00rootroot00000000000000package httprp_test import ( "context" "io/ioutil" "net/http" "net/http/httptest" "net/url" "testing" httptransport "github.com/go-kit/kit/transport/httprp" ) func TestServerHappyPathSingleServer(t *testing.T) { originServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) w.Write([]byte("hey")) })) defer originServer.Close() originURL, _ := url.Parse(originServer.URL) handler := httptransport.NewServer( originURL, ) proxyServer := httptest.NewServer(handler) defer proxyServer.Close() resp, _ := http.Get(proxyServer.URL) if want, have := http.StatusOK, resp.StatusCode; want != have { t.Errorf("want %d, have %d", want, have) } responseBody, _ := ioutil.ReadAll(resp.Body) if want, have := "hey", string(responseBody); want != have { t.Errorf("want %q, have %q", want, have) } } func TestServerHappyPathSingleServerWithServerOptions(t *testing.T) { const ( headerKey = "X-TEST-HEADER" headerVal = "go-kit-proxy" ) originServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if want, have := headerVal, r.Header.Get(headerKey); want != have { t.Errorf("want %q, have %q", want, have) } w.WriteHeader(http.StatusOK) w.Write([]byte("hey")) })) defer originServer.Close() originURL, _ := url.Parse(originServer.URL) handler := httptransport.NewServer( originURL, httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context { r.Header.Add(headerKey, headerVal) return ctx }), ) proxyServer := httptest.NewServer(handler) defer proxyServer.Close() resp, _ := http.Get(proxyServer.URL) if want, have := http.StatusOK, resp.StatusCode; want != have { t.Errorf("want %d, have %d", want, have) } responseBody, _ := ioutil.ReadAll(resp.Body) if want, have := "hey", string(responseBody); want != have { t.Errorf("want %q, have %q", want, have) } } func TestServerOriginServerNotFoundResponse(t *testing.T) { originServer := httptest.NewServer(http.NotFoundHandler()) defer originServer.Close() originURL, _ := url.Parse(originServer.URL) handler := httptransport.NewServer( originURL, ) proxyServer := httptest.NewServer(handler) defer proxyServer.Close() resp, _ := http.Get(proxyServer.URL) if want, have := http.StatusNotFound, resp.StatusCode; want != have { t.Errorf("want %d, have %d", want, have) } } func TestServerOriginServerUnreachable(t *testing.T) { // create a server, then promptly shut it down originServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })) originURL, _ := url.Parse(originServer.URL) originServer.Close() handler := httptransport.NewServer( originURL, ) proxyServer := httptest.NewServer(handler) defer proxyServer.Close() resp, _ := http.Get(proxyServer.URL) switch resp.StatusCode { case http.StatusBadGateway: // go1.7 and beyond break case http.StatusInternalServerError: // to go1.7 break default: t.Errorf("want %d or %d, have %d", http.StatusBadGateway, http.StatusInternalServerError, resp.StatusCode) } } func TestMultipleServerBefore(t *testing.T) { const ( headerKey = "X-TEST-HEADER" headerVal = "go-kit-proxy" ) originServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if want, have := headerVal, r.Header.Get(headerKey); want != have { t.Errorf("want %q, have %q", want, have) } w.WriteHeader(http.StatusOK) w.Write([]byte("hey")) })) defer originServer.Close() originURL, _ := url.Parse(originServer.URL) handler := httptransport.NewServer( originURL, httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context { r.Header.Add(headerKey, headerVal) return ctx }), httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context { return ctx }), ) proxyServer := httptest.NewServer(handler) defer proxyServer.Close() resp, _ := http.Get(proxyServer.URL) if want, have := http.StatusOK, resp.StatusCode; want != have { t.Errorf("want %d, have %d", want, have) } responseBody, _ := ioutil.ReadAll(resp.Body) if want, have := "hey", string(responseBody); want != have { t.Errorf("want %q, have %q", want, have) } } golang-github-go-kit-kit-0.6.0/transport/netrpc/000077500000000000000000000000001316471211400215505ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/transport/netrpc/README.md000066400000000000000000000016021316471211400230260ustar00rootroot00000000000000# net/rpc [net/rpc](https://golang.org/pkg/net/rpc) is an RPC transport that's part of the Go standard library. It's a simple and fast transport that's appropriate when all of your services are written in Go. Using net/rpc with Go kit is very simple. Just write a simple binding from your service definition to the net/rpc definition. See [netrpc_binding.go](https://github.com/go-kit/kit/blob/ec8b02591ee873433565a1ae9d317353412d1d27/examples/addsvc/netrpc_binding.go) for an example. That's it! The net/rpc binding can be registered to a name, and bound to an HTTP handler, the same as any other net/rpc endpoint. And within your service, you can use standard Go kit components and idioms. See [addsvc](https://github.com/go-kit/kit/tree/master/examples/addsvc) for a complete working example with net/rpc support. And remember: Go kit services can support multiple transports simultaneously. golang-github-go-kit-kit-0.6.0/transport/thrift/000077500000000000000000000000001316471211400215555ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/transport/thrift/README.md000066400000000000000000000035661316471211400230460ustar00rootroot00000000000000# Thrift [Thrift](https://thrift.apache.org/) is a large IDL and transport package from Apache, popularized by Facebook. Thrift is well-supported in Go kit, for organizations that already have significant Thrift investment. And using Thrift with Go kit is very simple. First, define your service in the Thrift IDL. The [Thrift IDL documentation](https://thrift.apache.org/docs/idl) provides more details. See [add.thrift](https://github.com/go-kit/kit/blob/ec8b02591ee873433565a1ae9d317353412d1d27/examples/addsvc/_thrift/add.thrift) for an example. Make sure the Thrift definition matches your service's Go kit (interface) definition. Next, [download Thrift](https://thrift.apache.org/download) and [install the compiler](https://thrift.apache.org/docs/install/). On a Mac, you may be able to `brew install thrift`. Then, compile your service definition, from .thrift to .go. You'll probably want to specify the package_prefix option to the --gen go flag. See [THRIFT-3021](https://issues.apache.org/jira/browse/THRIFT-3021) for more details. ``` thrift -r --gen go:package_prefix=github.com/my-org/my-repo/thrift/gen-go/ add.thrift ``` Finally, write a tiny binding from your service definition to the Thrift definition. It's a straightforward conversion from one domain to the other. See [thrift_binding.go](https://github.com/go-kit/kit/blob/ec8b02591ee873433565a1ae9d317353412d1d27/examples/addsvc/thrift_binding.go) for an example. That's it! The Thrift binding can be bound to a listener and serve normal Thrift requests. And within your service, you can use standard Go kit components and idioms. Unfortunately, setting up a Thrift listener is rather laborious and nonidiomatic in Go. Fortunately, [addsvc](https://github.com/go-kit/kit/tree/master/examples/addsvc) is a complete working example with Thrift support. And remember: Go kit services can support multiple transports simultaneously. golang-github-go-kit-kit-0.6.0/update_deps.bash000077500000000000000000000011721316471211400213610ustar00rootroot00000000000000#!/usr/bin/env bash # This script updates each non-stdlib, non-Go-kit dependency to its most recent # commit. It can be invoked to aid in debugging after a dependency-related # failure on continuous integration. function deps { go list -f '{{join .Deps "\n"}}' ./... } function not_stdlib { xargs go list -f '{{if not .Standard}}{{.ImportPath}}{{end}}' } function not_gokit { grep -v 'go-kit/kit' } function go_get_update { while read d do echo $d go get -u $d || echo "failed, trying again with master" && cd $GOPATH/src/$d && git checkout master && go get -u $d done } deps | not_stdlib | not_gokit | go_get_update golang-github-go-kit-kit-0.6.0/util/000077500000000000000000000000001316471211400171765ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/util/README.md000066400000000000000000000003101316471211400204470ustar00rootroot00000000000000# util This directory holds packages of general utility to multiple consumers within Go kit, and potentially other consumers in the wider Go ecosystem. There is no `package util` and will never be. golang-github-go-kit-kit-0.6.0/util/conn/000077500000000000000000000000001316471211400201335ustar00rootroot00000000000000golang-github-go-kit-kit-0.6.0/util/conn/doc.go000066400000000000000000000001101316471211400212170ustar00rootroot00000000000000// Package conn provides utilities related to connections. package conn golang-github-go-kit-kit-0.6.0/util/conn/manager.go000066400000000000000000000100211316471211400220660ustar00rootroot00000000000000package conn import ( "errors" "net" "time" "github.com/go-kit/kit/log" ) // Dialer imitates net.Dial. Dialer is assumed to yield connections that are // safe for use by multiple concurrent goroutines. type Dialer func(network, address string) (net.Conn, error) // AfterFunc imitates time.After. type AfterFunc func(time.Duration) <-chan time.Time // Manager manages a net.Conn. // // Clients provide a way to create the connection with a Dialer, network, and // address. Clients should Take the connection when they want to use it, and Put // back whatever error they receive from its use. When a non-nil error is Put, // the connection is invalidated, and a new connection is established. // Connection failures are retried after an exponential backoff. type Manager struct { dialer Dialer network string address string after AfterFunc logger log.Logger takec chan net.Conn putc chan error } // NewManager returns a connection manager using the passed Dialer, network, and // address. The AfterFunc is used to control exponential backoff and retries. // The logger is used to log errors; pass a log.NopLogger if you don't care to // receive them. For normal use, prefer NewDefaultManager. func NewManager(d Dialer, network, address string, after AfterFunc, logger log.Logger) *Manager { m := &Manager{ dialer: d, network: network, address: address, after: after, logger: logger, takec: make(chan net.Conn), putc: make(chan error), } go m.loop() return m } // NewDefaultManager is a helper constructor, suitable for most normal use in // real (non-test) code. It uses the real net.Dial and time.After functions. func NewDefaultManager(network, address string, logger log.Logger) *Manager { return NewManager(net.Dial, network, address, time.After, logger) } // Take yields the current connection. It may be nil. func (m *Manager) Take() net.Conn { return <-m.takec } // Put accepts an error that came from a previously yielded connection. If the // error is non-nil, the manager will invalidate the current connection and try // to reconnect, with exponential backoff. Putting a nil error is a no-op. func (m *Manager) Put(err error) { m.putc <- err } // Write writes the passed data to the connection in a single Take/Put cycle. func (m *Manager) Write(b []byte) (int, error) { conn := m.Take() if conn == nil { return 0, ErrConnectionUnavailable } n, err := conn.Write(b) defer m.Put(err) return n, err } func (m *Manager) loop() { var ( conn = dial(m.dialer, m.network, m.address, m.logger) // may block slightly connc = make(chan net.Conn, 1) reconnectc <-chan time.Time // initially nil backoff = time.Second ) // If the initial dial fails, we need to trigger a reconnect via the loop // body, below. If we did this in a goroutine, we would race on the conn // variable. So we use a buffered chan instead. connc <- conn for { select { case <-reconnectc: reconnectc = nil // one-shot go func() { connc <- dial(m.dialer, m.network, m.address, m.logger) }() case conn = <-connc: if conn == nil { // didn't work backoff = exponential(backoff) // wait longer reconnectc = m.after(backoff) // try again } else { // worked! backoff = time.Second // reset wait time reconnectc = nil // no retry necessary } case m.takec <- conn: case err := <-m.putc: if err != nil && conn != nil { m.logger.Log("err", err) conn = nil // connection is bad reconnectc = m.after(time.Nanosecond) // trigger immediately } } } } func dial(d Dialer, network, address string, logger log.Logger) net.Conn { conn, err := d(network, address) if err != nil { logger.Log("err", err) conn = nil // just to be sure } return conn } func exponential(d time.Duration) time.Duration { d *= 2 if d > time.Minute { d = time.Minute } return d } // ErrConnectionUnavailable is returned by the Manager's Write method when the // manager cannot yield a good connection. var ErrConnectionUnavailable = errors.New("connection unavailable") golang-github-go-kit-kit-0.6.0/util/conn/manager_test.go000066400000000000000000000077711316471211400231470ustar00rootroot00000000000000package conn import ( "errors" "net" "sync/atomic" "testing" "time" "github.com/go-kit/kit/log" ) func TestManager(t *testing.T) { var ( tickc = make(chan time.Time) after = func(time.Duration) <-chan time.Time { return tickc } dialconn = &mockConn{} dialerr = error(nil) dialer = func(string, string) (net.Conn, error) { return dialconn, dialerr } mgr = NewManager(dialer, "netw", "addr", after, log.NewNopLogger()) ) // First conn should be fine. conn := mgr.Take() if conn == nil { t.Fatal("nil conn") } // Write and check it went through. if _, err := conn.Write([]byte{1, 2, 3}); err != nil { t.Fatal(err) } if want, have := uint64(3), atomic.LoadUint64(&dialconn.wr); want != have { t.Errorf("want %d, have %d", want, have) } // Put an error to kill the conn. mgr.Put(errors.New("should kill the connection")) // First takes should fail. for i := 0; i < 10; i++ { if conn = mgr.Take(); conn != nil { t.Fatalf("iteration %d: want nil conn, got real conn", i) } } // Trigger the reconnect. tickc <- time.Now() // The dial should eventually succeed and yield a good conn. if !within(100*time.Millisecond, func() bool { conn = mgr.Take() return conn != nil }) { t.Fatal("conn remained nil") } // Write and check it went through. if _, err := conn.Write([]byte{4, 5}); err != nil { t.Fatal(err) } if want, have := uint64(5), atomic.LoadUint64(&dialconn.wr); want != have { t.Errorf("want %d, have %d", want, have) } // Dial starts failing. dialconn, dialerr = nil, errors.New("oh noes") mgr.Put(errors.New("trigger that reconnect y'all")) if conn = mgr.Take(); conn != nil { t.Fatalf("want nil conn, got real conn") } // As many reconnects as they want. go func() { done := time.After(100 * time.Millisecond) for { select { case tickc <- time.Now(): case <-done: return } } }() // The dial should never succeed. if within(100*time.Millisecond, func() bool { conn = mgr.Take() return conn != nil }) { t.Fatal("eventually got a good conn, despite failing dialer") } } func TestIssue292(t *testing.T) { // The util/conn.Manager won't attempt to reconnect to the provided endpoint // if the endpoint is initially unavailable (e.g. dial tcp :8080: // getsockopt: connection refused). If the endpoint is up when // conn.NewManager is called and then goes down/up, it reconnects just fine. var ( tickc = make(chan time.Time) after = func(time.Duration) <-chan time.Time { return tickc } dialconn = net.Conn(nil) dialerr = errors.New("fail") dialer = func(string, string) (net.Conn, error) { return dialconn, dialerr } mgr = NewManager(dialer, "netw", "addr", after, log.NewNopLogger()) ) if conn := mgr.Take(); conn != nil { t.Fatal("first Take should have yielded nil conn, but didn't") } dialconn, dialerr = &mockConn{}, nil select { case tickc <- time.Now(): case <-time.After(time.Second): t.Fatal("manager isn't listening for a tick, despite a failed dial") } if !within(time.Second, func() bool { return mgr.Take() != nil }) { t.Fatal("second Take should have yielded good conn, but didn't") } } type mockConn struct { rd, wr uint64 } func (c *mockConn) Read(b []byte) (n int, err error) { atomic.AddUint64(&c.rd, uint64(len(b))) return len(b), nil } func (c *mockConn) Write(b []byte) (n int, err error) { atomic.AddUint64(&c.wr, uint64(len(b))) return len(b), nil } func (c *mockConn) Close() error { return nil } func (c *mockConn) LocalAddr() net.Addr { return nil } func (c *mockConn) RemoteAddr() net.Addr { return nil } func (c *mockConn) SetDeadline(t time.Time) error { return nil } func (c *mockConn) SetReadDeadline(t time.Time) error { return nil } func (c *mockConn) SetWriteDeadline(t time.Time) error { return nil } func within(d time.Duration, f func() bool) bool { deadline := time.Now().Add(d) for { if time.Now().After(deadline) { return false } if f() { return true } time.Sleep(d / 10) } }