diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b594430 --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +tmp/ +out/ +cf-cli-plugin +mta-op-*/ +.DS_Store +*/.DS_Store +mta_plugin_darwin_amd64 +mta_plugin_linux_amd64 +mta_plugin_windows_amd64.exe diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..06ba3ca --- /dev/null +++ b/.travis.yml @@ -0,0 +1,11 @@ +language: go +go: + - 1.8 +install: + - chmod +x bin/test.sh + - chmod +x bin/build.sh + - go get -t -v ./... +script: bin/test.sh +branches: + only: + - master diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..5bcd46b --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,9 @@ +## Initial public version 1.0.5 + +* Supported MTA Operations: + * deploy - Deploy MTA + * undeploy - Undeploy MTA + * bg-deploy - Deploy MTA using blue-green approach + * mta/mtas - List existing MTA/MTAs + * mta-ops - Show MTA operations + * download-mta-op-logs - Download process logs for MTA \ No newline at end of file diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json new file mode 100644 index 0000000..3fce7b0 --- /dev/null +++ b/Godeps/Godeps.json @@ -0,0 +1,395 @@ +{ + "ImportPath": "github.com/SAP/cf-mta-plugin", + "GoVersion": "go1.8", + "GodepVersion": "v79", + "Packages": [ + "./..." + ], + "Deps": [ + { + "ImportPath": "github.com/PuerkitoBio/purell", + "Comment": "v1.1.0", + "Rev": "0bcb03f4b4d0a9428594752bd2a3b9aa0a9d4bd4" + }, + { + "ImportPath": "github.com/PuerkitoBio/urlesc", + "Rev": "5bd2802263f21d8788851d5305584c82a5c75d7e" + }, + { + "ImportPath": "github.com/asaskevich/govalidator", + "Comment": "v5", + "Rev": "7b3beb6df3c42abd3509abfc3bcacc0fbfb7c877" + }, + { + "ImportPath": "github.com/blang/semver", + "Comment": "v3.3.0", + "Rev": "60ec3488bfea7cca02b021d106d9911120d25fe9" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/cf", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/cf/configuration", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/cf/configuration/core_config", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/cf/formatters", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/cf/i18n", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/cf/models", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/cf/resources", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/cf/terminal", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/cf/trace", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/plugin", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/plugin/fakes", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/plugin/models", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/cli/testhelpers/io", + "Comment": "v6.16.1", + "Rev": "924508c30d84ba2ee677a79f26b926c516438166" + }, + { + "ImportPath": "github.com/cloudfoundry/gofileutils/fileutils", + "Rev": "9cc1c2584bed48590cb019b4ac5b962b2a81278a" + }, + { + "ImportPath": "github.com/dgrijalva/jwt-go", + "Comment": "v3.0.0-10-g9ed569b", + "Rev": "9ed569b5d1ac936e6494082958d63a6aa4fff99a" + }, + { + "ImportPath": "github.com/go-openapi/analysis", + "Rev": "7222828b8ce19afee3c595aef6643b9e42150120" + }, + { + "ImportPath": "github.com/go-openapi/errors", + "Rev": "49fe8b3a0e0d32a617d8d50c67f856ad6e45b28b" + }, + { + "ImportPath": "github.com/go-openapi/jsonpointer", + "Rev": "8d96a2dc61536b690bd36b2e9df0b3c0b62825b2" + }, + { + "ImportPath": "github.com/go-openapi/jsonreference", + "Rev": "36d33bfe519efae5632669801b180bf1a245da3b" + }, + { + "ImportPath": "github.com/go-openapi/loads", + "Rev": "5861a4879a2866943dce3c644c879af9e59c22a3" + }, + { + "ImportPath": "github.com/go-openapi/runtime", + "Rev": "12c07accf0687ab20b1e7b6293d8012ce282499c" + }, + { + "ImportPath": "github.com/go-openapi/runtime/client", + "Rev": "12c07accf0687ab20b1e7b6293d8012ce282499c" + }, + { + "ImportPath": "github.com/go-openapi/spec", + "Rev": "f7ae86df5bc115a2744343016c789a89f065a4bd" + }, + { + "ImportPath": "github.com/go-openapi/strfmt", + "Rev": "34fc3ba7c0f5fb615fda47a2b4fbd4c641b215f2" + }, + { + "ImportPath": "github.com/go-openapi/swag", + "Rev": "3b6d86cd965820f968760d5d419cb4add096bdd7" + }, + { + "ImportPath": "github.com/go-openapi/validate", + "Rev": "027696d4b54399770f1cdcc6c6daa56975f9e14e" + }, + { + "ImportPath": "github.com/jinzhu/copier", + "Rev": "e15f8e2a05f802ffc4890858fbaeb1975c88feed" + }, + { + "ImportPath": "github.com/mailru/easyjson/buffer", + "Rev": "159cdb893c982e3d1bc6450322fedd514f9c9de3" + }, + { + "ImportPath": "github.com/mailru/easyjson/jlexer", + "Rev": "159cdb893c982e3d1bc6450322fedd514f9c9de3" + }, + { + "ImportPath": "github.com/mailru/easyjson/jwriter", + "Rev": "159cdb893c982e3d1bc6450322fedd514f9c9de3" + }, + { + "ImportPath": "github.com/mitchellh/mapstructure", + "Rev": "f3009df150dadf309fdee4a54ed65c124afad715" + }, + { + "ImportPath": "github.com/nicksnyder/go-i18n/i18n", + "Comment": "v1.6.0-1-g991e81c", + "Rev": "991e81cc94f6c54209edb3192cb98e3995ad71c1" + }, + { + "ImportPath": "github.com/nicksnyder/go-i18n/i18n/bundle", + "Comment": "v1.6.0-1-g991e81c", + "Rev": "991e81cc94f6c54209edb3192cb98e3995ad71c1" + }, + { + "ImportPath": "github.com/nicksnyder/go-i18n/i18n/language", + "Comment": "v1.6.0-1-g991e81c", + "Rev": "991e81cc94f6c54209edb3192cb98e3995ad71c1" + }, + { + "ImportPath": "github.com/nicksnyder/go-i18n/i18n/translation", + "Comment": "v1.6.0-1-g991e81c", + "Rev": "991e81cc94f6c54209edb3192cb98e3995ad71c1" + }, + { + "ImportPath": "github.com/onsi/ginkgo", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/config", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/internal/codelocation", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/internal/containernode", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/internal/failer", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/internal/leafnodes", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/internal/remote", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/internal/spec", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/internal/specrunner", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/internal/suite", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/internal/testingtproxy", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/internal/writer", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/reporters", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/reporters/stenographer", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/reporters/stenographer/support/go-colorable", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/reporters/stenographer/support/go-isatty", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/ginkgo/types", + "Comment": "v1.2.0-87-g00054c0", + "Rev": "00054c0bb96fc880d4e0be1b90937fad438c5290" + }, + { + "ImportPath": "github.com/onsi/gomega", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/onsi/gomega/format", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/onsi/gomega/internal/assertion", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/onsi/gomega/internal/asyncassertion", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/onsi/gomega/internal/oraclematcher", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/onsi/gomega/internal/testingtsupport", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/onsi/gomega/matchers", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/onsi/gomega/matchers/support/goraph/bipartitegraph", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/onsi/gomega/matchers/support/goraph/edge", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/onsi/gomega/matchers/support/goraph/node", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/onsi/gomega/matchers/support/goraph/util", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/onsi/gomega/types", + "Comment": "v1.0-151-gf1f0f38", + "Rev": "f1f0f388b31eca4e2cbe7a6dd8a3a1dfddda5b1c" + }, + { + "ImportPath": "github.com/pborman/uuid", + "Comment": "v1.1", + "Rev": "e790cca94e6cc75c7064b1332e63811d4aae1a53" + }, + { + "ImportPath": "golang.org/x/crypto/ssh/terminal", + "Rev": "ede567c8e044a5913dad1d1af3696d9da953104c" + }, + { + "ImportPath": "golang.org/x/net/context", + "Rev": "4971afdc2f162e82d185353533d3cf16188a9f4e" + }, + { + "ImportPath": "golang.org/x/net/context/ctxhttp", + "Rev": "4971afdc2f162e82d185353533d3cf16188a9f4e" + }, + { + "ImportPath": "golang.org/x/net/idna", + "Rev": "4971afdc2f162e82d185353533d3cf16188a9f4e" + }, + { + "ImportPath": "golang.org/x/sync/errgroup", + "Rev": "1ae7c7b29e06598039be46c5083819ba6fd7a97e" + }, + { + "ImportPath": "golang.org/x/sys/unix", + "Rev": "30237cf4eefd639b184d1f2cb77a581ea0be8947" + }, + { + "ImportPath": "golang.org/x/text/secure/bidirule", + "Rev": "b01949dc0793a9af5e4cb3fce4d42999e76e8ca1" + }, + { + "ImportPath": "golang.org/x/text/transform", + "Rev": "b01949dc0793a9af5e4cb3fce4d42999e76e8ca1" + }, + { + "ImportPath": "golang.org/x/text/unicode/bidi", + "Rev": "b01949dc0793a9af5e4cb3fce4d42999e76e8ca1" + }, + { + "ImportPath": "golang.org/x/text/unicode/norm", + "Rev": "b01949dc0793a9af5e4cb3fce4d42999e76e8ca1" + }, + { + "ImportPath": "golang.org/x/text/width", + "Rev": "b01949dc0793a9af5e4cb3fce4d42999e76e8ca1" + }, + { + "ImportPath": "gopkg.in/yaml.v2", + "Rev": "a5b47d31c556af34a302ce5d659e6fea44d90de0" + }, + { + "ImportPath": "gopkg.in/mgo.v2/bson", + "Comment": "r2016.08.01-5-g3f83fa5", + "Rev": "3f83fa5005286a7fe593b055f0d7771a7dce4655" + }, + { + "ImportPath": "gopkg.in/mgo.v2/internal/json", + "Comment": "r2016.08.01-5-g3f83fa5", + "Rev": "3f83fa5005286a7fe593b055f0d7771a7dce4655" + } + ] +} \ No newline at end of file diff --git a/Godeps/Readme b/Godeps/Readme new file mode 100644 index 0000000..4cdaa53 --- /dev/null +++ b/Godeps/Readme @@ -0,0 +1,5 @@ +This directory tree is generated automatically by godep. + +Please do not edit. + +See https://github.com/tools/godep for more information. diff --git a/LICENSE b/LICENSE index 8dada3e..daa4f9e 100644 --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,4 @@ + Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ @@ -178,7 +179,7 @@ APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" + boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a @@ -186,7 +187,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright {yyyy} {name of copyright owner} + Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -199,3 +200,260 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. + +------------------------------------------------------------------------------ +APIs + +This project may include APIs to SAP or third party products or services. The +use of these APIs, products and services may be subject to additional +agreements. In no event shall the application of the Apache Software License, +v.2 to this project grant any rights in or to these APIs, products or services +that would alter, expand, be inconsistent with, or supersede any terms of +these additional agreements. �API� means application programming interfaces, +as well as their respective specifications and implementing code that allows +other software products to communicate with or call on SAP or third party +products or services (for example, SAP Enterprise Services, BAPIs, Idocs, RFCs +and ABAP calls or other user exits) and may be made available through SAP or +third party products, SDKs, documentation or other media. + +------------------------------------------------------------------------------ +SUBCOMPONENTS + +This project includes the following subcomponents that are subject to separate license terms. +Your use of these subcomponents is subject to the separate license terms applicable to +each subcomponent. + +Component: purell +Licensor: Martin Angers +Website: github.com/PuerkitoBio/purell +License: BSD 3-Clause license +Additional Notices: Copyright (c) 2012, Martin Angers All rights reserved. + +Component: urlesc +Licensor: The Go Authors +Website: github.com/PuerkitoBio/urlesc +License: BSD 3-Clause license +Additional Notices: Copyright (c) 2012 The Go Authors. All rights reserved. + +Component: govalidator +Licensor: Alex Saskevich +Website: github.com/asaskevich/govalidator +License: MIT License +Additional Notices: Copyright (c) 2014 Alex Saskevich + +Component: semver +Licensor: Benedikt Lang +Website: github.com/blang/semver +License: MIT License +Additional Notices: Copyright (c) 2014 Benedikt Lang + +Component: Cloud Foundry CLI +Licensor: CloudFoundry.org Foundation, Inc. +Website: github.com/cloudfoundry/cli +License: Apache License, Version 2.0 +Additional Notices: Copyright (c) 2015-Present CloudFoundry.org Foundation, Inc. +All Rights Reserved. + +Component: gofileutils +Licensor: CloudFoundry.org Foundation, Inc. +Website: github.com/cloudfoundry/gofileutils +License: Apache License, Version 2.0 +Additional Notices: Copyright (c) 2015-Present CloudFoundry.org Foundation, Inc. +All Rights Reserved. + +Component: jwt-go +Licensor: Dave Grijalva +Website: github.com/dgrijalva/jwt-go +License: MIT License +Additional Notices: Copyright (c) 2012 Dave Grijalva + +Component: go-openapi-analysis +Licensor: n/a +Website: github.com/go-openapi/analysis +License: Apache License, Version 2.0 +Additional Notices: n/a + +Component: go-openapi-errors +Licensor: n/a +Website: github.com/go-openapi/errors +License: Apache License, Version 2.0 +Additional Notices: n/a + +Component: go-openapi-jsonpointer +Licensor: n/a +Website: github.com/go-openapi/jsonpointer +License: Apache License, Version 2.0 +Additional Notices: n/a + +Component: go-openapi-jsonreference +Licensor: n/a +Website: github.com/go-openapi/jsonreference +License: Apache License, Version 2.0 +Additional Notices: n/a + +Component: go-openapi-loads +Licensor: n/a +Website: github.com/go-openapi/loads +License: Apache License, Version 2.0 +Additional Notices: n/a + +Component: go-openapi-runtime +Licensor: n/a +Website: github.com/go-openapi/runtime +License: Apache License, Version 2.0 +Additional Notices: n/a + +Component: go-openapi-spec +Licensor: n/a +Website: github.com/go-openapi/spec +License: Apache License, Version 2.0 +Additional Notices: n/a + +Component: go-openapi-strfmt +Licensor: n/a +Website: github.com/go-openapi/strfmt +License: Apache License, Version 2.0 +Additional Notices: n/a + +Component: go-openapi-swag +Licensor: n/a +Website: github.com/go-openapi/swag +License: Apache License, Version 2.0 +Additional Notices: n/a + +Component: go-openapi-validate +Licensor: n/a +Website: github.com/go-openapi/validate +License: Apache License, Version 2.0 +Additional Notices: n/a + +Component: copier +Licensor: Jinzhu +Website: github.com/jinzhu/copier +License: MIT License +Additional Notices: Copyright (c) 2015 Jinzhu + +Component: easyjson +Licensor: Mail.Ru Group +Website: github.com/mailru/easyjson +License: MIT License +Additional Notices: Copyright (c) 2016 Mail.Ru Group + +Component: mapstructure +Licensor: Mitchell Hashimoto +Website: github.com/mitchellh/mapstructure +License: MIT License +Additional Notices: Copyright (c) 2013 Mitchell Hashimoto + +Component: go-i18n +Licensor: Nick Snyder +Website: github.com/nicksnyder/go-i18n +License: MIT License +Additional Notices: Copyright (c) 2014 Nick Snyder https://github.com/nicksnyder + +Component: ginkgo +Licensor: Onsi Fakhouri +Website: github.com/onsi/ginkgo +License: MIT License +Additional Notices: Copyright (c) 2013-2014 Onsi Fakhouri + +Component: gomega +Licensor: Onsi Fakhouri +Website: github.com/onsi/gomega +License: MIT License +Additional Notices: Copyright (c) 2013-2014 Onsi Fakhouri + +Component: uuid +Licensor: Google Inc. +Website: github.com/pborman/uuid +License: BSD 3-Clause license +Additional Notices: Copyright (c) 2009,2014 Google Inc. All rights reserved. + +Component: crypto +Licensor: The Go Authors +Website: golang.org/x/crypto +License: BSD 3-Clause license +Additional Notices: Copyright (c) 2009 The Go Authors. All rights reserved. + +Component: net +Licensor: The Go Authors +Website: golang.org/x/net +License: BSD 3-Clause license +Additional Notices: Copyright (c) 2009 The Go Authors. All rights reserved. + +Component: sync +Licensor: The Go Authors +Website: golang.org/x/sync +License: BSD 3-Clause license +Additional Notices: Copyright (c) 2009 The Go Authors. All rights reserved. + +Component: sys +Licensor: The Go Authors +Website: golang.org/x/sys +License: BSD 3-Clause license +Additional Notices: Copyright (c) 2009 The Go Authors. All rights reserved. + +Component: text +Licensor: The Go Authors +Website: golang.org/x/text +License: BSD 3-Clause license +Additional Notices: Copyright (c) 2009 The Go Authors. All rights reserved. + +Component: yaml.v2 +Licensor: n/a +Website: gopkg.in/yaml.v2 +License: Apache License, Version 2.0 +Additional Notices: n/a + +------------------------------------------------------------------------------ +The BSD 3-Clause License + +Copyright (c) , +All rights reserved. +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of the project nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. + + +The MIT License (MIT) + +Copyright (c) 2014 Alex Saskevich + +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. +------------------------------------------------------------------------------ \ No newline at end of file diff --git a/NOTICE b/NOTICE new file mode 100644 index 0000000..815ce50 --- /dev/null +++ b/NOTICE @@ -0,0 +1 @@ +Copyright (c) 2015 SAP SE or an SAP affiliate company. All rights reserved. diff --git a/README.md b/README.md index db30ae0..50866ef 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,98 @@ -# cf-mta-plugin -TBD +# MTA CF CLI Plugin + +[![Build Status](TODO: put a link to the original link to the https://travis-ci.com/) + +# Description + +This is a Cloud Foundry CLI plugin for performing operations on [multi-target applications (MTAs)](https://www.sap.com/documents/2016/06/e2f618e4-757c-0010-82c7-eda71af511fa.html) in Cloud Foundry, such as deploying, removing, viewing, etc. It is a client for the [CF MTA deploy service](https://github.com/SAP/cf-mta-deploy-service), which is an MTA deployer implementation for Cloud Foundry. + +# Requirements + +- Installed CloudFoundry CLI - ensure that CloudFoundry CLI is installed and working. For more information about installation of CloudFoundry CLI, please visit the official CloudFoundry [documentation](https://docs.cloudfoundry.org/cf-cli/install-go-cli.html). +- Working CF deploy-service - this a CF plugin for the deploy-service application. Thus, a working deploy-service must be available on the CF landscape + +# Download and Installation + +## Download + +The latest version of the plugin can be found in the table below. Select the plugin for your platform(Darwin, Linux, Windows) and download it. + +Mac OS X 64 bit | Windows 64 bit | Linux 64 bit +--- | --- | --- +[cf-cli-mta-plugin-1.0.4-darwin.bin](TODO: link released libraries from github.com repo) | [cf-cli-mta-plugin-1.0.4-windows.exe](TODO: link released libraries from github.com repo) | [cf-cli-mta-plugin-1.0.4-linux.bin](TODO: link released libraries from github.com repo) | + + +## Installation + +Install the plugin, using the following command: + +``` +cf install-plugin -f +``` +:rotating_light: Note: if you are running on an Unix-based system, you need to make the plugin executable before installing it. In order to achieve this, execute the following commad `chmod +x ` + +:rotating_light: Check whether you have a previous version installed, using the command: `cf plugins`. If the MtaPlugin is already installed, you need to uninstall it first and then to install the new version. You can uninstall the plugin using command `cf uninstall-plugin MtaPlugin`. + +# Configuration + +The plugin attempts to deduce the deploy service URL based on the CF API URL. In case of issues, or if you want to target a deploy service instance different from the default one, you can configure the targeted deploy service URL via the `DEPLOY_SERVICE_URL` environment variable. + +The MTA CF CLI Plugin supports the following commands: + +Command Name | Command Description +--- | --- +`deploy` | Deploy a new multi-target app or sync changes to an existing one +`undeploy` | Undeploy (remove) a multi-target app +`mtas` | List all multi-target apps +`mta` | Display health and status for a multi-target app +`mta-ops` | List active multi-target app operations +`download-mta-op-logs` / `dmol` | Download logs of multi-target app operation +`bg-deploy` | Deploy a multi-target app using blue-green deployment +`purge-mta-config` | Purge stale configuration entries + +For more information, see the command help output available via `cf [command] --help` or `cf help [command]`. + +## Environment Variables + `DEBUG=1` - Prints in standart output HTTP requests, which are from CLI client to CF deploy service backend. + +## Usage + +You need to have the MTA CF CLI Plugin installed on your machine. +Here is an example deployment of the open-sourced com.sap.openSAP.hana5.example: +``` +git clone https://github.com/SAP/hana-shine-xsa.git +build it +cf deploy assembly/target/hello-world-java-assembly-0.1.0-SNAPSHOT.mtar +``` + +# How to obtain support + +If you need any support, have any question or have found a bug, please report it in the [GitHub bug tracking system](TODO: point to the github.com repostory issues). We shall get back to you. + +# Development + +## Building new release version +You can automatically build new release for all supported platforms by calling the build.sh script with the version of the build. +The version will be automatically included in the plugin, so it will be reported by `cf plugins`. + +:rotating_light: Note that the version parameter should follow the semver format (e.g. 1.2.3). +```bash +./build.sh 1.2.3 +``` + +This will produce `mta_plugin_linux_amd64`, `mta_plugin_darwin_amd64` and `mta_plugin_windows_amd64` in the repo's root directory. + +## Adding dependency into the cf-mta-plugin +#### If you want to add a dependecy which to be used later on during the build and development process, you need to follow these steps: +1. Make sure that you have godep installed(try to run `godep version`). If you do not have it, run the command: `go get github.com/tools/godep`. !!!IMPORTANT!!! Make sure that you are running on latest version of GO and godep!!! +2. Get the dependency by executing the command: `go get github.com/` . If you want to update it use the -u option. +3. Use the dependecy into your code(just import and use) +4. Make sure that the dependency is not in the Godeps/Godeps.json file(if it is, delete the entry related to it). Godeps.json file is holding information about all the dependencies which are used in the project. +5. Run `godep save ./...` - this will add all the newly used dependecies into the Godeps/Godeps.json and into the vendor/ folder. + +For more information about the godep tool, please refer to: [godep](https://github.com/tools/godep) + +# License + +This project is licensed under the Apache Software License, v. 2 except as noted otherwise in the LICENSE file. + diff --git a/bin/build.sh b/bin/build.sh new file mode 100644 index 0000000..646d22b --- /dev/null +++ b/bin/build.sh @@ -0,0 +1,12 @@ +#!/bin/bash + +set -e + +echo -e "Generating binaries..." + +ROOT_DIR=$(cd $(dirname $(dirname $0)) && pwd) + +rm -rf $ROOT_DIR/out/ +GOOS=darwin GOARCH=amd64 go build -o $ROOT_DIR/out/mta_plugin_darwin_amd64 +GOOS=linux GOARCH=amd64 go build -o $ROOT_DIR/out/mta_plugin_linux_amd64 +GOOS=windows GOARCH=amd64 go build -o $ROOT_DIR/out/mta_plugin_windows_amd64.exe diff --git a/bin/bump-version.sh b/bin/bump-version.sh new file mode 100644 index 0000000..814cfc3 --- /dev/null +++ b/bin/bump-version.sh @@ -0,0 +1,41 @@ +#!/usr/bin/env bash + +component=$1 + +version=$(cat VERSION) +major=$(echo $version | cut -d'.' -f 1) +minor=$(echo $version | cut -d'.' -f 2) +patch=$(echo $version | cut -d'.' -f 3) + +case "$component" in + major ) + major=$(expr $major + 1) + minor=0 + patch=0 + ;; + minor ) + minor=$(expr $minor + 1) + patch=0 + ;; + patch ) + patch=$(expr $patch + 1) + ;; + * ) + echo "Error - argument must be 'major', 'minor' or 'patch'" + echo "Usage: bump-version [major | minor | patch]" + exit 1 + ;; +esac + +version=$major.$minor.$patch + +echo "Updating VERSION file to $version..." +echo $version > VERSION + +echo "Committing change..." +git reset . +git add VERSION +git commit -m "Bump version to $version" + +echo "Creating v$version tag..." +git tag v$version diff --git a/bin/commit-version-bump.sh b/bin/commit-version-bump.sh new file mode 100644 index 0000000..b124ee8 --- /dev/null +++ b/bin/commit-version-bump.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +echo "Adding CHANGELOG..." +git add CHANGELOG.md +echo "Ammending commit with CHANGELOG update..." +git commit --amend + +echo "Retagging..." +git tag -d v$(cat VERSION) +git tag v$(cat VERSION) diff --git a/bin/generate-changelog.sh b/bin/generate-changelog.sh new file mode 100644 index 0000000..e5a2f69 --- /dev/null +++ b/bin/generate-changelog.sh @@ -0,0 +1,19 @@ +#!/usr/bin/env bash + +PREVIOUS_VERSION=$1 +CURRENT_VERSION=$2 + +if [ "$#" -ne 2 ]; then + cat <<-INFO +NAME: + generate-changelog - Generate changelog relative to a given version +USAGE: + generate-changelog PREVIOUS_VERSION CURRENT_VERSION +EXAMPLE: + generate-changelog v6.2.0 v6.3.0 +INFO + + exit 1 +fi + +git --no-pager log --grep \[.*\d*\] $PREVIOUS_VERSION..$CURRENT_VERSION --pretty='format:* %s' diff --git a/bin/install-plugin.sh b/bin/install-plugin.sh new file mode 100644 index 0000000..4ba1c7a --- /dev/null +++ b/bin/install-plugin.sh @@ -0,0 +1,9 @@ +#!/bin/bash + +set -e + +echo -e "Installing plugin..." + +go install +cf uninstall-plugin MtaPlugin +cf install-plugin $GOPATH/bin/cf-cli-plugin -f diff --git a/bin/test.sh b/bin/test.sh new file mode 100644 index 0000000..f4c9e92 --- /dev/null +++ b/bin/test.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +set -e + +function printStatus { + if [ $? -eq 0 ]; then + echo -e "SUITE SUCCESS" + else + echo -e "SUITE FAILURE" + fi +} + +trap printStatus EXIT + +if [ ! $(which ginkgo) ]; then + echo -e "Installing ginkgo..." + go get github.com/onsi/ginkgo/ginkgo +fi + +echo -e "Formatting packages..." +go fmt ./... + +echo -e "Vetting packages for potential issues..." +for file in $(find {clients,commands,log,testutil,ui,util} \( -name "*.go" -not -iname "*test.go" \)) +do + go tool vet -all $file +done + +echo -e "Testing packages..." +ginkgo -r $@ + +echo -e "Running build script to confirm everything compiles..." +bin/build.sh diff --git a/build.sh b/build.sh new file mode 100644 index 0000000..d07a94d --- /dev/null +++ b/build.sh @@ -0,0 +1,30 @@ +#!/bin/bash -eux + +function build() { + local version=$1 + local platform=$2 + local arch=$3 + + GOOS=$platform GOARCH=$arch go build \ + -ldflags "-X main.Version=${version}" \ + -o mta_plugin_${platform}_${arch} +} + +function main() { + if [[ $# -ne 1 ]]; then + echo "usage: ${0} " + exit 1 + fi + local version=$1 + local platforms="linux darwin windows" + for platform in $platforms; do + echo calling to build for $platform + build $version $platform "amd64" + #Make windows binary executable + if [[ $platform == "windows" ]] ; then + mv mta_plugin_${platform}_amd64 mta_plugin_${platform}_amd64.exe + fi + done +} + +main "$@" diff --git a/cfg/VERSION b/cfg/VERSION new file mode 100644 index 0000000..a6a3a43 --- /dev/null +++ b/cfg/VERSION @@ -0,0 +1 @@ +1.0.4 \ No newline at end of file diff --git a/cfg/build.py b/cfg/build.py new file mode 100644 index 0000000..4d7ac16 --- /dev/null +++ b/cfg/build.py @@ -0,0 +1,117 @@ +#build scripts must define a class 'build' +import spi +import log + +import os +import stat +import sys +import tarfile +import shutil +from distutils.dir_util import copy_tree + +class build(spi.BuildPlugin): + def __init__(self, build_cfg): + self.build_cfg = build_cfg #it is a good idea to store the build_cfg + + #Environment path variables + self.go_workspace = self.build_cfg.cfg_dir() + "/../gen/go-workspace" + self.gopath = self.go_workspace + "/go-path" + self.go_install_dir = self.go_workspace + "/go-install-dir" + self.goroot = self.go_install_dir + "/go" #set default path + self.path = self.goroot + "/bin" #set default path + + #Project parameters + self.go_project_name = "cf-cli-mta-plugin" + self.go_project_repo = "https://github.com/SAP/cf-mta-plugin" + self.go_project_build_path = self.gopath + "/src/" + self.go_project_repo.split(".git",1)[0].split("//")[1] + self.go_project_version_file= self.build_cfg.cfg_dir() + "/VERSION" + self.go_project_version = "" + + #Get imported binary (cfg/import.ais) file path and name + self.go_binary_file_name = "go-binary/go1.8.1.linux-amd64.tar.gz" + #self.go_binary_file_path = self.build_cfg.cfg_dir() + "/../import/content" + self.go_binary_file_path = self.go_project_build_path + + #Build file + self.build_sh = self.build_cfg.cfg_dir() + "/build.sh" + + #Artifacts names + self.go_project_artifacts = ['mta_plugin_linux_amd64', 'mta_plugin_darwin_amd64', 'mta_plugin_windows_amd64.exe'] + self.go_out_path = self.build_cfg.cfg_dir() + "/../gen/out" + + def run(self): + log.info( 'building..' ) #this is where the custom build commands go + + self.clean_workspace() + self.create_workspace() + self.get_src_package() + self.untar_go_binary() + self.generate_build_sh() + self.run_build_sh() + self.copy_binaries_to_gen_out() + + + def clean_workspace(self): + """ This method excute cleaning workspace """ + if ( os.path.isdir(self.go_workspace) ) : + log.info(' cleaning go workspace path ' + self.go_workspace) + shutil.rmtree(self.go_workspace) + log.info(' cleaned go workspace path ' + self.go_workspace) + + def create_workspace(self): + log.info(' creating environment paths for go ') + log.info(' creating go workspace path ' + self.go_workspace) + os.makedirs(self.go_workspace) + log.info(' creating go path ' + self.gopath) + os.makedirs(self.gopath) + log.info(' creating build path ' + self.go_project_build_path) + os.makedirs(self.go_project_build_path) + log.info(' creating go install directory path ' + self.go_install_dir) + os.makedirs(self.go_install_dir) + + + def untar_go_binary(self): + log.info(' untarring go tar file ' + self.go_binary_file_name + '...') + tar = tarfile.open(self.go_binary_file_path + "/" + self.go_binary_file_name ,"r") + tar.extractall(self.go_install_dir) + tar.close() + + def get_src_package(self): + log.info('Cloning go project repo' + self.go_project_repo) + os.system("git clone " + self.go_project_repo + " " + self.go_project_build_path ) + file = open(self.go_project_version_file, "r") + self.go_project_version = file.read().splitlines()[0] + file.close() + + def generate_build_sh(self): + fw = open ( self.build_sh , "w" ) + fw.write("#!/bin/bash -e\n") + fw.write("export GOPATH=" + self.gopath + "\n") + fw.write("export GOROOT=" + self.goroot + "\n") + fw.write("export PATH=$PATH:" + self.path + "\n") + fw.write("export BUILD_PATH=" + self.go_project_build_path + "\n") + fw.write("echo \"GOPATH ==> $GOPATH\"\n") + fw.write("echo \"GOROOT ==> $GOROOT\"\n") + fw.write("echo \"PATH ==> $PATH\"\n") + fw.write("echo \"BUILD_PATH ==> $BUILD_PATH\"\n") + fw.write("cd $BUILD_PATH\n") + fw.write("./build.sh " + self.go_project_version + "\n") + fw.close() + + os.system("chmod 777 " + self.build_sh ) + + def run_build_sh(self): + log.info( 'running ' + self.build_sh + '...') + os.system(self.build_sh) + + def copy_binaries_to_gen_out(self): + for name in self.go_project_artifacts : + shutil.copyfile(self.go_project_build_path + "/" + name, self.go_out_path + "/" + name) + os.system("chmod 777 " + self.go_out_path + "/*") + os.chdir(self.go_out_path) + os.chdir(self.build_cfg.cfg_dir() + "/..") + + #set groupID and artifacts names which is used by export.ads + def deploy_variables(self): + return {'groupId' : "com.sap.golang", 'artifactId' : "cf-cli-mta-plugin"} +#### diff --git a/cfg/export.ads b/cfg/export.ads new file mode 100644 index 0000000..0b0cb5f --- /dev/null +++ b/cfg/export.ads @@ -0,0 +1,12 @@ +artifacts builderVersion:"1.1", { + + version "${buildBaseVersion}", { + group "${groupId}", { + artifact "${artifactId}", { + file "${genroot}/out/mta_plugin_linux_amd64", classifier: "linux", extension: "bin" + file "${genroot}/out/mta_plugin_darwin_amd64", classifier: "darwin", extension: "bin" + file "${genroot}/out/mta_plugin_windows_amd64.exe", classifier: "windows", extension: "exe" + } + } + } +} diff --git a/cfg/import.ais b/cfg/import.ais new file mode 100644 index 0000000..ad8f378 --- /dev/null +++ b/cfg/import.ais @@ -0,0 +1,5 @@ +imports dslVersion:"1.2", { + targetRootDir id: "default", { + artifactFile "org.golang.download.go:go:tar.gz:1.8" + } +} diff --git a/clients/baseclient/base_client.go b/clients/baseclient/base_client.go new file mode 100644 index 0000000..c996fa0 --- /dev/null +++ b/clients/baseclient/base_client.go @@ -0,0 +1,42 @@ +package baseclient + +import ( + "net/http" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/runtime/client" +) + +var schemes = []string{"http", "https"} + +// BaseClient represents a base SLP client +type BaseClient struct { + TokenFactory TokenFactory +} + +// GetTokenFactory returns the authentication info +func (c *BaseClient) GetTokenFactory() TokenFactory { + return c.TokenFactory +} + +// SetTokenFactory sets the authentication info +func (c *BaseClient) SetTokenFactory(tokenFactory TokenFactory) { + c.TokenFactory = tokenFactory +} + +//NewBaseClient creates a new client with the specified authentication info +func NewBaseClient(tokenFactory TokenFactory) *BaseClient { + return &BaseClient{ + TokenFactory: tokenFactory, + } +} + +// NewHTTPTransport creates a new HTTP transport +func NewHTTPTransport(host, url string, rt http.RoundTripper, jar http.CookieJar) *client.Runtime { + transport := client.New(host, url, schemes) + transport.Consumers["text/html"] = runtime.TextConsumer() + transport.DefaultMediaType = "application/xml" + transport.Transport = rt + transport.Jar = jar + return transport +} diff --git a/clients/baseclient/client_error.go b/clients/baseclient/client_error.go new file mode 100644 index 0000000..5fd0e6f --- /dev/null +++ b/clients/baseclient/client_error.go @@ -0,0 +1,26 @@ +package baseclient + +import ( + "fmt" + + "github.com/go-openapi/runtime" +) + +type ClientError struct { + Code int + Status string + Description interface{} +} + +func (ce *ClientError) Error() string { + return fmt.Sprintf("%s (status %d): %v ", ce.Status, ce.Code, ce.Description) +} + +func NewClientError(err error) error { + ae, ok := err.(*runtime.APIError) + if ok { + resp := ae.Response.(runtime.ClientResponse) + return &ClientError{Code: ae.Code, Status: resp.Message(), Description: resp.Message()} + } + return err +} diff --git a/clients/baseclient/client_util.go b/clients/baseclient/client_util.go new file mode 100644 index 0000000..fcc8daa --- /dev/null +++ b/clients/baseclient/client_util.go @@ -0,0 +1,37 @@ +package baseclient + +import ( + "regexp" + "time" +) + +// CallWithRetry executes callback with retry +func CallWithRetry(callback func() (interface{}, error), maxRetriesCount int, retryInterval time.Duration) (interface{}, error) { + for index := 0; index < maxRetriesCount; index++ { + resp, err := callback() + if !shouldRetry(err) { + return resp, err + } + time.Sleep(retryInterval) + } + return callback() +} + +func shouldRetry(err error) bool { + if err == nil { + return false + } + isMatching, _ := regexp.MatchString(" EOF$", err.Error()) + if isMatching { + return true + } + ae, ok := err.(*ClientError) + if ok { + httpCode := ae.Code + httpCodeMajorDigit := httpCode / 100 + if httpCodeMajorDigit == 5 { + return true + } + } + return false +} diff --git a/clients/baseclient/test_token_factory.go b/clients/baseclient/test_token_factory.go new file mode 100644 index 0000000..226b8da --- /dev/null +++ b/clients/baseclient/test_token_factory.go @@ -0,0 +1,19 @@ +package baseclient + +import ( + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/go-openapi/runtime" +) + +// NewCustomTokenFactory represents mock of the TokenFactory +func NewCustomTokenFactory(token string) TokenFactory { + return &customTokenfactory{tokenString: token} +} + +type customTokenfactory struct { + tokenString string +} + +func (c *customTokenfactory) NewToken() (runtime.ClientAuthInfoWriter, error) { + return testutil.NewCustomBearerToken(c.tokenString), nil +} diff --git a/clients/baseclient/token_factory.go b/clients/baseclient/token_factory.go new file mode 100644 index 0000000..f96e063 --- /dev/null +++ b/clients/baseclient/token_factory.go @@ -0,0 +1,8 @@ +package baseclient + +import "github.com/go-openapi/runtime" + +// TokenFactory factory for generating new OAuth token +type TokenFactory interface { + NewToken() (runtime.ClientAuthInfoWriter, error) +} diff --git a/clients/client_factory.go b/clients/client_factory.go new file mode 100644 index 0000000..453dcab --- /dev/null +++ b/clients/client_factory.go @@ -0,0 +1,17 @@ +package clients + +import ( + "net/http" + + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + restclient "github.com/SAP/cf-mta-plugin/clients/restclient" + slmpclient "github.com/SAP/cf-mta-plugin/clients/slmpclient" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" +) + +// ClientFactory is a factory for creating XxxClientOperations instances +type ClientFactory interface { + NewSlmpClient(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) slmpclient.SlmpClientOperations + NewSlppClient(host, org, space, serviceID, processID string, rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) slppclient.SlppClientOperations + NewRestClient(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) restclient.RestClientOperations +} diff --git a/clients/clients_suite_test.go b/clients/clients_suite_test.go new file mode 100644 index 0000000..58c6c4b --- /dev/null +++ b/clients/clients_suite_test.go @@ -0,0 +1,13 @@ +package clients_test + +import ( + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "testing" +) + +func TestClients(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "Clients Suite") +} diff --git a/clients/csrf/transport.go b/clients/csrf/transport.go new file mode 100644 index 0000000..1c7df8d --- /dev/null +++ b/clients/csrf/transport.go @@ -0,0 +1,34 @@ +package csrf + +import ( + "net/http" + + "github.com/jinzhu/copier" +) + +type Csrf struct { + Header string + Token string +} + +type Transport struct { + Transport http.RoundTripper + Csrf *Csrf +} + +func (t Transport) RoundTrip(req *http.Request) (*http.Response, error) { + req2 := http.Request{} + copier.Copy(&req2, req) + if t.Csrf.Header != "" && t.Csrf.Token != "" { + req2.Header.Set(t.Csrf.Header, t.Csrf.Token) + } + res, err := t.Transport.RoundTrip(&req2) + if err != nil { + return res, err + } + csrfHeader, csrfToken := res.Header.Get("X-Csrf-Header"), res.Header.Get("X-Csrf-Token") + if csrfHeader != "" && csrfToken != "" { + t.Csrf.Header, t.Csrf.Token = csrfHeader, csrfToken + } + return res, err +} diff --git a/clients/fakes/fake_client_factory.go b/clients/fakes/fake_client_factory.go new file mode 100644 index 0000000..1426379 --- /dev/null +++ b/clients/fakes/fake_client_factory.go @@ -0,0 +1,172 @@ +// This file was generated by counterfeiter +package fakes + +import ( + "net/http" + "sync" + + "github.com/SAP/cf-mta-plugin/clients" + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + restclient "github.com/SAP/cf-mta-plugin/clients/restclient" + slmpclient "github.com/SAP/cf-mta-plugin/clients/slmpclient" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" +) + +type FakeClientFactory struct { + NewSlmpClientStub func(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) slmpclient.SlmpClientOperations + newSlmpClientMutex sync.RWMutex + newSlmpClientArgsForCall []struct { + host string + org string + space string + rt http.RoundTripper + jar http.CookieJar + tokenfactory baseclient.TokenFactory + } + newSlmpClientReturns struct { + result1 slmpclient.SlmpClientOperations + } + NewSlppClientStub func(host, org, space, serviceID, processID string, rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) slppclient.SlppClientOperations + newSlppClientMutex sync.RWMutex + newSlppClientArgsForCall []struct { + host string + org string + space string + serviceID string + processID string + rt http.RoundTripper + jar http.CookieJar + tokenfactory baseclient.TokenFactory + } + newSlppClientReturns struct { + result1 slppclient.SlppClientOperations + } + NewRestClientStub func(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) restclient.RestClientOperations + newRestClientMutex sync.RWMutex + newRestClientArgsForCall []struct { + host string + org string + space string + rt http.RoundTripper + jar http.CookieJar + tokenfactory baseclient.TokenFactory + } + newRestClientReturns struct { + result1 restclient.RestClientOperations + } +} + +func (fake *FakeClientFactory) NewSlmpClient(host string, org string, space string, rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) slmpclient.SlmpClientOperations { + fake.newSlmpClientMutex.Lock() + fake.newSlmpClientArgsForCall = append(fake.newSlmpClientArgsForCall, struct { + host string + org string + space string + rt http.RoundTripper + jar http.CookieJar + tokenfactory baseclient.TokenFactory + }{host, org, space, rt, jar, tokenfactory}) + fake.newSlmpClientMutex.Unlock() + if fake.NewSlmpClientStub != nil { + return fake.NewSlmpClientStub(host, org, space, rt, jar, tokenfactory) + } else { + return fake.newSlmpClientReturns.result1 + } +} + +func (fake *FakeClientFactory) NewSlmpClientCallCount() int { + fake.newSlmpClientMutex.RLock() + defer fake.newSlmpClientMutex.RUnlock() + return len(fake.newSlmpClientArgsForCall) +} + +func (fake *FakeClientFactory) NewSlmpClientArgsForCall(i int) (string, string, string, http.RoundTripper, http.CookieJar, baseclient.TokenFactory) { + fake.newSlmpClientMutex.RLock() + defer fake.newSlmpClientMutex.RUnlock() + return fake.newSlmpClientArgsForCall[i].host, fake.newSlmpClientArgsForCall[i].org, fake.newSlmpClientArgsForCall[i].space, fake.newSlmpClientArgsForCall[i].rt, fake.newSlmpClientArgsForCall[i].jar, fake.newSlmpClientArgsForCall[i].tokenfactory +} + +func (fake *FakeClientFactory) NewSlmpClientReturns(result1 slmpclient.SlmpClientOperations) { + fake.NewSlmpClientStub = nil + fake.newSlmpClientReturns = struct { + result1 slmpclient.SlmpClientOperations + }{result1} +} + +func (fake *FakeClientFactory) NewSlppClient(host string, org string, space string, serviceID string, processID string, rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) slppclient.SlppClientOperations { + fake.newSlppClientMutex.Lock() + fake.newSlppClientArgsForCall = append(fake.newSlppClientArgsForCall, struct { + host string + org string + space string + serviceID string + processID string + rt http.RoundTripper + jar http.CookieJar + tokenfactory baseclient.TokenFactory + }{host, org, space, serviceID, processID, rt, jar, tokenfactory}) + fake.newSlppClientMutex.Unlock() + if fake.NewSlppClientStub != nil { + return fake.NewSlppClientStub(host, org, space, serviceID, processID, rt, jar, tokenfactory) + } else { + return fake.newSlppClientReturns.result1 + } +} + +func (fake *FakeClientFactory) NewSlppClientCallCount() int { + fake.newSlppClientMutex.RLock() + defer fake.newSlppClientMutex.RUnlock() + return len(fake.newSlppClientArgsForCall) +} + +func (fake *FakeClientFactory) NewSlppClientArgsForCall(i int) (string, string, string, string, string, http.RoundTripper, http.CookieJar, baseclient.TokenFactory) { + fake.newSlppClientMutex.RLock() + defer fake.newSlppClientMutex.RUnlock() + return fake.newSlppClientArgsForCall[i].host, fake.newSlppClientArgsForCall[i].org, fake.newSlppClientArgsForCall[i].space, fake.newSlppClientArgsForCall[i].serviceID, fake.newSlppClientArgsForCall[i].processID, fake.newSlppClientArgsForCall[i].rt, fake.newSlppClientArgsForCall[i].jar, fake.newSlppClientArgsForCall[i].tokenfactory +} + +func (fake *FakeClientFactory) NewSlppClientReturns(result1 slppclient.SlppClientOperations) { + fake.NewSlppClientStub = nil + fake.newSlppClientReturns = struct { + result1 slppclient.SlppClientOperations + }{result1} +} + +func (fake *FakeClientFactory) NewRestClient(host string, org string, space string, rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) restclient.RestClientOperations { + fake.newRestClientMutex.Lock() + fake.newRestClientArgsForCall = append(fake.newRestClientArgsForCall, struct { + host string + org string + space string + rt http.RoundTripper + jar http.CookieJar + tokenfactory baseclient.TokenFactory + }{host, org, space, rt, jar, tokenfactory}) + fake.newRestClientMutex.Unlock() + if fake.NewRestClientStub != nil { + return fake.NewRestClientStub(host, org, space, rt, jar, tokenfactory) + } else { + return fake.newRestClientReturns.result1 + } +} + +func (fake *FakeClientFactory) NewRestClientCallCount() int { + fake.newRestClientMutex.RLock() + defer fake.newRestClientMutex.RUnlock() + return len(fake.newRestClientArgsForCall) +} + +func (fake *FakeClientFactory) NewRestClientArgsForCall(i int) (string, string, string, http.RoundTripper, http.CookieJar, baseclient.TokenFactory) { + fake.newRestClientMutex.RLock() + defer fake.newRestClientMutex.RUnlock() + return fake.newRestClientArgsForCall[i].host, fake.newRestClientArgsForCall[i].org, fake.newRestClientArgsForCall[i].space, fake.newRestClientArgsForCall[i].rt, fake.newRestClientArgsForCall[i].jar, fake.newRestClientArgsForCall[i].tokenfactory +} + +func (fake *FakeClientFactory) NewRestClientReturns(result1 restclient.RestClientOperations) { + fake.NewRestClientStub = nil + fake.newRestClientReturns = struct { + result1 restclient.RestClientOperations + }{result1} +} + +var _ clients.ClientFactory = new(FakeClientFactory) diff --git a/clients/fakes/fake_token_factory.go b/clients/fakes/fake_token_factory.go new file mode 100644 index 0000000..edcf52d --- /dev/null +++ b/clients/fakes/fake_token_factory.go @@ -0,0 +1,70 @@ +// This file was generated by counterfeiter +package fakes + +import ( + "sync" + + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + + "github.com/go-openapi/runtime" +) + +type FakeTokenFactory struct { + NewTokenStub func() (runtime.ClientAuthInfoWriter, error) + newTokenMutex sync.RWMutex + newTokenArgsForCall []struct{} + newTokenReturns struct { + result1 runtime.ClientAuthInfoWriter + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeTokenFactory) NewToken() (runtime.ClientAuthInfoWriter, error) { + fake.newTokenMutex.Lock() + fake.newTokenArgsForCall = append(fake.newTokenArgsForCall, struct{}{}) + fake.recordInvocation("NewToken", []interface{}{}) + fake.newTokenMutex.Unlock() + if fake.NewTokenStub != nil { + return fake.NewTokenStub() + } else { + return fake.newTokenReturns.result1, fake.newTokenReturns.result2 + } +} + +func (fake *FakeTokenFactory) NewTokenCallCount() int { + fake.newTokenMutex.RLock() + defer fake.newTokenMutex.RUnlock() + return len(fake.newTokenArgsForCall) +} + +func (fake *FakeTokenFactory) NewTokenReturns(result1 runtime.ClientAuthInfoWriter, result2 error) { + fake.NewTokenStub = nil + fake.newTokenReturns = struct { + result1 runtime.ClientAuthInfoWriter + result2 error + }{result1, result2} +} + +func (fake *FakeTokenFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.newTokenMutex.RLock() + defer fake.newTokenMutex.RUnlock() + return fake.invocations +} + +func (fake *FakeTokenFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ baseclient.TokenFactory = new(FakeTokenFactory) diff --git a/clients/models/action.go b/clients/models/action.go new file mode 100644 index 0000000..f788f7d --- /dev/null +++ b/clients/models/action.go @@ -0,0 +1,102 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// Action Action represents... +// swagger:model Action +type Action struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Action"` + + // action type + // Required: true + ActionType *SlpAction `xml:"action_type"` + + // active + Active bool `xml:"active,omitempty"` + + // description + Description string `xml:"description,omitempty"` + + // display name + DisplayName string `xml:"displayName,omitempty"` + + // external info + ExternalInfo strfmt.URI `xml:"externalInfo,omitempty"` + + // id + // Required: true + ID *string `xml:"id"` + + // in dialog + // Required: true + InDialog *bool `xml:"inDialog"` +} + +// Validate validates this action +func (m *Action) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateActionType(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateInDialog(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Action) validateActionType(formats strfmt.Registry) error { + + if err := validate.Required("action_type", "body", m.ActionType); err != nil { + return err + } + + if m.ActionType != nil { + + if err := m.ActionType.Validate(formats); err != nil { + return err + } + } + + return nil +} + +func (m *Action) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *Action) validateInDialog(formats strfmt.Registry) error { + + if err := validate.Required("inDialog", "body", m.InDialog); err != nil { + return err + } + + return nil +} diff --git a/clients/models/actions.go b/clients/models/actions.go new file mode 100644 index 0000000..63d90cb --- /dev/null +++ b/clients/models/actions.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Actions actions +// swagger:model actions +type Actions struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp actions"` + Actions []*Action `xml:"Action,omitempty"` +} + +// Validate validates this actions +func (m Actions) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Actions); i++ { + + if swag.IsZero(m.Actions[i]) { // not required + continue + } + + if m.Actions[i] != nil { + + if err := m.Actions[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/breakpoint.go b/clients/models/breakpoint.go new file mode 100644 index 0000000..d1b4315 --- /dev/null +++ b/clients/models/breakpoint.go @@ -0,0 +1,95 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// Breakpoint Breakpoint element +// swagger:model Breakpoint +type Breakpoint struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Breakpoint"` + + // description + Description string `xml:"description,omitempty"` + + // display name + DisplayName string `xml:"displayName,omitempty"` + + // enabled + Enabled bool `xml:"enabled,omitempty"` + + // external info + ExternalInfo strfmt.URI `xml:"externalInfo,omitempty"` + + // id + // Required: true + ID *string `xml:"id"` + + // status + // Required: true + Status SlpBreakpointStatus `xml:"status"` + + // technical name + // Required: true + TechnicalName *string `xml:"technicalName"` +} + +// Validate validates this breakpoint +func (m *Breakpoint) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateStatus(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateTechnicalName(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Breakpoint) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *Breakpoint) validateStatus(formats strfmt.Registry) error { + + if err := m.Status.Validate(formats); err != nil { + return err + } + + return nil +} + +func (m *Breakpoint) validateTechnicalName(formats strfmt.Registry) error { + + if err := validate.Required("technicalName", "body", m.TechnicalName); err != nil { + return err + } + + return nil +} diff --git a/clients/models/breakpoints.go b/clients/models/breakpoints.go new file mode 100644 index 0000000..a0e3745 --- /dev/null +++ b/clients/models/breakpoints.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Breakpoints breakpoints +// swagger:model breakpoints +type Breakpoints struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp breakpoints"` + Breakpoints []*Breakpoint `xml:"Breakpoint,omitempty"` +} + +// Validate validates this breakpoints +func (m Breakpoints) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Breakpoints); i++ { + + if swag.IsZero(m.Breakpoints[i]) { // not required + continue + } + + if m.Breakpoints[i] != nil { + + if err := m.Breakpoints[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/component_version.go b/clients/models/component_version.go new file mode 100644 index 0000000..d09e550 --- /dev/null +++ b/clients/models/component_version.go @@ -0,0 +1,83 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// ComponentVersion Version element provides version information about a component participating in the implementation of a SL process +// swagger:model ComponentVersion +type ComponentVersion struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp ComponentVersion"` + + // component + // Required: true + Component *string `xml:"component"` + + // id + // Required: true + ID *string `xml:"id"` + + // version + // Required: true + Version *string `xml:"version"` +} + +// Validate validates this component version +func (m *ComponentVersion) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateComponent(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateVersion(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *ComponentVersion) validateComponent(formats strfmt.Registry) error { + + if err := validate.Required("component", "body", m.Component); err != nil { + return err + } + + return nil +} + +func (m *ComponentVersion) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *ComponentVersion) validateVersion(formats strfmt.Registry) error { + + if err := validate.Required("version", "body", m.Version); err != nil { + return err + } + + return nil +} diff --git a/clients/models/components.go b/clients/models/components.go new file mode 100644 index 0000000..da872e7 --- /dev/null +++ b/clients/models/components.go @@ -0,0 +1,89 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +type ComponentsMtas struct { + Mtas []*Mta `xml:"mta,omitempty"` +} + +type ComponentsStandaloneApps struct { + StandaloneApps []string `xml:"standaloneApp,omitempty"` +} + +// Components components +// swagger:model components +type Components struct { + XMLName xml.Name `xml:"components"` + + // mtas + // Required: true + Mtas ComponentsMtas `json:"mtas" xml:"mtas"` + + // standalone apps + // Required: true + StandaloneApps ComponentsStandaloneApps `xml:"standaloneApps,omitempty"` +} + +// Validate validates this components +func (m *Components) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateMtas(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateStandaloneApps(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Components) validateMtas(formats strfmt.Registry) error { + + if err := validate.Required("mtas", "body", m.Mtas); err != nil { + return err + } + + for i := 0; i < len(m.Mtas.Mtas); i++ { + + if swag.IsZero(m.Mtas.Mtas[i]) { // not required + continue + } + + if m.Mtas.Mtas[i] != nil { + + if err := m.Mtas.Mtas[i].Validate(formats); err != nil { + return err + } + } + + } + + return nil +} + +func (m *Components) validateStandaloneApps(formats strfmt.Registry) error { + + if err := validate.Required("standaloneApps", "body", m.StandaloneApps); err != nil { + return err + } + + return nil +} diff --git a/clients/models/config.go b/clients/models/config.go new file mode 100644 index 0000000..d7a6b48 --- /dev/null +++ b/clients/models/config.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Config config +// swagger:model config +type Config struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp config"` + Parameters []*Parameter `xml:"Parameter,omitempty"` +} + +// Validate validates this config +func (m Config) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Parameters); i++ { + + if swag.IsZero(m.Parameters[i]) { // not required + continue + } + + if m.Parameters[i] != nil { + + if err := m.Parameters[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/current_breakpoints.go b/clients/models/current_breakpoints.go new file mode 100644 index 0000000..bb7aa41 --- /dev/null +++ b/clients/models/current_breakpoints.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// CurrentBreakpoints current breakpoints +// swagger:model currentBreakpoints +type CurrentBreakpoints struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp currentBreakpoints"` + Breakpoints []*Breakpoint `xml:"Breakpoint,omitempty"` +} + +// Validate validates this current breakpoints +func (m CurrentBreakpoints) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Breakpoints); i++ { + + if swag.IsZero(m.Breakpoints[i]) { // not required + continue + } + + if m.Breakpoints[i] != nil { + + if err := m.Breakpoints[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/dialog.go b/clients/models/dialog.go new file mode 100644 index 0000000..64dbc2e --- /dev/null +++ b/clients/models/dialog.go @@ -0,0 +1,86 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// Dialog Dialog element describes the request for parameter specification +// swagger:model Dialog +type Dialog struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Dialog"` + + // description + // Required: true + Description *string `xml:"description"` + + // display name + // Required: true + DisplayName *string `xml:"displayName"` + + // id + // Required: true + ID *string `xml:"id"` + + // metadialog + Metadialog strfmt.URI `xml:"metadialog,omitempty"` +} + +// Validate validates this dialog +func (m *Dialog) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateDescription(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateDisplayName(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Dialog) validateDescription(formats strfmt.Registry) error { + + if err := validate.Required("description", "body", m.Description); err != nil { + return err + } + + return nil +} + +func (m *Dialog) validateDisplayName(formats strfmt.Registry) error { + + if err := validate.Required("displayName", "body", m.DisplayName); err != nil { + return err + } + + return nil +} + +func (m *Dialog) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} diff --git a/clients/models/dialogs.go b/clients/models/dialogs.go new file mode 100644 index 0000000..23abaf3 --- /dev/null +++ b/clients/models/dialogs.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Dialogs dialogs +// swagger:model dialogs +type Dialogs struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp dialogs"` + Dialogs []*Dialog `xml:"Dialog,omitempty"` +} + +// Validate validates this dialogs +func (m Dialogs) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Dialogs); i++ { + + if swag.IsZero(m.Dialogs[i]) { // not required + continue + } + + if m.Dialogs[i] != nil { + + if err := m.Dialogs[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/error.go b/clients/models/error.go new file mode 100644 index 0000000..017c3f0 --- /dev/null +++ b/clients/models/error.go @@ -0,0 +1,95 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// Error Error element provides an error description +// swagger:model Error +type Error struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Error"` + + // code + // Required: true + Code *string `xml:"code"` + + // description + Description string `xml:"description,omitempty"` + + // display name + // Required: true + DisplayName *string `xml:"displayName"` + + // external info + ExternalInfo strfmt.URI `xml:"externalInfo,omitempty"` + + // id + // Required: true + ID *string `xml:"id"` + + // logs + Logs strfmt.URI `xml:"logs,omitempty"` + + // occurred at + OccurredAt SlpTimestamp `xml:"occurredAt,omitempty"` +} + +// Validate validates this error +func (m *Error) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateCode(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateDisplayName(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Error) validateCode(formats strfmt.Registry) error { + + if err := validate.Required("code", "body", m.Code); err != nil { + return err + } + + return nil +} + +func (m *Error) validateDisplayName(formats strfmt.Registry) error { + + if err := validate.Required("displayName", "body", m.DisplayName); err != nil { + return err + } + + return nil +} + +func (m *Error) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} diff --git a/clients/models/file.go b/clients/models/file.go new file mode 100644 index 0000000..dd82772 --- /dev/null +++ b/clients/models/file.go @@ -0,0 +1,80 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// File Files that could be used by a subsequent execution of a particular service +// swagger:model File +type File struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp File"` + + // digest + Digest string `xml:"digest,omitempty"` + + // digest algorithm + DigestAlgorithm string `xml:"digestAlgorithm,omitempty"` + + // file name + // Required: true + FileName *string `xml:"fileName"` + + // file path + FilePath string `xml:"filePath,omitempty"` + + // file size + FileSize int64 `xml:"fileSize,omitempty"` + + // id + // Required: true + ID *string `xml:"id"` + + // modification time + ModificationTime SlpTimestamp `xml:"modificationTime,omitempty"` +} + +// Validate validates this file +func (m *File) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateFileName(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *File) validateFileName(formats strfmt.Registry) error { + + if err := validate.Required("fileName", "body", m.FileName); err != nil { + return err + } + + return nil +} + +func (m *File) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} diff --git a/clients/models/files.go b/clients/models/files.go new file mode 100644 index 0000000..99da6d9 --- /dev/null +++ b/clients/models/files.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Files files +// swagger:model files +type Files struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp files"` + Files []*File `xml:"File,omitempty"` +} + +// Validate validates this files +func (m Files) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Files); i++ { + + if swag.IsZero(m.Files[i]) { // not required + continue + } + + if m.Files[i] != nil { + + if err := m.Files[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/info.go b/clients/models/info.go new file mode 100644 index 0000000..863fea0 --- /dev/null +++ b/clients/models/info.go @@ -0,0 +1,37 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" +) + +// Info Collection of general purpose informational attributes which can be included in different other elements +// swagger:model Info +type Info struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Info"` + + // description + Description string `xml:"description,omitempty"` + + // display name + DisplayName string `xml:"displayName,omitempty"` + + // external info + ExternalInfo strfmt.URI `xml:"externalInfo,omitempty"` +} + +// Validate validates this info +func (m *Info) Validate(formats strfmt.Registry) error { + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/log.go b/clients/models/log.go new file mode 100644 index 0000000..459eaac --- /dev/null +++ b/clients/models/log.go @@ -0,0 +1,105 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// Log Log provides access to a single log. The actual content of the log is available through the content url +// swagger:model Log +type Log struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Log"` + + // content + // Required: true + Content *strfmt.URI `xml:"content"` + + // description + Description string `xml:"description,omitempty"` + + // display name + DisplayName string `xml:"displayName,omitempty"` + + // external info + ExternalInfo strfmt.URI `xml:"externalInfo,omitempty"` + + // format + // Required: true + Format *SlpLogFormat `xml:"format"` + + // id + // Required: true + ID *string `xml:"id"` + + // last modified + LastModified SlpTimestamp `xml:"lastModified,omitempty"` + + // size + Size int64 `xml:"size,omitempty"` +} + +// Validate validates this log +func (m *Log) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateContent(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateFormat(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Log) validateContent(formats strfmt.Registry) error { + + if err := validate.Required("content", "body", m.Content); err != nil { + return err + } + + return nil +} + +func (m *Log) validateFormat(formats strfmt.Registry) error { + + if err := validate.Required("format", "body", m.Format); err != nil { + return err + } + + if m.Format != nil { + + if err := m.Format.Validate(formats); err != nil { + return err + } + } + + return nil +} + +func (m *Log) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} diff --git a/clients/models/logs.go b/clients/models/logs.go new file mode 100644 index 0000000..e1b6e33 --- /dev/null +++ b/clients/models/logs.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Logs logs +// swagger:model logs +type Logs struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp logs"` + Logs []*Log `xml:"Log,omitempty"` +} + +// Validate validates this logs +func (m Logs) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Logs); i++ { + + if swag.IsZero(m.Logs[i]) { // not required + continue + } + + if m.Logs[i] != nil { + + if err := m.Logs[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/meta_dialogs.go b/clients/models/meta_dialogs.go new file mode 100644 index 0000000..013f0a7 --- /dev/null +++ b/clients/models/meta_dialogs.go @@ -0,0 +1,29 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" +) + +// MetaDialogs meta dialogs +// swagger:model metaDialogs +type MetaDialogs struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp metaDialogs"` + MetaDialogs []string `xml:"MetaDialog,omitempty"` +} + +// Validate validates this meta dialogs +func (m MetaDialogs) Validate(formats strfmt.Registry) error { + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/metadata.go b/clients/models/metadata.go new file mode 100644 index 0000000..1924db0 --- /dev/null +++ b/clients/models/metadata.go @@ -0,0 +1,34 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" +) + +// Metadata Container element for specifying metadata +// swagger:model Metadata +type Metadata struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Metadata"` + + // slmpversion + Slmpversion string `xml:"slmpversion,omitempty"` + + // slppversion + Slppversion string `xml:"slppversion,omitempty"` +} + +// Validate validates this metadata +func (m *Metadata) Validate(formats strfmt.Registry) error { + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/monitor.go b/clients/models/monitor.go new file mode 100644 index 0000000..819ecb3 --- /dev/null +++ b/clients/models/monitor.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Monitor monitor +// swagger:model monitor +type Monitor struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp monitor"` + Tasks []*Task `xml:"Task,omitempty"` +} + +// Validate validates this monitor +func (m Monitor) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Tasks); i++ { + + if swag.IsZero(m.Tasks[i]) { // not required + continue + } + + if m.Tasks[i] != nil { + + if err := m.Tasks[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/mta.go b/clients/models/mta.go new file mode 100644 index 0000000..1d82e1f --- /dev/null +++ b/clients/models/mta.go @@ -0,0 +1,260 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +type MtaModules struct { + Modules []*MtaModulesItems0 `xml:"module,omitempty"` +} + +type MtaServices struct { + Services []string `xml:"service,omitempty"` +} + +// Mta mta +// swagger:model mta +type Mta struct { + XMLName xml.Name `xml:"mta"` + + // metadata + // Required: true + Metadata *MtaMetadata `xml:"metadata,omitempty"` + + // modules + // Required: true + Modules MtaModules `xml:"modules,omitempty"` + + // services + // Required: true + Services MtaServices `xml:"services,omitempty"` +} + +// Validate validates this mta +func (m *Mta) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateMetadata(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateModules(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateServices(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Mta) validateMetadata(formats strfmt.Registry) error { + + if err := validate.Required("metadata", "body", m.Metadata); err != nil { + return err + } + + if m.Metadata != nil { + + if err := m.Metadata.Validate(formats); err != nil { + return err + } + } + + return nil +} + +func (m *Mta) validateModules(formats strfmt.Registry) error { + + if err := validate.Required("modules", "body", m.Modules); err != nil { + return err + } + + for i := 0; i < len(m.Modules.Modules); i++ { + + if swag.IsZero(m.Modules.Modules[i]) { // not required + continue + } + + if m.Modules.Modules[i] != nil { + + if err := m.Modules.Modules[i].Validate(formats); err != nil { + return err + } + } + + } + + return nil +} + +func (m *Mta) validateServices(formats strfmt.Registry) error { + + if err := validate.Required("services", "body", m.Services); err != nil { + return err + } + + return nil +} + +// MtaMetadata mta metadata +// swagger:model MtaMetadata +type MtaMetadata struct { + + // id + // Required: true + ID *string `xml:"id"` + + // version + // Required: true + Version *string `xml:"version"` +} + +// Validate validates this mta metadata +func (m *MtaMetadata) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateVersion(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *MtaMetadata) validateID(formats strfmt.Registry) error { + + if err := validate.Required("metadata"+"."+"id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *MtaMetadata) validateVersion(formats strfmt.Registry) error { + + if err := validate.Required("metadata"+"."+"version", "body", m.Version); err != nil { + return err + } + + return nil +} + +type MtaModulesItems0ProvidedDependencies struct { + ProvidedDependencies []string `xml:"providedDependency,omitempty"` +} + +type MtaModulesItems0Services struct { + Services []string `xml:"service,omitempty"` +} + +// MtaModulesItems0 mta modules items0 +// swagger:model MtaModulesItems0 +type MtaModulesItems0 struct { + + // app name + // Required: true + AppName *string `xml:"appName"` + + // module name + // Required: true + ModuleName *string `xml:"moduleName"` + + // provided dependencies + // Required: true + ProvidedDependencies MtaModulesItems0ProvidedDependencies `xml:"providedDependencies,omitempty"` + + // services + // Required: true + Services MtaModulesItems0Services `xml:"services,omitempty"` +} + +// Validate validates this mta modules items0 +func (m *MtaModulesItems0) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateAppName(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateModuleName(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateProvidedDependencies(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateServices(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *MtaModulesItems0) validateAppName(formats strfmt.Registry) error { + + if err := validate.Required("appName", "body", m.AppName); err != nil { + return err + } + + return nil +} + +func (m *MtaModulesItems0) validateModuleName(formats strfmt.Registry) error { + + if err := validate.Required("moduleName", "body", m.ModuleName); err != nil { + return err + } + + return nil +} + +func (m *MtaModulesItems0) validateProvidedDependencies(formats strfmt.Registry) error { + + if err := validate.Required("providedDependencies", "body", m.ProvidedDependencies); err != nil { + return err + } + + return nil +} + +func (m *MtaModulesItems0) validateServices(formats strfmt.Registry) error { + + if err := validate.Required("services", "body", m.Services); err != nil { + return err + } + + return nil +} diff --git a/clients/models/operation.go b/clients/models/operation.go new file mode 100644 index 0000000..2ac0214 --- /dev/null +++ b/clients/models/operation.go @@ -0,0 +1,158 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// Operation operation +// swagger:model operation +type Operation struct { + XMLName xml.Name `xml:"ongoing-operation"` + + // acquired lock + // Required: true + AcquiredLock *bool `xml:"acquired-lock,omitempty"` + + // mta id + MtaID string `xml:"mta-id,omitempty"` + + // process id + // Required: true + ProcessID *string `xml:"process-id,omitempty"` + + // process type + // Required: true + ProcessType ProcessType `xml:"process-type,omitempty"` + + // space id + // Required: true + SpaceID *string `xml:"space-id,omitempty"` + + // started at + // Required: true + StartedAt *string `xml:"started-at,omitempty"` + + // state + // Required: true + State SlpTaskStateEnum `xml:"state,omitempty"` + + // user + // Required: true + User *string `xml:"user"` +} + +// Validate validates this operation +func (m *Operation) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateAcquiredLock(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateProcessID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateProcessType(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateSpaceID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateStartedAt(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateState(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateUser(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Operation) validateAcquiredLock(formats strfmt.Registry) error { + + if err := validate.Required("acquired-lock", "body", m.AcquiredLock); err != nil { + return err + } + + return nil +} + +func (m *Operation) validateProcessID(formats strfmt.Registry) error { + + if err := validate.Required("process-id", "body", m.ProcessID); err != nil { + return err + } + + return nil +} + +func (m *Operation) validateProcessType(formats strfmt.Registry) error { + + if err := m.ProcessType.Validate(formats); err != nil { + return err + } + + return nil +} + +func (m *Operation) validateSpaceID(formats strfmt.Registry) error { + + if err := validate.Required("space-id", "body", m.SpaceID); err != nil { + return err + } + + return nil +} + +func (m *Operation) validateStartedAt(formats strfmt.Registry) error { + + if err := validate.Required("started-at", "body", m.StartedAt); err != nil { + return err + } + + return nil +} + +func (m *Operation) validateState(formats strfmt.Registry) error { + + if err := m.State.Validate(formats); err != nil { + return err + } + + return nil +} + +func (m *Operation) validateUser(formats strfmt.Registry) error { + + if err := validate.Required("user", "body", m.User); err != nil { + return err + } + + return nil +} diff --git a/clients/models/operations.go b/clients/models/operations.go new file mode 100644 index 0000000..d3b080d --- /dev/null +++ b/clients/models/operations.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Operations operations +// swagger:model operations +type Operations struct { + XMLName xml.Name `xml:"ongoing-operations"` + Operations []*Operation `xml:"ongoing-operation,omitempty"` +} + +// Validate validates this operations +func (m Operations) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Operations); i++ { + + if swag.IsZero(m.Operations[i]) { // not required + continue + } + + if m.Operations[i] != nil { + + if err := m.Operations[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/parameter.go b/clients/models/parameter.go new file mode 100644 index 0000000..0329388 --- /dev/null +++ b/clients/models/parameter.go @@ -0,0 +1,221 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +type ParameterParameters struct { + Parameters []*Parameter `xml:"Parameter,omitempty"` +} + +type ParameterTuples struct { + Tuples []*Tuple `xml:"Tuple,omitempty"` +} + +type ParameterValidationStatuses struct { + ValidationStatuses []*ValidationStatus `xml:"ValidationStatus,omitempty"` +} + +// Parameter Combination of definition and value in one element for easier usage +// swagger:model Parameter +type Parameter struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Parameter"` + + // default + Default string `xml:"default,omitempty"` + + // id + // Required: true + ID *string `xml:"id"` + + // required + Required bool `xml:"required,omitempty"` + + // secure + Secure bool `xml:"secure,omitempty"` + + // structure + Structure ParameterParameters `xml:"structure,omitempty"` + + // tablevalue + Tablevalue ParameterTuples `xml:"tablevalue,omitempty"` + + // tuplevalue + Tuplevalue ParameterParameters `xml:"tuplevalue,omitempty"` + + // type + Type SlpParameterType `xml:"type,omitempty"` + + // validation result + ValidationResult ParameterValidationStatuses `xml:"validationResult,omitempty"` + + // value + Value string `xml:"value,omitempty"` +} + +// Validate validates this parameter +func (m *Parameter) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateStructure(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateTablevalue(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateTuplevalue(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateType(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateValidationResult(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Parameter) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *Parameter) validateStructure(formats strfmt.Registry) error { + + if swag.IsZero(m.Structure) { // not required + return nil + } + + for i := 0; i < len(m.Structure.Parameters); i++ { + + if swag.IsZero(m.Structure.Parameters[i]) { // not required + continue + } + + if m.Structure.Parameters[i] != nil { + + if err := m.Structure.Parameters[i].Validate(formats); err != nil { + return err + } + } + + } + + return nil +} + +func (m *Parameter) validateTablevalue(formats strfmt.Registry) error { + + if swag.IsZero(m.Tablevalue) { // not required + return nil + } + + for i := 0; i < len(m.Tablevalue.Tuples); i++ { + + if swag.IsZero(m.Tablevalue.Tuples[i]) { // not required + continue + } + + if m.Tablevalue.Tuples[i] != nil { + + if err := m.Tablevalue.Tuples[i].Validate(formats); err != nil { + return err + } + } + + } + + return nil +} + +func (m *Parameter) validateTuplevalue(formats strfmt.Registry) error { + + if swag.IsZero(m.Tuplevalue) { // not required + return nil + } + + for i := 0; i < len(m.Tuplevalue.Parameters); i++ { + + if swag.IsZero(m.Tuplevalue.Parameters[i]) { // not required + continue + } + + if m.Tuplevalue.Parameters[i] != nil { + + if err := m.Tuplevalue.Parameters[i].Validate(formats); err != nil { + return err + } + } + + } + + return nil +} + +func (m *Parameter) validateType(formats strfmt.Registry) error { + + if swag.IsZero(m.Type) { // not required + return nil + } + + if err := m.Type.Validate(formats); err != nil { + return err + } + + return nil +} + +func (m *Parameter) validateValidationResult(formats strfmt.Registry) error { + + if swag.IsZero(m.ValidationResult) { // not required + return nil + } + + for i := 0; i < len(m.ValidationResult.ValidationStatuses); i++ { + + if swag.IsZero(m.ValidationResult.ValidationStatuses[i]) { // not required + continue + } + + if m.ValidationResult.ValidationStatuses[i] != nil { + + if err := m.ValidationResult.ValidationStatuses[i].Validate(formats); err != nil { + return err + } + } + + } + + return nil +} diff --git a/clients/models/parameters.go b/clients/models/parameters.go new file mode 100644 index 0000000..fee3b3a --- /dev/null +++ b/clients/models/parameters.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Parameters parameters +// swagger:model parameters +type Parameters struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp parameters"` + Parameters []*Parameter `xml:"Parameter,omitempty"` +} + +// Validate validates this parameters +func (m Parameters) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Parameters); i++ { + + if swag.IsZero(m.Parameters[i]) { // not required + continue + } + + if m.Parameters[i] != nil { + + if err := m.Parameters[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/process.go b/clients/models/process.go new file mode 100644 index 0000000..3f76af9 --- /dev/null +++ b/clients/models/process.go @@ -0,0 +1,154 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +type ProcessParameters struct { + Parameters []*Parameter `xml:"Parameter,omitempty"` +} + +type ProcessVersions struct { + ComponentVersions []*ComponentVersion `xml:"ComponentVersion,omitempty"` +} + +// Process SL Process which can be seen as an instance of a SL service +// swagger:model Process +type Process struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Process"` + + // description + Description string `xml:"description,omitempty"` + + // display name + DisplayName string `xml:"displayName,omitempty"` + + // external info + ExternalInfo strfmt.URI `xml:"externalInfo,omitempty"` + + // id + ID string `xml:"id,omitempty"` + + // parameters + // Required: true + Parameters ProcessParameters `xml:"parameters,omitempty"` + + // root URL + RootURL strfmt.URI `xml:"rootURL,omitempty"` + + // service + // Required: true + Service *strfmt.URI `xml:"service"` + + // status + // Required: true + Status SlpProcessState `xml:"status"` + + // versions + Versions ProcessVersions `xml:"versions,omitempty"` +} + +// Validate validates this process +func (m *Process) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateParameters(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateService(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateStatus(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateVersions(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Process) validateParameters(formats strfmt.Registry) error { + + if err := validate.Required("parameters", "body", m.Parameters); err != nil { + return err + } + + for i := 0; i < len(m.Parameters.Parameters); i++ { + + if swag.IsZero(m.Parameters.Parameters[i]) { // not required + continue + } + + if m.Parameters.Parameters[i] != nil { + + if err := m.Parameters.Parameters[i].Validate(formats); err != nil { + return err + } + } + + } + + return nil +} + +func (m *Process) validateService(formats strfmt.Registry) error { + + if err := validate.Required("service", "body", m.Service); err != nil { + return err + } + + return nil +} + +func (m *Process) validateStatus(formats strfmt.Registry) error { + + if err := m.Status.Validate(formats); err != nil { + return err + } + + return nil +} + +func (m *Process) validateVersions(formats strfmt.Registry) error { + + if swag.IsZero(m.Versions) { // not required + return nil + } + + for i := 0; i < len(m.Versions.ComponentVersions); i++ { + + if swag.IsZero(m.Versions.ComponentVersions[i]) { // not required + continue + } + + if m.Versions.ComponentVersions[i] != nil { + + if err := m.Versions.ComponentVersions[i].Validate(formats); err != nil { + return err + } + } + + } + + return nil +} diff --git a/clients/models/process_type.go b/clients/models/process_type.go new file mode 100644 index 0000000..e43cbba --- /dev/null +++ b/clients/models/process_type.go @@ -0,0 +1,57 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// ProcessType process type +// swagger:model process_type +type ProcessType string + +const ( + ProcessTypeDeploy ProcessType = "deploy" + ProcessTypeUndeploy ProcessType = "undeploy" + ProcessTypeBlueGreenDeploy ProcessType = "blue-green-deploy" +) + +// for schema +var processTypeEnum []interface{} + +func (m ProcessType) validateProcessTypeEnum(path, location string, value ProcessType) error { + if processTypeEnum == nil { + var res []ProcessType + if err := json.Unmarshal([]byte(`["deploy","undeploy","blue-green-deploy"]`), &res); err != nil { + return err + } + for _, v := range res { + processTypeEnum = append(processTypeEnum, v) + } + } + if err := validate.Enum(path, location, value, processTypeEnum); err != nil { + return err + } + return nil +} + +// Validate validates this process type +func (m ProcessType) Validate(formats strfmt.Registry) error { + var res []error + + // value enum + if err := m.validateProcessTypeEnum("", "body", m); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/processes.go b/clients/models/processes.go new file mode 100644 index 0000000..d3bd3da --- /dev/null +++ b/clients/models/processes.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Processes processes +// swagger:model processes +type Processes struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp processes"` + Processes []*Process `xml:"Process,omitempty"` +} + +// Validate validates this processes +func (m Processes) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Processes); i++ { + + if swag.IsZero(m.Processes[i]) { // not required + continue + } + + if m.Processes[i] != nil { + + if err := m.Processes[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/progress_message.go b/clients/models/progress_message.go new file mode 100644 index 0000000..43eb6a5 --- /dev/null +++ b/clients/models/progress_message.go @@ -0,0 +1,65 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// ProgressMessage Progress message to be shown on the UI +// swagger:model ProgressMessage +type ProgressMessage struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp ProgressMessage"` + + // id + // Required: true + ID *string `xml:"id"` + + // message + // Required: true + Message *string `xml:"message"` +} + +// Validate validates this progress message +func (m *ProgressMessage) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateMessage(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *ProgressMessage) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *ProgressMessage) validateMessage(formats strfmt.Registry) error { + + if err := validate.Required("message", "body", m.Message); err != nil { + return err + } + + return nil +} diff --git a/clients/models/properties.go b/clients/models/properties.go new file mode 100644 index 0000000..840b3d8 --- /dev/null +++ b/clients/models/properties.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Properties properties +// swagger:model properties +type Properties struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp properties"` + Properties []*Property `xml:"Property,omitempty"` +} + +// Validate validates this properties +func (m Properties) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Properties); i++ { + + if swag.IsZero(m.Properties[i]) { // not required + continue + } + + if m.Properties[i] != nil { + + if err := m.Properties[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/property.go b/clients/models/property.go new file mode 100644 index 0000000..9e5e936 --- /dev/null +++ b/clients/models/property.go @@ -0,0 +1,68 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// Property Property element allows providing a process specific information which may be interesting for the user +// swagger:model Property +type Property struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Property"` + + // id + // Required: true + ID *string `json:"id"` + + // info + Info strfmt.URI `json:"info,omitempty"` + + // value + // Required: true + Value *string `json:"value"` +} + +// Validate validates this property +func (m *Property) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateValue(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Property) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *Property) validateValue(formats strfmt.Registry) error { + + if err := validate.Required("value", "body", m.Value); err != nil { + return err + } + + return nil +} diff --git a/clients/models/roadmap.go b/clients/models/roadmap.go new file mode 100644 index 0000000..71d44f9 --- /dev/null +++ b/clients/models/roadmap.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Roadmap roadmap +// swagger:model roadmap +type Roadmap struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp roadmap"` + Tasks []*Task `xml:"Task,omitempty"` +} + +// Validate validates this roadmap +func (m Roadmap) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Tasks); i++ { + + if swag.IsZero(m.Tasks[i]) { // not required + continue + } + + if m.Tasks[i] != nil { + + if err := m.Tasks[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/service.go b/clients/models/service.go new file mode 100644 index 0000000..35eed89 --- /dev/null +++ b/clients/models/service.go @@ -0,0 +1,138 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +type ServiceParameters struct { + Parameters []*Parameter `xml:"Parameter,omitempty"` +} + +// Service SLMP is a protocol for managing SL processes. It provides facilities for querying SL services available on managed object, accessing historical information associated with a finished processes and creation of new processes +// swagger:model Service +type Service struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Service"` + + // description + Description string `xml:"description,omitempty"` + + // display name + DisplayName string `xml:"displayName,omitempty"` + + // external info + ExternalInfo strfmt.URI `xml:"externalInfo,omitempty"` + + // files + Files strfmt.URI `xml:"files,omitempty"` + + // id + // Required: true + ID *strfmt.URI `xml:"id"` + + // parameters + Parameters ServiceParameters `xml:"parameters,omitempty"` + + // processes + // Required: true + Processes *strfmt.URI `xml:"processes"` + + // slppversion + // Required: true + Slppversion *string `xml:"slppversion"` + + // synchronous + Synchronous bool `xml:"synchronous,omitempty"` + + // versions + Versions strfmt.URI `xml:"versions,omitempty"` +} + +// Validate validates this service +func (m *Service) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateParameters(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateProcesses(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateSlppversion(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Service) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *Service) validateParameters(formats strfmt.Registry) error { + + if swag.IsZero(m.Parameters.Parameters) { // not required + return nil + } + + for i := 0; i < len(m.Parameters.Parameters); i++ { + + if swag.IsZero(m.Parameters.Parameters[i]) { // not required + continue + } + + if m.Parameters.Parameters[i] != nil { + + if err := m.Parameters.Parameters[i].Validate(formats); err != nil { + return err + } + } + + } + + return nil +} + +func (m *Service) validateProcesses(formats strfmt.Registry) error { + + if err := validate.Required("processes", "body", m.Processes); err != nil { + return err + } + + return nil +} + +func (m *Service) validateSlppversion(formats strfmt.Registry) error { + + if err := validate.Required("slppversion", "body", m.Slppversion); err != nil { + return err + } + + return nil +} diff --git a/clients/models/services.go b/clients/models/services.go new file mode 100644 index 0000000..aaf75bf --- /dev/null +++ b/clients/models/services.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Services services +// swagger:model services +type Services struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp services"` + Services []*Service `xml:"Service,omitempty"` +} + +// Validate validates this services +func (m Services) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Services); i++ { + + if swag.IsZero(m.Services[i]) { // not required + continue + } + + if m.Services[i] != nil { + + if err := m.Services[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_action.go b/clients/models/slp_action.go new file mode 100644 index 0000000..2c4b630 --- /dev/null +++ b/clients/models/slp_action.go @@ -0,0 +1,35 @@ +package models + +import ( + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" +) + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +// SlpAction slp action +// swagger:model slp_action +type SlpAction struct { + SlpActionEnum + + SlpActionExtensions +} + +// Validate validates this slp action +func (m *SlpAction) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.SlpActionEnum.Validate(formats); err != nil { + res = append(res, err) + } + + if err := m.SlpActionExtensions.Validate(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_action_enum.go b/clients/models/slp_action_enum.go new file mode 100644 index 0000000..925a9fd --- /dev/null +++ b/clients/models/slp_action_enum.go @@ -0,0 +1,60 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// SlpActionEnum Actions on the SL processes +// swagger:model slp_action_enum +type SlpActionEnum string + +const ( + SlpActionEnumSlpActionSTOP SlpActionEnum = "slp.action.STOP" + SlpActionEnumSlpActionABORT SlpActionEnum = "slp.action.ABORT" + SlpActionEnumSlpActionRESUME SlpActionEnum = "slp.action.RESUME" + SlpActionEnumSlpActionSUBMIT SlpActionEnum = "slp.action.SUBMIT" + SlpActionEnumSlpActionREPEAT SlpActionEnum = "slp.action.REPEAT" + SlpActionEnumSlpActionSTART SlpActionEnum = "slp.action.START" +) + +// for schema +var slpActionEnumEnum []interface{} + +func (m SlpActionEnum) validateSlpActionEnumEnum(path, location string, value SlpActionEnum) error { + if slpActionEnumEnum == nil { + var res []SlpActionEnum + if err := json.Unmarshal([]byte(`["slp.action.STOP","slp.action.ABORT","slp.action.RESUME","slp.action.SUBMIT","slp.action.REPEAT","slp.action.START"]`), &res); err != nil { + return err + } + for _, v := range res { + slpActionEnumEnum = append(slpActionEnumEnum, v) + } + } + if err := validate.Enum(path, location, value, slpActionEnumEnum); err != nil { + return err + } + return nil +} + +// Validate validates this slp action enum +func (m SlpActionEnum) Validate(formats strfmt.Registry) error { + var res []error + + // value enum + if err := m.validateSlpActionEnumEnum("", "body", m); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_action_extensions.go b/clients/models/slp_action_extensions.go new file mode 100644 index 0000000..9ae26c6 --- /dev/null +++ b/clients/models/slp_action_extensions.go @@ -0,0 +1,29 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// SlpActionExtensions slp action extensions +// swagger:model slp_action_extensions +type SlpActionExtensions string + +// Validate validates this slp action extensions +func (m SlpActionExtensions) Validate(formats strfmt.Registry) error { + var res []error + + if err := validate.Pattern("", "body", string(m), `slp.action.[A-Z]+`); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_breakpoint_status.go b/clients/models/slp_breakpoint_status.go new file mode 100644 index 0000000..688fb27 --- /dev/null +++ b/clients/models/slp_breakpoint_status.go @@ -0,0 +1,57 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// SlpBreakpointStatus Supported breakpoint statuses +// swagger:model slp_breakpoint_status +type SlpBreakpointStatus string + +const ( + SlpBreakpointStatusSlpBreakpointStatusBEFORE SlpBreakpointStatus = "slp.breakpoint.status.BEFORE" + SlpBreakpointStatusSlpBreakpointStatusAT SlpBreakpointStatus = "slp.breakpoint.status.AT" + SlpBreakpointStatusSlpBreakpointStatusAFTER SlpBreakpointStatus = "slp.breakpoint.status.AFTER" +) + +// for schema +var slpBreakpointStatusEnum []interface{} + +func (m SlpBreakpointStatus) validateSlpBreakpointStatusEnum(path, location string, value SlpBreakpointStatus) error { + if slpBreakpointStatusEnum == nil { + var res []SlpBreakpointStatus + if err := json.Unmarshal([]byte(`["slp.breakpoint.status.BEFORE","slp.breakpoint.status.AT","slp.breakpoint.status.AFTER"]`), &res); err != nil { + return err + } + for _, v := range res { + slpBreakpointStatusEnum = append(slpBreakpointStatusEnum, v) + } + } + if err := validate.Enum(path, location, value, slpBreakpointStatusEnum); err != nil { + return err + } + return nil +} + +// Validate validates this slp breakpoint status +func (m SlpBreakpointStatus) Validate(formats strfmt.Registry) error { + var res []error + + // value enum + if err := m.validateSlpBreakpointStatusEnum("", "body", m); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_log_format.go b/clients/models/slp_log_format.go new file mode 100644 index 0000000..ab87148 --- /dev/null +++ b/clients/models/slp_log_format.go @@ -0,0 +1,35 @@ +package models + +import ( + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" +) + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +// SlpLogFormat slp log format +// swagger:model slp_log_format +type SlpLogFormat struct { + SlpLogFormatEnum + + SlpLogFormatExtensions +} + +// Validate validates this slp log format +func (m *SlpLogFormat) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.SlpLogFormatEnum.Validate(formats); err != nil { + res = append(res, err) + } + + if err := m.SlpLogFormatExtensions.Validate(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_log_format_enum.go b/clients/models/slp_log_format_enum.go new file mode 100644 index 0000000..86dba29 --- /dev/null +++ b/clients/models/slp_log_format_enum.go @@ -0,0 +1,57 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// SlpLogFormatEnum Supported log formats +// swagger:model slp_log_format_enum +type SlpLogFormatEnum string + +const ( + SlpLogFormatEnumSlpLogFormatTEXT SlpLogFormatEnum = "slp.log.format.TEXT" + SlpLogFormatEnumSlpLogFormatHTML SlpLogFormatEnum = "slp.log.format.HTML" + SlpLogFormatEnumSlpLogFormatGLF SlpLogFormatEnum = "slp.log.format.GLF" +) + +// for schema +var slpLogFormatEnumEnum []interface{} + +func (m SlpLogFormatEnum) validateSlpLogFormatEnumEnum(path, location string, value SlpLogFormatEnum) error { + if slpLogFormatEnumEnum == nil { + var res []SlpLogFormatEnum + if err := json.Unmarshal([]byte(`["slp.log.format.TEXT","slp.log.format.HTML","slp.log.format.GLF"]`), &res); err != nil { + return err + } + for _, v := range res { + slpLogFormatEnumEnum = append(slpLogFormatEnumEnum, v) + } + } + if err := validate.Enum(path, location, value, slpLogFormatEnumEnum); err != nil { + return err + } + return nil +} + +// Validate validates this slp log format enum +func (m SlpLogFormatEnum) Validate(formats strfmt.Registry) error { + var res []error + + // value enum + if err := m.validateSlpLogFormatEnumEnum("", "body", m); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_log_format_extensions.go b/clients/models/slp_log_format_extensions.go new file mode 100644 index 0000000..b7d4116 --- /dev/null +++ b/clients/models/slp_log_format_extensions.go @@ -0,0 +1,29 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// SlpLogFormatExtensions slp log format extensions +// swagger:model slp_log_format_extensions +type SlpLogFormatExtensions string + +// Validate validates this slp log format extensions +func (m SlpLogFormatExtensions) Validate(formats strfmt.Registry) error { + var res []error + + if err := validate.Pattern("", "body", string(m), `slp.log.format.[A-Z]+`); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_parameter_type.go b/clients/models/slp_parameter_type.go new file mode 100644 index 0000000..b9e0767 --- /dev/null +++ b/clients/models/slp_parameter_type.go @@ -0,0 +1,58 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// SlpParameterType Defines the structural type of the parameter +// swagger:model slp_parameter_type +type SlpParameterType string + +const ( + SlpParameterTypeSlpParameterTypeSCALAR SlpParameterType = "slp.parameter.type.SCALAR" + SlpParameterTypeSlpParameterTypeTUPLE SlpParameterType = "slp.parameter.type.TUPLE" + SlpParameterTypeSlpParameterTypeTABLE SlpParameterType = "slp.parameter.type.TABLE" + SlpParameterTypeSlpParameterTypeFILE SlpParameterType = "slp.parameter.type.FILE" +) + +// for schema +var slpParameterTypeEnum []interface{} + +func (m SlpParameterType) validateSlpParameterTypeEnum(path, location string, value SlpParameterType) error { + if slpParameterTypeEnum == nil { + var res []SlpParameterType + if err := json.Unmarshal([]byte(`["slp.parameter.type.SCALAR","slp.parameter.type.TUPLE","slp.parameter.type.TABLE","slp.parameter.type.FILE"]`), &res); err != nil { + return err + } + for _, v := range res { + slpParameterTypeEnum = append(slpParameterTypeEnum, v) + } + } + if err := validate.Enum(path, location, value, slpParameterTypeEnum); err != nil { + return err + } + return nil +} + +// Validate validates this slp parameter type +func (m SlpParameterType) Validate(formats strfmt.Registry) error { + var res []error + + // value enum + if err := m.validateSlpParameterTypeEnum("", "body", m); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_parameter_validation_status.go b/clients/models/slp_parameter_validation_status.go new file mode 100644 index 0000000..1cfdced --- /dev/null +++ b/clients/models/slp_parameter_validation_status.go @@ -0,0 +1,58 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// SlpParameterValidationStatus Parameter validation status +// swagger:model slp_parameter_validation_status +type SlpParameterValidationStatus string + +const ( + SlpParameterValidationStatusSlpParameterValidationStatusERROR SlpParameterValidationStatus = "slp.parameter.validation.status.ERROR" + SlpParameterValidationStatusSlpParameterValidationStatusOK SlpParameterValidationStatus = "slp.parameter.validation.status.OK" + SlpParameterValidationStatusSlpParameterValidationStatusWARNING SlpParameterValidationStatus = "slp.parameter.validation.status.WARNING" + SlpParameterValidationStatusSlpParameterValidationStatusINFO SlpParameterValidationStatus = "slp.parameter.validation.status.INFO" +) + +// for schema +var slpParameterValidationStatusEnum []interface{} + +func (m SlpParameterValidationStatus) validateSlpParameterValidationStatusEnum(path, location string, value SlpParameterValidationStatus) error { + if slpParameterValidationStatusEnum == nil { + var res []SlpParameterValidationStatus + if err := json.Unmarshal([]byte(`["slp.parameter.validation.status.ERROR","slp.parameter.validation.status.OK","slp.parameter.validation.status.WARNING","slp.parameter.validation.status.INFO"]`), &res); err != nil { + return err + } + for _, v := range res { + slpParameterValidationStatusEnum = append(slpParameterValidationStatusEnum, v) + } + } + if err := validate.Enum(path, location, value, slpParameterValidationStatusEnum); err != nil { + return err + } + return nil +} + +// Validate validates this slp parameter validation status +func (m SlpParameterValidationStatus) Validate(formats strfmt.Registry) error { + var res []error + + // value enum + if err := m.validateSlpParameterValidationStatusEnum("", "body", m); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_process_state.go b/clients/models/slp_process_state.go new file mode 100644 index 0000000..08eb18e --- /dev/null +++ b/clients/models/slp_process_state.go @@ -0,0 +1,56 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// SlpProcessState Values allowed for a process state +// swagger:model slp_process_state +type SlpProcessState string + +const ( + SlpProcessStateSlpProcessStateACTIVE SlpProcessState = "slp.process.state.ACTIVE" + SlpProcessStateSlpProcessStateFINISHED SlpProcessState = "slp.process.state.FINISHED" +) + +// for schema +var slpProcessStateEnum []interface{} + +func (m SlpProcessState) validateSlpProcessStateEnum(path, location string, value SlpProcessState) error { + if slpProcessStateEnum == nil { + var res []SlpProcessState + if err := json.Unmarshal([]byte(`["slp.process.state.ACTIVE","slp.process.state.FINISHED"]`), &res); err != nil { + return err + } + for _, v := range res { + slpProcessStateEnum = append(slpProcessStateEnum, v) + } + } + if err := validate.Enum(path, location, value, slpProcessStateEnum); err != nil { + return err + } + return nil +} + +// Validate validates this slp process state +func (m SlpProcessState) Validate(formats strfmt.Registry) error { + var res []error + + // value enum + if err := m.validateSlpProcessStateEnum("", "body", m); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_task_state.go b/clients/models/slp_task_state.go new file mode 100644 index 0000000..44512e4 --- /dev/null +++ b/clients/models/slp_task_state.go @@ -0,0 +1,64 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// SlpTaskState Values allowed for task's state +// swagger:model slp_task_state +type SlpTaskState string + +const ( + SlpTaskStateSlpTaskStateINITIAL SlpTaskState = "slp.task.state.INITIAL" + SlpTaskStateSlpTaskStateRUNNING SlpTaskState = "slp.task.state.RUNNING" + SlpTaskStateSlpTaskStateERROR SlpTaskState = "slp.task.state.ERROR" + SlpTaskStateSlpTaskStateDIALOG SlpTaskState = "slp.task.state.DIALOG" + SlpTaskStateSlpTaskStateFINISHED SlpTaskState = "slp.task.state.FINISHED" + SlpTaskStateSlpTaskStateABORTED SlpTaskState = "slp.task.state.ABORTED" + SlpTaskStateSlpTaskStateSKIPPED SlpTaskState = "slp.task.state.SKIPPED" + SlpTaskStateSlpTaskStateACTIONREQUIRED SlpTaskState = "slp.task.state.ACTION_REQUIRED" + SlpTaskStateSlpTaskStateBREAKPOINT SlpTaskState = "slp.task.state.BREAKPOINT" + SlpTaskStateSlpTaskStateSTOPPED SlpTaskState = "slp.task.state.STOPPED" +) + +// for schema +var slpTaskStateEnum []interface{} + +func (m SlpTaskState) validateSlpTaskStateEnum(path, location string, value SlpTaskState) error { + if slpTaskStateEnum == nil { + var res []SlpTaskState + if err := json.Unmarshal([]byte(`["slp.task.state.INITIAL","slp.task.state.RUNNING","slp.task.state.ERROR","slp.task.state.DIALOG","slp.task.state.FINISHED","slp.task.state.ABORTED","slp.task.state.SKIPPED","slp.task.state.ACTION_REQUIRED","slp.task.state.BREAKPOINT","slp.task.state.STOPPED"]`), &res); err != nil { + return err + } + for _, v := range res { + slpTaskStateEnum = append(slpTaskStateEnum, v) + } + } + if err := validate.Enum(path, location, value, slpTaskStateEnum); err != nil { + return err + } + return nil +} + +// Validate validates this slp task state +func (m SlpTaskState) Validate(formats strfmt.Registry) error { + var res []error + + // value enum + if err := m.validateSlpTaskStateEnum("", "body", m); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_task_state_enum.go b/clients/models/slp_task_state_enum.go new file mode 100644 index 0000000..43d2cf7 --- /dev/null +++ b/clients/models/slp_task_state_enum.go @@ -0,0 +1,64 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// SlpTaskStateEnum slp task state enum +// swagger:model slp_task_state_enum +type SlpTaskStateEnum string + +const ( + SlpTaskStateEnumSLPTASKSTATEINITIAL SlpTaskStateEnum = "SLP_TASK_STATE_INITIAL" + SlpTaskStateEnumSLPTASKSTATERUNNING SlpTaskStateEnum = "SLP_TASK_STATE_RUNNING" + SlpTaskStateEnumSLPTASKSTATEERROR SlpTaskStateEnum = "SLP_TASK_STATE_ERROR" + SlpTaskStateEnumSLPTASKSTATEDIALOG SlpTaskStateEnum = "SLP_TASK_STATE_DIALOG" + SlpTaskStateEnumSLPTASKSTATEFINISHED SlpTaskStateEnum = "SLP_TASK_STATE_FINISHED" + SlpTaskStateEnumSLPTASKSTATEABORTED SlpTaskStateEnum = "SLP_TASK_STATE_ABORTED" + SlpTaskStateEnumSLPTASKSTATESKIPPED SlpTaskStateEnum = "SLP_TASK_STATE_SKIPPED" + SlpTaskStateEnumSLPTASKSTATEACTIONREQUIRED SlpTaskStateEnum = "SLP_TASK_STATE_ACTION_REQUIRED" + SlpTaskStateEnumSLPTASKSTATEBREAKPOINT SlpTaskStateEnum = "SLP_TASK_STATE_BREAKPOINT" + SlpTaskStateEnumSLPTASKSTATESTOPPED SlpTaskStateEnum = "SLP_TASK_STATE_STOPPED" +) + +// for schema +var slpTaskStateEnumEnum []interface{} + +func (m SlpTaskStateEnum) validateSlpTaskStateEnumEnum(path, location string, value SlpTaskStateEnum) error { + if slpTaskStateEnumEnum == nil { + var res []SlpTaskStateEnum + if err := json.Unmarshal([]byte(`["SLP_TASK_STATE_INITIAL","SLP_TASK_STATE_RUNNING","SLP_TASK_STATE_ERROR","SLP_TASK_STATE_DIALOG","SLP_TASK_STATE_FINISHED","SLP_TASK_STATE_ABORTED","SLP_TASK_STATE_SKIPPED","SLP_TASK_STATE_ACTION_REQUIRED","SLP_TASK_STATE_BREAKPOINT","SLP_TASK_STATE_STOPPED"]`), &res); err != nil { + return err + } + for _, v := range res { + slpTaskStateEnumEnum = append(slpTaskStateEnumEnum, v) + } + } + if err := validate.Enum(path, location, value, slpTaskStateEnumEnum); err != nil { + return err + } + return nil +} + +// Validate validates this slp task state enum +func (m SlpTaskStateEnum) Validate(formats strfmt.Registry) error { + var res []error + + // value enum + if err := m.validateSlpTaskStateEnumEnum("", "body", m); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_task_type.go b/clients/models/slp_task_type.go new file mode 100644 index 0000000..8f7df99 --- /dev/null +++ b/clients/models/slp_task_type.go @@ -0,0 +1,58 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// SlpTaskType Values allowed for task's type +// swagger:model slp_task_type +type SlpTaskType string + +const ( + SlpTaskTypeSlpTaskTypePROCESS SlpTaskType = "slp.task.type.PROCESS" + SlpTaskTypeSlpTaskTypeROADMAPTECH SlpTaskType = "slp.task.type.ROADMAP.TECH" + SlpTaskTypeSlpTaskTypeROADMAPUSER SlpTaskType = "slp.task.type.ROADMAP.USER" + SlpTaskTypeSlpTaskTypeSTEP SlpTaskType = "slp.task.type.STEP" +) + +// for schema +var slpTaskTypeEnum []interface{} + +func (m SlpTaskType) validateSlpTaskTypeEnum(path, location string, value SlpTaskType) error { + if slpTaskTypeEnum == nil { + var res []SlpTaskType + if err := json.Unmarshal([]byte(`["slp.task.type.PROCESS","slp.task.type.ROADMAP.TECH","slp.task.type.ROADMAP.USER","slp.task.type.STEP"]`), &res); err != nil { + return err + } + for _, v := range res { + slpTaskTypeEnum = append(slpTaskTypeEnum, v) + } + } + if err := validate.Enum(path, location, value, slpTaskTypeEnum); err != nil { + return err + } + return nil +} + +// Validate validates this slp task type +func (m SlpTaskType) Validate(formats strfmt.Registry) error { + var res []error + + // value enum + if err := m.validateSlpTaskTypeEnum("", "body", m); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/slp_timestamp.go b/clients/models/slp_timestamp.go new file mode 100644 index 0000000..e92b3b4 --- /dev/null +++ b/clients/models/slp_timestamp.go @@ -0,0 +1,15 @@ +package models + +import "github.com/go-openapi/strfmt" + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +// SlpTimestamp slp timestamp +// swagger:model slp_timestamp +type SlpTimestamp strfmt.DateTime + +// Validate validates this slp timestamp +func (m SlpTimestamp) Validate(formats strfmt.Registry) error { + return nil +} diff --git a/clients/models/task.go b/clients/models/task.go new file mode 100644 index 0000000..48d30ed --- /dev/null +++ b/clients/models/task.go @@ -0,0 +1,168 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +type TaskProgressMessages struct { + ProgressMessages []*ProgressMessage `xml:"ProgressMessage,omitempty"` +} + +// Task Task element represents runtime information about SL processes. All kinds of operations comprising an SL processes are considered to be tasks during the execution. This applies to the top level processes like system update in the same way as to a single operation like copy file +// swagger:model Task +type Task struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Task"` + + // description + Description string `xml:"description,omitempty"` + + // display name + DisplayName string `xml:"displayName,omitempty"` + + // error + Error strfmt.URI `xml:"error,omitempty"` + + // external info + ExternalInfo strfmt.URI `xml:"externalInfo,omitempty"` + + // finished at + FinishedAt SlpTimestamp `xml:"finishedAt,omitempty"` + + // id + // Required: true + ID *string `xml:"id"` + + // logs + Logs strfmt.URI `xml:"logs,omitempty"` + + // parent + Parent string `xml:"parent,omitempty"` + + // progress + Progress int32 `xml:"progress,omitempty"` + + // progress messages + ProgressMessages TaskProgressMessages `xml:"progressMessages,omitempty"` + + // refresh rate + RefreshRate int32 `xml:"refreshRate,omitempty"` + + // started at + StartedAt SlpTimestamp `xml:"startedAt,omitempty"` + + // status + // Required: true + Status SlpTaskState `xml:"status"` + + // technical name + // Required: true + TechnicalName *string `xml:"technicalName"` + + // type + // Required: true + Type SlpTaskType `xml:"type"` +} + +// Validate validates this task +func (m *Task) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateProgressMessages(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateStatus(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateTechnicalName(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateType(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Task) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *Task) validateProgressMessages(formats strfmt.Registry) error { + + if swag.IsZero(m.ProgressMessages) { // not required + return nil + } + + for i := 0; i < len(m.ProgressMessages.ProgressMessages); i++ { + + if swag.IsZero(m.ProgressMessages.ProgressMessages[i]) { // not required + continue + } + + if m.ProgressMessages.ProgressMessages[i] != nil { + + if err := m.ProgressMessages.ProgressMessages[i].Validate(formats); err != nil { + return err + } + } + + } + + return nil +} + +func (m *Task) validateStatus(formats strfmt.Registry) error { + + if err := m.Status.Validate(formats); err != nil { + return err + } + + return nil +} + +func (m *Task) validateTechnicalName(formats strfmt.Registry) error { + + if err := validate.Required("technicalName", "body", m.TechnicalName); err != nil { + return err + } + + return nil +} + +func (m *Task) validateType(formats strfmt.Registry) error { + + if err := m.Type.Validate(formats); err != nil { + return err + } + + return nil +} diff --git a/clients/models/tasklist.go b/clients/models/tasklist.go new file mode 100644 index 0000000..7bde1f0 --- /dev/null +++ b/clients/models/tasklist.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Tasklist tasklist +// swagger:model tasklist +type Tasklist struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp tasklist"` + Tasks []*Task `xml:"Task,omitempty"` +} + +// Validate validates this tasklist +func (m Tasklist) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.Tasks); i++ { + + if swag.IsZero(m.Tasks[i]) { // not required + continue + } + + if m.Tasks[i] != nil { + + if err := m.Tasks[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/models/tuple.go b/clients/models/tuple.go new file mode 100644 index 0000000..be5119e --- /dev/null +++ b/clients/models/tuple.go @@ -0,0 +1,85 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +type TupleParameters struct { + Parameters []*Parameter `xml:"Parameter,omitempty"` +} + +// Tuple Defines a tuple as a array of Parameter elements +// swagger:model Tuple +type Tuple struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp Tuple"` + + // id + // Required: true + ID *string `xml:"id"` + + // value + // Required: true + Value TupleParameters `xml:"value,omitempty"` +} + +// Validate validates this tuple +func (m *Tuple) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateValue(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Tuple) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *Tuple) validateValue(formats strfmt.Registry) error { + + if err := validate.Required("value", "body", m.Value); err != nil { + return err + } + + for i := 0; i < len(m.Value.Parameters); i++ { + + if swag.IsZero(m.Value.Parameters[i]) { // not required + continue + } + + if m.Value.Parameters[i] != nil { + + if err := m.Value.Parameters[i].Validate(formats); err != nil { + return err + } + } + + } + + return nil +} diff --git a/clients/models/validation_status.go b/clients/models/validation_status.go new file mode 100644 index 0000000..44f91af --- /dev/null +++ b/clients/models/validation_status.go @@ -0,0 +1,65 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/validate" +) + +// ValidationStatus Result of parameter validation +// swagger:model ValidationStatus +type ValidationStatus struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp ValidationStatus"` + + // message + // Required: true + Message *string `xml:"message"` + + // status + // Required: true + Status SlpParameterValidationStatus `xml:"status"` +} + +// Validate validates this validation status +func (m *ValidationStatus) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateMessage(formats); err != nil { + // prop + res = append(res, err) + } + + if err := m.validateStatus(formats); err != nil { + // prop + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *ValidationStatus) validateMessage(formats strfmt.Registry) error { + + if err := validate.Required("message", "body", m.Message); err != nil { + return err + } + + return nil +} + +func (m *ValidationStatus) validateStatus(formats strfmt.Registry) error { + + if err := m.Status.Validate(formats); err != nil { + return err + } + + return nil +} diff --git a/clients/models/versions.go b/clients/models/versions.go new file mode 100644 index 0000000..92fcf99 --- /dev/null +++ b/clients/models/versions.go @@ -0,0 +1,45 @@ +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/xml" + + strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + + "github.com/go-openapi/errors" +) + +// Versions versions +// swagger:model versions +type Versions struct { + XMLName xml.Name `xml:"http://www.sap.com/lmsl/slp versions"` + ComponentVersions []*ComponentVersion `xml:"ComponentVersion,omitempty"` +} + +// Validate validates this versions +func (m Versions) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m.ComponentVersions); i++ { + + if swag.IsZero(m.ComponentVersions[i]) { // not required + continue + } + + if m.ComponentVersions[i] != nil { + + if err := m.ComponentVersions[i].Validate(formats); err != nil { + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/restclient/fakes/fake_rest_client_builder.go b/clients/restclient/fakes/fake_rest_client_builder.go new file mode 100644 index 0000000..24aab8b --- /dev/null +++ b/clients/restclient/fakes/fake_rest_client_builder.go @@ -0,0 +1,97 @@ +package fakes + +import ( + "strconv" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +type mtaResult struct { + *models.Mta + error +} + +// FakeRestClientBuilder is a builder of FakeRestClientOperations instances +type FakeRestClientBuilder struct { + fakeRestClient FakeRestClientOperations + mtaResults map[string]mtaResult +} + +// NewFakeRestClientBuilder creates a new builder +func NewFakeRestClientBuilder() *FakeRestClientBuilder { + return &FakeRestClientBuilder{} +} + +// GetOperations sets the operations to return from the GetOperations operation +func (b *FakeRestClientBuilder) GetOperations(lastRequestedOperations *string, requestedStates []string, operations models.Operations, err error) *FakeRestClientBuilder { + ops := operations + if lastRequestedOperations != nil { + ops = getLastOperations(*lastRequestedOperations, operations) + } else if requestedStates != nil && len(requestedStates) > 0 { + ops = getOperationsByStates(requestedStates, operations) + } + b.fakeRestClient.GetOperationsReturns(ops, err) + return b +} + +func getOperationsByStates(requestedStates []string, operations models.Operations) models.Operations { + var ops models.Operations + requestedStatesMap := getRequestedStatesMap(requestedStates) + for _, operation := range operations.Operations { + if isRequested(&operation.State, requestedStatesMap) { + ops.Operations = append(ops.Operations, operation) + } + } + return ops +} + +func getRequestedStatesMap(requestedStates []string) map[string]bool { + var requestedStatesMap = make(map[string]bool) + for _, requestedState := range requestedStates { + requestedStatesMap[requestedState] = true + } + return requestedStatesMap +} + +func isRequested(state *models.SlpTaskStateEnum, requestedStates map[string]bool) bool { + return requestedStates[string(*state)] +} + +func getLastOperations(lastRequestedOperationsCount string, operations models.Operations) models.Operations { + operationsCount, _ := strconv.Atoi(lastRequestedOperationsCount) + if operationsCount > len(operations.Operations) { + return operations + } + operationsLength := len(operations.Operations) + return models.Operations{Operations: operations.Operations[operationsLength-operationsCount:]} +} + +// GetComponents sets the components to return from the GetComponents operations +func (b *FakeRestClientBuilder) GetComponents(components *models.Components, err error) *FakeRestClientBuilder { + b.fakeRestClient.GetComponentsReturns(components, err) + return b +} + +// GetMta sets the MTA to return from the GetMta operation +func (b *FakeRestClientBuilder) GetMta(mtaID string, mta *models.Mta, err error) *FakeRestClientBuilder { + if mtaID == "" { + b.fakeRestClient.GetMtaReturns(mta, err) + return b + } + if b.mtaResults == nil { + b.mtaResults = make(map[string]mtaResult) + } + b.mtaResults[mtaID] = mtaResult{mta, err} + if b.fakeRestClient.GetMtaStub == nil { + b.fakeRestClient.GetMtaStub = func(arg0 string) (*models.Mta, error) { + result := b.mtaResults[arg0] + return result.Mta, result.error + } + } + return b +} + +// Build builds a FakeRestClientOperations instance +func (b *FakeRestClientBuilder) Build() *FakeRestClientOperations { + return &b.fakeRestClient +} diff --git a/clients/restclient/fakes/fake_rest_client_operations.go b/clients/restclient/fakes/fake_rest_client_operations.go new file mode 100644 index 0000000..1a1ace9 --- /dev/null +++ b/clients/restclient/fakes/fake_rest_client_operations.go @@ -0,0 +1,174 @@ +// This file was generated by counterfeiter +package fakes + +import ( + "sync" + + "github.com/SAP/cf-mta-plugin/clients/models" + restclient "github.com/SAP/cf-mta-plugin/clients/restclient" +) + +type FakeRestClientOperations struct { + GetOperationsStub func(lastRequestedOperations *string, requestedStates []string) (models.Operations, error) + getOperationsMutex sync.RWMutex + getOperationsArgsForCall []struct { + lastRequestedOperations *string + requestedStates []string + } + getOperationsReturns struct { + result1 models.Operations + result2 error + } + GetComponentsStub func() (*models.Components, error) + getComponentsMutex sync.RWMutex + getComponentsArgsForCall []struct{} + getComponentsReturns struct { + result1 *models.Components + result2 error + } + GetMtaStub func(mtaID string) (*models.Mta, error) + getMtaMutex sync.RWMutex + getMtaArgsForCall []struct { + mtaID string + } + getMtaReturns struct { + result1 *models.Mta + result2 error + } + PurgeConfigurationStub func(org, space string) error + purgeConfigurationMutex sync.RWMutex + purgeConfigurationArgsForCall []struct { + org string + space string + } + purgeConfigurationReturns struct { + result1 error + } +} + +func (fake *FakeRestClientOperations) GetOperations(lastRequestedOperations *string, requestedStates []string) (models.Operations, error) { + fake.getOperationsMutex.Lock() + fake.getOperationsArgsForCall = append(fake.getOperationsArgsForCall, struct { + lastRequestedOperations *string + requestedStates []string + }{lastRequestedOperations, requestedStates}) + fake.getOperationsMutex.Unlock() + if fake.GetOperationsStub != nil { + return fake.GetOperationsStub(lastRequestedOperations, requestedStates) + } else { + return fake.getOperationsReturns.result1, fake.getOperationsReturns.result2 + } +} + +func (fake *FakeRestClientOperations) GetOperationsCallCount() int { + fake.getOperationsMutex.RLock() + defer fake.getOperationsMutex.RUnlock() + return len(fake.getOperationsArgsForCall) +} + +func (fake *FakeRestClientOperations) GetOperationsArgsForCall(i int) (*string, []string) { + fake.getOperationsMutex.RLock() + defer fake.getOperationsMutex.RUnlock() + return fake.getOperationsArgsForCall[i].lastRequestedOperations, fake.getOperationsArgsForCall[i].requestedStates +} + +func (fake *FakeRestClientOperations) GetOperationsReturns(result1 models.Operations, result2 error) { + fake.GetOperationsStub = nil + fake.getOperationsReturns = struct { + result1 models.Operations + result2 error + }{result1, result2} +} + +func (fake *FakeRestClientOperations) GetComponents() (*models.Components, error) { + fake.getComponentsMutex.Lock() + fake.getComponentsArgsForCall = append(fake.getComponentsArgsForCall, struct{}{}) + fake.getComponentsMutex.Unlock() + if fake.GetComponentsStub != nil { + return fake.GetComponentsStub() + } else { + return fake.getComponentsReturns.result1, fake.getComponentsReturns.result2 + } +} + +func (fake *FakeRestClientOperations) GetComponentsCallCount() int { + fake.getComponentsMutex.RLock() + defer fake.getComponentsMutex.RUnlock() + return len(fake.getComponentsArgsForCall) +} + +func (fake *FakeRestClientOperations) GetComponentsReturns(result1 *models.Components, result2 error) { + fake.GetComponentsStub = nil + fake.getComponentsReturns = struct { + result1 *models.Components + result2 error + }{result1, result2} +} + +func (fake *FakeRestClientOperations) GetMta(mtaID string) (*models.Mta, error) { + fake.getMtaMutex.Lock() + fake.getMtaArgsForCall = append(fake.getMtaArgsForCall, struct { + mtaID string + }{mtaID}) + fake.getMtaMutex.Unlock() + if fake.GetMtaStub != nil { + return fake.GetMtaStub(mtaID) + } else { + return fake.getMtaReturns.result1, fake.getMtaReturns.result2 + } +} + +func (fake *FakeRestClientOperations) GetMtaCallCount() int { + fake.getMtaMutex.RLock() + defer fake.getMtaMutex.RUnlock() + return len(fake.getMtaArgsForCall) +} + +func (fake *FakeRestClientOperations) GetMtaArgsForCall(i int) string { + fake.getMtaMutex.RLock() + defer fake.getMtaMutex.RUnlock() + return fake.getMtaArgsForCall[i].mtaID +} + +func (fake *FakeRestClientOperations) GetMtaReturns(result1 *models.Mta, result2 error) { + fake.GetMtaStub = nil + fake.getMtaReturns = struct { + result1 *models.Mta + result2 error + }{result1, result2} +} + +func (fake *FakeRestClientOperations) PurgeConfiguration(org string, space string) error { + fake.purgeConfigurationMutex.Lock() + fake.purgeConfigurationArgsForCall = append(fake.purgeConfigurationArgsForCall, struct { + org string + space string + }{org, space}) + fake.purgeConfigurationMutex.Unlock() + if fake.PurgeConfigurationStub != nil { + return fake.PurgeConfigurationStub(org, space) + } else { + return fake.purgeConfigurationReturns.result1 + } +} + +func (fake *FakeRestClientOperations) PurgeConfigurationCallCount() int { + fake.purgeConfigurationMutex.RLock() + defer fake.purgeConfigurationMutex.RUnlock() + return len(fake.purgeConfigurationArgsForCall) +} + +func (fake *FakeRestClientOperations) PurgeConfigurationArgsForCall(i int) (string, string) { + fake.purgeConfigurationMutex.RLock() + defer fake.purgeConfigurationMutex.RUnlock() + return fake.purgeConfigurationArgsForCall[i].org, fake.purgeConfigurationArgsForCall[i].space +} + +func (fake *FakeRestClientOperations) PurgeConfigurationReturns(result1 error) { + fake.PurgeConfigurationStub = nil + fake.purgeConfigurationReturns = struct { + result1 error + }{result1} +} + +var _ restclient.RestClientOperations = new(FakeRestClientOperations) diff --git a/clients/restclient/http_rest_client.go b/clients/restclient/http_rest_client.go new file mode 100644 index 0000000..bd794ec --- /dev/null +++ b/clients/restclient/http_rest_client.go @@ -0,0 +1,50 @@ +package restclient + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "github.com/go-openapi/runtime" + httptransport "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/restclient/operations" +) + +// Default rest HTTP client. +var Default = NewHTTPClient(nil) + +// NewHTTPClient creates a new rest HTTP client. +func NewHTTPClient(formats strfmt.Registry) *Rest { + if formats == nil { + formats = strfmt.Default + } + transport := httptransport.New("example.com", "/rest/", []string{"http", "https"}) + return New(transport, formats) +} + +// New creates a new rest client +func New(transport runtime.ClientTransport, formats strfmt.Registry) *Rest { + cli := new(Rest) + cli.Transport = transport + + cli.Operations = operations.New(transport, formats) + + return cli +} + +// Rest is a client for rest +type Rest struct { + Operations *operations.Client + + Transport runtime.ClientTransport +} + +// SetTransport changes the transport on the client and all its subresources +func (c *Rest) SetTransport(transport runtime.ClientTransport) { + c.Transport = transport + + c.Operations.SetTransport(transport) + +} diff --git a/clients/restclient/http_rest_client_test.go b/clients/restclient/http_rest_client_test.go new file mode 100644 index 0000000..697e7dc --- /dev/null +++ b/clients/restclient/http_rest_client_test.go @@ -0,0 +1,255 @@ +package restclient + +import ( + "context" + "encoding/xml" + "net/http" + "net/http/httptest" + "net/url" + "testing" + + "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" + "github.com/stretchr/testify/assert" + "github.com/SAP/cf-mta-plugin/clients/models" + "github.com/SAP/cf-mta-plugin/clients/restclient/operations" + "github.com/SAP/cf-mta-plugin/clients/testutil" +) + +const xmlHeader = `` + +const operationsPayload = xmlHeader + ` +` + + operationElement + ` +` + +const activeOperationsPayload = xmlHeader + ` +` + + operationElement + + activeElement + ` +` + +const operationPayload = xmlHeader + operationElement + +const operationElement = ` + + 1 + deploy + 2016-03-04T14:23:24.521Z[Etc/UTC] + 5bea6497-6d70-4a31-9ad2-1ac64a520f8f + admin + SLP_TASK_STATE_ERROR + false +` + +const activeElement = ` + + 2 + deploy + 2016-03-04T14:23:24.521Z[Etc/UTC] + 5bea6497-6d70-4a31-9ad2-1ac64a520f8f + admin + SLP_TASK_STATE_RUNNING + false +` + +var operationsResult = models.Operations{ + XMLName: xml.Name{Local: "ongoing-operations"}, + Operations: []*models.Operation{&operationResult}, +} + +var mixedOperationsResult = models.Operations{ + XMLName: xml.Name{Local: "ongoing-operations"}, + Operations: []*models.Operation{&operationResult, &activeOperationResult}, +} + +var operationResult = models.Operation{ + XMLName: xml.Name{Local: "ongoing-operation"}, + ProcessID: strptr("1"), + ProcessType: models.ProcessType("deploy"), + StartedAt: strptr("2016-03-04T14:23:24.521Z[Etc/UTC]"), + SpaceID: strptr("5bea6497-6d70-4a31-9ad2-1ac64a520f8f"), + User: strptr("admin"), + State: models.SlpTaskStateEnum("SLP_TASK_STATE_ERROR"), + AcquiredLock: boolptr(false), +} + +var activeOperationResult = models.Operation{ + XMLName: xml.Name{Local: "ongoing-operation"}, + ProcessID: strptr("2"), + ProcessType: models.ProcessType("deploy"), + StartedAt: strptr("2016-03-04T14:23:24.521Z[Etc/UTC]"), + SpaceID: strptr("5bea6497-6d70-4a31-9ad2-1ac64a520f8f"), + User: strptr("admin"), + State: models.SlpTaskStateEnum("SLP_TASK_STATE_RUNNING"), + AcquiredLock: boolptr(false), +} + +const componentsPayload = xmlHeader + ` + + ` + + mtaElement + ` + + + deploy-service + +` + +const mtaPayload = xmlHeader + mtaElement + +const mtaElement = ` + + + org.cloudfoundry.samples.music + 1.0 + + + + spring-music + spring-music + + postgresql + + + spring-music + + + + + postgresql + +` + +var componentsResult = models.Components{ + XMLName: xml.Name{Local: "components"}, + Mtas: models.ComponentsMtas{ + Mtas: []*models.Mta{&mtaResult}, + }, + StandaloneApps: models.ComponentsStandaloneApps{ + StandaloneApps: []string{"deploy-service"}, + }, +} + +var mtaResult = models.Mta{ + XMLName: xml.Name{Local: "mta"}, + Metadata: &models.MtaMetadata{ + ID: strptr("org.cloudfoundry.samples.music"), + Version: strptr("1.0"), + }, + Modules: models.MtaModules{ + Modules: []*models.MtaModulesItems0{ + &models.MtaModulesItems0{ + ModuleName: strptr("spring-music"), + AppName: strptr("spring-music"), + Services: models.MtaModulesItems0Services{ + Services: []string{"postgresql"}, + }, + ProvidedDependencies: models.MtaModulesItems0ProvidedDependencies{ + ProvidedDependencies: []string{"spring-music"}, + }, + }, + }, + }, + Services: models.MtaServices{ + Services: []string{"postgresql"}, + }, +} + +func TestGetOperations(t *testing.T) { + server := testutil.NewGetXMLOKServer("/operations", []byte(operationsPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetOperationsParams{ + Context: context.TODO(), + } + res, err := client.Operations.GetOperations(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, operationsResult, res.Payload) + } +} + +func TestGetOperationsWithLastOperationCount(t *testing.T) { + server := testutil.NewGetXMLOKServer("/operations", []byte(operationsPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetOperationsParams{ + Context: context.TODO(), + Last: strptr("1"), + } + res, err := client.Operations.GetOperations(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, operationsResult, res.Payload) + } +} + +func TestGetOperationsWithMixedOperationsRequested(t *testing.T) { + server := testutil.NewGetXMLOKServer("/operations", []byte(activeOperationsPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetOperationsParams{ + Context: context.TODO(), + Status: []string{"SLP_TASK_STATE_RUNNING", "SLP_TASK_STATE_ERROR"}, + } + res, err := client.Operations.GetOperations(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, mixedOperationsResult, res.Payload) + } +} + +func TestGetOperation(t *testing.T) { + server := testutil.NewGetXMLOKServer("/operations/1", []byte(operationPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetOperationParams{ + Context: context.TODO(), + ProcessID: "1", + } + res, err := client.Operations.GetOperation(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, operationResult, *res.Payload) + } +} + +func TestGetComponents(t *testing.T) { + server := testutil.NewGetXMLOKServer("/components", []byte(componentsPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetComponentsParams{ + Context: context.TODO(), + } + res, err := client.Operations.GetComponents(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, &componentsResult, res.Payload) + } +} + +func TestGetMta(t *testing.T) { + server := testutil.NewGetXMLOKServer("/components/org.cloudfoundry.samples.music", []byte(mtaPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetMtaParams{ + Context: context.TODO(), + MtaID: "org.cloudfoundry.samples.music", + } + res, err := client.Operations.GetMta(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, &mtaResult, res.Payload) + } +} + +func newClient(server *httptest.Server, rt http.RoundTripper) *Rest { + hu, _ := url.Parse(server.URL) + runtime := client.New(hu.Host, "/", []string{"http"}) + if rt != nil { + runtime.Transport = rt + } + return New(runtime, strfmt.Default) +} + +func strptr(s string) *string { + return &s +} + +func boolptr(b bool) *bool { + return &b +} diff --git a/clients/restclient/operations/get_components_parameters.go b/clients/restclient/operations/get_components_parameters.go new file mode 100644 index 0000000..e8c665d --- /dev/null +++ b/clients/restclient/operations/get_components_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetComponentsParams creates a new GetComponentsParams object +// with the default values initialized. +func NewGetComponentsParams() *GetComponentsParams { + + return &GetComponentsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetComponentsParamsWithTimeout creates a new GetComponentsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetComponentsParamsWithTimeout(timeout time.Duration) *GetComponentsParams { + + return &GetComponentsParams{ + + timeout: timeout, + } +} + +// NewGetComponentsParamsWithContext creates a new GetComponentsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetComponentsParamsWithContext(ctx context.Context) *GetComponentsParams { + + return &GetComponentsParams{ + + Context: ctx, + } +} + +/*GetComponentsParams contains all the parameters to send to the API endpoint +for the get components operation typically these are written to a http.Request +*/ +type GetComponentsParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get components params +func (o *GetComponentsParams) WithTimeout(timeout time.Duration) *GetComponentsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get components params +func (o *GetComponentsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get components params +func (o *GetComponentsParams) WithContext(ctx context.Context) *GetComponentsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get components params +func (o *GetComponentsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetComponentsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/restclient/operations/get_components_responses.go b/clients/restclient/operations/get_components_responses.go new file mode 100644 index 0000000..874284e --- /dev/null +++ b/clients/restclient/operations/get_components_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetComponentsReader is a Reader for the GetComponents structure. +type GetComponentsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetComponentsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetComponentsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetComponentsOK creates a GetComponentsOK with default headers values +func NewGetComponentsOK() *GetComponentsOK { + return &GetComponentsOK{} +} + +/*GetComponentsOK handles this case with default header values. + +OK +*/ +type GetComponentsOK struct { + Payload *models.Components +} + +func (o *GetComponentsOK) Error() string { + return fmt.Sprintf("[GET /components][%d] getComponentsOK %+v", 200, o.Payload) +} + +func (o *GetComponentsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Components) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/restclient/operations/get_mta_parameters.go b/clients/restclient/operations/get_mta_parameters.go new file mode 100644 index 0000000..f9c7422 --- /dev/null +++ b/clients/restclient/operations/get_mta_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetMtaParams creates a new GetMtaParams object +// with the default values initialized. +func NewGetMtaParams() *GetMtaParams { + var () + return &GetMtaParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetMtaParamsWithTimeout creates a new GetMtaParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetMtaParamsWithTimeout(timeout time.Duration) *GetMtaParams { + var () + return &GetMtaParams{ + + timeout: timeout, + } +} + +// NewGetMtaParamsWithContext creates a new GetMtaParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetMtaParamsWithContext(ctx context.Context) *GetMtaParams { + var () + return &GetMtaParams{ + + Context: ctx, + } +} + +/*GetMtaParams contains all the parameters to send to the API endpoint +for the get mta operation typically these are written to a http.Request +*/ +type GetMtaParams struct { + + /*MtaID*/ + MtaID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get mta params +func (o *GetMtaParams) WithTimeout(timeout time.Duration) *GetMtaParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get mta params +func (o *GetMtaParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get mta params +func (o *GetMtaParams) WithContext(ctx context.Context) *GetMtaParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get mta params +func (o *GetMtaParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithMtaID adds the mtaID to the get mta params +func (o *GetMtaParams) WithMtaID(mtaID string) *GetMtaParams { + o.SetMtaID(mtaID) + return o +} + +// SetMtaID adds the mtaId to the get mta params +func (o *GetMtaParams) SetMtaID(mtaID string) { + o.MtaID = mtaID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetMtaParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param mtaId + if err := r.SetPathParam("mtaId", o.MtaID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/restclient/operations/get_mta_responses.go b/clients/restclient/operations/get_mta_responses.go new file mode 100644 index 0000000..c0e9533 --- /dev/null +++ b/clients/restclient/operations/get_mta_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetMtaReader is a Reader for the GetMta structure. +type GetMtaReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetMtaReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetMtaOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetMtaOK creates a GetMtaOK with default headers values +func NewGetMtaOK() *GetMtaOK { + return &GetMtaOK{} +} + +/*GetMtaOK handles this case with default header values. + +OK +*/ +type GetMtaOK struct { + Payload *models.Mta +} + +func (o *GetMtaOK) Error() string { + return fmt.Sprintf("[GET /components/{mtaId}][%d] getMtaOK %+v", 200, o.Payload) +} + +func (o *GetMtaOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Mta) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/restclient/operations/get_operation_parameters.go b/clients/restclient/operations/get_operation_parameters.go new file mode 100644 index 0000000..9b35517 --- /dev/null +++ b/clients/restclient/operations/get_operation_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetOperationParams creates a new GetOperationParams object +// with the default values initialized. +func NewGetOperationParams() *GetOperationParams { + var () + return &GetOperationParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetOperationParamsWithTimeout creates a new GetOperationParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetOperationParamsWithTimeout(timeout time.Duration) *GetOperationParams { + var () + return &GetOperationParams{ + + timeout: timeout, + } +} + +// NewGetOperationParamsWithContext creates a new GetOperationParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetOperationParamsWithContext(ctx context.Context) *GetOperationParams { + var () + return &GetOperationParams{ + + Context: ctx, + } +} + +/*GetOperationParams contains all the parameters to send to the API endpoint +for the get operation operation typically these are written to a http.Request +*/ +type GetOperationParams struct { + + /*ProcessID*/ + ProcessID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get operation params +func (o *GetOperationParams) WithTimeout(timeout time.Duration) *GetOperationParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get operation params +func (o *GetOperationParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get operation params +func (o *GetOperationParams) WithContext(ctx context.Context) *GetOperationParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get operation params +func (o *GetOperationParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithProcessID adds the processID to the get operation params +func (o *GetOperationParams) WithProcessID(processID string) *GetOperationParams { + o.SetProcessID(processID) + return o +} + +// SetProcessID adds the processId to the get operation params +func (o *GetOperationParams) SetProcessID(processID string) { + o.ProcessID = processID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetOperationParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param processId + if err := r.SetPathParam("processId", o.ProcessID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/restclient/operations/get_operation_responses.go b/clients/restclient/operations/get_operation_responses.go new file mode 100644 index 0000000..22c5328 --- /dev/null +++ b/clients/restclient/operations/get_operation_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetOperationReader is a Reader for the GetOperation structure. +type GetOperationReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetOperationReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetOperationOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetOperationOK creates a GetOperationOK with default headers values +func NewGetOperationOK() *GetOperationOK { + return &GetOperationOK{} +} + +/*GetOperationOK handles this case with default header values. + +OK +*/ +type GetOperationOK struct { + Payload *models.Operation +} + +func (o *GetOperationOK) Error() string { + return fmt.Sprintf("[GET /operations/{processId}][%d] getOperationOK %+v", 200, o.Payload) +} + +func (o *GetOperationOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Operation) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/restclient/operations/get_operations_parameters.go b/clients/restclient/operations/get_operations_parameters.go new file mode 100644 index 0000000..36dd383 --- /dev/null +++ b/clients/restclient/operations/get_operations_parameters.go @@ -0,0 +1,141 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/swag" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetOperationsParams creates a new GetOperationsParams object +// with the default values initialized. +func NewGetOperationsParams() *GetOperationsParams { + var () + return &GetOperationsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetOperationsParamsWithTimeout creates a new GetOperationsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetOperationsParamsWithTimeout(timeout time.Duration) *GetOperationsParams { + var () + return &GetOperationsParams{ + + timeout: timeout, + } +} + +// NewGetOperationsParamsWithContext creates a new GetOperationsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetOperationsParamsWithContext(ctx context.Context) *GetOperationsParams { + var () + return &GetOperationsParams{ + + Context: ctx, + } +} + +/*GetOperationsParams contains all the parameters to send to the API endpoint +for the get operations operation typically these are written to a http.Request +*/ +type GetOperationsParams struct { + + /*Last*/ + Last *string + /*Status*/ + Status []string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get operations params +func (o *GetOperationsParams) WithTimeout(timeout time.Duration) *GetOperationsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get operations params +func (o *GetOperationsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get operations params +func (o *GetOperationsParams) WithContext(ctx context.Context) *GetOperationsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get operations params +func (o *GetOperationsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithLast adds the last to the get operations params +func (o *GetOperationsParams) WithLast(last *string) *GetOperationsParams { + o.SetLast(last) + return o +} + +// SetLast adds the last to the get operations params +func (o *GetOperationsParams) SetLast(last *string) { + o.Last = last +} + +// WithStatus adds the status to the get operations params +func (o *GetOperationsParams) WithStatus(status []string) *GetOperationsParams { + o.SetStatus(status) + return o +} + +// SetStatus adds the status to the get operations params +func (o *GetOperationsParams) SetStatus(status []string) { + o.Status = status +} + +// WriteToRequest writes these params to a swagger request +func (o *GetOperationsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if o.Last != nil { + + // query param last + var qrLast string + if o.Last != nil { + qrLast = *o.Last + } + qLast := qrLast + if qLast != "" { + if err := r.SetQueryParam("last", qLast); err != nil { + return err + } + } + + } + + valuesStatus := o.Status + + joinedStatus := swag.JoinByFormat(valuesStatus, "multi") + // query array param status + if err := r.SetQueryParam("status", joinedStatus...); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/restclient/operations/get_operations_responses.go b/clients/restclient/operations/get_operations_responses.go new file mode 100644 index 0000000..903fad3 --- /dev/null +++ b/clients/restclient/operations/get_operations_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetOperationsReader is a Reader for the GetOperations structure. +type GetOperationsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetOperationsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetOperationsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetOperationsOK creates a GetOperationsOK with default headers values +func NewGetOperationsOK() *GetOperationsOK { + return &GetOperationsOK{} +} + +/*GetOperationsOK handles this case with default header values. + +OK +*/ +type GetOperationsOK struct { + Payload models.Operations +} + +func (o *GetOperationsOK) Error() string { + return fmt.Sprintf("[GET /operations][%d] getOperationsOK %+v", 200, o.Payload) +} + +func (o *GetOperationsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/restclient/operations/operations_client.go b/clients/restclient/operations/operations_client.go new file mode 100644 index 0000000..178befb --- /dev/null +++ b/clients/restclient/operations/operations_client.go @@ -0,0 +1,168 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" +) + +// New creates a new operations API client. +func New(transport runtime.ClientTransport, formats strfmt.Registry) *Client { + return &Client{transport: transport, formats: formats} +} + +/* +Client for operations API +*/ +type Client struct { + transport runtime.ClientTransport + formats strfmt.Registry +} + +/* +GetComponents get components API +*/ +func (a *Client) GetComponents(params *GetComponentsParams, authInfo runtime.ClientAuthInfoWriter) (*GetComponentsOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetComponentsParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetComponents", + Method: "GET", + PathPattern: "/components", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetComponentsReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetComponentsOK), nil + +} + +/* +GetMta get mta API +*/ +func (a *Client) GetMta(params *GetMtaParams, authInfo runtime.ClientAuthInfoWriter) (*GetMtaOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetMtaParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetMta", + Method: "GET", + PathPattern: "/components/{mtaId}", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetMtaReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetMtaOK), nil + +} + +/* +GetOperation get operation API +*/ +func (a *Client) GetOperation(params *GetOperationParams, authInfo runtime.ClientAuthInfoWriter) (*GetOperationOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetOperationParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetOperation", + Method: "GET", + PathPattern: "/operations/{processId}", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetOperationReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetOperationOK), nil + +} + +/* +GetOperations get operations API +*/ +func (a *Client) GetOperations(params *GetOperationsParams, authInfo runtime.ClientAuthInfoWriter) (*GetOperationsOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetOperationsParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetOperations", + Method: "GET", + PathPattern: "/operations", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetOperationsReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetOperationsOK), nil + +} + +/* +PurgeConfiguration purge configuration API +*/ +func (a *Client) PurgeConfiguration(params *PurgeConfigurationParams, authInfo runtime.ClientAuthInfoWriter) (*PurgeConfigurationNoContent, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewPurgeConfigurationParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "PurgeConfiguration", + Method: "POST", + PathPattern: "/configuration-entries/purge", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &PurgeConfigurationReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*PurgeConfigurationNoContent), nil + +} + +// SetTransport changes the transport on the client +func (a *Client) SetTransport(transport runtime.ClientTransport) { + a.transport = transport +} diff --git a/clients/restclient/operations/purge_configuration_parameters.go b/clients/restclient/operations/purge_configuration_parameters.go new file mode 100644 index 0000000..368fc3d --- /dev/null +++ b/clients/restclient/operations/purge_configuration_parameters.go @@ -0,0 +1,134 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewPurgeConfigurationParams creates a new PurgeConfigurationParams object +// with the default values initialized. +func NewPurgeConfigurationParams() *PurgeConfigurationParams { + var () + return &PurgeConfigurationParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewPurgeConfigurationParamsWithTimeout creates a new PurgeConfigurationParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewPurgeConfigurationParamsWithTimeout(timeout time.Duration) *PurgeConfigurationParams { + var () + return &PurgeConfigurationParams{ + + timeout: timeout, + } +} + +// NewPurgeConfigurationParamsWithContext creates a new PurgeConfigurationParams object +// with the default values initialized, and the ability to set a context for a request +func NewPurgeConfigurationParamsWithContext(ctx context.Context) *PurgeConfigurationParams { + var () + return &PurgeConfigurationParams{ + + Context: ctx, + } +} + +/*PurgeConfigurationParams contains all the parameters to send to the API endpoint +for the purge configuration operation typically these are written to a http.Request +*/ +type PurgeConfigurationParams struct { + + /*Org*/ + Org string + /*Space*/ + Space string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the purge configuration params +func (o *PurgeConfigurationParams) WithTimeout(timeout time.Duration) *PurgeConfigurationParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the purge configuration params +func (o *PurgeConfigurationParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the purge configuration params +func (o *PurgeConfigurationParams) WithContext(ctx context.Context) *PurgeConfigurationParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the purge configuration params +func (o *PurgeConfigurationParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithOrg adds the org to the purge configuration params +func (o *PurgeConfigurationParams) WithOrg(org string) *PurgeConfigurationParams { + o.SetOrg(org) + return o +} + +// SetOrg adds the org to the purge configuration params +func (o *PurgeConfigurationParams) SetOrg(org string) { + o.Org = org +} + +// WithSpace adds the space to the purge configuration params +func (o *PurgeConfigurationParams) WithSpace(space string) *PurgeConfigurationParams { + o.SetSpace(space) + return o +} + +// SetSpace adds the space to the purge configuration params +func (o *PurgeConfigurationParams) SetSpace(space string) { + o.Space = space +} + +// WriteToRequest writes these params to a swagger request +func (o *PurgeConfigurationParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // query param org + qrOrg := o.Org + qOrg := qrOrg + if qOrg != "" { + if err := r.SetQueryParam("org", qOrg); err != nil { + return err + } + } + + // query param space + qrSpace := o.Space + qSpace := qrSpace + if qSpace != "" { + if err := r.SetQueryParam("space", qSpace); err != nil { + return err + } + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/restclient/operations/purge_configuration_responses.go b/clients/restclient/operations/purge_configuration_responses.go new file mode 100644 index 0000000..536d6d2 --- /dev/null +++ b/clients/restclient/operations/purge_configuration_responses.go @@ -0,0 +1,54 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" +) + +// PurgeConfigurationReader is a Reader for the PurgeConfiguration structure. +type PurgeConfigurationReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *PurgeConfigurationReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 204: + result := NewPurgeConfigurationNoContent() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewPurgeConfigurationNoContent creates a PurgeConfigurationNoContent with default headers values +func NewPurgeConfigurationNoContent() *PurgeConfigurationNoContent { + return &PurgeConfigurationNoContent{} +} + +/*PurgeConfigurationNoContent handles this case with default header values. + +OK +*/ +type PurgeConfigurationNoContent struct { +} + +func (o *PurgeConfigurationNoContent) Error() string { + return fmt.Sprintf("[POST /configuration-entries/purge][%d] purgeConfigurationNoContent ", 204) +} + +func (o *PurgeConfigurationNoContent) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + return nil +} diff --git a/clients/restclient/rest_client.go b/clients/restclient/rest_client.go new file mode 100644 index 0000000..572687a --- /dev/null +++ b/clients/restclient/rest_client.go @@ -0,0 +1,97 @@ +package restclient + +import ( + "context" + "net/http" + + "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" + operations "github.com/SAP/cf-mta-plugin/clients/restclient/operations" +) + +// RestClient represents a client for the MTA deployer REST protocol +type RestClient struct { + baseclient.BaseClient + Client *Rest +} + +// NewRestClient creates a new Rest client +func NewRestClient(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) RestClientOperations { + t := baseclient.NewHTTPTransport(host, getRestURL(org, space), rt, jar) + client := New(t, strfmt.Default) + return RestClient{baseclient.BaseClient{tokenFactory}, client} +} + +// GetOperations retrieves all ongoing operations +func (c RestClient) GetOperations(lastRequestedOperations *string, requestedStates []string) (models.Operations, error) { + params := &operations.GetOperationsParams{ + Last: lastRequestedOperations, + Status: requestedStates, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return models.Operations{}, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetOperations(params, token) + if err != nil { + return models.Operations{}, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +// GetComponents retrieves all deployed components (MTAs and standalone apps) +func (c RestClient) GetComponents() (*models.Components, error) { + params := &operations.GetComponentsParams{ + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return nil, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetComponents(params, token) + if err != nil { + return nil, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +// GetMta retrieves the deployed MTA with the specified MTA ID +func (c RestClient) GetMta(mtaID string) (*models.Mta, error) { + params := &operations.GetMtaParams{ + MtaID: mtaID, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return nil, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetMta(params, token) + if err != nil { + return nil, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +func getRestURL(org, space string) string { + return "rest/" + org + "/" + space +} + +func (c RestClient) PurgeConfiguration(org, space string) error { + params := &operations.PurgeConfigurationParams{ + Org: org, + Space: space, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return baseclient.NewClientError(err) + } + _, err = c.Client.Operations.PurgeConfiguration(params, token) + if err != nil { + return baseclient.NewClientError(err) + } + return nil +} diff --git a/clients/restclient/rest_client_operations.go b/clients/restclient/rest_client_operations.go new file mode 100644 index 0000000..f2f65e7 --- /dev/null +++ b/clients/restclient/rest_client_operations.go @@ -0,0 +1,11 @@ +package restclient + +import models "github.com/SAP/cf-mta-plugin/clients/models" + +// RestClientOperations is an interface having all RestClient operations +type RestClientOperations interface { + GetOperations(lastRequestedOperations *string, requestedStates []string) (models.Operations, error) + GetComponents() (*models.Components, error) + GetMta(mtaID string) (*models.Mta, error) + PurgeConfiguration(org, space string) error +} diff --git a/clients/restclient/rest_client_test.go b/clients/restclient/rest_client_test.go new file mode 100644 index 0000000..f86b16f --- /dev/null +++ b/clients/restclient/rest_client_test.go @@ -0,0 +1,91 @@ +package restclient_test + +import ( + "net/http" + "net/http/cookiejar" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + restclient "github.com/SAP/cf-mta-plugin/clients/restclient" + "github.com/SAP/cf-mta-plugin/testutil" +) + +var _ = Describe("RestClient", func() { + + Describe("GetOperations", func() { + Context("with valid ongoing operations returned by the backend", func() { + It("should return the ongoing operations returned by the backend", func() { + client := newRestClient(200, testutil.OperationsResult) + result, err := client.GetOperations(nil, nil) + testutil.ExpectNoErrorAndResult(err, result, testutil.OperationsResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRestClient(404, nil) + result, err := client.GetOperations(nil, nil) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("GetComponents", func() { + Context("with valid deployed components returned by the backend", func() { + It("should return the deployed components returned by the backend", func() { + client := newRestClient(200, testutil.ComponentsResult) + result, err := client.GetComponents() + testutil.ExpectNoErrorAndResult(err, result, &testutil.ComponentsResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRestClient(404, nil) + result, err := client.GetComponents() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("GetMta", func() { + Context("with a valid MTA returned by the backend", func() { + It("should return the MTA returned by the backend", func() { + client := newRestClient(200, testutil.MtaResult) + result, err := client.GetMta(testutil.MtaID) + testutil.ExpectNoErrorAndResult(err, result, &testutil.MtaResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRestClient(404, nil) + result, err := client.GetMta(testutil.MtaID) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("PurgeConfiguration", func() { + Context("when the backend returns not 204 No Content", func() { + It("should return an error", func() { + client := newRestClient(http.StatusInternalServerError, nil) + err := client.PurgeConfiguration("org", "space") + Ω(err).Should(HaveOccurred()) + }) + }) + + Context("when the backend returns 204 No Content", func() { + It("should not return an error", func() { + client := newRestClient(http.StatusNoContent, nil) + err := client.PurgeConfiguration("org", "space") + Ω(err).ShouldNot(HaveOccurred()) + }) + }) + }) +}) + +func newRestClient(statusCode int, v interface{}) restclient.RestClientOperations { + tokenFactory := baseclient.NewCustomTokenFactory("test-token") + cookieJar, _ := cookiejar.New(nil) + roundTripper := testutil.NewCustomTransport(statusCode, v) + return restclient.NewRestClient("http://localhost:1000", "test-org", "test-space", roundTripper, cookieJar, tokenFactory) +} diff --git a/clients/restclient/restclient_suite_test.go b/clients/restclient/restclient_suite_test.go new file mode 100644 index 0000000..138e1ad --- /dev/null +++ b/clients/restclient/restclient_suite_test.go @@ -0,0 +1,13 @@ +package restclient_test + +import ( + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "testing" +) + +func TestRestclient(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "Restclient Suite") +} diff --git a/clients/restclient/retryable_rest_client.go b/clients/restclient/retryable_rest_client.go new file mode 100644 index 0000000..3f1b0fc --- /dev/null +++ b/clients/restclient/retryable_rest_client.go @@ -0,0 +1,58 @@ +package restclient + +import ( + "net/http" + "time" + + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// RetryableRestClient represents retryable REST client for the MTA deployer REST protocol +type RetryableRestClient struct { + RestClient RestClientOperations + MaxRetriesCount int + RetryInterval time.Duration +} + +// NewRetryableRestClient creates a new retryable REST client +func NewRetryableRestClient(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) RestClientOperations { + restClient := NewRestClient(host, org, space, rt, jar, tokenFactory) + return RetryableRestClient{restClient, 3, time.Second * 3} +} + +// GetOperations retrieves all ongoing operations +func (c RetryableRestClient) GetOperations(lastRequestedOperations *string, requestedStates []string) (models.Operations, error) { + getOperationsCb := func() (interface{}, error) { + return c.RestClient.GetOperations(lastRequestedOperations, requestedStates) + } + resp, err := baseclient.CallWithRetry(getOperationsCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(models.Operations), err +} + +// GetComponents retrieves all deployed components (MTAs and standalone apps) +func (c RetryableRestClient) GetComponents() (*models.Components, error) { + getComponentsCb := func() (interface{}, error) { + return c.RestClient.GetComponents() + } + resp, err := baseclient.CallWithRetry(getComponentsCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(*models.Components), err +} + +// GetMta retrieves the deployed MTA with the specified MTA ID +func (c RetryableRestClient) GetMta(mtaID string) (*models.Mta, error) { + GetMtaCb := func() (interface{}, error) { + return c.RestClient.GetMta(mtaID) + } + resp, err := baseclient.CallWithRetry(GetMtaCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(*models.Mta), err +} + +// PurgeConfiguration purges a configuration +func (c RetryableRestClient) PurgeConfiguration(org, space string) error { + purgeConfigurationCb := func() (interface{}, error) { + return nil, c.RestClient.PurgeConfiguration(org, space) + } + _, err := baseclient.CallWithRetry(purgeConfigurationCb, c.MaxRetriesCount, c.RetryInterval) + return err +} diff --git a/clients/restclient/retryable_rest_client_test.go b/clients/restclient/retryable_rest_client_test.go new file mode 100644 index 0000000..433f7c1 --- /dev/null +++ b/clients/restclient/retryable_rest_client_test.go @@ -0,0 +1,220 @@ +package restclient_test + +import ( + "net/http" + "net/http/cookiejar" + "time" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" + "github.com/SAP/cf-mta-plugin/clients/restclient" + "github.com/SAP/cf-mta-plugin/testutil" +) + +var _ = Describe("RetryableRestClient", func() { + expectedRetriesCount := 4 + + Describe("GetOperations", func() { + Context("with valid ongoing operations returned by the backend", func() { + It("should return the ongoing operations returned by the backend", func() { + client := newRetryableRestClient(200, testutil.OperationsResult) + result, err := client.GetOperations(nil, nil) + testutil.ExpectNoErrorAndResult(err, result, testutil.OperationsResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableRestClient(404, nil) + result, err := client.GetOperations(nil, nil) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableRestClient(500, nil) + retryableRestClient := client.(restclient.RetryableRestClient) + result, err := retryableRestClient.GetOperations(nil, nil) + testutil.ExpectErrorAndZeroResult(err, result) + mockRestClient := retryableRestClient.RestClient.(*MockRestClient) + Expect(mockRestClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableRestClient(502, nil) + retryableRestClient := client.(restclient.RetryableRestClient) + result, err := retryableRestClient.GetOperations(nil, nil) + testutil.ExpectErrorAndZeroResult(err, result) + mockRestClient := retryableRestClient.RestClient.(*MockRestClient) + Expect(mockRestClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("GetComponents", func() { + Context("with valid deployed components returned by the backend", func() { + It("should return the deployed components returned by the backend", func() { + client := newRetryableRestClient(200, testutil.ComponentsResult) + result, err := client.GetComponents() + testutil.ExpectNoErrorAndResult(err, result, &testutil.ComponentsResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableRestClient(404, nil) + result, err := client.GetComponents() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableRestClient(500, nil) + retryableRestClient := client.(restclient.RetryableRestClient) + result, err := retryableRestClient.GetComponents() + testutil.ExpectErrorAndZeroResult(err, result) + mockRestClient := retryableRestClient.RestClient.(*MockRestClient) + Expect(mockRestClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableRestClient(502, nil) + retryableRestClient := client.(restclient.RetryableRestClient) + result, err := retryableRestClient.GetComponents() + testutil.ExpectErrorAndZeroResult(err, result) + mockRestClient := retryableRestClient.RestClient.(*MockRestClient) + Expect(mockRestClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("GetMta", func() { + Context("with a valid MTA returned by the backend", func() { + It("should return the MTA returned by the backend", func() { + client := newRetryableRestClient(200, testutil.MtaResult) + result, err := client.GetMta(testutil.MtaID) + testutil.ExpectNoErrorAndResult(err, result, &testutil.MtaResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableRestClient(404, nil) + result, err := client.GetMta(testutil.MtaID) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableRestClient(500, nil) + retryableRestClient := client.(restclient.RetryableRestClient) + result, err := retryableRestClient.GetMta(testutil.MtaID) + testutil.ExpectErrorAndZeroResult(err, result) + mockRestClient := retryableRestClient.RestClient.(*MockRestClient) + Expect(mockRestClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableRestClient(502, nil) + retryableRestClient := client.(restclient.RetryableRestClient) + result, err := retryableRestClient.GetMta(testutil.MtaID) + testutil.ExpectErrorAndZeroResult(err, result) + mockRestClient := retryableRestClient.RestClient.(*MockRestClient) + Expect(mockRestClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("PurgeConfiguration", func() { + Context("when the backend returns not 204 No Content", func() { + It("should return an error", func() { + client := newRetryableRestClient(http.StatusInternalServerError, nil) + err := client.PurgeConfiguration("org", "space") + Expect(err).To(HaveOccurred()) + }) + }) + + Context("when the backend returns 204 No Content", func() { + It("should not return an error", func() { + client := newRetryableRestClient(http.StatusNoContent, nil) + err := client.PurgeConfiguration("org", "space") + Expect(err).ToNot(HaveOccurred()) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableRestClient(500, nil) + retryableRestClient := client.(restclient.RetryableRestClient) + err := retryableRestClient.PurgeConfiguration("org", "space") + testutil.ExpectError(err) + mockRestClient := retryableRestClient.RestClient.(*MockRestClient) + Expect(mockRestClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableRestClient(502, nil) + retryableRestClient := client.(restclient.RetryableRestClient) + err := retryableRestClient.PurgeConfiguration("org", "space") + testutil.ExpectError(err) + mockRestClient := retryableRestClient.RestClient.(*MockRestClient) + Expect(mockRestClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) +}) + +func newRetryableRestClient(statusCode int, v interface{}) restclient.RestClientOperations { + tokenFactory := baseclient.NewCustomTokenFactory("test-token") + cookieJar, _ := cookiejar.New(nil) + roundTripper := testutil.NewCustomTransport(statusCode, v) + return NewMockRetryableRestClient("http://localhost:1000", "test-org", "test-space", roundTripper, cookieJar, tokenFactory) +} + +// NewRetryableRestClient creates a new retryable REST client +func NewMockRetryableRestClient(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) restclient.RestClientOperations { + restClient := NewMockRestClient(host, org, space, rt, jar, tokenFactory) + return restclient.RetryableRestClient{RestClient: restClient, MaxRetriesCount: 3, RetryInterval: time.Microsecond * 1} +} + +type MockRestClient struct { + restClient restclient.RestClientOperations + retriesCount int +} + +// NewMockRestClient creates a new Rest client +func NewMockRestClient(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) restclient.RestClientOperations { + restClient := restclient.NewRestClient(host, org, space, rt, jar, tokenFactory) + return &MockRestClient{restClient, 0} +} + +// GetOperations retrieves all ongoing operations +func (c *MockRestClient) GetOperations(lastRequestedOperations *string, requestedStates []string) (models.Operations, error) { + c.retriesCount++ + return c.restClient.GetOperations(lastRequestedOperations, requestedStates) +} + +// GetComponents retrieves all deployed components (MTAs and standalone apps) +func (c *MockRestClient) GetComponents() (*models.Components, error) { + c.retriesCount++ + return c.restClient.GetComponents() +} + +// GetMta retrieves the deployed MTA with the specified MTA ID +func (c *MockRestClient) GetMta(mtaID string) (*models.Mta, error) { + c.retriesCount++ + return c.restClient.GetMta(mtaID) +} + +// PurgeConfiguration purges configuration +func (c *MockRestClient) PurgeConfiguration(org, space string) error { + c.retriesCount++ + return c.restClient.PurgeConfiguration(org, space) +} + +// GetRetriesCount returns retries count +func (c *MockRestClient) GetRetriesCount() int { + return c.retriesCount +} diff --git a/clients/slmpclient/fakes/fake_slmp_client_builder.go b/clients/slmpclient/fakes/fake_slmp_client_builder.go new file mode 100644 index 0000000..ca3cd50 --- /dev/null +++ b/clients/slmpclient/fakes/fake_slmp_client_builder.go @@ -0,0 +1,218 @@ +package fakes + +import ( + "os" + "path/filepath" + + models "github.com/SAP/cf-mta-plugin/clients/models" +) + +type serviceResult struct { + *models.Service + error +} + +type processesResult struct { + models.Processes + error +} + +type filesResult struct { + models.Files + error +} + +type processResult struct { + *models.Process + error +} + +type versionsResult struct { + models.Versions + error +} + +type createServiceFileParams struct { + serviceID string + fileName string +} + +type createServiceProcessParams struct { + serviceID string + processID string +} + +// FakeSlmpClientBuilder is a builder of FakeSlmpClientOperations instances +type FakeSlmpClientBuilder struct { + fakeSlmpClient FakeSlmpClientOperations + getServiceResults map[string]serviceResult + getServiceProcessesResults map[string]processesResult + getServiceFilesResults map[string]filesResult + createServiceFileResults map[createServiceFileParams]filesResult + createServiceProcessResults map[createServiceProcessParams]processResult + getServiceVersionsResults map[string]versionsResult + getProcessResults map[string]processResult +} + +// NewFakeSlmpClientBuilder creates a new builder +func NewFakeSlmpClientBuilder() *FakeSlmpClientBuilder { + return &FakeSlmpClientBuilder{} +} + +// GetMetadata sets the metadata to return from the GetMetadata operation +func (b *FakeSlmpClientBuilder) GetMetadata(metadata *models.Metadata, err error) *FakeSlmpClientBuilder { + b.fakeSlmpClient.GetMetadataReturns(metadata, err) + return b +} + +// GetServices sets the services to return from the GetServices operations +func (b *FakeSlmpClientBuilder) GetServices(services models.Services, err error) *FakeSlmpClientBuilder { + b.fakeSlmpClient.GetServicesReturns(services, err) + return b +} + +// GetProcess returns a process by its corresponding id + +func (b *FakeSlmpClientBuilder) GetProcess(processID string, process *models.Process, err error) *FakeSlmpClientBuilder { + if processID == "" { + b.fakeSlmpClient.GetProcessReturns(process, err) + return b + } + if b.getProcessResults == nil { + b.getProcessResults = make(map[string]processResult) + } + b.getProcessResults[processID] = processResult{process, err} + if b.fakeSlmpClient.GetProcessStub == nil { + b.fakeSlmpClient.GetProcessStub = func(arg0 string) (*models.Process, error) { + result := b.getProcessResults[arg0] + return result.Process, result.error + } + } + return b +} + +// GetService sets the service to return from the GetService operation +func (b *FakeSlmpClientBuilder) GetService(serviceID string, service *models.Service, err error) *FakeSlmpClientBuilder { + if serviceID == "" { + b.fakeSlmpClient.GetServiceReturns(service, err) + return b + } + if b.getServiceResults == nil { + b.getServiceResults = make(map[string]serviceResult) + } + b.getServiceResults[serviceID] = serviceResult{service, err} + if b.fakeSlmpClient.GetServiceStub == nil { + b.fakeSlmpClient.GetServiceStub = func(arg0 string) (*models.Service, error) { + result := b.getServiceResults[arg0] + return result.Service, result.error + } + } + return b +} + +// GetServiceProcesses sets the services processes to return from the GetServiceProcesses operation +func (b *FakeSlmpClientBuilder) GetServiceProcesses(serviceID string, processes models.Processes, err error) *FakeSlmpClientBuilder { + if serviceID == "" { + b.fakeSlmpClient.GetServiceProcessesReturns(processes, err) + return b + } + if b.getServiceProcessesResults == nil { + b.getServiceProcessesResults = make(map[string]processesResult) + } + b.getServiceProcessesResults[serviceID] = processesResult{processes, err} + if b.fakeSlmpClient.GetServiceProcessesStub == nil { + b.fakeSlmpClient.GetServiceProcessesStub = func(arg0 string) (models.Processes, error) { + result := b.getServiceProcessesResults[arg0] + return result.Processes, result.error + } + } + return b +} + +// GetServiceFiles sets the service files to return from the GetServiceFiles operation +func (b *FakeSlmpClientBuilder) GetServiceFiles(serviceID string, files models.Files, err error) *FakeSlmpClientBuilder { + if serviceID == "" { + b.fakeSlmpClient.GetServiceFilesReturns(files, err) + return b + } + if b.getServiceFilesResults == nil { + b.getServiceFilesResults = make(map[string]filesResult) + } + b.getServiceFilesResults[serviceID] = filesResult{files, err} + if b.fakeSlmpClient.GetServiceFilesStub == nil { + b.fakeSlmpClient.GetServiceFilesStub = func(arg string) (models.Files, error) { + result := b.getServiceFilesResults[arg] + return result.Files, result.error + } + } + return b +} + +// CreateServiceFile sets the files to return from the CreateServiceFile operation +func (b *FakeSlmpClientBuilder) CreateServiceFile(serviceID string, file *os.File, files models.Files, err error) *FakeSlmpClientBuilder { + if serviceID == "" && file == nil { + b.fakeSlmpClient.CreateServiceFileReturns(files, err) + return b + } + filePath, _ := filepath.Abs(file.Name()) + if b.createServiceFileResults == nil { + b.createServiceFileResults = make(map[createServiceFileParams]filesResult) + } + b.createServiceFileResults[createServiceFileParams{serviceID, filePath}] = filesResult{files, err} + if b.fakeSlmpClient.CreateServiceFileStub == nil { + b.fakeSlmpClient.CreateServiceFileStub = func(arg0 string, arg1 os.File) (models.Files, error) { + arg1Path, _ := filepath.Abs(arg1.Name()) + result := b.createServiceFileResults[createServiceFileParams{arg0, arg1Path}] + return result.Files, result.error + } + } + return b +} + +// CreateServiceProcess sets the process to return from the CreateServiceProcess operation +func (b *FakeSlmpClientBuilder) CreateServiceProcess(serviceID string, process *models.Process, process2 *models.Process, err error) *FakeSlmpClientBuilder { + if serviceID == "" && process == nil { + b.fakeSlmpClient.CreateServiceProcessReturns(process2, err) + return b + } + if b.createServiceProcessResults == nil { + b.createServiceProcessResults = make(map[createServiceProcessParams]processResult) + } + b.createServiceProcessResults[createServiceProcessParams{serviceID, process.ID}] = processResult{process2, err} + if b.fakeSlmpClient.CreateServiceProcessStub == nil { + b.fakeSlmpClient.CreateServiceProcessStub = func(arg0 string, arg1 *models.Process) (*models.Process, error) { + result := b.createServiceProcessResults[createServiceProcessParams{arg0, arg1.ID}] + return result.Process, result.error + } + } + return b +} + +// GetServiceVersions sets the versions for the service with the specified ID +func (b *FakeSlmpClientBuilder) GetServiceVersions(serviceID string, versions models.Versions, err error) *FakeSlmpClientBuilder { + if b.getServiceVersionsResults == nil { + b.getServiceVersionsResults = make(map[string]versionsResult) + } + + b.getServiceVersionsResults[serviceID] = versionsResult{versions, err} + if b.fakeSlmpClient.GetServiceVersionsStub == nil { + b.fakeSlmpClient.GetServiceVersionsStub = func(arg0 string) (models.Versions, error) { + result := b.getServiceVersionsResults[serviceID] + return result.Versions, result.error + } + + } + return b +} + +// Build builds a FakeSlmpClientOperations instance +func (b *FakeSlmpClientBuilder) Build() *FakeSlmpClientOperations { + return &b.fakeSlmpClient +} + +func safeDeref(s *string) string { + if s != nil { + return *s + } + return "" +} diff --git a/clients/slmpclient/fakes/fake_slmp_client_operations.go b/clients/slmpclient/fakes/fake_slmp_client_operations.go new file mode 100644 index 0000000..10df717 --- /dev/null +++ b/clients/slmpclient/fakes/fake_slmp_client_operations.go @@ -0,0 +1,617 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package fakes + +import ( + "os" + "sync" + + models "github.com/SAP/cf-mta-plugin/clients/models" + slmpclient "github.com/SAP/cf-mta-plugin/clients/slmpclient" +) + +type FakeSlmpClientOperations struct { + GetMetadataStub func() (*models.Metadata, error) + getMetadataMutex sync.RWMutex + getMetadataArgsForCall []struct{} + getMetadataReturns struct { + result1 *models.Metadata + result2 error + } + getMetadataReturnsOnCall map[int]struct { + result1 *models.Metadata + result2 error + } + GetServicesStub func() (models.Services, error) + getServicesMutex sync.RWMutex + getServicesArgsForCall []struct{} + getServicesReturns struct { + result1 models.Services + result2 error + } + getServicesReturnsOnCall map[int]struct { + result1 models.Services + result2 error + } + GetServiceStub func(serviceID string) (*models.Service, error) + getServiceMutex sync.RWMutex + getServiceArgsForCall []struct { + serviceID string + } + getServiceReturns struct { + result1 *models.Service + result2 error + } + getServiceReturnsOnCall map[int]struct { + result1 *models.Service + result2 error + } + GetServiceProcessesStub func(serviceID string) (models.Processes, error) + getServiceProcessesMutex sync.RWMutex + getServiceProcessesArgsForCall []struct { + serviceID string + } + getServiceProcessesReturns struct { + result1 models.Processes + result2 error + } + getServiceProcessesReturnsOnCall map[int]struct { + result1 models.Processes + result2 error + } + GetServiceFilesStub func(serviceID string) (models.Files, error) + getServiceFilesMutex sync.RWMutex + getServiceFilesArgsForCall []struct { + serviceID string + } + getServiceFilesReturns struct { + result1 models.Files + result2 error + } + getServiceFilesReturnsOnCall map[int]struct { + result1 models.Files + result2 error + } + CreateServiceFileStub func(serviceID string, file os.File) (models.Files, error) + createServiceFileMutex sync.RWMutex + createServiceFileArgsForCall []struct { + serviceID string + file os.File + } + createServiceFileReturns struct { + result1 models.Files + result2 error + } + createServiceFileReturnsOnCall map[int]struct { + result1 models.Files + result2 error + } + CreateServiceProcessStub func(serviceID string, process *models.Process) (*models.Process, error) + createServiceProcessMutex sync.RWMutex + createServiceProcessArgsForCall []struct { + serviceID string + process *models.Process + } + createServiceProcessReturns struct { + result1 *models.Process + result2 error + } + createServiceProcessReturnsOnCall map[int]struct { + result1 *models.Process + result2 error + } + GetServiceVersionsStub func(serviceID string) (models.Versions, error) + getServiceVersionsMutex sync.RWMutex + getServiceVersionsArgsForCall []struct { + serviceID string + } + getServiceVersionsReturns struct { + result1 models.Versions + result2 error + } + getServiceVersionsReturnsOnCall map[int]struct { + result1 models.Versions + result2 error + } + GetProcessStub func(processID string) (*models.Process, error) + getProcessMutex sync.RWMutex + getProcessArgsForCall []struct { + processID string + } + getProcessReturns struct { + result1 *models.Process + result2 error + } + getProcessReturnsOnCall map[int]struct { + result1 *models.Process + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeSlmpClientOperations) GetMetadata() (*models.Metadata, error) { + fake.getMetadataMutex.Lock() + ret, specificReturn := fake.getMetadataReturnsOnCall[len(fake.getMetadataArgsForCall)] + fake.getMetadataArgsForCall = append(fake.getMetadataArgsForCall, struct{}{}) + fake.recordInvocation("GetMetadata", []interface{}{}) + fake.getMetadataMutex.Unlock() + if fake.GetMetadataStub != nil { + return fake.GetMetadataStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getMetadataReturns.result1, fake.getMetadataReturns.result2 +} + +func (fake *FakeSlmpClientOperations) GetMetadataCallCount() int { + fake.getMetadataMutex.RLock() + defer fake.getMetadataMutex.RUnlock() + return len(fake.getMetadataArgsForCall) +} + +func (fake *FakeSlmpClientOperations) GetMetadataReturns(result1 *models.Metadata, result2 error) { + fake.GetMetadataStub = nil + fake.getMetadataReturns = struct { + result1 *models.Metadata + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetMetadataReturnsOnCall(i int, result1 *models.Metadata, result2 error) { + fake.GetMetadataStub = nil + if fake.getMetadataReturnsOnCall == nil { + fake.getMetadataReturnsOnCall = make(map[int]struct { + result1 *models.Metadata + result2 error + }) + } + fake.getMetadataReturnsOnCall[i] = struct { + result1 *models.Metadata + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetServices() (models.Services, error) { + fake.getServicesMutex.Lock() + ret, specificReturn := fake.getServicesReturnsOnCall[len(fake.getServicesArgsForCall)] + fake.getServicesArgsForCall = append(fake.getServicesArgsForCall, struct{}{}) + fake.recordInvocation("GetServices", []interface{}{}) + fake.getServicesMutex.Unlock() + if fake.GetServicesStub != nil { + return fake.GetServicesStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getServicesReturns.result1, fake.getServicesReturns.result2 +} + +func (fake *FakeSlmpClientOperations) GetServicesCallCount() int { + fake.getServicesMutex.RLock() + defer fake.getServicesMutex.RUnlock() + return len(fake.getServicesArgsForCall) +} + +func (fake *FakeSlmpClientOperations) GetServicesReturns(result1 models.Services, result2 error) { + fake.GetServicesStub = nil + fake.getServicesReturns = struct { + result1 models.Services + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetServicesReturnsOnCall(i int, result1 models.Services, result2 error) { + fake.GetServicesStub = nil + if fake.getServicesReturnsOnCall == nil { + fake.getServicesReturnsOnCall = make(map[int]struct { + result1 models.Services + result2 error + }) + } + fake.getServicesReturnsOnCall[i] = struct { + result1 models.Services + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetService(serviceID string) (*models.Service, error) { + fake.getServiceMutex.Lock() + ret, specificReturn := fake.getServiceReturnsOnCall[len(fake.getServiceArgsForCall)] + fake.getServiceArgsForCall = append(fake.getServiceArgsForCall, struct { + serviceID string + }{serviceID}) + fake.recordInvocation("GetService", []interface{}{serviceID}) + fake.getServiceMutex.Unlock() + if fake.GetServiceStub != nil { + return fake.GetServiceStub(serviceID) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getServiceReturns.result1, fake.getServiceReturns.result2 +} + +func (fake *FakeSlmpClientOperations) GetServiceCallCount() int { + fake.getServiceMutex.RLock() + defer fake.getServiceMutex.RUnlock() + return len(fake.getServiceArgsForCall) +} + +func (fake *FakeSlmpClientOperations) GetServiceArgsForCall(i int) string { + fake.getServiceMutex.RLock() + defer fake.getServiceMutex.RUnlock() + return fake.getServiceArgsForCall[i].serviceID +} + +func (fake *FakeSlmpClientOperations) GetServiceReturns(result1 *models.Service, result2 error) { + fake.GetServiceStub = nil + fake.getServiceReturns = struct { + result1 *models.Service + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetServiceReturnsOnCall(i int, result1 *models.Service, result2 error) { + fake.GetServiceStub = nil + if fake.getServiceReturnsOnCall == nil { + fake.getServiceReturnsOnCall = make(map[int]struct { + result1 *models.Service + result2 error + }) + } + fake.getServiceReturnsOnCall[i] = struct { + result1 *models.Service + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetServiceProcesses(serviceID string) (models.Processes, error) { + fake.getServiceProcessesMutex.Lock() + ret, specificReturn := fake.getServiceProcessesReturnsOnCall[len(fake.getServiceProcessesArgsForCall)] + fake.getServiceProcessesArgsForCall = append(fake.getServiceProcessesArgsForCall, struct { + serviceID string + }{serviceID}) + fake.recordInvocation("GetServiceProcesses", []interface{}{serviceID}) + fake.getServiceProcessesMutex.Unlock() + if fake.GetServiceProcessesStub != nil { + return fake.GetServiceProcessesStub(serviceID) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getServiceProcessesReturns.result1, fake.getServiceProcessesReturns.result2 +} + +func (fake *FakeSlmpClientOperations) GetServiceProcessesCallCount() int { + fake.getServiceProcessesMutex.RLock() + defer fake.getServiceProcessesMutex.RUnlock() + return len(fake.getServiceProcessesArgsForCall) +} + +func (fake *FakeSlmpClientOperations) GetServiceProcessesArgsForCall(i int) string { + fake.getServiceProcessesMutex.RLock() + defer fake.getServiceProcessesMutex.RUnlock() + return fake.getServiceProcessesArgsForCall[i].serviceID +} + +func (fake *FakeSlmpClientOperations) GetServiceProcessesReturns(result1 models.Processes, result2 error) { + fake.GetServiceProcessesStub = nil + fake.getServiceProcessesReturns = struct { + result1 models.Processes + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetServiceProcessesReturnsOnCall(i int, result1 models.Processes, result2 error) { + fake.GetServiceProcessesStub = nil + if fake.getServiceProcessesReturnsOnCall == nil { + fake.getServiceProcessesReturnsOnCall = make(map[int]struct { + result1 models.Processes + result2 error + }) + } + fake.getServiceProcessesReturnsOnCall[i] = struct { + result1 models.Processes + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetServiceFiles(serviceID string) (models.Files, error) { + fake.getServiceFilesMutex.Lock() + ret, specificReturn := fake.getServiceFilesReturnsOnCall[len(fake.getServiceFilesArgsForCall)] + fake.getServiceFilesArgsForCall = append(fake.getServiceFilesArgsForCall, struct { + serviceID string + }{serviceID}) + fake.recordInvocation("GetServiceFiles", []interface{}{serviceID}) + fake.getServiceFilesMutex.Unlock() + if fake.GetServiceFilesStub != nil { + return fake.GetServiceFilesStub(serviceID) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getServiceFilesReturns.result1, fake.getServiceFilesReturns.result2 +} + +func (fake *FakeSlmpClientOperations) GetServiceFilesCallCount() int { + fake.getServiceFilesMutex.RLock() + defer fake.getServiceFilesMutex.RUnlock() + return len(fake.getServiceFilesArgsForCall) +} + +func (fake *FakeSlmpClientOperations) GetServiceFilesArgsForCall(i int) string { + fake.getServiceFilesMutex.RLock() + defer fake.getServiceFilesMutex.RUnlock() + return fake.getServiceFilesArgsForCall[i].serviceID +} + +func (fake *FakeSlmpClientOperations) GetServiceFilesReturns(result1 models.Files, result2 error) { + fake.GetServiceFilesStub = nil + fake.getServiceFilesReturns = struct { + result1 models.Files + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetServiceFilesReturnsOnCall(i int, result1 models.Files, result2 error) { + fake.GetServiceFilesStub = nil + if fake.getServiceFilesReturnsOnCall == nil { + fake.getServiceFilesReturnsOnCall = make(map[int]struct { + result1 models.Files + result2 error + }) + } + fake.getServiceFilesReturnsOnCall[i] = struct { + result1 models.Files + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) CreateServiceFile(serviceID string, file os.File) (models.Files, error) { + fake.createServiceFileMutex.Lock() + ret, specificReturn := fake.createServiceFileReturnsOnCall[len(fake.createServiceFileArgsForCall)] + fake.createServiceFileArgsForCall = append(fake.createServiceFileArgsForCall, struct { + serviceID string + file os.File + }{serviceID, file}) + fake.recordInvocation("CreateServiceFile", []interface{}{serviceID, file}) + fake.createServiceFileMutex.Unlock() + if fake.CreateServiceFileStub != nil { + return fake.CreateServiceFileStub(serviceID, file) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.createServiceFileReturns.result1, fake.createServiceFileReturns.result2 +} + +func (fake *FakeSlmpClientOperations) CreateServiceFileCallCount() int { + fake.createServiceFileMutex.RLock() + defer fake.createServiceFileMutex.RUnlock() + return len(fake.createServiceFileArgsForCall) +} + +func (fake *FakeSlmpClientOperations) CreateServiceFileArgsForCall(i int) (string, os.File) { + fake.createServiceFileMutex.RLock() + defer fake.createServiceFileMutex.RUnlock() + return fake.createServiceFileArgsForCall[i].serviceID, fake.createServiceFileArgsForCall[i].file +} + +func (fake *FakeSlmpClientOperations) CreateServiceFileReturns(result1 models.Files, result2 error) { + fake.CreateServiceFileStub = nil + fake.createServiceFileReturns = struct { + result1 models.Files + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) CreateServiceFileReturnsOnCall(i int, result1 models.Files, result2 error) { + fake.CreateServiceFileStub = nil + if fake.createServiceFileReturnsOnCall == nil { + fake.createServiceFileReturnsOnCall = make(map[int]struct { + result1 models.Files + result2 error + }) + } + fake.createServiceFileReturnsOnCall[i] = struct { + result1 models.Files + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) CreateServiceProcess(serviceID string, process *models.Process) (*models.Process, error) { + fake.createServiceProcessMutex.Lock() + ret, specificReturn := fake.createServiceProcessReturnsOnCall[len(fake.createServiceProcessArgsForCall)] + fake.createServiceProcessArgsForCall = append(fake.createServiceProcessArgsForCall, struct { + serviceID string + process *models.Process + }{serviceID, process}) + fake.recordInvocation("CreateServiceProcess", []interface{}{serviceID, process}) + fake.createServiceProcessMutex.Unlock() + if fake.CreateServiceProcessStub != nil { + return fake.CreateServiceProcessStub(serviceID, process) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.createServiceProcessReturns.result1, fake.createServiceProcessReturns.result2 +} + +func (fake *FakeSlmpClientOperations) CreateServiceProcessCallCount() int { + fake.createServiceProcessMutex.RLock() + defer fake.createServiceProcessMutex.RUnlock() + return len(fake.createServiceProcessArgsForCall) +} + +func (fake *FakeSlmpClientOperations) CreateServiceProcessArgsForCall(i int) (string, *models.Process) { + fake.createServiceProcessMutex.RLock() + defer fake.createServiceProcessMutex.RUnlock() + return fake.createServiceProcessArgsForCall[i].serviceID, fake.createServiceProcessArgsForCall[i].process +} + +func (fake *FakeSlmpClientOperations) CreateServiceProcessReturns(result1 *models.Process, result2 error) { + fake.CreateServiceProcessStub = nil + fake.createServiceProcessReturns = struct { + result1 *models.Process + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) CreateServiceProcessReturnsOnCall(i int, result1 *models.Process, result2 error) { + fake.CreateServiceProcessStub = nil + if fake.createServiceProcessReturnsOnCall == nil { + fake.createServiceProcessReturnsOnCall = make(map[int]struct { + result1 *models.Process + result2 error + }) + } + fake.createServiceProcessReturnsOnCall[i] = struct { + result1 *models.Process + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetServiceVersions(serviceID string) (models.Versions, error) { + fake.getServiceVersionsMutex.Lock() + ret, specificReturn := fake.getServiceVersionsReturnsOnCall[len(fake.getServiceVersionsArgsForCall)] + fake.getServiceVersionsArgsForCall = append(fake.getServiceVersionsArgsForCall, struct { + serviceID string + }{serviceID}) + fake.recordInvocation("GetServiceVersions", []interface{}{serviceID}) + fake.getServiceVersionsMutex.Unlock() + if fake.GetServiceVersionsStub != nil { + return fake.GetServiceVersionsStub(serviceID) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getServiceVersionsReturns.result1, fake.getServiceVersionsReturns.result2 +} + +func (fake *FakeSlmpClientOperations) GetServiceVersionsCallCount() int { + fake.getServiceVersionsMutex.RLock() + defer fake.getServiceVersionsMutex.RUnlock() + return len(fake.getServiceVersionsArgsForCall) +} + +func (fake *FakeSlmpClientOperations) GetServiceVersionsArgsForCall(i int) string { + fake.getServiceVersionsMutex.RLock() + defer fake.getServiceVersionsMutex.RUnlock() + return fake.getServiceVersionsArgsForCall[i].serviceID +} + +func (fake *FakeSlmpClientOperations) GetServiceVersionsReturns(result1 models.Versions, result2 error) { + fake.GetServiceVersionsStub = nil + fake.getServiceVersionsReturns = struct { + result1 models.Versions + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetServiceVersionsReturnsOnCall(i int, result1 models.Versions, result2 error) { + fake.GetServiceVersionsStub = nil + if fake.getServiceVersionsReturnsOnCall == nil { + fake.getServiceVersionsReturnsOnCall = make(map[int]struct { + result1 models.Versions + result2 error + }) + } + fake.getServiceVersionsReturnsOnCall[i] = struct { + result1 models.Versions + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetProcess(processID string) (*models.Process, error) { + fake.getProcessMutex.Lock() + ret, specificReturn := fake.getProcessReturnsOnCall[len(fake.getProcessArgsForCall)] + fake.getProcessArgsForCall = append(fake.getProcessArgsForCall, struct { + processID string + }{processID}) + fake.recordInvocation("GetProcess", []interface{}{processID}) + fake.getProcessMutex.Unlock() + if fake.GetProcessStub != nil { + return fake.GetProcessStub(processID) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getProcessReturns.result1, fake.getProcessReturns.result2 +} + +func (fake *FakeSlmpClientOperations) GetProcessCallCount() int { + fake.getProcessMutex.RLock() + defer fake.getProcessMutex.RUnlock() + return len(fake.getProcessArgsForCall) +} + +func (fake *FakeSlmpClientOperations) GetProcessArgsForCall(i int) string { + fake.getProcessMutex.RLock() + defer fake.getProcessMutex.RUnlock() + return fake.getProcessArgsForCall[i].processID +} + +func (fake *FakeSlmpClientOperations) GetProcessReturns(result1 *models.Process, result2 error) { + fake.GetProcessStub = nil + fake.getProcessReturns = struct { + result1 *models.Process + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) GetProcessReturnsOnCall(i int, result1 *models.Process, result2 error) { + fake.GetProcessStub = nil + if fake.getProcessReturnsOnCall == nil { + fake.getProcessReturnsOnCall = make(map[int]struct { + result1 *models.Process + result2 error + }) + } + fake.getProcessReturnsOnCall[i] = struct { + result1 *models.Process + result2 error + }{result1, result2} +} + +func (fake *FakeSlmpClientOperations) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.getMetadataMutex.RLock() + defer fake.getMetadataMutex.RUnlock() + fake.getServicesMutex.RLock() + defer fake.getServicesMutex.RUnlock() + fake.getServiceMutex.RLock() + defer fake.getServiceMutex.RUnlock() + fake.getServiceProcessesMutex.RLock() + defer fake.getServiceProcessesMutex.RUnlock() + fake.getServiceFilesMutex.RLock() + defer fake.getServiceFilesMutex.RUnlock() + fake.createServiceFileMutex.RLock() + defer fake.createServiceFileMutex.RUnlock() + fake.createServiceProcessMutex.RLock() + defer fake.createServiceProcessMutex.RUnlock() + fake.getServiceVersionsMutex.RLock() + defer fake.getServiceVersionsMutex.RUnlock() + fake.getProcessMutex.RLock() + defer fake.getProcessMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeSlmpClientOperations) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ slmpclient.SlmpClientOperations = new(FakeSlmpClientOperations) diff --git a/clients/slmpclient/http_slmp_client.go b/clients/slmpclient/http_slmp_client.go new file mode 100644 index 0000000..c119464 --- /dev/null +++ b/clients/slmpclient/http_slmp_client.go @@ -0,0 +1,50 @@ +package slmpclient + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "github.com/go-openapi/runtime" + httptransport "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/slmpclient/operations" +) + +// Default slmp HTTP client. +var Default = NewHTTPClient(nil) + +// NewHTTPClient creates a new slmp HTTP client. +func NewHTTPClient(formats strfmt.Registry) *Slmp { + if formats == nil { + formats = strfmt.Default + } + transport := httptransport.New("example.com", "/slprot/slmp/", []string{"http", "https"}) + return New(transport, formats) +} + +// New creates a new slmp client +func New(transport runtime.ClientTransport, formats strfmt.Registry) *Slmp { + cli := new(Slmp) + cli.Transport = transport + + cli.Operations = operations.New(transport, formats) + + return cli +} + +// Slmp is a client for slmp +type Slmp struct { + Operations *operations.Client + + Transport runtime.ClientTransport +} + +// SetTransport changes the transport on the client and all its subresources +func (c *Slmp) SetTransport(transport runtime.ClientTransport) { + c.Transport = transport + + c.Operations.SetTransport(transport) + +} diff --git a/clients/slmpclient/http_slmp_client_test.go b/clients/slmpclient/http_slmp_client_test.go new file mode 100644 index 0000000..406ecbc --- /dev/null +++ b/clients/slmpclient/http_slmp_client_test.go @@ -0,0 +1,496 @@ +package slmpclient + +import ( + "context" + "encoding/xml" + "io/ioutil" + "net/http" + "net/http/httptest" + "net/url" + "os" + "testing" + + "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" + "github.com/stretchr/testify/assert" + "github.com/SAP/cf-mta-plugin/clients/csrf" + "github.com/SAP/cf-mta-plugin/clients/models" + "github.com/SAP/cf-mta-plugin/clients/slmpclient/operations" + testutil "github.com/SAP/cf-mta-plugin/clients/testutil" +) + +const xmlHeader = `` +const xmlns = "http://www.sap.com/lmsl/slp" + +const metadataPayload = xmlHeader + ` + + 1.2.0 +` + +var metadataResult = models.Metadata{ + XMLName: xml.Name{Space: xmlns, Local: "Metadata"}, + Slmpversion: "1.2.0", +} + +const servicesPayload = xmlHeader + ` +` + + serviceElement + ` +` + +const servicePayload = xmlHeader + serviceElement + +const serviceElement = ` + + xs2-undeploy + services/xs2-undeploy/processes + ` + + parameterElement + ` + + services/xs2-undeploy/files + services/xs2-undeploy/versions + 1.2.0 + Undeploy + Undeploy +` + +var servicesResult = models.Services{ + XMLName: xml.Name{Space: xmlns, Local: "services"}, + Services: []*models.Service{&serviceResult}, +} + +var serviceResult = models.Service{ + XMLName: xml.Name{Space: xmlns, Local: "Service"}, + ID: uriptr(strfmt.URI("xs2-undeploy")), + Processes: uriptr(strfmt.URI("services/xs2-undeploy/processes")), + Parameters: models.ServiceParameters{ + Parameters: []*models.Parameter{¶meterResult}, + }, + Files: strfmt.URI("services/xs2-undeploy/files"), + Versions: strfmt.URI("services/xs2-undeploy/versions"), + Slppversion: strptr("1.2.0"), + DisplayName: "Undeploy", + Description: "Undeploy", +} + +const processesPayload = xmlHeader + ` +` + + processElement + ` +` + +const processPayload = xmlHeader + processElement + +const processElement = ` + + 1 + xs2-deploy + slp.process.state.ACTIVE + runs/xs2-deploy/1 + + + appArchiveId + slp.parameter.type.SCALAR + true + d204bf6a-5a56-4c91-952e-1e8dce81fca2 + + + Deploy + Deploy +` + +var processesResult = models.Processes{ + XMLName: xml.Name{Space: xmlns, Local: "processes"}, + Processes: []*models.Process{&processResult}, +} + +var processResult = models.Process{ + XMLName: xml.Name{Space: xmlns, Local: "Process"}, + ID: "1", + Service: uriptr(strfmt.URI("xs2-deploy")), + Status: models.SlpProcessState("slp.process.state.ACTIVE"), + RootURL: strfmt.URI("runs/xs2-deploy/1"), + Parameters: models.ProcessParameters{ + Parameters: []*models.Parameter{ + &models.Parameter{ + XMLName: xml.Name{Space: xmlns, Local: "Parameter"}, + ID: strptr("appArchiveId"), + Type: models.SlpParameterType("slp.parameter.type.SCALAR"), + Required: true, + Value: "d204bf6a-5a56-4c91-952e-1e8dce81fca2", + }, + }, + }, + DisplayName: "Deploy", + Description: "Deploy", +} + +const versionsPayload = xmlHeader + ` + + + xs2-deploy_VERSIONS_1.0 + xs2-deploy + 1.0 + +` + +var versionsResult = models.Versions{ + XMLName: xml.Name{Space: xmlns, Local: "versions"}, + ComponentVersions: []*models.ComponentVersion{ + &models.ComponentVersion{ + XMLName: xml.Name{Space: xmlns, Local: "ComponentVersion"}, + ID: strptr("xs2-deploy_VERSIONS_1.0"), + Component: strptr("xs2-deploy"), + Version: strptr("1.0"), + }, + }, +} + +const parametersPayload = xmlHeader + ` +` + + parameterElement + ` +` + +const parameterPayload = xmlHeader + parameterElement + +const parameterElement = ` + + mtaId + slp.parameter.type.SCALAR + true +` + +var parametersResult = models.Parameters{ + XMLName: xml.Name{Space: xmlns, Local: "parameters"}, + Parameters: []*models.Parameter{¶meterResult}, +} + +var parameterResult = models.Parameter{ + XMLName: xml.Name{Space: xmlns, Local: "Parameter"}, + ID: strptr("mtaId"), + Type: models.SlpParameterType("slp.parameter.type.SCALAR"), + Required: true, +} + +const filesPayload = xmlHeader + ` +` + + fileElement + ` +` + +const filePayload = xmlHeader + fileElement + +const fileElement = ` + + d204bf6a-5a56-4c91-952e-1e8dce81fca2 + xs2-deploy + 5 + test.txt + D8E8FCA2DC0F896FD7CB4CB0031BA249 + MD5 +` + +var filesResult = models.Files{ + XMLName: xml.Name{Space: xmlns, Local: "files"}, + Files: []*models.File{&fileResult}, +} + +// TODO Fix DateTime parsing by the client +// var dateTime, _ = strfmt.ParseDateTime("2016-03-04T00:00:00Z") +// var timestamp = models.SlpTimestamp(dateTime) + +var fileResult = models.File{ + XMLName: xml.Name{Space: xmlns, Local: "File"}, + ID: strptr("d204bf6a-5a56-4c91-952e-1e8dce81fca2"), + FilePath: "xs2-deploy", + FileSize: 5, + FileName: strptr("test.txt"), + // ModificationTime: ×tamp, + Digest: "D8E8FCA2DC0F896FD7CB4CB0031BA249", + DigestAlgorithm: "MD5", +} + +func TestGetMetadata(t *testing.T) { + server := testutil.NewGetXMLOKServer("/metadata", []byte(metadataPayload)) + defer server.Close() + client := newClient(server, nil) + res, err := client.Operations.GetMetadata(nil, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, metadataResult, *res.Payload) + } +} + +func TestGetMetadata_OAuth(t *testing.T) { + server := testutil.NewGetXMLOAuthOKServer("/metadata", "dummy", []byte(metadataPayload)) + defer server.Close() + slmp := newClient(server, nil) + authInfo := client.BearerToken("dummy") + res, err := slmp.Operations.GetMetadata(nil, authInfo) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, metadataResult, *res.Payload) + } +} + +func TestGetMetadata_Error(t *testing.T) { + server := testutil.NewStatusServer(http.StatusUnauthorized) + defer server.Close() + client := newClient(server, nil) + res, err := client.Operations.GetMetadata(nil, nil) + if assert.Error(t, err) { + testutil.CheckError(t, err, "unknown error", http.StatusUnauthorized, res) + } +} + +func TestGetServices(t *testing.T) { + server := testutil.NewGetXMLOKServer("/services", []byte(servicesPayload)) + defer server.Close() + client := newClient(server, nil) + res, err := client.Operations.GetServices(nil, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, servicesResult, res.Payload) + } +} + +func TestGetService(t *testing.T) { + server := testutil.NewGetXMLOKServer("/services/xs2-undeploy", []byte(servicePayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetServiceParams{ + Context: context.TODO(), + ServiceID: "xs2-undeploy", + } + res, err := client.Operations.GetService(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, serviceResult, *res.Payload) + } +} + +func TestGetServiceProcesses(t *testing.T) { + server := testutil.NewGetXMLOKServer("/services/xs2-deploy/processes", []byte(processesPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetServiceProcessesParams{ + Context: context.TODO(), + ServiceID: "xs2-deploy", + } + res, err := client.Operations.GetServiceProcesses(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, processesResult, res.Payload) + } +} + +func TestCreateServiceProcess(t *testing.T) { + process := models.Process{ + Service: uriptr(strfmt.URI("xs2-deploy")), + Parameters: models.ProcessParameters{ + Parameters: []*models.Parameter{ + &models.Parameter{ + ID: strptr("appArchiveId"), + Type: models.SlpParameterType("slp.parameter.type.SCALAR"), + Value: "d204bf6a-5a56-4c91-952e-1e8dce81fca2", + }, + }, + }, + } + body, _ := xml.Marshal(process) + server := testutil.NewPostXMLOKServer("/services/xs2-deploy/processes", body, []byte(processPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.CreateServiceProcessParams{ + Context: context.TODO(), + ServiceID: "xs2-deploy", + Process: &process, + } + res, err := client.Operations.CreateServiceProcess(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, processResult, *res.Payload) + } +} + +func TestDeleteServiceProcess(t *testing.T) { + server := testutil.NewDeleteNoContentServer("/services/xs2-deploy/processes/1") + defer server.Close() + client := newClient(server, nil) + params := &operations.DeleteServiceProcessParams{ + Context: context.TODO(), + ServiceID: "xs2-deploy", + ProcessID: "1", + } + _, err := client.Operations.DeleteServiceProcess(params, nil) + assert.NoError(t, err) +} + +func TestGetServiceParameters(t *testing.T) { + server := testutil.NewGetXMLOKServer("/services/xs2-undeploy/parameters", []byte(parametersPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetServiceParametersParams{ + Context: context.TODO(), + ServiceID: "xs2-undeploy", + } + res, err := client.Operations.GetServiceParameters(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, parametersResult, res.Payload) + } +} + +func TestGetServiceVersions(t *testing.T) { + server := testutil.NewGetXMLOKServer("/services/xs2-deploy/versions", []byte(versionsPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetServiceVersionsParams{ + Context: context.TODO(), + ServiceID: "xs2-deploy", + } + res, err := client.Operations.GetServiceVersions(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, versionsResult, res.Payload) + } +} + +func TestGetServiceFiles(t *testing.T) { + server := testutil.NewGetXMLOKServer("/services/xs2-deploy/files", []byte(filesPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetServiceFilesParams{ + Context: context.TODO(), + ServiceID: "xs2-deploy", + } + res, err := client.Operations.GetServiceFiles(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, filesResult, res.Payload) + } +} + +func TestCreateServiceFiles(t *testing.T) { + fileName, data := "test.txt", []byte("This is a test") + server := testutil.NewPostFileXMLOKServer("/services/xs2-deploy/files", "files", data, []byte(filesPayload)) + defer server.Close() + err := ioutil.WriteFile(fileName, data, 0777) + assert.NoError(t, err) + defer os.Remove(fileName) + file, err := os.Open(fileName) + assert.NoError(t, err) + defer file.Close() + client := newClient(server, nil) + params := &operations.CreateServiceFilesParams{ + Context: context.TODO(), + ServiceID: "xs2-deploy", + Files: *file, + } + res, err := client.Operations.CreateServiceFiles(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, filesResult, res.Payload) + } +} + +func TestDeleteServiceFiles(t *testing.T) { + server := testutil.NewDeleteNoContentServer("/services/xs2-deploy/files") + defer server.Close() + client := newClient(server, nil) + params := &operations.DeleteServiceFilesParams{ + Context: context.TODO(), + ServiceID: "xs2-deploy", + } + _, err := client.Operations.DeleteServiceFiles(params, nil) + assert.NoError(t, err) +} + +func TestDeleteServiceFiles_Csrf(t *testing.T) { + server := testutil.NewGetXMLOKDeleteNoContentCsrfServer("/services/xs2-deploy/files", []byte(filesPayload)) + defer server.Close() + csrfx := csrf.Csrf{Header: "", Token: ""} + transport := csrf.Transport{Transport: http.DefaultTransport, Csrf: &csrfx} + client := newClient(server, transport) + params := &operations.GetServiceFilesParams{ + Context: context.TODO(), + ServiceID: "xs2-deploy", + } + res, err := client.Operations.GetServiceFiles(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, filesResult, res.Payload) + } + delparams := &operations.DeleteServiceFilesParams{ + Context: context.TODO(), + ServiceID: "xs2-deploy", + } + _, err = client.Operations.DeleteServiceFiles(delparams, nil) + assert.NoError(t, err) +} + +func TestDeleteServiceFile(t *testing.T) { + server := testutil.NewDeleteNoContentServer("/services/xs2-deploy/files/d204bf6a-5a56-4c91-952e-1e8dce81fca2") + defer server.Close() + client := newClient(server, nil) + params := &operations.DeleteServiceFileParams{ + Context: context.TODO(), + ServiceID: "xs2-deploy", + FileID: "d204bf6a-5a56-4c91-952e-1e8dce81fca2", + } + _, err := client.Operations.DeleteServiceFile(params, nil) + assert.NoError(t, err) +} + +func TestGetProcesses(t *testing.T) { + server := testutil.NewGetXMLOKServer("/processes", []byte(processesPayload)) + defer server.Close() + client := newClient(server, nil) + res, err := client.Operations.GetProcesses(nil, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, processesResult, res.Payload) + } +} + +func TestGetProcess(t *testing.T) { + server := testutil.NewGetXMLOKServer("/processes/1", []byte(processPayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetProcessParams{ + Context: context.TODO(), + ProcessID: "1", + } + res, err := client.Operations.GetProcess(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, processResult, *res.Payload) + } +} + +func TestDeleteProcess(t *testing.T) { + server := testutil.NewDeleteNoContentServer("/processes/1") + defer server.Close() + client := newClient(server, nil) + params := &operations.DeleteProcessParams{ + Context: context.TODO(), + ProcessID: "1", + } + _, err := client.Operations.DeleteProcess(params, nil) + assert.NoError(t, err) +} + +func TestGetProcessService(t *testing.T) { + server := testutil.NewGetXMLOKServer("/processes/2/service", []byte(servicePayload)) + defer server.Close() + client := newClient(server, nil) + params := &operations.GetProcessServiceParams{ + Context: context.TODO(), + ProcessID: "2", + } + res, err := client.Operations.GetProcessService(params, nil) + if assert.NoError(t, err) { + testutil.CheckSuccess(t, serviceResult, *res.Payload) + } +} + +func newClient(server *httptest.Server, rt http.RoundTripper) *Slmp { + hu, _ := url.Parse(server.URL) + slmp := client.New(hu.Host, "/", []string{"http"}) + if rt != nil { + slmp.Transport = rt + } + return New(slmp, strfmt.Default) +} + +func strptr(s string) *string { + return &s +} + +func uriptr(u strfmt.URI) *strfmt.URI { + return &u +} diff --git a/clients/slmpclient/operations/create_service_files_parameters.go b/clients/slmpclient/operations/create_service_files_parameters.go new file mode 100644 index 0000000..19636d1 --- /dev/null +++ b/clients/slmpclient/operations/create_service_files_parameters.go @@ -0,0 +1,130 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "os" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewCreateServiceFilesParams creates a new CreateServiceFilesParams object +// with the default values initialized. +func NewCreateServiceFilesParams() *CreateServiceFilesParams { + var () + return &CreateServiceFilesParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewCreateServiceFilesParamsWithTimeout creates a new CreateServiceFilesParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewCreateServiceFilesParamsWithTimeout(timeout time.Duration) *CreateServiceFilesParams { + var () + return &CreateServiceFilesParams{ + + timeout: timeout, + } +} + +// NewCreateServiceFilesParamsWithContext creates a new CreateServiceFilesParams object +// with the default values initialized, and the ability to set a context for a request +func NewCreateServiceFilesParamsWithContext(ctx context.Context) *CreateServiceFilesParams { + var () + return &CreateServiceFilesParams{ + + Context: ctx, + } +} + +/*CreateServiceFilesParams contains all the parameters to send to the API endpoint +for the create service files operation typically these are written to a http.Request +*/ +type CreateServiceFilesParams struct { + + /*Files + contains multiple files separated by a boundary according to RFC 1867 and RFC 2854. S. also File Upload Specification. + + */ + Files os.File + /*ServiceID*/ + ServiceID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the create service files params +func (o *CreateServiceFilesParams) WithTimeout(timeout time.Duration) *CreateServiceFilesParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the create service files params +func (o *CreateServiceFilesParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the create service files params +func (o *CreateServiceFilesParams) WithContext(ctx context.Context) *CreateServiceFilesParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the create service files params +func (o *CreateServiceFilesParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithFiles adds the files to the create service files params +func (o *CreateServiceFilesParams) WithFiles(files os.File) *CreateServiceFilesParams { + o.SetFiles(files) + return o +} + +// SetFiles adds the files to the create service files params +func (o *CreateServiceFilesParams) SetFiles(files os.File) { + o.Files = files +} + +// WithServiceID adds the serviceID to the create service files params +func (o *CreateServiceFilesParams) WithServiceID(serviceID string) *CreateServiceFilesParams { + o.SetServiceID(serviceID) + return o +} + +// SetServiceID adds the serviceId to the create service files params +func (o *CreateServiceFilesParams) SetServiceID(serviceID string) { + o.ServiceID = serviceID +} + +// WriteToRequest writes these params to a swagger request +func (o *CreateServiceFilesParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // form file param files + if err := r.SetFileParam("files", &o.Files); err != nil { + return err + } + + // path param serviceId + if err := r.SetPathParam("serviceId", o.ServiceID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/create_service_files_responses.go b/clients/slmpclient/operations/create_service_files_responses.go new file mode 100644 index 0000000..49a5eb8 --- /dev/null +++ b/clients/slmpclient/operations/create_service_files_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// CreateServiceFilesReader is a Reader for the CreateServiceFiles structure. +type CreateServiceFilesReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *CreateServiceFilesReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewCreateServiceFilesOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewCreateServiceFilesOK creates a CreateServiceFilesOK with default headers values +func NewCreateServiceFilesOK() *CreateServiceFilesOK { + return &CreateServiceFilesOK{} +} + +/*CreateServiceFilesOK handles this case with default header values. + +Created +*/ +type CreateServiceFilesOK struct { + Payload models.Files +} + +func (o *CreateServiceFilesOK) Error() string { + return fmt.Sprintf("[POST /services/{serviceId}/files][%d] createServiceFilesOK %+v", 200, o.Payload) +} + +func (o *CreateServiceFilesOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/create_service_process_parameters.go b/clients/slmpclient/operations/create_service_process_parameters.go new file mode 100644 index 0000000..a63a6ec --- /dev/null +++ b/clients/slmpclient/operations/create_service_process_parameters.go @@ -0,0 +1,134 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// NewCreateServiceProcessParams creates a new CreateServiceProcessParams object +// with the default values initialized. +func NewCreateServiceProcessParams() *CreateServiceProcessParams { + var () + return &CreateServiceProcessParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewCreateServiceProcessParamsWithTimeout creates a new CreateServiceProcessParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewCreateServiceProcessParamsWithTimeout(timeout time.Duration) *CreateServiceProcessParams { + var () + return &CreateServiceProcessParams{ + + timeout: timeout, + } +} + +// NewCreateServiceProcessParamsWithContext creates a new CreateServiceProcessParams object +// with the default values initialized, and the ability to set a context for a request +func NewCreateServiceProcessParamsWithContext(ctx context.Context) *CreateServiceProcessParams { + var () + return &CreateServiceProcessParams{ + + Context: ctx, + } +} + +/*CreateServiceProcessParams contains all the parameters to send to the API endpoint +for the create service process operation typically these are written to a http.Request +*/ +type CreateServiceProcessParams struct { + + /*Process + The important elements are slp.parameters and slp.versions. + + */ + Process *models.Process + /*ServiceID*/ + ServiceID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the create service process params +func (o *CreateServiceProcessParams) WithTimeout(timeout time.Duration) *CreateServiceProcessParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the create service process params +func (o *CreateServiceProcessParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the create service process params +func (o *CreateServiceProcessParams) WithContext(ctx context.Context) *CreateServiceProcessParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the create service process params +func (o *CreateServiceProcessParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithProcess adds the process to the create service process params +func (o *CreateServiceProcessParams) WithProcess(process *models.Process) *CreateServiceProcessParams { + o.SetProcess(process) + return o +} + +// SetProcess adds the process to the create service process params +func (o *CreateServiceProcessParams) SetProcess(process *models.Process) { + o.Process = process +} + +// WithServiceID adds the serviceID to the create service process params +func (o *CreateServiceProcessParams) WithServiceID(serviceID string) *CreateServiceProcessParams { + o.SetServiceID(serviceID) + return o +} + +// SetServiceID adds the serviceId to the create service process params +func (o *CreateServiceProcessParams) SetServiceID(serviceID string) { + o.ServiceID = serviceID +} + +// WriteToRequest writes these params to a swagger request +func (o *CreateServiceProcessParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if o.Process == nil { + o.Process = new(models.Process) + } + + if err := r.SetBodyParam(o.Process); err != nil { + return err + } + + // path param serviceId + if err := r.SetPathParam("serviceId", o.ServiceID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/create_service_process_responses.go b/clients/slmpclient/operations/create_service_process_responses.go new file mode 100644 index 0000000..be25443 --- /dev/null +++ b/clients/slmpclient/operations/create_service_process_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// CreateServiceProcessReader is a Reader for the CreateServiceProcess structure. +type CreateServiceProcessReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *CreateServiceProcessReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewCreateServiceProcessOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewCreateServiceProcessOK creates a CreateServiceProcessOK with default headers values +func NewCreateServiceProcessOK() *CreateServiceProcessOK { + return &CreateServiceProcessOK{} +} + +/*CreateServiceProcessOK handles this case with default header values. + +Created +*/ +type CreateServiceProcessOK struct { + Payload *models.Process +} + +func (o *CreateServiceProcessOK) Error() string { + return fmt.Sprintf("[POST /services/{serviceId}/processes][%d] createServiceProcessOK %+v", 200, o.Payload) +} + +func (o *CreateServiceProcessOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Process) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/delete_process_parameters.go b/clients/slmpclient/operations/delete_process_parameters.go new file mode 100644 index 0000000..6ac723b --- /dev/null +++ b/clients/slmpclient/operations/delete_process_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewDeleteProcessParams creates a new DeleteProcessParams object +// with the default values initialized. +func NewDeleteProcessParams() *DeleteProcessParams { + var () + return &DeleteProcessParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewDeleteProcessParamsWithTimeout creates a new DeleteProcessParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewDeleteProcessParamsWithTimeout(timeout time.Duration) *DeleteProcessParams { + var () + return &DeleteProcessParams{ + + timeout: timeout, + } +} + +// NewDeleteProcessParamsWithContext creates a new DeleteProcessParams object +// with the default values initialized, and the ability to set a context for a request +func NewDeleteProcessParamsWithContext(ctx context.Context) *DeleteProcessParams { + var () + return &DeleteProcessParams{ + + Context: ctx, + } +} + +/*DeleteProcessParams contains all the parameters to send to the API endpoint +for the delete process operation typically these are written to a http.Request +*/ +type DeleteProcessParams struct { + + /*ProcessID*/ + ProcessID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the delete process params +func (o *DeleteProcessParams) WithTimeout(timeout time.Duration) *DeleteProcessParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the delete process params +func (o *DeleteProcessParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the delete process params +func (o *DeleteProcessParams) WithContext(ctx context.Context) *DeleteProcessParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the delete process params +func (o *DeleteProcessParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithProcessID adds the processID to the delete process params +func (o *DeleteProcessParams) WithProcessID(processID string) *DeleteProcessParams { + o.SetProcessID(processID) + return o +} + +// SetProcessID adds the processId to the delete process params +func (o *DeleteProcessParams) SetProcessID(processID string) { + o.ProcessID = processID +} + +// WriteToRequest writes these params to a swagger request +func (o *DeleteProcessParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param processId + if err := r.SetPathParam("processId", o.ProcessID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/delete_process_responses.go b/clients/slmpclient/operations/delete_process_responses.go new file mode 100644 index 0000000..0fb4f16 --- /dev/null +++ b/clients/slmpclient/operations/delete_process_responses.go @@ -0,0 +1,54 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" +) + +// DeleteProcessReader is a Reader for the DeleteProcess structure. +type DeleteProcessReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *DeleteProcessReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 204: + result := NewDeleteProcessNoContent() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewDeleteProcessNoContent creates a DeleteProcessNoContent with default headers values +func NewDeleteProcessNoContent() *DeleteProcessNoContent { + return &DeleteProcessNoContent{} +} + +/*DeleteProcessNoContent handles this case with default header values. + +Deleted +*/ +type DeleteProcessNoContent struct { +} + +func (o *DeleteProcessNoContent) Error() string { + return fmt.Sprintf("[DELETE /processes/{processId}][%d] deleteProcessNoContent ", 204) +} + +func (o *DeleteProcessNoContent) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + return nil +} diff --git a/clients/slmpclient/operations/delete_service_file_parameters.go b/clients/slmpclient/operations/delete_service_file_parameters.go new file mode 100644 index 0000000..b24f491 --- /dev/null +++ b/clients/slmpclient/operations/delete_service_file_parameters.go @@ -0,0 +1,126 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewDeleteServiceFileParams creates a new DeleteServiceFileParams object +// with the default values initialized. +func NewDeleteServiceFileParams() *DeleteServiceFileParams { + var () + return &DeleteServiceFileParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewDeleteServiceFileParamsWithTimeout creates a new DeleteServiceFileParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewDeleteServiceFileParamsWithTimeout(timeout time.Duration) *DeleteServiceFileParams { + var () + return &DeleteServiceFileParams{ + + timeout: timeout, + } +} + +// NewDeleteServiceFileParamsWithContext creates a new DeleteServiceFileParams object +// with the default values initialized, and the ability to set a context for a request +func NewDeleteServiceFileParamsWithContext(ctx context.Context) *DeleteServiceFileParams { + var () + return &DeleteServiceFileParams{ + + Context: ctx, + } +} + +/*DeleteServiceFileParams contains all the parameters to send to the API endpoint +for the delete service file operation typically these are written to a http.Request +*/ +type DeleteServiceFileParams struct { + + /*FileID*/ + FileID string + /*ServiceID*/ + ServiceID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the delete service file params +func (o *DeleteServiceFileParams) WithTimeout(timeout time.Duration) *DeleteServiceFileParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the delete service file params +func (o *DeleteServiceFileParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the delete service file params +func (o *DeleteServiceFileParams) WithContext(ctx context.Context) *DeleteServiceFileParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the delete service file params +func (o *DeleteServiceFileParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithFileID adds the fileID to the delete service file params +func (o *DeleteServiceFileParams) WithFileID(fileID string) *DeleteServiceFileParams { + o.SetFileID(fileID) + return o +} + +// SetFileID adds the fileId to the delete service file params +func (o *DeleteServiceFileParams) SetFileID(fileID string) { + o.FileID = fileID +} + +// WithServiceID adds the serviceID to the delete service file params +func (o *DeleteServiceFileParams) WithServiceID(serviceID string) *DeleteServiceFileParams { + o.SetServiceID(serviceID) + return o +} + +// SetServiceID adds the serviceId to the delete service file params +func (o *DeleteServiceFileParams) SetServiceID(serviceID string) { + o.ServiceID = serviceID +} + +// WriteToRequest writes these params to a swagger request +func (o *DeleteServiceFileParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param fileId + if err := r.SetPathParam("fileId", o.FileID); err != nil { + return err + } + + // path param serviceId + if err := r.SetPathParam("serviceId", o.ServiceID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/delete_service_file_responses.go b/clients/slmpclient/operations/delete_service_file_responses.go new file mode 100644 index 0000000..84daa1e --- /dev/null +++ b/clients/slmpclient/operations/delete_service_file_responses.go @@ -0,0 +1,54 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" +) + +// DeleteServiceFileReader is a Reader for the DeleteServiceFile structure. +type DeleteServiceFileReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *DeleteServiceFileReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 204: + result := NewDeleteServiceFileNoContent() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewDeleteServiceFileNoContent creates a DeleteServiceFileNoContent with default headers values +func NewDeleteServiceFileNoContent() *DeleteServiceFileNoContent { + return &DeleteServiceFileNoContent{} +} + +/*DeleteServiceFileNoContent handles this case with default header values. + +Deleted +*/ +type DeleteServiceFileNoContent struct { +} + +func (o *DeleteServiceFileNoContent) Error() string { + return fmt.Sprintf("[DELETE /services/{serviceId}/files/{fileId}][%d] deleteServiceFileNoContent ", 204) +} + +func (o *DeleteServiceFileNoContent) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + return nil +} diff --git a/clients/slmpclient/operations/delete_service_files_parameters.go b/clients/slmpclient/operations/delete_service_files_parameters.go new file mode 100644 index 0000000..d256bc6 --- /dev/null +++ b/clients/slmpclient/operations/delete_service_files_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewDeleteServiceFilesParams creates a new DeleteServiceFilesParams object +// with the default values initialized. +func NewDeleteServiceFilesParams() *DeleteServiceFilesParams { + var () + return &DeleteServiceFilesParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewDeleteServiceFilesParamsWithTimeout creates a new DeleteServiceFilesParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewDeleteServiceFilesParamsWithTimeout(timeout time.Duration) *DeleteServiceFilesParams { + var () + return &DeleteServiceFilesParams{ + + timeout: timeout, + } +} + +// NewDeleteServiceFilesParamsWithContext creates a new DeleteServiceFilesParams object +// with the default values initialized, and the ability to set a context for a request +func NewDeleteServiceFilesParamsWithContext(ctx context.Context) *DeleteServiceFilesParams { + var () + return &DeleteServiceFilesParams{ + + Context: ctx, + } +} + +/*DeleteServiceFilesParams contains all the parameters to send to the API endpoint +for the delete service files operation typically these are written to a http.Request +*/ +type DeleteServiceFilesParams struct { + + /*ServiceID*/ + ServiceID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the delete service files params +func (o *DeleteServiceFilesParams) WithTimeout(timeout time.Duration) *DeleteServiceFilesParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the delete service files params +func (o *DeleteServiceFilesParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the delete service files params +func (o *DeleteServiceFilesParams) WithContext(ctx context.Context) *DeleteServiceFilesParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the delete service files params +func (o *DeleteServiceFilesParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithServiceID adds the serviceID to the delete service files params +func (o *DeleteServiceFilesParams) WithServiceID(serviceID string) *DeleteServiceFilesParams { + o.SetServiceID(serviceID) + return o +} + +// SetServiceID adds the serviceId to the delete service files params +func (o *DeleteServiceFilesParams) SetServiceID(serviceID string) { + o.ServiceID = serviceID +} + +// WriteToRequest writes these params to a swagger request +func (o *DeleteServiceFilesParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param serviceId + if err := r.SetPathParam("serviceId", o.ServiceID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/delete_service_files_responses.go b/clients/slmpclient/operations/delete_service_files_responses.go new file mode 100644 index 0000000..0a52852 --- /dev/null +++ b/clients/slmpclient/operations/delete_service_files_responses.go @@ -0,0 +1,54 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" +) + +// DeleteServiceFilesReader is a Reader for the DeleteServiceFiles structure. +type DeleteServiceFilesReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *DeleteServiceFilesReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 204: + result := NewDeleteServiceFilesNoContent() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewDeleteServiceFilesNoContent creates a DeleteServiceFilesNoContent with default headers values +func NewDeleteServiceFilesNoContent() *DeleteServiceFilesNoContent { + return &DeleteServiceFilesNoContent{} +} + +/*DeleteServiceFilesNoContent handles this case with default header values. + +Deleted +*/ +type DeleteServiceFilesNoContent struct { +} + +func (o *DeleteServiceFilesNoContent) Error() string { + return fmt.Sprintf("[DELETE /services/{serviceId}/files][%d] deleteServiceFilesNoContent ", 204) +} + +func (o *DeleteServiceFilesNoContent) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + return nil +} diff --git a/clients/slmpclient/operations/delete_service_process_parameters.go b/clients/slmpclient/operations/delete_service_process_parameters.go new file mode 100644 index 0000000..c564c68 --- /dev/null +++ b/clients/slmpclient/operations/delete_service_process_parameters.go @@ -0,0 +1,126 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewDeleteServiceProcessParams creates a new DeleteServiceProcessParams object +// with the default values initialized. +func NewDeleteServiceProcessParams() *DeleteServiceProcessParams { + var () + return &DeleteServiceProcessParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewDeleteServiceProcessParamsWithTimeout creates a new DeleteServiceProcessParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewDeleteServiceProcessParamsWithTimeout(timeout time.Duration) *DeleteServiceProcessParams { + var () + return &DeleteServiceProcessParams{ + + timeout: timeout, + } +} + +// NewDeleteServiceProcessParamsWithContext creates a new DeleteServiceProcessParams object +// with the default values initialized, and the ability to set a context for a request +func NewDeleteServiceProcessParamsWithContext(ctx context.Context) *DeleteServiceProcessParams { + var () + return &DeleteServiceProcessParams{ + + Context: ctx, + } +} + +/*DeleteServiceProcessParams contains all the parameters to send to the API endpoint +for the delete service process operation typically these are written to a http.Request +*/ +type DeleteServiceProcessParams struct { + + /*ProcessID*/ + ProcessID string + /*ServiceID*/ + ServiceID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the delete service process params +func (o *DeleteServiceProcessParams) WithTimeout(timeout time.Duration) *DeleteServiceProcessParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the delete service process params +func (o *DeleteServiceProcessParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the delete service process params +func (o *DeleteServiceProcessParams) WithContext(ctx context.Context) *DeleteServiceProcessParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the delete service process params +func (o *DeleteServiceProcessParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithProcessID adds the processID to the delete service process params +func (o *DeleteServiceProcessParams) WithProcessID(processID string) *DeleteServiceProcessParams { + o.SetProcessID(processID) + return o +} + +// SetProcessID adds the processId to the delete service process params +func (o *DeleteServiceProcessParams) SetProcessID(processID string) { + o.ProcessID = processID +} + +// WithServiceID adds the serviceID to the delete service process params +func (o *DeleteServiceProcessParams) WithServiceID(serviceID string) *DeleteServiceProcessParams { + o.SetServiceID(serviceID) + return o +} + +// SetServiceID adds the serviceId to the delete service process params +func (o *DeleteServiceProcessParams) SetServiceID(serviceID string) { + o.ServiceID = serviceID +} + +// WriteToRequest writes these params to a swagger request +func (o *DeleteServiceProcessParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param processId + if err := r.SetPathParam("processId", o.ProcessID); err != nil { + return err + } + + // path param serviceId + if err := r.SetPathParam("serviceId", o.ServiceID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/delete_service_process_responses.go b/clients/slmpclient/operations/delete_service_process_responses.go new file mode 100644 index 0000000..4b6d909 --- /dev/null +++ b/clients/slmpclient/operations/delete_service_process_responses.go @@ -0,0 +1,54 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" +) + +// DeleteServiceProcessReader is a Reader for the DeleteServiceProcess structure. +type DeleteServiceProcessReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *DeleteServiceProcessReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 204: + result := NewDeleteServiceProcessNoContent() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewDeleteServiceProcessNoContent creates a DeleteServiceProcessNoContent with default headers values +func NewDeleteServiceProcessNoContent() *DeleteServiceProcessNoContent { + return &DeleteServiceProcessNoContent{} +} + +/*DeleteServiceProcessNoContent handles this case with default header values. + +Deleted +*/ +type DeleteServiceProcessNoContent struct { +} + +func (o *DeleteServiceProcessNoContent) Error() string { + return fmt.Sprintf("[DELETE /services/{serviceId}/processes/{processId}][%d] deleteServiceProcessNoContent ", 204) +} + +func (o *DeleteServiceProcessNoContent) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + return nil +} diff --git a/clients/slmpclient/operations/get_metadata_parameters.go b/clients/slmpclient/operations/get_metadata_parameters.go new file mode 100644 index 0000000..02f343a --- /dev/null +++ b/clients/slmpclient/operations/get_metadata_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetMetadataParams creates a new GetMetadataParams object +// with the default values initialized. +func NewGetMetadataParams() *GetMetadataParams { + + return &GetMetadataParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetMetadataParamsWithTimeout creates a new GetMetadataParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetMetadataParamsWithTimeout(timeout time.Duration) *GetMetadataParams { + + return &GetMetadataParams{ + + timeout: timeout, + } +} + +// NewGetMetadataParamsWithContext creates a new GetMetadataParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetMetadataParamsWithContext(ctx context.Context) *GetMetadataParams { + + return &GetMetadataParams{ + + Context: ctx, + } +} + +/*GetMetadataParams contains all the parameters to send to the API endpoint +for the get metadata operation typically these are written to a http.Request +*/ +type GetMetadataParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get metadata params +func (o *GetMetadataParams) WithTimeout(timeout time.Duration) *GetMetadataParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get metadata params +func (o *GetMetadataParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get metadata params +func (o *GetMetadataParams) WithContext(ctx context.Context) *GetMetadataParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get metadata params +func (o *GetMetadataParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetMetadataParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/get_metadata_responses.go b/clients/slmpclient/operations/get_metadata_responses.go new file mode 100644 index 0000000..0df8834 --- /dev/null +++ b/clients/slmpclient/operations/get_metadata_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetMetadataReader is a Reader for the GetMetadata structure. +type GetMetadataReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetMetadataReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetMetadataOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetMetadataOK creates a GetMetadataOK with default headers values +func NewGetMetadataOK() *GetMetadataOK { + return &GetMetadataOK{} +} + +/*GetMetadataOK handles this case with default header values. + +OK +*/ +type GetMetadataOK struct { + Payload *models.Metadata +} + +func (o *GetMetadataOK) Error() string { + return fmt.Sprintf("[GET /metadata][%d] getMetadataOK %+v", 200, o.Payload) +} + +func (o *GetMetadataOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Metadata) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/get_process_parameters.go b/clients/slmpclient/operations/get_process_parameters.go new file mode 100644 index 0000000..0cddcee --- /dev/null +++ b/clients/slmpclient/operations/get_process_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetProcessParams creates a new GetProcessParams object +// with the default values initialized. +func NewGetProcessParams() *GetProcessParams { + var () + return &GetProcessParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetProcessParamsWithTimeout creates a new GetProcessParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetProcessParamsWithTimeout(timeout time.Duration) *GetProcessParams { + var () + return &GetProcessParams{ + + timeout: timeout, + } +} + +// NewGetProcessParamsWithContext creates a new GetProcessParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetProcessParamsWithContext(ctx context.Context) *GetProcessParams { + var () + return &GetProcessParams{ + + Context: ctx, + } +} + +/*GetProcessParams contains all the parameters to send to the API endpoint +for the get process operation typically these are written to a http.Request +*/ +type GetProcessParams struct { + + /*ProcessID*/ + ProcessID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get process params +func (o *GetProcessParams) WithTimeout(timeout time.Duration) *GetProcessParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get process params +func (o *GetProcessParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get process params +func (o *GetProcessParams) WithContext(ctx context.Context) *GetProcessParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get process params +func (o *GetProcessParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithProcessID adds the processID to the get process params +func (o *GetProcessParams) WithProcessID(processID string) *GetProcessParams { + o.SetProcessID(processID) + return o +} + +// SetProcessID adds the processId to the get process params +func (o *GetProcessParams) SetProcessID(processID string) { + o.ProcessID = processID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetProcessParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param processId + if err := r.SetPathParam("processId", o.ProcessID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/get_process_responses.go b/clients/slmpclient/operations/get_process_responses.go new file mode 100644 index 0000000..9bc7b4c --- /dev/null +++ b/clients/slmpclient/operations/get_process_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetProcessReader is a Reader for the GetProcess structure. +type GetProcessReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetProcessReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetProcessOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetProcessOK creates a GetProcessOK with default headers values +func NewGetProcessOK() *GetProcessOK { + return &GetProcessOK{} +} + +/*GetProcessOK handles this case with default header values. + +OK +*/ +type GetProcessOK struct { + Payload *models.Process +} + +func (o *GetProcessOK) Error() string { + return fmt.Sprintf("[GET /processes/{processId}][%d] getProcessOK %+v", 200, o.Payload) +} + +func (o *GetProcessOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Process) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/get_process_service_parameters.go b/clients/slmpclient/operations/get_process_service_parameters.go new file mode 100644 index 0000000..0715d8a --- /dev/null +++ b/clients/slmpclient/operations/get_process_service_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetProcessServiceParams creates a new GetProcessServiceParams object +// with the default values initialized. +func NewGetProcessServiceParams() *GetProcessServiceParams { + var () + return &GetProcessServiceParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetProcessServiceParamsWithTimeout creates a new GetProcessServiceParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetProcessServiceParamsWithTimeout(timeout time.Duration) *GetProcessServiceParams { + var () + return &GetProcessServiceParams{ + + timeout: timeout, + } +} + +// NewGetProcessServiceParamsWithContext creates a new GetProcessServiceParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetProcessServiceParamsWithContext(ctx context.Context) *GetProcessServiceParams { + var () + return &GetProcessServiceParams{ + + Context: ctx, + } +} + +/*GetProcessServiceParams contains all the parameters to send to the API endpoint +for the get process service operation typically these are written to a http.Request +*/ +type GetProcessServiceParams struct { + + /*ProcessID*/ + ProcessID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get process service params +func (o *GetProcessServiceParams) WithTimeout(timeout time.Duration) *GetProcessServiceParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get process service params +func (o *GetProcessServiceParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get process service params +func (o *GetProcessServiceParams) WithContext(ctx context.Context) *GetProcessServiceParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get process service params +func (o *GetProcessServiceParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithProcessID adds the processID to the get process service params +func (o *GetProcessServiceParams) WithProcessID(processID string) *GetProcessServiceParams { + o.SetProcessID(processID) + return o +} + +// SetProcessID adds the processId to the get process service params +func (o *GetProcessServiceParams) SetProcessID(processID string) { + o.ProcessID = processID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetProcessServiceParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param processId + if err := r.SetPathParam("processId", o.ProcessID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/get_process_service_responses.go b/clients/slmpclient/operations/get_process_service_responses.go new file mode 100644 index 0000000..65cb8ce --- /dev/null +++ b/clients/slmpclient/operations/get_process_service_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetProcessServiceReader is a Reader for the GetProcessService structure. +type GetProcessServiceReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetProcessServiceReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetProcessServiceOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetProcessServiceOK creates a GetProcessServiceOK with default headers values +func NewGetProcessServiceOK() *GetProcessServiceOK { + return &GetProcessServiceOK{} +} + +/*GetProcessServiceOK handles this case with default header values. + +OK +*/ +type GetProcessServiceOK struct { + Payload *models.Service +} + +func (o *GetProcessServiceOK) Error() string { + return fmt.Sprintf("[GET /processes/{processId}/service][%d] getProcessServiceOK %+v", 200, o.Payload) +} + +func (o *GetProcessServiceOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Service) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/get_processes_parameters.go b/clients/slmpclient/operations/get_processes_parameters.go new file mode 100644 index 0000000..4498c3e --- /dev/null +++ b/clients/slmpclient/operations/get_processes_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetProcessesParams creates a new GetProcessesParams object +// with the default values initialized. +func NewGetProcessesParams() *GetProcessesParams { + + return &GetProcessesParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetProcessesParamsWithTimeout creates a new GetProcessesParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetProcessesParamsWithTimeout(timeout time.Duration) *GetProcessesParams { + + return &GetProcessesParams{ + + timeout: timeout, + } +} + +// NewGetProcessesParamsWithContext creates a new GetProcessesParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetProcessesParamsWithContext(ctx context.Context) *GetProcessesParams { + + return &GetProcessesParams{ + + Context: ctx, + } +} + +/*GetProcessesParams contains all the parameters to send to the API endpoint +for the get processes operation typically these are written to a http.Request +*/ +type GetProcessesParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get processes params +func (o *GetProcessesParams) WithTimeout(timeout time.Duration) *GetProcessesParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get processes params +func (o *GetProcessesParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get processes params +func (o *GetProcessesParams) WithContext(ctx context.Context) *GetProcessesParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get processes params +func (o *GetProcessesParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetProcessesParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/get_processes_responses.go b/clients/slmpclient/operations/get_processes_responses.go new file mode 100644 index 0000000..1d0a521 --- /dev/null +++ b/clients/slmpclient/operations/get_processes_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetProcessesReader is a Reader for the GetProcesses structure. +type GetProcessesReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetProcessesReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetProcessesOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetProcessesOK creates a GetProcessesOK with default headers values +func NewGetProcessesOK() *GetProcessesOK { + return &GetProcessesOK{} +} + +/*GetProcessesOK handles this case with default header values. + +OK +*/ +type GetProcessesOK struct { + Payload models.Processes +} + +func (o *GetProcessesOK) Error() string { + return fmt.Sprintf("[GET /processes][%d] getProcessesOK %+v", 200, o.Payload) +} + +func (o *GetProcessesOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/get_service_files_parameters.go b/clients/slmpclient/operations/get_service_files_parameters.go new file mode 100644 index 0000000..ed1b5d9 --- /dev/null +++ b/clients/slmpclient/operations/get_service_files_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetServiceFilesParams creates a new GetServiceFilesParams object +// with the default values initialized. +func NewGetServiceFilesParams() *GetServiceFilesParams { + var () + return &GetServiceFilesParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetServiceFilesParamsWithTimeout creates a new GetServiceFilesParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetServiceFilesParamsWithTimeout(timeout time.Duration) *GetServiceFilesParams { + var () + return &GetServiceFilesParams{ + + timeout: timeout, + } +} + +// NewGetServiceFilesParamsWithContext creates a new GetServiceFilesParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetServiceFilesParamsWithContext(ctx context.Context) *GetServiceFilesParams { + var () + return &GetServiceFilesParams{ + + Context: ctx, + } +} + +/*GetServiceFilesParams contains all the parameters to send to the API endpoint +for the get service files operation typically these are written to a http.Request +*/ +type GetServiceFilesParams struct { + + /*ServiceID*/ + ServiceID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get service files params +func (o *GetServiceFilesParams) WithTimeout(timeout time.Duration) *GetServiceFilesParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get service files params +func (o *GetServiceFilesParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get service files params +func (o *GetServiceFilesParams) WithContext(ctx context.Context) *GetServiceFilesParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get service files params +func (o *GetServiceFilesParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithServiceID adds the serviceID to the get service files params +func (o *GetServiceFilesParams) WithServiceID(serviceID string) *GetServiceFilesParams { + o.SetServiceID(serviceID) + return o +} + +// SetServiceID adds the serviceId to the get service files params +func (o *GetServiceFilesParams) SetServiceID(serviceID string) { + o.ServiceID = serviceID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetServiceFilesParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param serviceId + if err := r.SetPathParam("serviceId", o.ServiceID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/get_service_files_responses.go b/clients/slmpclient/operations/get_service_files_responses.go new file mode 100644 index 0000000..7d17388 --- /dev/null +++ b/clients/slmpclient/operations/get_service_files_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetServiceFilesReader is a Reader for the GetServiceFiles structure. +type GetServiceFilesReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetServiceFilesReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetServiceFilesOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetServiceFilesOK creates a GetServiceFilesOK with default headers values +func NewGetServiceFilesOK() *GetServiceFilesOK { + return &GetServiceFilesOK{} +} + +/*GetServiceFilesOK handles this case with default header values. + +OK +*/ +type GetServiceFilesOK struct { + Payload models.Files +} + +func (o *GetServiceFilesOK) Error() string { + return fmt.Sprintf("[GET /services/{serviceId}/files][%d] getServiceFilesOK %+v", 200, o.Payload) +} + +func (o *GetServiceFilesOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/get_service_parameters.go b/clients/slmpclient/operations/get_service_parameters.go new file mode 100644 index 0000000..acb7309 --- /dev/null +++ b/clients/slmpclient/operations/get_service_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetServiceParams creates a new GetServiceParams object +// with the default values initialized. +func NewGetServiceParams() *GetServiceParams { + var () + return &GetServiceParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetServiceParamsWithTimeout creates a new GetServiceParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetServiceParamsWithTimeout(timeout time.Duration) *GetServiceParams { + var () + return &GetServiceParams{ + + timeout: timeout, + } +} + +// NewGetServiceParamsWithContext creates a new GetServiceParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetServiceParamsWithContext(ctx context.Context) *GetServiceParams { + var () + return &GetServiceParams{ + + Context: ctx, + } +} + +/*GetServiceParams contains all the parameters to send to the API endpoint +for the get service operation typically these are written to a http.Request +*/ +type GetServiceParams struct { + + /*ServiceID*/ + ServiceID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get service params +func (o *GetServiceParams) WithTimeout(timeout time.Duration) *GetServiceParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get service params +func (o *GetServiceParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get service params +func (o *GetServiceParams) WithContext(ctx context.Context) *GetServiceParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get service params +func (o *GetServiceParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithServiceID adds the serviceID to the get service params +func (o *GetServiceParams) WithServiceID(serviceID string) *GetServiceParams { + o.SetServiceID(serviceID) + return o +} + +// SetServiceID adds the serviceId to the get service params +func (o *GetServiceParams) SetServiceID(serviceID string) { + o.ServiceID = serviceID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetServiceParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param serviceId + if err := r.SetPathParam("serviceId", o.ServiceID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/get_service_parameters_parameters.go b/clients/slmpclient/operations/get_service_parameters_parameters.go new file mode 100644 index 0000000..dc60c05 --- /dev/null +++ b/clients/slmpclient/operations/get_service_parameters_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetServiceParametersParams creates a new GetServiceParametersParams object +// with the default values initialized. +func NewGetServiceParametersParams() *GetServiceParametersParams { + var () + return &GetServiceParametersParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetServiceParametersParamsWithTimeout creates a new GetServiceParametersParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetServiceParametersParamsWithTimeout(timeout time.Duration) *GetServiceParametersParams { + var () + return &GetServiceParametersParams{ + + timeout: timeout, + } +} + +// NewGetServiceParametersParamsWithContext creates a new GetServiceParametersParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetServiceParametersParamsWithContext(ctx context.Context) *GetServiceParametersParams { + var () + return &GetServiceParametersParams{ + + Context: ctx, + } +} + +/*GetServiceParametersParams contains all the parameters to send to the API endpoint +for the get service parameters operation typically these are written to a http.Request +*/ +type GetServiceParametersParams struct { + + /*ServiceID*/ + ServiceID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get service parameters params +func (o *GetServiceParametersParams) WithTimeout(timeout time.Duration) *GetServiceParametersParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get service parameters params +func (o *GetServiceParametersParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get service parameters params +func (o *GetServiceParametersParams) WithContext(ctx context.Context) *GetServiceParametersParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get service parameters params +func (o *GetServiceParametersParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithServiceID adds the serviceID to the get service parameters params +func (o *GetServiceParametersParams) WithServiceID(serviceID string) *GetServiceParametersParams { + o.SetServiceID(serviceID) + return o +} + +// SetServiceID adds the serviceId to the get service parameters params +func (o *GetServiceParametersParams) SetServiceID(serviceID string) { + o.ServiceID = serviceID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetServiceParametersParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param serviceId + if err := r.SetPathParam("serviceId", o.ServiceID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/get_service_parameters_responses.go b/clients/slmpclient/operations/get_service_parameters_responses.go new file mode 100644 index 0000000..2310774 --- /dev/null +++ b/clients/slmpclient/operations/get_service_parameters_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetServiceParametersReader is a Reader for the GetServiceParameters structure. +type GetServiceParametersReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetServiceParametersReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetServiceParametersOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetServiceParametersOK creates a GetServiceParametersOK with default headers values +func NewGetServiceParametersOK() *GetServiceParametersOK { + return &GetServiceParametersOK{} +} + +/*GetServiceParametersOK handles this case with default header values. + +OK +*/ +type GetServiceParametersOK struct { + Payload models.Parameters +} + +func (o *GetServiceParametersOK) Error() string { + return fmt.Sprintf("[GET /services/{serviceId}/parameters][%d] getServiceParametersOK %+v", 200, o.Payload) +} + +func (o *GetServiceParametersOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/get_service_processes_parameters.go b/clients/slmpclient/operations/get_service_processes_parameters.go new file mode 100644 index 0000000..7f96036 --- /dev/null +++ b/clients/slmpclient/operations/get_service_processes_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetServiceProcessesParams creates a new GetServiceProcessesParams object +// with the default values initialized. +func NewGetServiceProcessesParams() *GetServiceProcessesParams { + var () + return &GetServiceProcessesParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetServiceProcessesParamsWithTimeout creates a new GetServiceProcessesParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetServiceProcessesParamsWithTimeout(timeout time.Duration) *GetServiceProcessesParams { + var () + return &GetServiceProcessesParams{ + + timeout: timeout, + } +} + +// NewGetServiceProcessesParamsWithContext creates a new GetServiceProcessesParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetServiceProcessesParamsWithContext(ctx context.Context) *GetServiceProcessesParams { + var () + return &GetServiceProcessesParams{ + + Context: ctx, + } +} + +/*GetServiceProcessesParams contains all the parameters to send to the API endpoint +for the get service processes operation typically these are written to a http.Request +*/ +type GetServiceProcessesParams struct { + + /*ServiceID*/ + ServiceID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get service processes params +func (o *GetServiceProcessesParams) WithTimeout(timeout time.Duration) *GetServiceProcessesParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get service processes params +func (o *GetServiceProcessesParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get service processes params +func (o *GetServiceProcessesParams) WithContext(ctx context.Context) *GetServiceProcessesParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get service processes params +func (o *GetServiceProcessesParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithServiceID adds the serviceID to the get service processes params +func (o *GetServiceProcessesParams) WithServiceID(serviceID string) *GetServiceProcessesParams { + o.SetServiceID(serviceID) + return o +} + +// SetServiceID adds the serviceId to the get service processes params +func (o *GetServiceProcessesParams) SetServiceID(serviceID string) { + o.ServiceID = serviceID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetServiceProcessesParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param serviceId + if err := r.SetPathParam("serviceId", o.ServiceID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/get_service_processes_responses.go b/clients/slmpclient/operations/get_service_processes_responses.go new file mode 100644 index 0000000..50f0272 --- /dev/null +++ b/clients/slmpclient/operations/get_service_processes_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetServiceProcessesReader is a Reader for the GetServiceProcesses structure. +type GetServiceProcessesReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetServiceProcessesReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetServiceProcessesOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetServiceProcessesOK creates a GetServiceProcessesOK with default headers values +func NewGetServiceProcessesOK() *GetServiceProcessesOK { + return &GetServiceProcessesOK{} +} + +/*GetServiceProcessesOK handles this case with default header values. + +OK +*/ +type GetServiceProcessesOK struct { + Payload models.Processes +} + +func (o *GetServiceProcessesOK) Error() string { + return fmt.Sprintf("[GET /services/{serviceId}/processes][%d] getServiceProcessesOK %+v", 200, o.Payload) +} + +func (o *GetServiceProcessesOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/get_service_responses.go b/clients/slmpclient/operations/get_service_responses.go new file mode 100644 index 0000000..68c011f --- /dev/null +++ b/clients/slmpclient/operations/get_service_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetServiceReader is a Reader for the GetService structure. +type GetServiceReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetServiceReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetServiceOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetServiceOK creates a GetServiceOK with default headers values +func NewGetServiceOK() *GetServiceOK { + return &GetServiceOK{} +} + +/*GetServiceOK handles this case with default header values. + +OK +*/ +type GetServiceOK struct { + Payload *models.Service +} + +func (o *GetServiceOK) Error() string { + return fmt.Sprintf("[GET /services/{serviceId}][%d] getServiceOK %+v", 200, o.Payload) +} + +func (o *GetServiceOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Service) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/get_service_versions_parameters.go b/clients/slmpclient/operations/get_service_versions_parameters.go new file mode 100644 index 0000000..8c4134b --- /dev/null +++ b/clients/slmpclient/operations/get_service_versions_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetServiceVersionsParams creates a new GetServiceVersionsParams object +// with the default values initialized. +func NewGetServiceVersionsParams() *GetServiceVersionsParams { + var () + return &GetServiceVersionsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetServiceVersionsParamsWithTimeout creates a new GetServiceVersionsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetServiceVersionsParamsWithTimeout(timeout time.Duration) *GetServiceVersionsParams { + var () + return &GetServiceVersionsParams{ + + timeout: timeout, + } +} + +// NewGetServiceVersionsParamsWithContext creates a new GetServiceVersionsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetServiceVersionsParamsWithContext(ctx context.Context) *GetServiceVersionsParams { + var () + return &GetServiceVersionsParams{ + + Context: ctx, + } +} + +/*GetServiceVersionsParams contains all the parameters to send to the API endpoint +for the get service versions operation typically these are written to a http.Request +*/ +type GetServiceVersionsParams struct { + + /*ServiceID*/ + ServiceID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get service versions params +func (o *GetServiceVersionsParams) WithTimeout(timeout time.Duration) *GetServiceVersionsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get service versions params +func (o *GetServiceVersionsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get service versions params +func (o *GetServiceVersionsParams) WithContext(ctx context.Context) *GetServiceVersionsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get service versions params +func (o *GetServiceVersionsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithServiceID adds the serviceID to the get service versions params +func (o *GetServiceVersionsParams) WithServiceID(serviceID string) *GetServiceVersionsParams { + o.SetServiceID(serviceID) + return o +} + +// SetServiceID adds the serviceId to the get service versions params +func (o *GetServiceVersionsParams) SetServiceID(serviceID string) { + o.ServiceID = serviceID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetServiceVersionsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param serviceId + if err := r.SetPathParam("serviceId", o.ServiceID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/get_service_versions_responses.go b/clients/slmpclient/operations/get_service_versions_responses.go new file mode 100644 index 0000000..4adb145 --- /dev/null +++ b/clients/slmpclient/operations/get_service_versions_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetServiceVersionsReader is a Reader for the GetServiceVersions structure. +type GetServiceVersionsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetServiceVersionsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetServiceVersionsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetServiceVersionsOK creates a GetServiceVersionsOK with default headers values +func NewGetServiceVersionsOK() *GetServiceVersionsOK { + return &GetServiceVersionsOK{} +} + +/*GetServiceVersionsOK handles this case with default header values. + +OK +*/ +type GetServiceVersionsOK struct { + Payload models.Versions +} + +func (o *GetServiceVersionsOK) Error() string { + return fmt.Sprintf("[GET /services/{serviceId}/versions][%d] getServiceVersionsOK %+v", 200, o.Payload) +} + +func (o *GetServiceVersionsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/get_services_parameters.go b/clients/slmpclient/operations/get_services_parameters.go new file mode 100644 index 0000000..104de42 --- /dev/null +++ b/clients/slmpclient/operations/get_services_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetServicesParams creates a new GetServicesParams object +// with the default values initialized. +func NewGetServicesParams() *GetServicesParams { + + return &GetServicesParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetServicesParamsWithTimeout creates a new GetServicesParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetServicesParamsWithTimeout(timeout time.Duration) *GetServicesParams { + + return &GetServicesParams{ + + timeout: timeout, + } +} + +// NewGetServicesParamsWithContext creates a new GetServicesParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetServicesParamsWithContext(ctx context.Context) *GetServicesParams { + + return &GetServicesParams{ + + Context: ctx, + } +} + +/*GetServicesParams contains all the parameters to send to the API endpoint +for the get services operation typically these are written to a http.Request +*/ +type GetServicesParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get services params +func (o *GetServicesParams) WithTimeout(timeout time.Duration) *GetServicesParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get services params +func (o *GetServicesParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get services params +func (o *GetServicesParams) WithContext(ctx context.Context) *GetServicesParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get services params +func (o *GetServicesParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetServicesParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slmpclient/operations/get_services_responses.go b/clients/slmpclient/operations/get_services_responses.go new file mode 100644 index 0000000..cf1dfa0 --- /dev/null +++ b/clients/slmpclient/operations/get_services_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetServicesReader is a Reader for the GetServices structure. +type GetServicesReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetServicesReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetServicesOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetServicesOK creates a GetServicesOK with default headers values +func NewGetServicesOK() *GetServicesOK { + return &GetServicesOK{} +} + +/*GetServicesOK handles this case with default header values. + +OK +*/ +type GetServicesOK struct { + Payload models.Services +} + +func (o *GetServicesOK) Error() string { + return fmt.Sprintf("[GET /services][%d] getServicesOK %+v", 200, o.Payload) +} + +func (o *GetServicesOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slmpclient/operations/operations_client.go b/clients/slmpclient/operations/operations_client.go new file mode 100644 index 0000000..836af1e --- /dev/null +++ b/clients/slmpclient/operations/operations_client.go @@ -0,0 +1,476 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" +) + +// New creates a new operations API client. +func New(transport runtime.ClientTransport, formats strfmt.Registry) *Client { + return &Client{transport: transport, formats: formats} +} + +/* +Client for operations API +*/ +type Client struct { + transport runtime.ClientTransport + formats strfmt.Registry +} + +/* +CreateServiceFiles Upload multiple files for a specific service +*/ +func (a *Client) CreateServiceFiles(params *CreateServiceFilesParams, authInfo runtime.ClientAuthInfoWriter) (*CreateServiceFilesOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewCreateServiceFilesParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "CreateServiceFiles", + Method: "POST", + PathPattern: "/services/{serviceId}/files", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"multipart/form-data"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &CreateServiceFilesReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*CreateServiceFilesOK), nil + +} + +/* +CreateServiceProcess create service process API +*/ +func (a *Client) CreateServiceProcess(params *CreateServiceProcessParams, authInfo runtime.ClientAuthInfoWriter) (*CreateServiceProcessOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewCreateServiceProcessParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "CreateServiceProcess", + Method: "POST", + PathPattern: "/services/{serviceId}/processes", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &CreateServiceProcessReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*CreateServiceProcessOK), nil + +} + +/* +DeleteProcess The deletion of an SL process results in the clean-up of the resources used by the process (e.g. deleting downloaded files, logs, parameter files, etc.) +*/ +func (a *Client) DeleteProcess(params *DeleteProcessParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteProcessNoContent, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewDeleteProcessParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "DeleteProcess", + Method: "DELETE", + PathPattern: "/processes/{processId}", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &DeleteProcessReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*DeleteProcessNoContent), nil + +} + +/* +DeleteServiceFile Delete a single file for a specific service +*/ +func (a *Client) DeleteServiceFile(params *DeleteServiceFileParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteServiceFileNoContent, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewDeleteServiceFileParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "DeleteServiceFile", + Method: "DELETE", + PathPattern: "/services/{serviceId}/files/{fileId}", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &DeleteServiceFileReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*DeleteServiceFileNoContent), nil + +} + +/* +DeleteServiceFiles Delete all files for a specific service +*/ +func (a *Client) DeleteServiceFiles(params *DeleteServiceFilesParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteServiceFilesNoContent, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewDeleteServiceFilesParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "DeleteServiceFiles", + Method: "DELETE", + PathPattern: "/services/{serviceId}/files", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &DeleteServiceFilesReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*DeleteServiceFilesNoContent), nil + +} + +/* +DeleteServiceProcess The deletion of an SL process results in the clean-up of the resources used by the process (e.g. deleting downloaded files, logs, parameter files, etc.) +*/ +func (a *Client) DeleteServiceProcess(params *DeleteServiceProcessParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteServiceProcessNoContent, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewDeleteServiceProcessParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "DeleteServiceProcess", + Method: "DELETE", + PathPattern: "/services/{serviceId}/processes/{processId}", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &DeleteServiceProcessReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*DeleteServiceProcessNoContent), nil + +} + +/* +GetMetadata Metadata, relevant to this SL process manager (Mandatory) +*/ +func (a *Client) GetMetadata(params *GetMetadataParams, authInfo runtime.ClientAuthInfoWriter) (*GetMetadataOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetMetadataParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetMetadata", + Method: "GET", + PathPattern: "/metadata", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetMetadataReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetMetadataOK), nil + +} + +/* +GetProcess get process API +*/ +func (a *Client) GetProcess(params *GetProcessParams, authInfo runtime.ClientAuthInfoWriter) (*GetProcessOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetProcessParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetProcess", + Method: "GET", + PathPattern: "/processes/{processId}", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetProcessReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetProcessOK), nil + +} + +/* +GetProcessService get process service API +*/ +func (a *Client) GetProcessService(params *GetProcessServiceParams, authInfo runtime.ClientAuthInfoWriter) (*GetProcessServiceOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetProcessServiceParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetProcessService", + Method: "GET", + PathPattern: "/processes/{processId}/service", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetProcessServiceReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetProcessServiceOK), nil + +} + +/* +GetProcesses Processes that are running in the particular process manager +*/ +func (a *Client) GetProcesses(params *GetProcessesParams, authInfo runtime.ClientAuthInfoWriter) (*GetProcessesOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetProcessesParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetProcesses", + Method: "GET", + PathPattern: "/processes", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetProcessesReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetProcessesOK), nil + +} + +/* +GetService get service API +*/ +func (a *Client) GetService(params *GetServiceParams, authInfo runtime.ClientAuthInfoWriter) (*GetServiceOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetServiceParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetService", + Method: "GET", + PathPattern: "/services/{serviceId}", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetServiceReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetServiceOK), nil + +} + +/* +GetServiceFiles get service files API +*/ +func (a *Client) GetServiceFiles(params *GetServiceFilesParams, authInfo runtime.ClientAuthInfoWriter) (*GetServiceFilesOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetServiceFilesParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetServiceFiles", + Method: "GET", + PathPattern: "/services/{serviceId}/files", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetServiceFilesReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetServiceFilesOK), nil + +} + +/* +GetServiceParameters get service parameters API +*/ +func (a *Client) GetServiceParameters(params *GetServiceParametersParams, authInfo runtime.ClientAuthInfoWriter) (*GetServiceParametersOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetServiceParametersParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetServiceParameters", + Method: "GET", + PathPattern: "/services/{serviceId}/parameters", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetServiceParametersReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetServiceParametersOK), nil + +} + +/* +GetServiceProcesses Retrieves the currently running and recently finished processes +*/ +func (a *Client) GetServiceProcesses(params *GetServiceProcessesParams, authInfo runtime.ClientAuthInfoWriter) (*GetServiceProcessesOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetServiceProcessesParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetServiceProcesses", + Method: "GET", + PathPattern: "/services/{serviceId}/processes", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetServiceProcessesReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetServiceProcessesOK), nil + +} + +/* +GetServiceVersions get service versions API +*/ +func (a *Client) GetServiceVersions(params *GetServiceVersionsParams, authInfo runtime.ClientAuthInfoWriter) (*GetServiceVersionsOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetServiceVersionsParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetServiceVersions", + Method: "GET", + PathPattern: "/services/{serviceId}/versions", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetServiceVersionsReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetServiceVersionsOK), nil + +} + +/* +GetServices Collection of metadata elements describing definitions of SL services known to a process manager (Mandatory) +*/ +func (a *Client) GetServices(params *GetServicesParams, authInfo runtime.ClientAuthInfoWriter) (*GetServicesOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetServicesParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetServices", + Method: "GET", + PathPattern: "/services", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetServicesReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + }) + if err != nil { + return nil, err + } + return result.(*GetServicesOK), nil + +} + +// SetTransport changes the transport on the client +func (a *Client) SetTransport(transport runtime.ClientTransport) { + a.transport = transport +} diff --git a/clients/slmpclient/retryable_slmp_client.go b/clients/slmpclient/retryable_slmp_client.go new file mode 100644 index 0000000..7c49569 --- /dev/null +++ b/clients/slmpclient/retryable_slmp_client.go @@ -0,0 +1,104 @@ +package slmpclient + +import ( + "net/http" + "os" + "time" + + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// RetryableSlmpClient represents a client for the SLMP protocol +type RetryableSlmpClient struct { + SlmpClient SlmpClientOperations + MaxRetriesCount int + RetryInterval time.Duration +} + +// NewRetryableSlmpClient creates a new retryable SLMP client +func NewRetryableSlmpClient(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) SlmpClientOperations { + slmpClient := NewSlmpClient(host, org, space, rt, jar, tokenFactory) + return RetryableSlmpClient{slmpClient, 3, time.Second * 3} +} + +// GetMetadata retrieves the SLMP metadata +func (c RetryableSlmpClient) GetMetadata() (*models.Metadata, error) { + getMetadataCb := func() (interface{}, error) { + return c.SlmpClient.GetMetadata() + } + resp, err := baseclient.CallWithRetry(getMetadataCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(*models.Metadata), err +} + +// GetServices retrieves all services +func (c RetryableSlmpClient) GetServices() (models.Services, error) { + getServicesCb := func() (interface{}, error) { + return c.SlmpClient.GetServices() + } + resp, err := baseclient.CallWithRetry(getServicesCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(models.Services), err +} + +// GetService retrieves the service with the specified service ID +func (c RetryableSlmpClient) GetService(serviceID string) (*models.Service, error) { + getServiceCb := func() (interface{}, error) { + return c.SlmpClient.GetService(serviceID) + } + resp, err := baseclient.CallWithRetry(getServiceCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(*models.Service), err +} + +// GetServiceProcesses retrieves all processes for the service with the specified service ID +func (c RetryableSlmpClient) GetServiceProcesses(serviceID string) (models.Processes, error) { + getServiceProcessesCb := func() (interface{}, error) { + return c.SlmpClient.GetServiceProcesses(serviceID) + } + resp, err := baseclient.CallWithRetry(getServiceProcessesCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(models.Processes), err +} + +// GetProcess retrieves process with the specified process ID +func (c RetryableSlmpClient) GetProcess(processID string) (*models.Process, error) { + getProcessCb := func() (interface{}, error) { + return c.SlmpClient.GetProcess(processID) + } + resp, err := baseclient.CallWithRetry(getProcessCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(*models.Process), err +} + +// GetServiceFiles retrieves all files for the service with the specified service ID +func (c RetryableSlmpClient) GetServiceFiles(serviceID string) (models.Files, error) { + getServiceFilesCb := func() (interface{}, error) { + return c.SlmpClient.GetServiceFiles(serviceID) + } + resp, err := baseclient.CallWithRetry(getServiceFilesCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(models.Files), err +} + +// CreateServiceFile uploads a file for the service with the specified service ID +func (c RetryableSlmpClient) CreateServiceFile(serviceID string, file os.File) (models.Files, error) { + createServiceFileCb := func() (interface{}, error) { + return c.SlmpClient.CreateServiceFile(serviceID, file) + } + resp, err := baseclient.CallWithRetry(createServiceFileCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(models.Files), err +} + +// CreateServiceProcess creates a process for the service with the specified service ID +func (c RetryableSlmpClient) CreateServiceProcess(serviceID string, process *models.Process) (*models.Process, error) { + createServiceProcessCb := func() (interface{}, error) { + return c.SlmpClient.CreateServiceProcess(serviceID, process) + } + resp, err := baseclient.CallWithRetry(createServiceProcessCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(*models.Process), err +} + +// GetServiceVersions retrieves the versions for the service with the specified service ID +func (c RetryableSlmpClient) GetServiceVersions(serviceID string) (models.Versions, error) { + getServiceVersionsCb := func() (interface{}, error) { + return c.SlmpClient.GetServiceVersions(serviceID) + } + resp, err := baseclient.CallWithRetry(getServiceVersionsCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(models.Versions), err +} diff --git a/clients/slmpclient/retryable_slmp_client_test.go b/clients/slmpclient/retryable_slmp_client_test.go new file mode 100644 index 0000000..06a3e10 --- /dev/null +++ b/clients/slmpclient/retryable_slmp_client_test.go @@ -0,0 +1,323 @@ +package slmpclient_test + +import ( + "net/http" + "net/http/cookiejar" + "os" + "time" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" + slmpclient "github.com/SAP/cf-mta-plugin/clients/slmpclient" + "github.com/SAP/cf-mta-plugin/testutil" +) + +var _ = Describe("RetryableSlmpClient", func() { + expectedRetriesCount := 4 + + Describe("GetMetadata", func() { + Context("with valid metadata returned by the backend", func() { + It("should return the metadata returned by the backend", func() { + client := newRetryableSlmpClient(200, testutil.SlmpMetadataResult) + result, err := client.GetMetadata() + testutil.ExpectNoErrorAndResult(err, result, &testutil.SlmpMetadataResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlmpClient(404, nil) + result, err := client.GetMetadata() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(500, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.GetMetadata() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(502, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.GetMetadata() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("GetServices", func() { + Context("with valid services returned by the backend", func() { + It("should return all services returned by the backend", func() { + client := newRetryableSlmpClient(200, testutil.ServicesResult) + result, err := client.GetServices() + testutil.ExpectNoErrorAndResult(err, result, testutil.ServicesResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlmpClient(404, nil) + result, err := client.GetServices() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(500, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.GetServices() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(502, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.GetServices() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("GetService", func() { + Context("with a valid service returned by the backend", func() { + It("should return the specific service returned by the backend", func() { + client := newRetryableSlmpClient(200, testutil.ServiceResult) + result, err := client.GetService(testutil.ServiceID) + testutil.ExpectNoErrorAndResult(err, result, &testutil.ServiceResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlmpClient(404, nil) + result, err := client.GetService(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(500, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.GetService(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(502, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.GetService(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("GetServiceProcesses", func() { + Context("with valid service processes returned by the backend", func() { + It("should return all service processes returned by the backend", func() { + client := newRetryableSlmpClient(200, testutil.ProcessesResult) + result, err := client.GetServiceProcesses(testutil.ServiceID) + testutil.ExpectNoErrorAndResult(err, result, testutil.ProcessesResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlmpClient(404, nil) + result, err := client.GetServiceProcesses(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(500, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.GetServiceProcesses(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(502, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.GetServiceProcesses(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("GetServiceFiles", func() { + Context("with valid service files returned by the backend", func() { + It("should return all service files returned by the backend", func() { + client := newRetryableSlmpClient(200, testutil.FilesResult) + result, err := client.GetServiceFiles("xs2-deploy") + testutil.ExpectNoErrorAndResult(err, result, testutil.FilesResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlmpClient(404, nil) + result, err := client.GetServiceFiles("xs2-deploy") + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(500, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.GetServiceFiles("xs2-deploy") + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(502, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.GetServiceFiles("xs2-deploy") + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("CreateServiceProcess", func() { + Context("with a valid newly created process retuned by the backend", func() { + It("should return the process returned by the backend", func() { + client := newRetryableSlmpClient(200, testutil.ProcessResult) + result, err := client.CreateServiceProcess(testutil.ServiceID, &testutil.ProcessResult) + testutil.ExpectNoErrorAndResult(err, result, &testutil.ProcessResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlmpClient(404, nil) + result, err := client.CreateServiceProcess(testutil.ServiceID, &testutil.ProcessResult) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(500, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.CreateServiceProcess(testutil.ServiceID, &testutil.ProcessResult) + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlmpClient(502, nil) + retryableSlmpClient := client.(slmpclient.RetryableSlmpClient) + result, err := retryableSlmpClient.CreateServiceProcess(testutil.ServiceID, &testutil.ProcessResult) + testutil.ExpectErrorAndZeroResult(err, result) + mockSlmpClient := retryableSlmpClient.SlmpClient.(*MockSlmpClient) + Expect(mockSlmpClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) +}) + +func newRetryableSlmpClient(statusCode int, v interface{}) slmpclient.SlmpClientOperations { + tokenFactory := baseclient.NewCustomTokenFactory("test-token") + cookieJar, _ := cookiejar.New(nil) + roundTripper := testutil.NewCustomTransport(statusCode, v) + return NewMockRetryableSlmpClient("http://localhost:1000", "test-org", "test-space", roundTripper, cookieJar, tokenFactory) +} + +// NewMockRetryableSlmpClient creates a new retryable REST client +func NewMockRetryableSlmpClient(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) slmpclient.SlmpClientOperations { + slmpClient := NewMockSlmpClient(host, org, space, rt, jar, tokenFactory) + return slmpclient.RetryableSlmpClient{SlmpClient: slmpClient, MaxRetriesCount: 3, RetryInterval: time.Microsecond * 1} +} + +type MockSlmpClient struct { + slmpClient slmpclient.SlmpClientOperations + retriesCount int +} + +// NewMockSlmpClient creates a new Rest client +func NewMockSlmpClient(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) slmpclient.SlmpClientOperations { + slmpClient := slmpclient.NewSlmpClient(host, org, space, rt, jar, tokenFactory) + return &MockSlmpClient{slmpClient, 0} +} + +// GetMetadata retrieves the SLMP metadata +func (c *MockSlmpClient) GetMetadata() (*models.Metadata, error) { + c.retriesCount++ + return c.slmpClient.GetMetadata() +} + +// GetServices retrieves all services +func (c *MockSlmpClient) GetServices() (models.Services, error) { + c.retriesCount++ + return c.slmpClient.GetServices() +} + +// GetService retrieves the service with the specified service ID +func (c *MockSlmpClient) GetService(serviceID string) (*models.Service, error) { + c.retriesCount++ + return c.slmpClient.GetService(serviceID) +} + +// GetServiceProcesses retrieves all processes for the service with the specified service ID +func (c *MockSlmpClient) GetServiceProcesses(serviceID string) (models.Processes, error) { + c.retriesCount++ + return c.slmpClient.GetServiceProcesses(serviceID) +} + +func (c *MockSlmpClient) GetProcess(processID string) (*models.Process, error) { + c.retriesCount++ + return c.slmpClient.GetProcess(processID) +} + +// GetServiceFiles retrieves all files for the service with the specified service ID +func (c *MockSlmpClient) GetServiceFiles(serviceID string) (models.Files, error) { + c.retriesCount++ + return c.slmpClient.GetServiceFiles(serviceID) +} + +// CreateServiceFile uploads a file for the service with the specified service ID +func (c *MockSlmpClient) CreateServiceFile(serviceID string, file os.File) (models.Files, error) { + c.retriesCount++ + return c.slmpClient.CreateServiceFile(serviceID, file) +} + +// CreateServiceProcess creates a process for the service with the specified service ID +func (c *MockSlmpClient) CreateServiceProcess(serviceID string, process *models.Process) (*models.Process, error) { + c.retriesCount++ + return c.slmpClient.CreateServiceProcess(serviceID, process) +} + +// GetServiceVersions retrieves the versions for the service with the specified service ID +func (c *MockSlmpClient) GetServiceVersions(serviceID string) (models.Versions, error) { + c.retriesCount++ + return c.slmpClient.GetServiceVersions(serviceID) +} + +// GetRetriesCount returns retries count +func (c *MockSlmpClient) GetRetriesCount() int { + return c.retriesCount +} diff --git a/clients/slmpclient/slmp_client.go b/clients/slmpclient/slmp_client.go new file mode 100644 index 0000000..e6a04e7 --- /dev/null +++ b/clients/slmpclient/slmp_client.go @@ -0,0 +1,182 @@ +package slmpclient + +import ( + "context" + "net/http" + "os" + + "github.com/go-openapi/strfmt" + + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" + "github.com/SAP/cf-mta-plugin/clients/slmpclient/operations" +) + +// SlmpClient represents a client for the SLMP protocol +type SlmpClient struct { + baseclient.BaseClient + Client *Slmp +} + +// NewSlmpClient creates a new SLMP client +func NewSlmpClient(host, org, space string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) SlmpClientOperations { + t := baseclient.NewHTTPTransport(host, getSlmpURL(org, space), rt, jar) + client := New(t, strfmt.Default) + return SlmpClient{baseclient.BaseClient{TokenFactory: tokenFactory}, client} +} + +// GetMetadata retrieves the SLMP metadata +func (c SlmpClient) GetMetadata() (*models.Metadata, error) { + params := &operations.GetMetadataParams{ + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return nil, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetMetadata(params, token) + if err != nil { + return nil, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +// GetServices retrieves all services +func (c SlmpClient) GetServices() (models.Services, error) { + params := &operations.GetServicesParams{ + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return models.Services{}, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetServices(params, token) + if err != nil { + return models.Services{}, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +// GetService retrieves the service with the specified service ID +func (c SlmpClient) GetService(serviceID string) (*models.Service, error) { + params := &operations.GetServiceParams{ + ServiceID: serviceID, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return nil, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetService(params, token) + if err != nil { + return nil, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +// GetServiceProcesses retrieves all processes for the service with the specified service ID +func (c SlmpClient) GetServiceProcesses(serviceID string) (models.Processes, error) { + params := &operations.GetServiceProcessesParams{ + ServiceID: serviceID, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return models.Processes{}, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetServiceProcesses(params, token) + if err != nil { + return models.Processes{}, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +func (c SlmpClient) GetProcess(processID string) (*models.Process, error) { + params := &operations.GetProcessParams{ + ProcessID: processID, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return nil, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetProcess(params, token) + if err != nil { + return nil, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +// GetServiceFiles retrieves all files for the service with the specified service ID +func (c SlmpClient) GetServiceFiles(serviceID string) (models.Files, error) { + params := &operations.GetServiceFilesParams{ + ServiceID: serviceID, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return models.Files{}, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetServiceFiles(params, token) + if err != nil { + return models.Files{}, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +// CreateServiceFile uploads a file for the service with the specified service ID +func (c SlmpClient) CreateServiceFile(serviceID string, file os.File) (models.Files, error) { + params := &operations.CreateServiceFilesParams{ + ServiceID: serviceID, + Files: file, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return models.Files{}, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.CreateServiceFiles(params, token) + if err != nil { + return models.Files{}, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +// CreateServiceProcess creates a process for the service with the specified service ID +func (c SlmpClient) CreateServiceProcess(serviceID string, process *models.Process) (*models.Process, error) { + params := &operations.CreateServiceProcessParams{ + ServiceID: serviceID, + Process: process, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return nil, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.CreateServiceProcess(params, token) + if err != nil { + return nil, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +// GetServiceVersions retrieves the versions for the service with the specified service ID +func (c SlmpClient) GetServiceVersions(serviceID string) (models.Versions, error) { + params := &operations.GetServiceVersionsParams{ + ServiceID: serviceID, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return models.Versions{}, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetServiceVersions(params, token) + if err != nil { + return models.Versions{}, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +func getSlmpURL(org, space string) string { + return "slprot/" + org + "/" + space + "/slp" +} diff --git a/clients/slmpclient/slmp_client_operations.go b/clients/slmpclient/slmp_client_operations.go new file mode 100644 index 0000000..2066d6f --- /dev/null +++ b/clients/slmpclient/slmp_client_operations.go @@ -0,0 +1,20 @@ +package slmpclient + +import ( + "os" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// SlmpClientOperations is an interface having all SlmpClient operations +type SlmpClientOperations interface { + GetMetadata() (*models.Metadata, error) + GetServices() (models.Services, error) + GetService(serviceID string) (*models.Service, error) + GetServiceProcesses(serviceID string) (models.Processes, error) + GetServiceFiles(serviceID string) (models.Files, error) + CreateServiceFile(serviceID string, file os.File) (models.Files, error) + CreateServiceProcess(serviceID string, process *models.Process) (*models.Process, error) + GetServiceVersions(serviceID string) (models.Versions, error) + GetProcess(processID string) (*models.Process, error) +} diff --git a/clients/slmpclient/slmp_client_test.go b/clients/slmpclient/slmp_client_test.go new file mode 100644 index 0000000..3ddce24 --- /dev/null +++ b/clients/slmpclient/slmp_client_test.go @@ -0,0 +1,122 @@ +package slmpclient_test + +import ( + "net/http/cookiejar" + + . "github.com/onsi/ginkgo" + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + slmpclient "github.com/SAP/cf-mta-plugin/clients/slmpclient" + "github.com/SAP/cf-mta-plugin/testutil" +) + +var _ = Describe("SlmpClient", func() { + + Describe("GetMetadata", func() { + Context("with valid metadata returned by the backend", func() { + It("should return the metadata returned by the backend", func() { + client := newSlmpClient(200, testutil.SlmpMetadataResult) + result, err := client.GetMetadata() + testutil.ExpectNoErrorAndResult(err, result, &testutil.SlmpMetadataResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlmpClient(404, nil) + result, err := client.GetMetadata() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("GetServices", func() { + Context("with valid services returned by the backend", func() { + It("should return all services returned by the backend", func() { + client := newSlmpClient(200, testutil.ServicesResult) + result, err := client.GetServices() + testutil.ExpectNoErrorAndResult(err, result, testutil.ServicesResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlmpClient(404, nil) + result, err := client.GetServices() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("GetService", func() { + Context("with a valid service returned by the backend", func() { + It("should return the specific service returned by the backend", func() { + client := newSlmpClient(200, testutil.ServiceResult) + result, err := client.GetService(testutil.ServiceID) + testutil.ExpectNoErrorAndResult(err, result, &testutil.ServiceResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlmpClient(404, nil) + result, err := client.GetService(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("GetServiceProcesses", func() { + Context("with valid service processes returned by the backend", func() { + It("should return all service processes returned by the backend", func() { + client := newSlmpClient(200, testutil.ProcessesResult) + result, err := client.GetServiceProcesses(testutil.ServiceID) + testutil.ExpectNoErrorAndResult(err, result, testutil.ProcessesResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlmpClient(404, nil) + result, err := client.GetServiceProcesses(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("GetServiceFiles", func() { + Context("with valid service files returned by the backend", func() { + It("should return all service files returned by the backend", func() { + client := newSlmpClient(200, testutil.FilesResult) + result, err := client.GetServiceFiles("xs2-deploy") + testutil.ExpectNoErrorAndResult(err, result, testutil.FilesResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlmpClient(404, nil) + result, err := client.GetServiceFiles("xs2-deploy") + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("CreateServiceProcess", func() { + Context("with a valid newly created process retuned by the backend", func() { + It("should return the process returned by the backend", func() { + client := newSlmpClient(200, testutil.ProcessResult) + result, err := client.CreateServiceProcess(testutil.ServiceID, &testutil.ProcessResult) + testutil.ExpectNoErrorAndResult(err, result, &testutil.ProcessResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlmpClient(404, nil) + result, err := client.CreateServiceProcess(testutil.ServiceID, &testutil.ProcessResult) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) +}) + +func newSlmpClient(statusCode int, v interface{}) slmpclient.SlmpClientOperations { + tokenFactory := baseclient.NewCustomTokenFactory("test-token") + cookieJar, _ := cookiejar.New(nil) + roundTripper := testutil.NewCustomTransport(statusCode, v) + return slmpclient.NewSlmpClient("http://localhost:1000", "test-org", "test-space", roundTripper, cookieJar, tokenFactory) +} diff --git a/clients/slmpclient/slmpclient_suite_test.go b/clients/slmpclient/slmpclient_suite_test.go new file mode 100644 index 0000000..1014f05 --- /dev/null +++ b/clients/slmpclient/slmpclient_suite_test.go @@ -0,0 +1,13 @@ +package slmpclient_test + +import ( + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "testing" +) + +func TestSlmpclient(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "Slmpclient Suite") +} diff --git a/clients/slppclient/fakes/fake_slpp_client_builder.go b/clients/slppclient/fakes/fake_slpp_client_builder.go new file mode 100644 index 0000000..08aba27 --- /dev/null +++ b/clients/slppclient/fakes/fake_slpp_client_builder.go @@ -0,0 +1,104 @@ +package fakes + +import models "github.com/SAP/cf-mta-plugin/clients/models" + +type logContentResult struct { + string + error +} + +// FakeSlppClientBuilder is a builder of FakeSlppClientOperations instances +type FakeSlppClientBuilder struct { + fakeSlppClient FakeSlppClientOperations + getLogContentResults map[string]logContentResult + executeActionResults map[string]error +} + +// NewFakeSlppClientBuilder creates a new builder +func NewFakeSlppClientBuilder() *FakeSlppClientBuilder { + return &FakeSlppClientBuilder{} +} + +// GetMetadata sets the metadata to return from the GetMetadata operation +func (b *FakeSlppClientBuilder) GetMetadata(metadata *models.Metadata, err error) *FakeSlppClientBuilder { + b.fakeSlppClient.GetMetadataReturns(metadata, err) + return b +} + +// GetLogs sets the logs to return from the GetLogs operation +func (b *FakeSlppClientBuilder) GetLogs(logs models.Logs, err error) *FakeSlppClientBuilder { + b.fakeSlppClient.GetLogsReturns(logs, err) + return b +} + +// GetLogContent sets the log content to return from the GetLogContent operation +func (b *FakeSlppClientBuilder) GetLogContent(logID string, logContent string, err error) *FakeSlppClientBuilder { + if logID == "" { + b.fakeSlppClient.GetLogContentReturns(logContent, err) + return b + } + if b.getLogContentResults == nil { + b.getLogContentResults = make(map[string]logContentResult) + } + b.getLogContentResults[logID] = logContentResult{logContent, err} + if b.fakeSlppClient.GetLogContentStub == nil { + b.fakeSlppClient.GetLogContentStub = func(arg0 string) (string, error) { + result := b.getLogContentResults[arg0] + return result.string, result.error + } + } + return b +} + +// GetTasklist sets the tasklist to return from the GetTasklist operation +func (b *FakeSlppClientBuilder) GetTasklist(tasklist models.Tasklist, err error) *FakeSlppClientBuilder { + b.fakeSlppClient.GetTasklistReturns(tasklist, err) + return b +} + +// GetTasklistTask sets the task to return from the GetTasklistTask operation +func (b *FakeSlppClientBuilder) GetTasklistTask(task *models.Task, err error) *FakeSlppClientBuilder { + b.fakeSlppClient.GetTasklistTaskReturns(task, err) + return b +} + +// GetServiceID sets the serviceID to return from the GetServiceID operation +func (b *FakeSlppClientBuilder) GetServiceID(serviceID string) *FakeSlppClientBuilder { + b.fakeSlppClient.GetServiceIDReturns(serviceID) + return b +} + +// GetError sets the error to return from the GetError operation +func (b *FakeSlppClientBuilder) GetError(errorx *models.Error, err error) *FakeSlppClientBuilder { + b.fakeSlppClient.GetErrorReturns(errorx, err) + return b +} + +// ExecuteAction sets the result to return from the ExecuteAction operation +func (b *FakeSlppClientBuilder) ExecuteAction(actionID string, err error) *FakeSlppClientBuilder { + if actionID == "" { + b.fakeSlppClient.ExecuteActionReturns(err) + return b + } + if b.executeActionResults == nil { + b.executeActionResults = make(map[string]error) + } + b.executeActionResults[actionID] = err + if b.fakeSlppClient.ExecuteActionStub == nil { + b.fakeSlppClient.ExecuteActionStub = func(arg0 string) error { + return b.executeActionResults[arg0] + } + } + return b +} + +// GetActions sets the actions to return from the GetActions operation +func (b *FakeSlppClientBuilder) GetActions(actions models.Actions, err error) *FakeSlppClientBuilder { + b.fakeSlppClient.GetActionsReturns(actions, err) + return b +} + +// Build builds a FakeSlppClientOperations instance +func (b *FakeSlppClientBuilder) Build() *FakeSlppClientOperations { + return &b.fakeSlppClient +} diff --git a/clients/slppclient/fakes/fake_slpp_client_operations.go b/clients/slppclient/fakes/fake_slpp_client_operations.go new file mode 100644 index 0000000..5cf002a --- /dev/null +++ b/clients/slppclient/fakes/fake_slpp_client_operations.go @@ -0,0 +1,318 @@ +// This file was generated by counterfeiter +package fakes + +import ( + "sync" + + models "github.com/SAP/cf-mta-plugin/clients/models" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" +) + +type FakeSlppClientOperations struct { + GetMetadataStub func() (*models.Metadata, error) + getMetadataMutex sync.RWMutex + getMetadataArgsForCall []struct{} + getMetadataReturns struct { + result1 *models.Metadata + result2 error + } + GetLogsStub func() (models.Logs, error) + getLogsMutex sync.RWMutex + getLogsArgsForCall []struct{} + getLogsReturns struct { + result1 models.Logs + result2 error + } + GetLogContentStub func(logID string) (string, error) + getLogContentMutex sync.RWMutex + getLogContentArgsForCall []struct { + logID string + } + getLogContentReturns struct { + result1 string + result2 error + } + GetTasklistStub func() (models.Tasklist, error) + getTasklistMutex sync.RWMutex + getTasklistArgsForCall []struct{} + getTasklistReturns struct { + result1 models.Tasklist + result2 error + } + GetTasklistTaskStub func(serviceID string) (*models.Task, error) + getTasklistTaskMutex sync.RWMutex + getTasklistTaskArgsForCall []struct{} + getTasklistTaskReturns struct { + result1 *models.Task + result2 error + } + GetServiceIDStub func() string + getServiceIDMutex sync.RWMutex + getServiceIDArgsForCall []struct{} + getServiceIDReturns struct { + result1 string + } + GetErrorStub func() (*models.Error, error) + getErrorMutex sync.RWMutex + getErrorArgsForCall []struct{} + getErrorReturns struct { + result1 *models.Error + result2 error + } + ExecuteActionStub func(actionID string) error + executeActionMutex sync.RWMutex + executeActionArgsForCall []struct { + actionID string + } + executeActionReturns struct { + result1 error + } + GetActionsStub func() (models.Actions, error) + getActionsMutex sync.RWMutex + getActionsArgsForCall []struct{} + getActionsReturns struct { + result1 models.Actions + result2 error + } +} + +func (fake *FakeSlppClientOperations) GetMetadata() (*models.Metadata, error) { + fake.getMetadataMutex.Lock() + fake.getMetadataArgsForCall = append(fake.getMetadataArgsForCall, struct{}{}) + fake.getMetadataMutex.Unlock() + if fake.GetMetadataStub != nil { + return fake.GetMetadataStub() + } else { + return fake.getMetadataReturns.result1, fake.getMetadataReturns.result2 + } +} + +func (fake *FakeSlppClientOperations) GetMetadataCallCount() int { + fake.getMetadataMutex.RLock() + defer fake.getMetadataMutex.RUnlock() + return len(fake.getMetadataArgsForCall) +} + +func (fake *FakeSlppClientOperations) GetMetadataReturns(result1 *models.Metadata, result2 error) { + fake.GetMetadataStub = nil + fake.getMetadataReturns = struct { + result1 *models.Metadata + result2 error + }{result1, result2} +} + +func (fake *FakeSlppClientOperations) GetLogs() (models.Logs, error) { + fake.getLogsMutex.Lock() + fake.getLogsArgsForCall = append(fake.getLogsArgsForCall, struct{}{}) + fake.getLogsMutex.Unlock() + if fake.GetLogsStub != nil { + return fake.GetLogsStub() + } else { + return fake.getLogsReturns.result1, fake.getLogsReturns.result2 + } +} + +func (fake *FakeSlppClientOperations) GetLogsCallCount() int { + fake.getLogsMutex.RLock() + defer fake.getLogsMutex.RUnlock() + return len(fake.getLogsArgsForCall) +} + +func (fake *FakeSlppClientOperations) GetLogsReturns(result1 models.Logs, result2 error) { + fake.GetLogsStub = nil + fake.getLogsReturns = struct { + result1 models.Logs + result2 error + }{result1, result2} +} + +func (fake *FakeSlppClientOperations) GetLogContent(logID string) (string, error) { + fake.getLogContentMutex.Lock() + fake.getLogContentArgsForCall = append(fake.getLogContentArgsForCall, struct { + logID string + }{logID}) + fake.getLogContentMutex.Unlock() + if fake.GetLogContentStub != nil { + return fake.GetLogContentStub(logID) + } else { + return fake.getLogContentReturns.result1, fake.getLogContentReturns.result2 + } +} + +func (fake *FakeSlppClientOperations) GetLogContentCallCount() int { + fake.getLogContentMutex.RLock() + defer fake.getLogContentMutex.RUnlock() + return len(fake.getLogContentArgsForCall) +} + +func (fake *FakeSlppClientOperations) GetLogContentArgsForCall(i int) string { + fake.getLogContentMutex.RLock() + defer fake.getLogContentMutex.RUnlock() + return fake.getLogContentArgsForCall[i].logID +} + +func (fake *FakeSlppClientOperations) GetLogContentReturns(result1 string, result2 error) { + fake.GetLogContentStub = nil + fake.getLogContentReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeSlppClientOperations) GetTasklist() (models.Tasklist, error) { + fake.getTasklistMutex.Lock() + fake.getTasklistArgsForCall = append(fake.getTasklistArgsForCall, struct{}{}) + fake.getTasklistMutex.Unlock() + if fake.GetTasklistStub != nil { + return fake.GetTasklistStub() + } else { + return fake.getTasklistReturns.result1, fake.getTasklistReturns.result2 + } +} + +func (fake *FakeSlppClientOperations) GetTasklistCallCount() int { + fake.getTasklistMutex.RLock() + defer fake.getTasklistMutex.RUnlock() + return len(fake.getTasklistArgsForCall) +} + +func (fake *FakeSlppClientOperations) GetTasklistReturns(result1 models.Tasklist, result2 error) { + fake.GetTasklistStub = nil + fake.getTasklistReturns = struct { + result1 models.Tasklist + result2 error + }{result1, result2} +} + +func (fake *FakeSlppClientOperations) GetTasklistTask(serviceID string) (*models.Task, error) { + fake.getTasklistTaskMutex.Lock() + fake.getTasklistTaskArgsForCall = append(fake.getTasklistTaskArgsForCall, struct{}{}) + fake.getTasklistTaskMutex.Unlock() + if fake.GetTasklistTaskStub != nil { + return fake.GetTasklistTaskStub(serviceID) + } else { + return fake.getTasklistTaskReturns.result1, fake.getTasklistTaskReturns.result2 + } +} + +func (fake *FakeSlppClientOperations) GetTasklistTaskCallCount() int { + fake.getTasklistTaskMutex.RLock() + defer fake.getTasklistTaskMutex.RUnlock() + return len(fake.getTasklistTaskArgsForCall) +} + +func (fake *FakeSlppClientOperations) GetTasklistTaskReturns(result1 *models.Task, result2 error) { + fake.GetTasklistTaskStub = nil + fake.getTasklistTaskReturns = struct { + result1 *models.Task + result2 error + }{result1, result2} +} + +func (fake *FakeSlppClientOperations) GetServiceID() string { + fake.getServiceIDMutex.Lock() + fake.getServiceIDArgsForCall = append(fake.getServiceIDArgsForCall, struct{}{}) + fake.getServiceIDMutex.Unlock() + if fake.GetServiceIDStub != nil { + return fake.GetServiceIDStub() + } else { + return fake.getServiceIDReturns.result1 + } +} + +func (fake *FakeSlppClientOperations) GetServiceIDCallCount() int { + fake.getServiceIDMutex.RLock() + defer fake.getServiceIDMutex.RUnlock() + return len(fake.getServiceIDArgsForCall) +} + +func (fake *FakeSlppClientOperations) GetServiceIDReturns(result1 string) { + fake.GetServiceIDStub = nil + fake.getServiceIDReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeSlppClientOperations) GetError() (*models.Error, error) { + fake.getErrorMutex.Lock() + fake.getErrorArgsForCall = append(fake.getErrorArgsForCall, struct{}{}) + fake.getErrorMutex.Unlock() + if fake.GetErrorStub != nil { + return fake.GetErrorStub() + } else { + return fake.getErrorReturns.result1, fake.getErrorReturns.result2 + } +} + +func (fake *FakeSlppClientOperations) GetErrorCallCount() int { + fake.getErrorMutex.RLock() + defer fake.getErrorMutex.RUnlock() + return len(fake.getErrorArgsForCall) +} + +func (fake *FakeSlppClientOperations) GetErrorReturns(result1 *models.Error, result2 error) { + fake.GetErrorStub = nil + fake.getErrorReturns = struct { + result1 *models.Error + result2 error + }{result1, result2} +} + +func (fake *FakeSlppClientOperations) ExecuteAction(actionID string) error { + fake.executeActionMutex.Lock() + fake.executeActionArgsForCall = append(fake.executeActionArgsForCall, struct { + actionID string + }{actionID}) + fake.executeActionMutex.Unlock() + if fake.ExecuteActionStub != nil { + return fake.ExecuteActionStub(actionID) + } else { + return fake.executeActionReturns.result1 + } +} + +func (fake *FakeSlppClientOperations) ExecuteActionCallCount() int { + fake.executeActionMutex.RLock() + defer fake.executeActionMutex.RUnlock() + return len(fake.executeActionArgsForCall) +} + +func (fake *FakeSlppClientOperations) ExecuteActionArgsForCall(i int) string { + fake.executeActionMutex.RLock() + defer fake.executeActionMutex.RUnlock() + return fake.executeActionArgsForCall[i].actionID +} + +func (fake *FakeSlppClientOperations) ExecuteActionReturns(result1 error) { + fake.ExecuteActionStub = nil + fake.executeActionReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeSlppClientOperations) GetActions() (models.Actions, error) { + fake.getActionsMutex.Lock() + fake.getActionsArgsForCall = append(fake.getActionsArgsForCall, struct{}{}) + fake.getActionsMutex.Unlock() + if fake.GetActionsStub != nil { + return fake.GetActionsStub() + } else { + return fake.getActionsReturns.result1, fake.getActionsReturns.result2 + } +} + +func (fake *FakeSlppClientOperations) GetActionsCallCount() int { + fake.getActionsMutex.RLock() + defer fake.getActionsMutex.RUnlock() + return len(fake.getActionsArgsForCall) +} + +func (fake *FakeSlppClientOperations) GetActionsReturns(result1 models.Actions, result2 error) { + fake.GetActionsStub = nil + fake.getActionsReturns = struct { + result1 models.Actions + result2 error + }{result1, result2} +} + +var _ slppclient.SlppClientOperations = new(FakeSlppClientOperations) diff --git a/clients/slppclient/http_slpp_client.go b/clients/slppclient/http_slpp_client.go new file mode 100644 index 0000000..532d361 --- /dev/null +++ b/clients/slppclient/http_slpp_client.go @@ -0,0 +1,115 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package slppclient + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "github.com/go-openapi/runtime" + httptransport "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/slppclient/operations" +) + +// Default slpp HTTP client. +var Default = NewHTTPClient(nil) + +const ( + // DefaultHost is the default Host + // found in Meta (info) section of spec file + DefaultHost string = "example.com" + // DefaultBasePath is the default BasePath + // found in Meta (info) section of spec file + DefaultBasePath string = "/slprot/slpp/" +) + +// DefaultSchemes are the default schemes found in Meta (info) section of spec file +var DefaultSchemes = []string{"http", "https"} + +// NewHTTPClient creates a new slpp HTTP client. +func NewHTTPClient(formats strfmt.Registry) *Slpp { + return NewHTTPClientWithConfig(formats, nil) +} + +// NewHTTPClientWithConfig creates a new slpp HTTP client, +// using a customizable transport config. +func NewHTTPClientWithConfig(formats strfmt.Registry, cfg *TransportConfig) *Slpp { + // ensure nullable parameters have default + if formats == nil { + formats = strfmt.Default + } + if cfg == nil { + cfg = DefaultTransportConfig() + } + + // create transport and client + transport := httptransport.New(cfg.Host, cfg.BasePath, cfg.Schemes) + return New(transport, formats) +} + +// New creates a new slpp client +func New(transport runtime.ClientTransport, formats strfmt.Registry) *Slpp { + cli := new(Slpp) + cli.Transport = transport + + cli.Operations = operations.New(transport, formats) + + return cli +} + +// DefaultTransportConfig creates a TransportConfig with the +// default settings taken from the meta section of the spec file. +func DefaultTransportConfig() *TransportConfig { + return &TransportConfig{ + Host: DefaultHost, + BasePath: DefaultBasePath, + Schemes: DefaultSchemes, + } +} + +// TransportConfig contains the transport related info, +// found in the meta section of the spec file. +type TransportConfig struct { + Host string + BasePath string + Schemes []string +} + +// WithHost overrides the default host, +// provided by the meta section of the spec file. +func (cfg *TransportConfig) WithHost(host string) *TransportConfig { + cfg.Host = host + return cfg +} + +// WithBasePath overrides the default basePath, +// provided by the meta section of the spec file. +func (cfg *TransportConfig) WithBasePath(basePath string) *TransportConfig { + cfg.BasePath = basePath + return cfg +} + +// WithSchemes overrides the default schemes, +// provided by the meta section of the spec file. +func (cfg *TransportConfig) WithSchemes(schemes []string) *TransportConfig { + cfg.Schemes = schemes + return cfg +} + +// Slpp is a client for slpp +type Slpp struct { + Operations *operations.Client + + Transport runtime.ClientTransport +} + +// SetTransport changes the transport on the client and all its subresources +func (c *Slpp) SetTransport(transport runtime.ClientTransport) { + c.Transport = transport + + c.Operations.SetTransport(transport) + +} diff --git a/clients/slppclient/operations/create_breakpoints_parameters.go b/clients/slppclient/operations/create_breakpoints_parameters.go new file mode 100644 index 0000000..d509e92 --- /dev/null +++ b/clients/slppclient/operations/create_breakpoints_parameters.go @@ -0,0 +1,109 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// NewCreateBreakpointsParams creates a new CreateBreakpointsParams object +// with the default values initialized. +func NewCreateBreakpointsParams() *CreateBreakpointsParams { + var () + return &CreateBreakpointsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewCreateBreakpointsParamsWithTimeout creates a new CreateBreakpointsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewCreateBreakpointsParamsWithTimeout(timeout time.Duration) *CreateBreakpointsParams { + var () + return &CreateBreakpointsParams{ + + timeout: timeout, + } +} + +// NewCreateBreakpointsParamsWithContext creates a new CreateBreakpointsParams object +// with the default values initialized, and the ability to set a context for a request +func NewCreateBreakpointsParamsWithContext(ctx context.Context) *CreateBreakpointsParams { + var () + return &CreateBreakpointsParams{ + + Context: ctx, + } +} + +/*CreateBreakpointsParams contains all the parameters to send to the API endpoint +for the create breakpoints operation typically these are written to a http.Request +*/ +type CreateBreakpointsParams struct { + + /*Breakpoints*/ + Breakpoints models.Breakpoints + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the create breakpoints params +func (o *CreateBreakpointsParams) WithTimeout(timeout time.Duration) *CreateBreakpointsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the create breakpoints params +func (o *CreateBreakpointsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the create breakpoints params +func (o *CreateBreakpointsParams) WithContext(ctx context.Context) *CreateBreakpointsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the create breakpoints params +func (o *CreateBreakpointsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithBreakpoints adds the breakpoints to the create breakpoints params +func (o *CreateBreakpointsParams) WithBreakpoints(breakpoints models.Breakpoints) *CreateBreakpointsParams { + o.SetBreakpoints(breakpoints) + return o +} + +// SetBreakpoints adds the breakpoints to the create breakpoints params +func (o *CreateBreakpointsParams) SetBreakpoints(breakpoints models.Breakpoints) { + o.Breakpoints = breakpoints +} + +// WriteToRequest writes these params to a swagger request +func (o *CreateBreakpointsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if err := r.SetBodyParam(o.Breakpoints); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/create_breakpoints_responses.go b/clients/slppclient/operations/create_breakpoints_responses.go new file mode 100644 index 0000000..f2ff90d --- /dev/null +++ b/clients/slppclient/operations/create_breakpoints_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// CreateBreakpointsReader is a Reader for the CreateBreakpoints structure. +type CreateBreakpointsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *CreateBreakpointsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewCreateBreakpointsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewCreateBreakpointsOK creates a CreateBreakpointsOK with default headers values +func NewCreateBreakpointsOK() *CreateBreakpointsOK { + return &CreateBreakpointsOK{} +} + +/*CreateBreakpointsOK handles this case with default header values. + +OK +*/ +type CreateBreakpointsOK struct { + Payload models.Breakpoints +} + +func (o *CreateBreakpointsOK) Error() string { + return fmt.Sprintf("[POST /breakpoints][%d] createBreakpointsOK %+v", 200, o.Payload) +} + +func (o *CreateBreakpointsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/create_config_parameters.go b/clients/slppclient/operations/create_config_parameters.go new file mode 100644 index 0000000..d7e9337 --- /dev/null +++ b/clients/slppclient/operations/create_config_parameters.go @@ -0,0 +1,109 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// NewCreateConfigParams creates a new CreateConfigParams object +// with the default values initialized. +func NewCreateConfigParams() *CreateConfigParams { + var () + return &CreateConfigParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewCreateConfigParamsWithTimeout creates a new CreateConfigParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewCreateConfigParamsWithTimeout(timeout time.Duration) *CreateConfigParams { + var () + return &CreateConfigParams{ + + timeout: timeout, + } +} + +// NewCreateConfigParamsWithContext creates a new CreateConfigParams object +// with the default values initialized, and the ability to set a context for a request +func NewCreateConfigParamsWithContext(ctx context.Context) *CreateConfigParams { + var () + return &CreateConfigParams{ + + Context: ctx, + } +} + +/*CreateConfigParams contains all the parameters to send to the API endpoint +for the create config operation typically these are written to a http.Request +*/ +type CreateConfigParams struct { + + /*Config*/ + Config models.Config + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the create config params +func (o *CreateConfigParams) WithTimeout(timeout time.Duration) *CreateConfigParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the create config params +func (o *CreateConfigParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the create config params +func (o *CreateConfigParams) WithContext(ctx context.Context) *CreateConfigParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the create config params +func (o *CreateConfigParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithConfig adds the config to the create config params +func (o *CreateConfigParams) WithConfig(config models.Config) *CreateConfigParams { + o.SetConfig(config) + return o +} + +// SetConfig adds the config to the create config params +func (o *CreateConfigParams) SetConfig(config models.Config) { + o.Config = config +} + +// WriteToRequest writes these params to a swagger request +func (o *CreateConfigParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if err := r.SetBodyParam(o.Config); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/create_config_responses.go b/clients/slppclient/operations/create_config_responses.go new file mode 100644 index 0000000..6633359 --- /dev/null +++ b/clients/slppclient/operations/create_config_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// CreateConfigReader is a Reader for the CreateConfig structure. +type CreateConfigReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *CreateConfigReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewCreateConfigOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewCreateConfigOK creates a CreateConfigOK with default headers values +func NewCreateConfigOK() *CreateConfigOK { + return &CreateConfigOK{} +} + +/*CreateConfigOK handles this case with default header values. + +Created +*/ +type CreateConfigOK struct { + Payload models.Config +} + +func (o *CreateConfigOK) Error() string { + return fmt.Sprintf("[POST /config][%d] createConfigOK %+v", 200, o.Payload) +} + +func (o *CreateConfigOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/execute_action_parameters.go b/clients/slppclient/operations/execute_action_parameters.go new file mode 100644 index 0000000..8f68f42 --- /dev/null +++ b/clients/slppclient/operations/execute_action_parameters.go @@ -0,0 +1,134 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewExecuteActionParams creates a new ExecuteActionParams object +// with the default values initialized. +func NewExecuteActionParams() *ExecuteActionParams { + var () + return &ExecuteActionParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewExecuteActionParamsWithTimeout creates a new ExecuteActionParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewExecuteActionParamsWithTimeout(timeout time.Duration) *ExecuteActionParams { + var () + return &ExecuteActionParams{ + + timeout: timeout, + } +} + +// NewExecuteActionParamsWithContext creates a new ExecuteActionParams object +// with the default values initialized, and the ability to set a context for a request +func NewExecuteActionParamsWithContext(ctx context.Context) *ExecuteActionParams { + var () + return &ExecuteActionParams{ + + Context: ctx, + } +} + +// NewExecuteActionParamsWithHTTPClient creates a new ExecuteActionParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewExecuteActionParamsWithHTTPClient(client *http.Client) *ExecuteActionParams { + var () + return &ExecuteActionParams{ + HTTPClient: client, + } +} + +/*ExecuteActionParams contains all the parameters to send to the API endpoint +for the execute action operation typically these are written to a http.Request +*/ +type ExecuteActionParams struct { + + /*ActionID*/ + ActionID string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the execute action params +func (o *ExecuteActionParams) WithTimeout(timeout time.Duration) *ExecuteActionParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the execute action params +func (o *ExecuteActionParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the execute action params +func (o *ExecuteActionParams) WithContext(ctx context.Context) *ExecuteActionParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the execute action params +func (o *ExecuteActionParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the execute action params +func (o *ExecuteActionParams) WithHTTPClient(client *http.Client) *ExecuteActionParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the execute action params +func (o *ExecuteActionParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithActionID adds the actionID to the execute action params +func (o *ExecuteActionParams) WithActionID(actionID string) *ExecuteActionParams { + o.SetActionID(actionID) + return o +} + +// SetActionID adds the actionId to the execute action params +func (o *ExecuteActionParams) SetActionID(actionID string) { + o.ActionID = actionID +} + +// WriteToRequest writes these params to a swagger request +func (o *ExecuteActionParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + // path param actionId + if err := r.SetPathParam("actionId", o.ActionID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/execute_action_responses.go b/clients/slppclient/operations/execute_action_responses.go new file mode 100644 index 0000000..772a19d --- /dev/null +++ b/clients/slppclient/operations/execute_action_responses.go @@ -0,0 +1,56 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" +) + +// ExecuteActionReader is a Reader for the ExecuteAction structure. +type ExecuteActionReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *ExecuteActionReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 204: + result := NewExecuteActionNoContent() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewExecuteActionNoContent creates a ExecuteActionNoContent with default headers values +func NewExecuteActionNoContent() *ExecuteActionNoContent { + return &ExecuteActionNoContent{} +} + +/*ExecuteActionNoContent handles this case with default header values. + +Executed +*/ +type ExecuteActionNoContent struct { +} + +func (o *ExecuteActionNoContent) Error() string { + return fmt.Sprintf("[POST /actions/{actionId}][%d] executeActionNoContent ", 204) +} + +func (o *ExecuteActionNoContent) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + return nil +} diff --git a/clients/slppclient/operations/get_action_parameters.go b/clients/slppclient/operations/get_action_parameters.go new file mode 100644 index 0000000..35d3fb0 --- /dev/null +++ b/clients/slppclient/operations/get_action_parameters.go @@ -0,0 +1,134 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetActionParams creates a new GetActionParams object +// with the default values initialized. +func NewGetActionParams() *GetActionParams { + var () + return &GetActionParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetActionParamsWithTimeout creates a new GetActionParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetActionParamsWithTimeout(timeout time.Duration) *GetActionParams { + var () + return &GetActionParams{ + + timeout: timeout, + } +} + +// NewGetActionParamsWithContext creates a new GetActionParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetActionParamsWithContext(ctx context.Context) *GetActionParams { + var () + return &GetActionParams{ + + Context: ctx, + } +} + +// NewGetActionParamsWithHTTPClient creates a new GetActionParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewGetActionParamsWithHTTPClient(client *http.Client) *GetActionParams { + var () + return &GetActionParams{ + HTTPClient: client, + } +} + +/*GetActionParams contains all the parameters to send to the API endpoint +for the get action operation typically these are written to a http.Request +*/ +type GetActionParams struct { + + /*ActionID*/ + ActionID string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the get action params +func (o *GetActionParams) WithTimeout(timeout time.Duration) *GetActionParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get action params +func (o *GetActionParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get action params +func (o *GetActionParams) WithContext(ctx context.Context) *GetActionParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get action params +func (o *GetActionParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get action params +func (o *GetActionParams) WithHTTPClient(client *http.Client) *GetActionParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get action params +func (o *GetActionParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithActionID adds the actionID to the get action params +func (o *GetActionParams) WithActionID(actionID string) *GetActionParams { + o.SetActionID(actionID) + return o +} + +// SetActionID adds the actionId to the get action params +func (o *GetActionParams) SetActionID(actionID string) { + o.ActionID = actionID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetActionParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + // path param actionId + if err := r.SetPathParam("actionId", o.ActionID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_action_responses.go b/clients/slppclient/operations/get_action_responses.go new file mode 100644 index 0000000..81e6b7a --- /dev/null +++ b/clients/slppclient/operations/get_action_responses.go @@ -0,0 +1,67 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetActionReader is a Reader for the GetAction structure. +type GetActionReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetActionReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetActionOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetActionOK creates a GetActionOK with default headers values +func NewGetActionOK() *GetActionOK { + return &GetActionOK{} +} + +/*GetActionOK handles this case with default header values. + +OK +*/ +type GetActionOK struct { + Payload *models.Action +} + +func (o *GetActionOK) Error() string { + return fmt.Sprintf("[GET /actions/{actionId}][%d] getActionOK %+v", 200, o.Payload) +} + +func (o *GetActionOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Action) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_actions_parameters.go b/clients/slppclient/operations/get_actions_parameters.go new file mode 100644 index 0000000..6a1ba40 --- /dev/null +++ b/clients/slppclient/operations/get_actions_parameters.go @@ -0,0 +1,114 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetActionsParams creates a new GetActionsParams object +// with the default values initialized. +func NewGetActionsParams() *GetActionsParams { + + return &GetActionsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetActionsParamsWithTimeout creates a new GetActionsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetActionsParamsWithTimeout(timeout time.Duration) *GetActionsParams { + + return &GetActionsParams{ + + timeout: timeout, + } +} + +// NewGetActionsParamsWithContext creates a new GetActionsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetActionsParamsWithContext(ctx context.Context) *GetActionsParams { + + return &GetActionsParams{ + + Context: ctx, + } +} + +// NewGetActionsParamsWithHTTPClient creates a new GetActionsParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewGetActionsParamsWithHTTPClient(client *http.Client) *GetActionsParams { + + return &GetActionsParams{ + HTTPClient: client, + } +} + +/*GetActionsParams contains all the parameters to send to the API endpoint +for the get actions operation typically these are written to a http.Request +*/ +type GetActionsParams struct { + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the get actions params +func (o *GetActionsParams) WithTimeout(timeout time.Duration) *GetActionsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get actions params +func (o *GetActionsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get actions params +func (o *GetActionsParams) WithContext(ctx context.Context) *GetActionsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get actions params +func (o *GetActionsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get actions params +func (o *GetActionsParams) WithHTTPClient(client *http.Client) *GetActionsParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get actions params +func (o *GetActionsParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WriteToRequest writes these params to a swagger request +func (o *GetActionsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_actions_responses.go b/clients/slppclient/operations/get_actions_responses.go new file mode 100644 index 0000000..a19e20c --- /dev/null +++ b/clients/slppclient/operations/get_actions_responses.go @@ -0,0 +1,65 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetActionsReader is a Reader for the GetActions structure. +type GetActionsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetActionsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetActionsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetActionsOK creates a GetActionsOK with default headers values +func NewGetActionsOK() *GetActionsOK { + return &GetActionsOK{} +} + +/*GetActionsOK handles this case with default header values. + +OK +*/ +type GetActionsOK struct { + Payload models.Actions +} + +func (o *GetActionsOK) Error() string { + return fmt.Sprintf("[GET /actions][%d] getActionsOK %+v", 200, o.Payload) +} + +func (o *GetActionsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_breakpoint_parameters.go b/clients/slppclient/operations/get_breakpoint_parameters.go new file mode 100644 index 0000000..00c6d15 --- /dev/null +++ b/clients/slppclient/operations/get_breakpoint_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetBreakpointParams creates a new GetBreakpointParams object +// with the default values initialized. +func NewGetBreakpointParams() *GetBreakpointParams { + var () + return &GetBreakpointParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetBreakpointParamsWithTimeout creates a new GetBreakpointParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetBreakpointParamsWithTimeout(timeout time.Duration) *GetBreakpointParams { + var () + return &GetBreakpointParams{ + + timeout: timeout, + } +} + +// NewGetBreakpointParamsWithContext creates a new GetBreakpointParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetBreakpointParamsWithContext(ctx context.Context) *GetBreakpointParams { + var () + return &GetBreakpointParams{ + + Context: ctx, + } +} + +/*GetBreakpointParams contains all the parameters to send to the API endpoint +for the get breakpoint operation typically these are written to a http.Request +*/ +type GetBreakpointParams struct { + + /*BreakpointID*/ + BreakpointID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get breakpoint params +func (o *GetBreakpointParams) WithTimeout(timeout time.Duration) *GetBreakpointParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get breakpoint params +func (o *GetBreakpointParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get breakpoint params +func (o *GetBreakpointParams) WithContext(ctx context.Context) *GetBreakpointParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get breakpoint params +func (o *GetBreakpointParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithBreakpointID adds the breakpointID to the get breakpoint params +func (o *GetBreakpointParams) WithBreakpointID(breakpointID string) *GetBreakpointParams { + o.SetBreakpointID(breakpointID) + return o +} + +// SetBreakpointID adds the breakpointId to the get breakpoint params +func (o *GetBreakpointParams) SetBreakpointID(breakpointID string) { + o.BreakpointID = breakpointID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetBreakpointParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param breakpointId + if err := r.SetPathParam("breakpointId", o.BreakpointID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_breakpoint_responses.go b/clients/slppclient/operations/get_breakpoint_responses.go new file mode 100644 index 0000000..d4e1036 --- /dev/null +++ b/clients/slppclient/operations/get_breakpoint_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetBreakpointReader is a Reader for the GetBreakpoint structure. +type GetBreakpointReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetBreakpointReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetBreakpointOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetBreakpointOK creates a GetBreakpointOK with default headers values +func NewGetBreakpointOK() *GetBreakpointOK { + return &GetBreakpointOK{} +} + +/*GetBreakpointOK handles this case with default header values. + +OK +*/ +type GetBreakpointOK struct { + Payload *models.Breakpoint +} + +func (o *GetBreakpointOK) Error() string { + return fmt.Sprintf("[GET /breakpoints/{breakpointId}][%d] getBreakpointOK %+v", 200, o.Payload) +} + +func (o *GetBreakpointOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Breakpoint) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_breakpoints_parameters.go b/clients/slppclient/operations/get_breakpoints_parameters.go new file mode 100644 index 0000000..7c0c96b --- /dev/null +++ b/clients/slppclient/operations/get_breakpoints_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetBreakpointsParams creates a new GetBreakpointsParams object +// with the default values initialized. +func NewGetBreakpointsParams() *GetBreakpointsParams { + + return &GetBreakpointsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetBreakpointsParamsWithTimeout creates a new GetBreakpointsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetBreakpointsParamsWithTimeout(timeout time.Duration) *GetBreakpointsParams { + + return &GetBreakpointsParams{ + + timeout: timeout, + } +} + +// NewGetBreakpointsParamsWithContext creates a new GetBreakpointsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetBreakpointsParamsWithContext(ctx context.Context) *GetBreakpointsParams { + + return &GetBreakpointsParams{ + + Context: ctx, + } +} + +/*GetBreakpointsParams contains all the parameters to send to the API endpoint +for the get breakpoints operation typically these are written to a http.Request +*/ +type GetBreakpointsParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get breakpoints params +func (o *GetBreakpointsParams) WithTimeout(timeout time.Duration) *GetBreakpointsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get breakpoints params +func (o *GetBreakpointsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get breakpoints params +func (o *GetBreakpointsParams) WithContext(ctx context.Context) *GetBreakpointsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get breakpoints params +func (o *GetBreakpointsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetBreakpointsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_breakpoints_responses.go b/clients/slppclient/operations/get_breakpoints_responses.go new file mode 100644 index 0000000..17e5b5e --- /dev/null +++ b/clients/slppclient/operations/get_breakpoints_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetBreakpointsReader is a Reader for the GetBreakpoints structure. +type GetBreakpointsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetBreakpointsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetBreakpointsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetBreakpointsOK creates a GetBreakpointsOK with default headers values +func NewGetBreakpointsOK() *GetBreakpointsOK { + return &GetBreakpointsOK{} +} + +/*GetBreakpointsOK handles this case with default header values. + +OK +*/ +type GetBreakpointsOK struct { + Payload models.Breakpoints +} + +func (o *GetBreakpointsOK) Error() string { + return fmt.Sprintf("[GET /breakpoints][%d] getBreakpointsOK %+v", 200, o.Payload) +} + +func (o *GetBreakpointsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_config_parameter_parameters.go b/clients/slppclient/operations/get_config_parameter_parameters.go new file mode 100644 index 0000000..81cfd36 --- /dev/null +++ b/clients/slppclient/operations/get_config_parameter_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetConfigParameterParams creates a new GetConfigParameterParams object +// with the default values initialized. +func NewGetConfigParameterParams() *GetConfigParameterParams { + var () + return &GetConfigParameterParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetConfigParameterParamsWithTimeout creates a new GetConfigParameterParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetConfigParameterParamsWithTimeout(timeout time.Duration) *GetConfigParameterParams { + var () + return &GetConfigParameterParams{ + + timeout: timeout, + } +} + +// NewGetConfigParameterParamsWithContext creates a new GetConfigParameterParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetConfigParameterParamsWithContext(ctx context.Context) *GetConfigParameterParams { + var () + return &GetConfigParameterParams{ + + Context: ctx, + } +} + +/*GetConfigParameterParams contains all the parameters to send to the API endpoint +for the get config parameter operation typically these are written to a http.Request +*/ +type GetConfigParameterParams struct { + + /*ParameterID*/ + ParameterID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get config parameter params +func (o *GetConfigParameterParams) WithTimeout(timeout time.Duration) *GetConfigParameterParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get config parameter params +func (o *GetConfigParameterParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get config parameter params +func (o *GetConfigParameterParams) WithContext(ctx context.Context) *GetConfigParameterParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get config parameter params +func (o *GetConfigParameterParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithParameterID adds the parameterID to the get config parameter params +func (o *GetConfigParameterParams) WithParameterID(parameterID string) *GetConfigParameterParams { + o.SetParameterID(parameterID) + return o +} + +// SetParameterID adds the parameterId to the get config parameter params +func (o *GetConfigParameterParams) SetParameterID(parameterID string) { + o.ParameterID = parameterID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetConfigParameterParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param parameterId + if err := r.SetPathParam("parameterId", o.ParameterID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_config_parameter_responses.go b/clients/slppclient/operations/get_config_parameter_responses.go new file mode 100644 index 0000000..a3664d1 --- /dev/null +++ b/clients/slppclient/operations/get_config_parameter_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetConfigParameterReader is a Reader for the GetConfigParameter structure. +type GetConfigParameterReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetConfigParameterReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetConfigParameterOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetConfigParameterOK creates a GetConfigParameterOK with default headers values +func NewGetConfigParameterOK() *GetConfigParameterOK { + return &GetConfigParameterOK{} +} + +/*GetConfigParameterOK handles this case with default header values. + +OK +*/ +type GetConfigParameterOK struct { + Payload *models.Parameter +} + +func (o *GetConfigParameterOK) Error() string { + return fmt.Sprintf("[GET /config/{parameterId}][%d] getConfigParameterOK %+v", 200, o.Payload) +} + +func (o *GetConfigParameterOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Parameter) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_config_parameters.go b/clients/slppclient/operations/get_config_parameters.go new file mode 100644 index 0000000..acab13f --- /dev/null +++ b/clients/slppclient/operations/get_config_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetConfigParams creates a new GetConfigParams object +// with the default values initialized. +func NewGetConfigParams() *GetConfigParams { + + return &GetConfigParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetConfigParamsWithTimeout creates a new GetConfigParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetConfigParamsWithTimeout(timeout time.Duration) *GetConfigParams { + + return &GetConfigParams{ + + timeout: timeout, + } +} + +// NewGetConfigParamsWithContext creates a new GetConfigParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetConfigParamsWithContext(ctx context.Context) *GetConfigParams { + + return &GetConfigParams{ + + Context: ctx, + } +} + +/*GetConfigParams contains all the parameters to send to the API endpoint +for the get config operation typically these are written to a http.Request +*/ +type GetConfigParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get config params +func (o *GetConfigParams) WithTimeout(timeout time.Duration) *GetConfigParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get config params +func (o *GetConfigParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get config params +func (o *GetConfigParams) WithContext(ctx context.Context) *GetConfigParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get config params +func (o *GetConfigParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetConfigParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_config_responses.go b/clients/slppclient/operations/get_config_responses.go new file mode 100644 index 0000000..8c63596 --- /dev/null +++ b/clients/slppclient/operations/get_config_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetConfigReader is a Reader for the GetConfig structure. +type GetConfigReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetConfigReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetConfigOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetConfigOK creates a GetConfigOK with default headers values +func NewGetConfigOK() *GetConfigOK { + return &GetConfigOK{} +} + +/*GetConfigOK handles this case with default header values. + +OK +*/ +type GetConfigOK struct { + Payload models.Config +} + +func (o *GetConfigOK) Error() string { + return fmt.Sprintf("[GET /config][%d] getConfigOK %+v", 200, o.Payload) +} + +func (o *GetConfigOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_current_breakpoint_parameters.go b/clients/slppclient/operations/get_current_breakpoint_parameters.go new file mode 100644 index 0000000..b0179bb --- /dev/null +++ b/clients/slppclient/operations/get_current_breakpoint_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetCurrentBreakpointParams creates a new GetCurrentBreakpointParams object +// with the default values initialized. +func NewGetCurrentBreakpointParams() *GetCurrentBreakpointParams { + var () + return &GetCurrentBreakpointParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetCurrentBreakpointParamsWithTimeout creates a new GetCurrentBreakpointParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetCurrentBreakpointParamsWithTimeout(timeout time.Duration) *GetCurrentBreakpointParams { + var () + return &GetCurrentBreakpointParams{ + + timeout: timeout, + } +} + +// NewGetCurrentBreakpointParamsWithContext creates a new GetCurrentBreakpointParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetCurrentBreakpointParamsWithContext(ctx context.Context) *GetCurrentBreakpointParams { + var () + return &GetCurrentBreakpointParams{ + + Context: ctx, + } +} + +/*GetCurrentBreakpointParams contains all the parameters to send to the API endpoint +for the get current breakpoint operation typically these are written to a http.Request +*/ +type GetCurrentBreakpointParams struct { + + /*CurrentBreakpointID*/ + CurrentBreakpointID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get current breakpoint params +func (o *GetCurrentBreakpointParams) WithTimeout(timeout time.Duration) *GetCurrentBreakpointParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get current breakpoint params +func (o *GetCurrentBreakpointParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get current breakpoint params +func (o *GetCurrentBreakpointParams) WithContext(ctx context.Context) *GetCurrentBreakpointParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get current breakpoint params +func (o *GetCurrentBreakpointParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithCurrentBreakpointID adds the currentBreakpointID to the get current breakpoint params +func (o *GetCurrentBreakpointParams) WithCurrentBreakpointID(currentBreakpointID string) *GetCurrentBreakpointParams { + o.SetCurrentBreakpointID(currentBreakpointID) + return o +} + +// SetCurrentBreakpointID adds the currentBreakpointId to the get current breakpoint params +func (o *GetCurrentBreakpointParams) SetCurrentBreakpointID(currentBreakpointID string) { + o.CurrentBreakpointID = currentBreakpointID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetCurrentBreakpointParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param currentBreakpointId + if err := r.SetPathParam("currentBreakpointId", o.CurrentBreakpointID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_current_breakpoint_responses.go b/clients/slppclient/operations/get_current_breakpoint_responses.go new file mode 100644 index 0000000..d5a8646 --- /dev/null +++ b/clients/slppclient/operations/get_current_breakpoint_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetCurrentBreakpointReader is a Reader for the GetCurrentBreakpoint structure. +type GetCurrentBreakpointReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetCurrentBreakpointReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetCurrentBreakpointOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetCurrentBreakpointOK creates a GetCurrentBreakpointOK with default headers values +func NewGetCurrentBreakpointOK() *GetCurrentBreakpointOK { + return &GetCurrentBreakpointOK{} +} + +/*GetCurrentBreakpointOK handles this case with default header values. + +OK +*/ +type GetCurrentBreakpointOK struct { + Payload *models.Breakpoint +} + +func (o *GetCurrentBreakpointOK) Error() string { + return fmt.Sprintf("[GET /currentBreakpoints/{currentBreakpointId}][%d] getCurrentBreakpointOK %+v", 200, o.Payload) +} + +func (o *GetCurrentBreakpointOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Breakpoint) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_current_breakpoints_parameters.go b/clients/slppclient/operations/get_current_breakpoints_parameters.go new file mode 100644 index 0000000..c4f2bae --- /dev/null +++ b/clients/slppclient/operations/get_current_breakpoints_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetCurrentBreakpointsParams creates a new GetCurrentBreakpointsParams object +// with the default values initialized. +func NewGetCurrentBreakpointsParams() *GetCurrentBreakpointsParams { + + return &GetCurrentBreakpointsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetCurrentBreakpointsParamsWithTimeout creates a new GetCurrentBreakpointsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetCurrentBreakpointsParamsWithTimeout(timeout time.Duration) *GetCurrentBreakpointsParams { + + return &GetCurrentBreakpointsParams{ + + timeout: timeout, + } +} + +// NewGetCurrentBreakpointsParamsWithContext creates a new GetCurrentBreakpointsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetCurrentBreakpointsParamsWithContext(ctx context.Context) *GetCurrentBreakpointsParams { + + return &GetCurrentBreakpointsParams{ + + Context: ctx, + } +} + +/*GetCurrentBreakpointsParams contains all the parameters to send to the API endpoint +for the get current breakpoints operation typically these are written to a http.Request +*/ +type GetCurrentBreakpointsParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get current breakpoints params +func (o *GetCurrentBreakpointsParams) WithTimeout(timeout time.Duration) *GetCurrentBreakpointsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get current breakpoints params +func (o *GetCurrentBreakpointsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get current breakpoints params +func (o *GetCurrentBreakpointsParams) WithContext(ctx context.Context) *GetCurrentBreakpointsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get current breakpoints params +func (o *GetCurrentBreakpointsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetCurrentBreakpointsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_current_breakpoints_responses.go b/clients/slppclient/operations/get_current_breakpoints_responses.go new file mode 100644 index 0000000..053a8b4 --- /dev/null +++ b/clients/slppclient/operations/get_current_breakpoints_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetCurrentBreakpointsReader is a Reader for the GetCurrentBreakpoints structure. +type GetCurrentBreakpointsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetCurrentBreakpointsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetCurrentBreakpointsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetCurrentBreakpointsOK creates a GetCurrentBreakpointsOK with default headers values +func NewGetCurrentBreakpointsOK() *GetCurrentBreakpointsOK { + return &GetCurrentBreakpointsOK{} +} + +/*GetCurrentBreakpointsOK handles this case with default header values. + +OK +*/ +type GetCurrentBreakpointsOK struct { + Payload models.Breakpoints +} + +func (o *GetCurrentBreakpointsOK) Error() string { + return fmt.Sprintf("[GET /currentBreakpoints][%d] getCurrentBreakpointsOK %+v", 200, o.Payload) +} + +func (o *GetCurrentBreakpointsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_dialog_parameters.go b/clients/slppclient/operations/get_dialog_parameters.go new file mode 100644 index 0000000..e64d850 --- /dev/null +++ b/clients/slppclient/operations/get_dialog_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetDialogParams creates a new GetDialogParams object +// with the default values initialized. +func NewGetDialogParams() *GetDialogParams { + var () + return &GetDialogParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetDialogParamsWithTimeout creates a new GetDialogParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetDialogParamsWithTimeout(timeout time.Duration) *GetDialogParams { + var () + return &GetDialogParams{ + + timeout: timeout, + } +} + +// NewGetDialogParamsWithContext creates a new GetDialogParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetDialogParamsWithContext(ctx context.Context) *GetDialogParams { + var () + return &GetDialogParams{ + + Context: ctx, + } +} + +/*GetDialogParams contains all the parameters to send to the API endpoint +for the get dialog operation typically these are written to a http.Request +*/ +type GetDialogParams struct { + + /*DialogID*/ + DialogID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get dialog params +func (o *GetDialogParams) WithTimeout(timeout time.Duration) *GetDialogParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get dialog params +func (o *GetDialogParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get dialog params +func (o *GetDialogParams) WithContext(ctx context.Context) *GetDialogParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get dialog params +func (o *GetDialogParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithDialogID adds the dialogID to the get dialog params +func (o *GetDialogParams) WithDialogID(dialogID string) *GetDialogParams { + o.SetDialogID(dialogID) + return o +} + +// SetDialogID adds the dialogId to the get dialog params +func (o *GetDialogParams) SetDialogID(dialogID string) { + o.DialogID = dialogID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetDialogParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param dialogId + if err := r.SetPathParam("dialogId", o.DialogID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_dialog_responses.go b/clients/slppclient/operations/get_dialog_responses.go new file mode 100644 index 0000000..a1b3013 --- /dev/null +++ b/clients/slppclient/operations/get_dialog_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetDialogReader is a Reader for the GetDialog structure. +type GetDialogReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetDialogReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetDialogOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetDialogOK creates a GetDialogOK with default headers values +func NewGetDialogOK() *GetDialogOK { + return &GetDialogOK{} +} + +/*GetDialogOK handles this case with default header values. + +OK +*/ +type GetDialogOK struct { + Payload *models.Dialog +} + +func (o *GetDialogOK) Error() string { + return fmt.Sprintf("[GET /dialogs/{dialogId}][%d] getDialogOK %+v", 200, o.Payload) +} + +func (o *GetDialogOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Dialog) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_dialogs_parameters.go b/clients/slppclient/operations/get_dialogs_parameters.go new file mode 100644 index 0000000..65a2c3b --- /dev/null +++ b/clients/slppclient/operations/get_dialogs_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetDialogsParams creates a new GetDialogsParams object +// with the default values initialized. +func NewGetDialogsParams() *GetDialogsParams { + + return &GetDialogsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetDialogsParamsWithTimeout creates a new GetDialogsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetDialogsParamsWithTimeout(timeout time.Duration) *GetDialogsParams { + + return &GetDialogsParams{ + + timeout: timeout, + } +} + +// NewGetDialogsParamsWithContext creates a new GetDialogsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetDialogsParamsWithContext(ctx context.Context) *GetDialogsParams { + + return &GetDialogsParams{ + + Context: ctx, + } +} + +/*GetDialogsParams contains all the parameters to send to the API endpoint +for the get dialogs operation typically these are written to a http.Request +*/ +type GetDialogsParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get dialogs params +func (o *GetDialogsParams) WithTimeout(timeout time.Duration) *GetDialogsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get dialogs params +func (o *GetDialogsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get dialogs params +func (o *GetDialogsParams) WithContext(ctx context.Context) *GetDialogsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get dialogs params +func (o *GetDialogsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetDialogsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_dialogs_responses.go b/clients/slppclient/operations/get_dialogs_responses.go new file mode 100644 index 0000000..a645d4c --- /dev/null +++ b/clients/slppclient/operations/get_dialogs_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetDialogsReader is a Reader for the GetDialogs structure. +type GetDialogsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetDialogsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetDialogsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetDialogsOK creates a GetDialogsOK with default headers values +func NewGetDialogsOK() *GetDialogsOK { + return &GetDialogsOK{} +} + +/*GetDialogsOK handles this case with default header values. + +OK +*/ +type GetDialogsOK struct { + Payload models.Dialogs +} + +func (o *GetDialogsOK) Error() string { + return fmt.Sprintf("[GET /dialogs][%d] getDialogsOK %+v", 200, o.Payload) +} + +func (o *GetDialogsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_error_parameters.go b/clients/slppclient/operations/get_error_parameters.go new file mode 100644 index 0000000..4efbd15 --- /dev/null +++ b/clients/slppclient/operations/get_error_parameters.go @@ -0,0 +1,114 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetErrorParams creates a new GetErrorParams object +// with the default values initialized. +func NewGetErrorParams() *GetErrorParams { + + return &GetErrorParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetErrorParamsWithTimeout creates a new GetErrorParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetErrorParamsWithTimeout(timeout time.Duration) *GetErrorParams { + + return &GetErrorParams{ + + timeout: timeout, + } +} + +// NewGetErrorParamsWithContext creates a new GetErrorParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetErrorParamsWithContext(ctx context.Context) *GetErrorParams { + + return &GetErrorParams{ + + Context: ctx, + } +} + +// NewGetErrorParamsWithHTTPClient creates a new GetErrorParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewGetErrorParamsWithHTTPClient(client *http.Client) *GetErrorParams { + + return &GetErrorParams{ + HTTPClient: client, + } +} + +/*GetErrorParams contains all the parameters to send to the API endpoint +for the get error operation typically these are written to a http.Request +*/ +type GetErrorParams struct { + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the get error params +func (o *GetErrorParams) WithTimeout(timeout time.Duration) *GetErrorParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get error params +func (o *GetErrorParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get error params +func (o *GetErrorParams) WithContext(ctx context.Context) *GetErrorParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get error params +func (o *GetErrorParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get error params +func (o *GetErrorParams) WithHTTPClient(client *http.Client) *GetErrorParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get error params +func (o *GetErrorParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WriteToRequest writes these params to a swagger request +func (o *GetErrorParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_error_responses.go b/clients/slppclient/operations/get_error_responses.go new file mode 100644 index 0000000..6f52083 --- /dev/null +++ b/clients/slppclient/operations/get_error_responses.go @@ -0,0 +1,67 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetErrorReader is a Reader for the GetError structure. +type GetErrorReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetErrorReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetErrorOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetErrorOK creates a GetErrorOK with default headers values +func NewGetErrorOK() *GetErrorOK { + return &GetErrorOK{} +} + +/*GetErrorOK handles this case with default header values. + +OK +*/ +type GetErrorOK struct { + Payload *models.Error +} + +func (o *GetErrorOK) Error() string { + return fmt.Sprintf("[GET /error][%d] getErrorOK %+v", 200, o.Payload) +} + +func (o *GetErrorOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_log_content_parameters.go b/clients/slppclient/operations/get_log_content_parameters.go new file mode 100644 index 0000000..68e5b47 --- /dev/null +++ b/clients/slppclient/operations/get_log_content_parameters.go @@ -0,0 +1,134 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetLogContentParams creates a new GetLogContentParams object +// with the default values initialized. +func NewGetLogContentParams() *GetLogContentParams { + var () + return &GetLogContentParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetLogContentParamsWithTimeout creates a new GetLogContentParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetLogContentParamsWithTimeout(timeout time.Duration) *GetLogContentParams { + var () + return &GetLogContentParams{ + + timeout: timeout, + } +} + +// NewGetLogContentParamsWithContext creates a new GetLogContentParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetLogContentParamsWithContext(ctx context.Context) *GetLogContentParams { + var () + return &GetLogContentParams{ + + Context: ctx, + } +} + +// NewGetLogContentParamsWithHTTPClient creates a new GetLogContentParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewGetLogContentParamsWithHTTPClient(client *http.Client) *GetLogContentParams { + var () + return &GetLogContentParams{ + HTTPClient: client, + } +} + +/*GetLogContentParams contains all the parameters to send to the API endpoint +for the get log content operation typically these are written to a http.Request +*/ +type GetLogContentParams struct { + + /*LogID*/ + LogID string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the get log content params +func (o *GetLogContentParams) WithTimeout(timeout time.Duration) *GetLogContentParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get log content params +func (o *GetLogContentParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get log content params +func (o *GetLogContentParams) WithContext(ctx context.Context) *GetLogContentParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get log content params +func (o *GetLogContentParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get log content params +func (o *GetLogContentParams) WithHTTPClient(client *http.Client) *GetLogContentParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get log content params +func (o *GetLogContentParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithLogID adds the logID to the get log content params +func (o *GetLogContentParams) WithLogID(logID string) *GetLogContentParams { + o.SetLogID(logID) + return o +} + +// SetLogID adds the logId to the get log content params +func (o *GetLogContentParams) SetLogID(logID string) { + o.LogID = logID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetLogContentParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + // path param logId + if err := r.SetPathParam("logId", o.LogID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_log_content_responses.go b/clients/slppclient/operations/get_log_content_responses.go new file mode 100644 index 0000000..ad12319 --- /dev/null +++ b/clients/slppclient/operations/get_log_content_responses.go @@ -0,0 +1,63 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" +) + +// GetLogContentReader is a Reader for the GetLogContent structure. +type GetLogContentReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetLogContentReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetLogContentOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetLogContentOK creates a GetLogContentOK with default headers values +func NewGetLogContentOK() *GetLogContentOK { + return &GetLogContentOK{} +} + +/*GetLogContentOK handles this case with default header values. + +OK +*/ +type GetLogContentOK struct { + Payload string +} + +func (o *GetLogContentOK) Error() string { + return fmt.Sprintf("[GET /logs/{logId}/content][%d] getLogContentOK %+v", 200, o.Payload) +} + +func (o *GetLogContentOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_log_parameters.go b/clients/slppclient/operations/get_log_parameters.go new file mode 100644 index 0000000..0a91df8 --- /dev/null +++ b/clients/slppclient/operations/get_log_parameters.go @@ -0,0 +1,134 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetLogParams creates a new GetLogParams object +// with the default values initialized. +func NewGetLogParams() *GetLogParams { + var () + return &GetLogParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetLogParamsWithTimeout creates a new GetLogParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetLogParamsWithTimeout(timeout time.Duration) *GetLogParams { + var () + return &GetLogParams{ + + timeout: timeout, + } +} + +// NewGetLogParamsWithContext creates a new GetLogParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetLogParamsWithContext(ctx context.Context) *GetLogParams { + var () + return &GetLogParams{ + + Context: ctx, + } +} + +// NewGetLogParamsWithHTTPClient creates a new GetLogParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewGetLogParamsWithHTTPClient(client *http.Client) *GetLogParams { + var () + return &GetLogParams{ + HTTPClient: client, + } +} + +/*GetLogParams contains all the parameters to send to the API endpoint +for the get log operation typically these are written to a http.Request +*/ +type GetLogParams struct { + + /*LogID*/ + LogID string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the get log params +func (o *GetLogParams) WithTimeout(timeout time.Duration) *GetLogParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get log params +func (o *GetLogParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get log params +func (o *GetLogParams) WithContext(ctx context.Context) *GetLogParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get log params +func (o *GetLogParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get log params +func (o *GetLogParams) WithHTTPClient(client *http.Client) *GetLogParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get log params +func (o *GetLogParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithLogID adds the logID to the get log params +func (o *GetLogParams) WithLogID(logID string) *GetLogParams { + o.SetLogID(logID) + return o +} + +// SetLogID adds the logId to the get log params +func (o *GetLogParams) SetLogID(logID string) { + o.LogID = logID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetLogParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + // path param logId + if err := r.SetPathParam("logId", o.LogID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_log_responses.go b/clients/slppclient/operations/get_log_responses.go new file mode 100644 index 0000000..f52ef21 --- /dev/null +++ b/clients/slppclient/operations/get_log_responses.go @@ -0,0 +1,67 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetLogReader is a Reader for the GetLog structure. +type GetLogReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetLogReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetLogOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetLogOK creates a GetLogOK with default headers values +func NewGetLogOK() *GetLogOK { + return &GetLogOK{} +} + +/*GetLogOK handles this case with default header values. + +OK +*/ +type GetLogOK struct { + Payload *models.Log +} + +func (o *GetLogOK) Error() string { + return fmt.Sprintf("[GET /logs/{logId}][%d] getLogOK %+v", 200, o.Payload) +} + +func (o *GetLogOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Log) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_logs_parameters.go b/clients/slppclient/operations/get_logs_parameters.go new file mode 100644 index 0000000..0978204 --- /dev/null +++ b/clients/slppclient/operations/get_logs_parameters.go @@ -0,0 +1,114 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetLogsParams creates a new GetLogsParams object +// with the default values initialized. +func NewGetLogsParams() *GetLogsParams { + + return &GetLogsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetLogsParamsWithTimeout creates a new GetLogsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetLogsParamsWithTimeout(timeout time.Duration) *GetLogsParams { + + return &GetLogsParams{ + + timeout: timeout, + } +} + +// NewGetLogsParamsWithContext creates a new GetLogsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetLogsParamsWithContext(ctx context.Context) *GetLogsParams { + + return &GetLogsParams{ + + Context: ctx, + } +} + +// NewGetLogsParamsWithHTTPClient creates a new GetLogsParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewGetLogsParamsWithHTTPClient(client *http.Client) *GetLogsParams { + + return &GetLogsParams{ + HTTPClient: client, + } +} + +/*GetLogsParams contains all the parameters to send to the API endpoint +for the get logs operation typically these are written to a http.Request +*/ +type GetLogsParams struct { + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the get logs params +func (o *GetLogsParams) WithTimeout(timeout time.Duration) *GetLogsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get logs params +func (o *GetLogsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get logs params +func (o *GetLogsParams) WithContext(ctx context.Context) *GetLogsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get logs params +func (o *GetLogsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get logs params +func (o *GetLogsParams) WithHTTPClient(client *http.Client) *GetLogsParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get logs params +func (o *GetLogsParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WriteToRequest writes these params to a swagger request +func (o *GetLogsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_logs_responses.go b/clients/slppclient/operations/get_logs_responses.go new file mode 100644 index 0000000..84cd24b --- /dev/null +++ b/clients/slppclient/operations/get_logs_responses.go @@ -0,0 +1,65 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetLogsReader is a Reader for the GetLogs structure. +type GetLogsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetLogsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetLogsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetLogsOK creates a GetLogsOK with default headers values +func NewGetLogsOK() *GetLogsOK { + return &GetLogsOK{} +} + +/*GetLogsOK handles this case with default header values. + +OK +*/ +type GetLogsOK struct { + Payload models.Logs +} + +func (o *GetLogsOK) Error() string { + return fmt.Sprintf("[GET /logs][%d] getLogsOK %+v", 200, o.Payload) +} + +func (o *GetLogsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_meta_dialogs_parameters.go b/clients/slppclient/operations/get_meta_dialogs_parameters.go new file mode 100644 index 0000000..ac0f993 --- /dev/null +++ b/clients/slppclient/operations/get_meta_dialogs_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetMetaDialogsParams creates a new GetMetaDialogsParams object +// with the default values initialized. +func NewGetMetaDialogsParams() *GetMetaDialogsParams { + var () + return &GetMetaDialogsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetMetaDialogsParamsWithTimeout creates a new GetMetaDialogsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetMetaDialogsParamsWithTimeout(timeout time.Duration) *GetMetaDialogsParams { + var () + return &GetMetaDialogsParams{ + + timeout: timeout, + } +} + +// NewGetMetaDialogsParamsWithContext creates a new GetMetaDialogsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetMetaDialogsParamsWithContext(ctx context.Context) *GetMetaDialogsParams { + var () + return &GetMetaDialogsParams{ + + Context: ctx, + } +} + +/*GetMetaDialogsParams contains all the parameters to send to the API endpoint +for the get meta dialogs operation typically these are written to a http.Request +*/ +type GetMetaDialogsParams struct { + + /*MetaDialogURL*/ + MetaDialogURL string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get meta dialogs params +func (o *GetMetaDialogsParams) WithTimeout(timeout time.Duration) *GetMetaDialogsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get meta dialogs params +func (o *GetMetaDialogsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get meta dialogs params +func (o *GetMetaDialogsParams) WithContext(ctx context.Context) *GetMetaDialogsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get meta dialogs params +func (o *GetMetaDialogsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithMetaDialogURL adds the metaDialogURL to the get meta dialogs params +func (o *GetMetaDialogsParams) WithMetaDialogURL(metaDialogURL string) *GetMetaDialogsParams { + o.SetMetaDialogURL(metaDialogURL) + return o +} + +// SetMetaDialogURL adds the metaDialogUrl to the get meta dialogs params +func (o *GetMetaDialogsParams) SetMetaDialogURL(metaDialogURL string) { + o.MetaDialogURL = metaDialogURL +} + +// WriteToRequest writes these params to a swagger request +func (o *GetMetaDialogsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param metaDialogURL + if err := r.SetPathParam("metaDialogURL", o.MetaDialogURL); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_meta_dialogs_responses.go b/clients/slppclient/operations/get_meta_dialogs_responses.go new file mode 100644 index 0000000..25a8d9a --- /dev/null +++ b/clients/slppclient/operations/get_meta_dialogs_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetMetaDialogsReader is a Reader for the GetMetaDialogs structure. +type GetMetaDialogsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetMetaDialogsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetMetaDialogsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetMetaDialogsOK creates a GetMetaDialogsOK with default headers values +func NewGetMetaDialogsOK() *GetMetaDialogsOK { + return &GetMetaDialogsOK{} +} + +/*GetMetaDialogsOK handles this case with default header values. + +OK +*/ +type GetMetaDialogsOK struct { + Payload models.MetaDialogs +} + +func (o *GetMetaDialogsOK) Error() string { + return fmt.Sprintf("[GET /dialogs/{metaDialogURL}][%d] getMetaDialogsOK %+v", 200, o.Payload) +} + +func (o *GetMetaDialogsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_metadata_parameters.go b/clients/slppclient/operations/get_metadata_parameters.go new file mode 100644 index 0000000..1f685a0 --- /dev/null +++ b/clients/slppclient/operations/get_metadata_parameters.go @@ -0,0 +1,114 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetMetadataParams creates a new GetMetadataParams object +// with the default values initialized. +func NewGetMetadataParams() *GetMetadataParams { + + return &GetMetadataParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetMetadataParamsWithTimeout creates a new GetMetadataParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetMetadataParamsWithTimeout(timeout time.Duration) *GetMetadataParams { + + return &GetMetadataParams{ + + timeout: timeout, + } +} + +// NewGetMetadataParamsWithContext creates a new GetMetadataParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetMetadataParamsWithContext(ctx context.Context) *GetMetadataParams { + + return &GetMetadataParams{ + + Context: ctx, + } +} + +// NewGetMetadataParamsWithHTTPClient creates a new GetMetadataParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewGetMetadataParamsWithHTTPClient(client *http.Client) *GetMetadataParams { + + return &GetMetadataParams{ + HTTPClient: client, + } +} + +/*GetMetadataParams contains all the parameters to send to the API endpoint +for the get metadata operation typically these are written to a http.Request +*/ +type GetMetadataParams struct { + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the get metadata params +func (o *GetMetadataParams) WithTimeout(timeout time.Duration) *GetMetadataParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get metadata params +func (o *GetMetadataParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get metadata params +func (o *GetMetadataParams) WithContext(ctx context.Context) *GetMetadataParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get metadata params +func (o *GetMetadataParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get metadata params +func (o *GetMetadataParams) WithHTTPClient(client *http.Client) *GetMetadataParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get metadata params +func (o *GetMetadataParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WriteToRequest writes these params to a swagger request +func (o *GetMetadataParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_metadata_responses.go b/clients/slppclient/operations/get_metadata_responses.go new file mode 100644 index 0000000..5c78734 --- /dev/null +++ b/clients/slppclient/operations/get_metadata_responses.go @@ -0,0 +1,67 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetMetadataReader is a Reader for the GetMetadata structure. +type GetMetadataReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetMetadataReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetMetadataOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetMetadataOK creates a GetMetadataOK with default headers values +func NewGetMetadataOK() *GetMetadataOK { + return &GetMetadataOK{} +} + +/*GetMetadataOK handles this case with default header values. + +OK +*/ +type GetMetadataOK struct { + Payload *models.Metadata +} + +func (o *GetMetadataOK) Error() string { + return fmt.Sprintf("[GET /metadata][%d] getMetadataOK %+v", 200, o.Payload) +} + +func (o *GetMetadataOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Metadata) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_monitor_parameters.go b/clients/slppclient/operations/get_monitor_parameters.go new file mode 100644 index 0000000..b89d729 --- /dev/null +++ b/clients/slppclient/operations/get_monitor_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetMonitorParams creates a new GetMonitorParams object +// with the default values initialized. +func NewGetMonitorParams() *GetMonitorParams { + + return &GetMonitorParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetMonitorParamsWithTimeout creates a new GetMonitorParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetMonitorParamsWithTimeout(timeout time.Duration) *GetMonitorParams { + + return &GetMonitorParams{ + + timeout: timeout, + } +} + +// NewGetMonitorParamsWithContext creates a new GetMonitorParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetMonitorParamsWithContext(ctx context.Context) *GetMonitorParams { + + return &GetMonitorParams{ + + Context: ctx, + } +} + +/*GetMonitorParams contains all the parameters to send to the API endpoint +for the get monitor operation typically these are written to a http.Request +*/ +type GetMonitorParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get monitor params +func (o *GetMonitorParams) WithTimeout(timeout time.Duration) *GetMonitorParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get monitor params +func (o *GetMonitorParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get monitor params +func (o *GetMonitorParams) WithContext(ctx context.Context) *GetMonitorParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get monitor params +func (o *GetMonitorParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetMonitorParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_monitor_responses.go b/clients/slppclient/operations/get_monitor_responses.go new file mode 100644 index 0000000..14af747 --- /dev/null +++ b/clients/slppclient/operations/get_monitor_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetMonitorReader is a Reader for the GetMonitor structure. +type GetMonitorReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetMonitorReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetMonitorOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetMonitorOK creates a GetMonitorOK with default headers values +func NewGetMonitorOK() *GetMonitorOK { + return &GetMonitorOK{} +} + +/*GetMonitorOK handles this case with default header values. + +OK +*/ +type GetMonitorOK struct { + Payload models.Monitor +} + +func (o *GetMonitorOK) Error() string { + return fmt.Sprintf("[GET /monitor][%d] getMonitorOK %+v", 200, o.Payload) +} + +func (o *GetMonitorOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_monitor_task_error_parameters.go b/clients/slppclient/operations/get_monitor_task_error_parameters.go new file mode 100644 index 0000000..bd9f3db --- /dev/null +++ b/clients/slppclient/operations/get_monitor_task_error_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetMonitorTaskErrorParams creates a new GetMonitorTaskErrorParams object +// with the default values initialized. +func NewGetMonitorTaskErrorParams() *GetMonitorTaskErrorParams { + var () + return &GetMonitorTaskErrorParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetMonitorTaskErrorParamsWithTimeout creates a new GetMonitorTaskErrorParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetMonitorTaskErrorParamsWithTimeout(timeout time.Duration) *GetMonitorTaskErrorParams { + var () + return &GetMonitorTaskErrorParams{ + + timeout: timeout, + } +} + +// NewGetMonitorTaskErrorParamsWithContext creates a new GetMonitorTaskErrorParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetMonitorTaskErrorParamsWithContext(ctx context.Context) *GetMonitorTaskErrorParams { + var () + return &GetMonitorTaskErrorParams{ + + Context: ctx, + } +} + +/*GetMonitorTaskErrorParams contains all the parameters to send to the API endpoint +for the get monitor task error operation typically these are written to a http.Request +*/ +type GetMonitorTaskErrorParams struct { + + /*TaskID*/ + TaskID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get monitor task error params +func (o *GetMonitorTaskErrorParams) WithTimeout(timeout time.Duration) *GetMonitorTaskErrorParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get monitor task error params +func (o *GetMonitorTaskErrorParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get monitor task error params +func (o *GetMonitorTaskErrorParams) WithContext(ctx context.Context) *GetMonitorTaskErrorParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get monitor task error params +func (o *GetMonitorTaskErrorParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithTaskID adds the taskID to the get monitor task error params +func (o *GetMonitorTaskErrorParams) WithTaskID(taskID string) *GetMonitorTaskErrorParams { + o.SetTaskID(taskID) + return o +} + +// SetTaskID adds the taskId to the get monitor task error params +func (o *GetMonitorTaskErrorParams) SetTaskID(taskID string) { + o.TaskID = taskID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetMonitorTaskErrorParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param taskId + if err := r.SetPathParam("taskId", o.TaskID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_monitor_task_error_responses.go b/clients/slppclient/operations/get_monitor_task_error_responses.go new file mode 100644 index 0000000..a280c34 --- /dev/null +++ b/clients/slppclient/operations/get_monitor_task_error_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetMonitorTaskErrorReader is a Reader for the GetMonitorTaskError structure. +type GetMonitorTaskErrorReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetMonitorTaskErrorReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetMonitorTaskErrorOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetMonitorTaskErrorOK creates a GetMonitorTaskErrorOK with default headers values +func NewGetMonitorTaskErrorOK() *GetMonitorTaskErrorOK { + return &GetMonitorTaskErrorOK{} +} + +/*GetMonitorTaskErrorOK handles this case with default header values. + +OK +*/ +type GetMonitorTaskErrorOK struct { + Payload *models.Error +} + +func (o *GetMonitorTaskErrorOK) Error() string { + return fmt.Sprintf("[GET /monitor/{taskId}/error][%d] getMonitorTaskErrorOK %+v", 200, o.Payload) +} + +func (o *GetMonitorTaskErrorOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_monitor_task_logs_parameters.go b/clients/slppclient/operations/get_monitor_task_logs_parameters.go new file mode 100644 index 0000000..92457ac --- /dev/null +++ b/clients/slppclient/operations/get_monitor_task_logs_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetMonitorTaskLogsParams creates a new GetMonitorTaskLogsParams object +// with the default values initialized. +func NewGetMonitorTaskLogsParams() *GetMonitorTaskLogsParams { + var () + return &GetMonitorTaskLogsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetMonitorTaskLogsParamsWithTimeout creates a new GetMonitorTaskLogsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetMonitorTaskLogsParamsWithTimeout(timeout time.Duration) *GetMonitorTaskLogsParams { + var () + return &GetMonitorTaskLogsParams{ + + timeout: timeout, + } +} + +// NewGetMonitorTaskLogsParamsWithContext creates a new GetMonitorTaskLogsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetMonitorTaskLogsParamsWithContext(ctx context.Context) *GetMonitorTaskLogsParams { + var () + return &GetMonitorTaskLogsParams{ + + Context: ctx, + } +} + +/*GetMonitorTaskLogsParams contains all the parameters to send to the API endpoint +for the get monitor task logs operation typically these are written to a http.Request +*/ +type GetMonitorTaskLogsParams struct { + + /*TaskID*/ + TaskID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get monitor task logs params +func (o *GetMonitorTaskLogsParams) WithTimeout(timeout time.Duration) *GetMonitorTaskLogsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get monitor task logs params +func (o *GetMonitorTaskLogsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get monitor task logs params +func (o *GetMonitorTaskLogsParams) WithContext(ctx context.Context) *GetMonitorTaskLogsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get monitor task logs params +func (o *GetMonitorTaskLogsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithTaskID adds the taskID to the get monitor task logs params +func (o *GetMonitorTaskLogsParams) WithTaskID(taskID string) *GetMonitorTaskLogsParams { + o.SetTaskID(taskID) + return o +} + +// SetTaskID adds the taskId to the get monitor task logs params +func (o *GetMonitorTaskLogsParams) SetTaskID(taskID string) { + o.TaskID = taskID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetMonitorTaskLogsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param taskId + if err := r.SetPathParam("taskId", o.TaskID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_monitor_task_logs_responses.go b/clients/slppclient/operations/get_monitor_task_logs_responses.go new file mode 100644 index 0000000..55f0547 --- /dev/null +++ b/clients/slppclient/operations/get_monitor_task_logs_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetMonitorTaskLogsReader is a Reader for the GetMonitorTaskLogs structure. +type GetMonitorTaskLogsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetMonitorTaskLogsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetMonitorTaskLogsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetMonitorTaskLogsOK creates a GetMonitorTaskLogsOK with default headers values +func NewGetMonitorTaskLogsOK() *GetMonitorTaskLogsOK { + return &GetMonitorTaskLogsOK{} +} + +/*GetMonitorTaskLogsOK handles this case with default header values. + +OK +*/ +type GetMonitorTaskLogsOK struct { + Payload models.Logs +} + +func (o *GetMonitorTaskLogsOK) Error() string { + return fmt.Sprintf("[GET /monitor/{taskId}/logs][%d] getMonitorTaskLogsOK %+v", 200, o.Payload) +} + +func (o *GetMonitorTaskLogsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_monitor_task_parameters.go b/clients/slppclient/operations/get_monitor_task_parameters.go new file mode 100644 index 0000000..b024c4d --- /dev/null +++ b/clients/slppclient/operations/get_monitor_task_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetMonitorTaskParams creates a new GetMonitorTaskParams object +// with the default values initialized. +func NewGetMonitorTaskParams() *GetMonitorTaskParams { + var () + return &GetMonitorTaskParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetMonitorTaskParamsWithTimeout creates a new GetMonitorTaskParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetMonitorTaskParamsWithTimeout(timeout time.Duration) *GetMonitorTaskParams { + var () + return &GetMonitorTaskParams{ + + timeout: timeout, + } +} + +// NewGetMonitorTaskParamsWithContext creates a new GetMonitorTaskParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetMonitorTaskParamsWithContext(ctx context.Context) *GetMonitorTaskParams { + var () + return &GetMonitorTaskParams{ + + Context: ctx, + } +} + +/*GetMonitorTaskParams contains all the parameters to send to the API endpoint +for the get monitor task operation typically these are written to a http.Request +*/ +type GetMonitorTaskParams struct { + + /*TaskID*/ + TaskID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get monitor task params +func (o *GetMonitorTaskParams) WithTimeout(timeout time.Duration) *GetMonitorTaskParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get monitor task params +func (o *GetMonitorTaskParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get monitor task params +func (o *GetMonitorTaskParams) WithContext(ctx context.Context) *GetMonitorTaskParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get monitor task params +func (o *GetMonitorTaskParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithTaskID adds the taskID to the get monitor task params +func (o *GetMonitorTaskParams) WithTaskID(taskID string) *GetMonitorTaskParams { + o.SetTaskID(taskID) + return o +} + +// SetTaskID adds the taskId to the get monitor task params +func (o *GetMonitorTaskParams) SetTaskID(taskID string) { + o.TaskID = taskID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetMonitorTaskParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param taskId + if err := r.SetPathParam("taskId", o.TaskID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_monitor_task_responses.go b/clients/slppclient/operations/get_monitor_task_responses.go new file mode 100644 index 0000000..3b8914d --- /dev/null +++ b/clients/slppclient/operations/get_monitor_task_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetMonitorTaskReader is a Reader for the GetMonitorTask structure. +type GetMonitorTaskReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetMonitorTaskReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetMonitorTaskOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetMonitorTaskOK creates a GetMonitorTaskOK with default headers values +func NewGetMonitorTaskOK() *GetMonitorTaskOK { + return &GetMonitorTaskOK{} +} + +/*GetMonitorTaskOK handles this case with default header values. + +OK +*/ +type GetMonitorTaskOK struct { + Payload *models.Task +} + +func (o *GetMonitorTaskOK) Error() string { + return fmt.Sprintf("[GET /monitor/{taskId}][%d] getMonitorTaskOK %+v", 200, o.Payload) +} + +func (o *GetMonitorTaskOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Task) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_properties_parameters.go b/clients/slppclient/operations/get_properties_parameters.go new file mode 100644 index 0000000..5d37014 --- /dev/null +++ b/clients/slppclient/operations/get_properties_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetPropertiesParams creates a new GetPropertiesParams object +// with the default values initialized. +func NewGetPropertiesParams() *GetPropertiesParams { + + return &GetPropertiesParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetPropertiesParamsWithTimeout creates a new GetPropertiesParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetPropertiesParamsWithTimeout(timeout time.Duration) *GetPropertiesParams { + + return &GetPropertiesParams{ + + timeout: timeout, + } +} + +// NewGetPropertiesParamsWithContext creates a new GetPropertiesParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetPropertiesParamsWithContext(ctx context.Context) *GetPropertiesParams { + + return &GetPropertiesParams{ + + Context: ctx, + } +} + +/*GetPropertiesParams contains all the parameters to send to the API endpoint +for the get properties operation typically these are written to a http.Request +*/ +type GetPropertiesParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get properties params +func (o *GetPropertiesParams) WithTimeout(timeout time.Duration) *GetPropertiesParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get properties params +func (o *GetPropertiesParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get properties params +func (o *GetPropertiesParams) WithContext(ctx context.Context) *GetPropertiesParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get properties params +func (o *GetPropertiesParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetPropertiesParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_properties_responses.go b/clients/slppclient/operations/get_properties_responses.go new file mode 100644 index 0000000..6f4f3b0 --- /dev/null +++ b/clients/slppclient/operations/get_properties_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetPropertiesReader is a Reader for the GetProperties structure. +type GetPropertiesReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetPropertiesReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetPropertiesOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetPropertiesOK creates a GetPropertiesOK with default headers values +func NewGetPropertiesOK() *GetPropertiesOK { + return &GetPropertiesOK{} +} + +/*GetPropertiesOK handles this case with default header values. + +OK +*/ +type GetPropertiesOK struct { + Payload models.Properties +} + +func (o *GetPropertiesOK) Error() string { + return fmt.Sprintf("[GET /properties][%d] getPropertiesOK %+v", 200, o.Payload) +} + +func (o *GetPropertiesOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_property_parameters.go b/clients/slppclient/operations/get_property_parameters.go new file mode 100644 index 0000000..0106636 --- /dev/null +++ b/clients/slppclient/operations/get_property_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetPropertyParams creates a new GetPropertyParams object +// with the default values initialized. +func NewGetPropertyParams() *GetPropertyParams { + var () + return &GetPropertyParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetPropertyParamsWithTimeout creates a new GetPropertyParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetPropertyParamsWithTimeout(timeout time.Duration) *GetPropertyParams { + var () + return &GetPropertyParams{ + + timeout: timeout, + } +} + +// NewGetPropertyParamsWithContext creates a new GetPropertyParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetPropertyParamsWithContext(ctx context.Context) *GetPropertyParams { + var () + return &GetPropertyParams{ + + Context: ctx, + } +} + +/*GetPropertyParams contains all the parameters to send to the API endpoint +for the get property operation typically these are written to a http.Request +*/ +type GetPropertyParams struct { + + /*PropertyID*/ + PropertyID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get property params +func (o *GetPropertyParams) WithTimeout(timeout time.Duration) *GetPropertyParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get property params +func (o *GetPropertyParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get property params +func (o *GetPropertyParams) WithContext(ctx context.Context) *GetPropertyParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get property params +func (o *GetPropertyParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithPropertyID adds the propertyID to the get property params +func (o *GetPropertyParams) WithPropertyID(propertyID string) *GetPropertyParams { + o.SetPropertyID(propertyID) + return o +} + +// SetPropertyID adds the propertyId to the get property params +func (o *GetPropertyParams) SetPropertyID(propertyID string) { + o.PropertyID = propertyID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetPropertyParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param propertyId + if err := r.SetPathParam("propertyId", o.PropertyID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_property_responses.go b/clients/slppclient/operations/get_property_responses.go new file mode 100644 index 0000000..e9af4cf --- /dev/null +++ b/clients/slppclient/operations/get_property_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetPropertyReader is a Reader for the GetProperty structure. +type GetPropertyReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetPropertyReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetPropertyOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetPropertyOK creates a GetPropertyOK with default headers values +func NewGetPropertyOK() *GetPropertyOK { + return &GetPropertyOK{} +} + +/*GetPropertyOK handles this case with default header values. + +OK +*/ +type GetPropertyOK struct { + Payload *models.Property +} + +func (o *GetPropertyOK) Error() string { + return fmt.Sprintf("[GET /properties/{propertyId}][%d] getPropertyOK %+v", 200, o.Payload) +} + +func (o *GetPropertyOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Property) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_roadmap_parameters.go b/clients/slppclient/operations/get_roadmap_parameters.go new file mode 100644 index 0000000..6f715bd --- /dev/null +++ b/clients/slppclient/operations/get_roadmap_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetRoadmapParams creates a new GetRoadmapParams object +// with the default values initialized. +func NewGetRoadmapParams() *GetRoadmapParams { + + return &GetRoadmapParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetRoadmapParamsWithTimeout creates a new GetRoadmapParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetRoadmapParamsWithTimeout(timeout time.Duration) *GetRoadmapParams { + + return &GetRoadmapParams{ + + timeout: timeout, + } +} + +// NewGetRoadmapParamsWithContext creates a new GetRoadmapParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetRoadmapParamsWithContext(ctx context.Context) *GetRoadmapParams { + + return &GetRoadmapParams{ + + Context: ctx, + } +} + +/*GetRoadmapParams contains all the parameters to send to the API endpoint +for the get roadmap operation typically these are written to a http.Request +*/ +type GetRoadmapParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get roadmap params +func (o *GetRoadmapParams) WithTimeout(timeout time.Duration) *GetRoadmapParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get roadmap params +func (o *GetRoadmapParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get roadmap params +func (o *GetRoadmapParams) WithContext(ctx context.Context) *GetRoadmapParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get roadmap params +func (o *GetRoadmapParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetRoadmapParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_roadmap_responses.go b/clients/slppclient/operations/get_roadmap_responses.go new file mode 100644 index 0000000..812766c --- /dev/null +++ b/clients/slppclient/operations/get_roadmap_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetRoadmapReader is a Reader for the GetRoadmap structure. +type GetRoadmapReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetRoadmapReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetRoadmapOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetRoadmapOK creates a GetRoadmapOK with default headers values +func NewGetRoadmapOK() *GetRoadmapOK { + return &GetRoadmapOK{} +} + +/*GetRoadmapOK handles this case with default header values. + +OK +*/ +type GetRoadmapOK struct { + Payload models.Roadmap +} + +func (o *GetRoadmapOK) Error() string { + return fmt.Sprintf("[GET /roadmap][%d] getRoadmapOK %+v", 200, o.Payload) +} + +func (o *GetRoadmapOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_roadmap_task_error_parameters.go b/clients/slppclient/operations/get_roadmap_task_error_parameters.go new file mode 100644 index 0000000..0340fdc --- /dev/null +++ b/clients/slppclient/operations/get_roadmap_task_error_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetRoadmapTaskErrorParams creates a new GetRoadmapTaskErrorParams object +// with the default values initialized. +func NewGetRoadmapTaskErrorParams() *GetRoadmapTaskErrorParams { + var () + return &GetRoadmapTaskErrorParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetRoadmapTaskErrorParamsWithTimeout creates a new GetRoadmapTaskErrorParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetRoadmapTaskErrorParamsWithTimeout(timeout time.Duration) *GetRoadmapTaskErrorParams { + var () + return &GetRoadmapTaskErrorParams{ + + timeout: timeout, + } +} + +// NewGetRoadmapTaskErrorParamsWithContext creates a new GetRoadmapTaskErrorParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetRoadmapTaskErrorParamsWithContext(ctx context.Context) *GetRoadmapTaskErrorParams { + var () + return &GetRoadmapTaskErrorParams{ + + Context: ctx, + } +} + +/*GetRoadmapTaskErrorParams contains all the parameters to send to the API endpoint +for the get roadmap task error operation typically these are written to a http.Request +*/ +type GetRoadmapTaskErrorParams struct { + + /*TaskID*/ + TaskID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get roadmap task error params +func (o *GetRoadmapTaskErrorParams) WithTimeout(timeout time.Duration) *GetRoadmapTaskErrorParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get roadmap task error params +func (o *GetRoadmapTaskErrorParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get roadmap task error params +func (o *GetRoadmapTaskErrorParams) WithContext(ctx context.Context) *GetRoadmapTaskErrorParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get roadmap task error params +func (o *GetRoadmapTaskErrorParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithTaskID adds the taskID to the get roadmap task error params +func (o *GetRoadmapTaskErrorParams) WithTaskID(taskID string) *GetRoadmapTaskErrorParams { + o.SetTaskID(taskID) + return o +} + +// SetTaskID adds the taskId to the get roadmap task error params +func (o *GetRoadmapTaskErrorParams) SetTaskID(taskID string) { + o.TaskID = taskID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetRoadmapTaskErrorParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param taskId + if err := r.SetPathParam("taskId", o.TaskID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_roadmap_task_error_responses.go b/clients/slppclient/operations/get_roadmap_task_error_responses.go new file mode 100644 index 0000000..97f1e3a --- /dev/null +++ b/clients/slppclient/operations/get_roadmap_task_error_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetRoadmapTaskErrorReader is a Reader for the GetRoadmapTaskError structure. +type GetRoadmapTaskErrorReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetRoadmapTaskErrorReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetRoadmapTaskErrorOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetRoadmapTaskErrorOK creates a GetRoadmapTaskErrorOK with default headers values +func NewGetRoadmapTaskErrorOK() *GetRoadmapTaskErrorOK { + return &GetRoadmapTaskErrorOK{} +} + +/*GetRoadmapTaskErrorOK handles this case with default header values. + +OK +*/ +type GetRoadmapTaskErrorOK struct { + Payload *models.Error +} + +func (o *GetRoadmapTaskErrorOK) Error() string { + return fmt.Sprintf("[GET /roadmap/{taskId}/error][%d] getRoadmapTaskErrorOK %+v", 200, o.Payload) +} + +func (o *GetRoadmapTaskErrorOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_roadmap_task_logs_parameters.go b/clients/slppclient/operations/get_roadmap_task_logs_parameters.go new file mode 100644 index 0000000..94c8959 --- /dev/null +++ b/clients/slppclient/operations/get_roadmap_task_logs_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetRoadmapTaskLogsParams creates a new GetRoadmapTaskLogsParams object +// with the default values initialized. +func NewGetRoadmapTaskLogsParams() *GetRoadmapTaskLogsParams { + var () + return &GetRoadmapTaskLogsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetRoadmapTaskLogsParamsWithTimeout creates a new GetRoadmapTaskLogsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetRoadmapTaskLogsParamsWithTimeout(timeout time.Duration) *GetRoadmapTaskLogsParams { + var () + return &GetRoadmapTaskLogsParams{ + + timeout: timeout, + } +} + +// NewGetRoadmapTaskLogsParamsWithContext creates a new GetRoadmapTaskLogsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetRoadmapTaskLogsParamsWithContext(ctx context.Context) *GetRoadmapTaskLogsParams { + var () + return &GetRoadmapTaskLogsParams{ + + Context: ctx, + } +} + +/*GetRoadmapTaskLogsParams contains all the parameters to send to the API endpoint +for the get roadmap task logs operation typically these are written to a http.Request +*/ +type GetRoadmapTaskLogsParams struct { + + /*TaskID*/ + TaskID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get roadmap task logs params +func (o *GetRoadmapTaskLogsParams) WithTimeout(timeout time.Duration) *GetRoadmapTaskLogsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get roadmap task logs params +func (o *GetRoadmapTaskLogsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get roadmap task logs params +func (o *GetRoadmapTaskLogsParams) WithContext(ctx context.Context) *GetRoadmapTaskLogsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get roadmap task logs params +func (o *GetRoadmapTaskLogsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithTaskID adds the taskID to the get roadmap task logs params +func (o *GetRoadmapTaskLogsParams) WithTaskID(taskID string) *GetRoadmapTaskLogsParams { + o.SetTaskID(taskID) + return o +} + +// SetTaskID adds the taskId to the get roadmap task logs params +func (o *GetRoadmapTaskLogsParams) SetTaskID(taskID string) { + o.TaskID = taskID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetRoadmapTaskLogsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param taskId + if err := r.SetPathParam("taskId", o.TaskID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_roadmap_task_logs_responses.go b/clients/slppclient/operations/get_roadmap_task_logs_responses.go new file mode 100644 index 0000000..2e41729 --- /dev/null +++ b/clients/slppclient/operations/get_roadmap_task_logs_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetRoadmapTaskLogsReader is a Reader for the GetRoadmapTaskLogs structure. +type GetRoadmapTaskLogsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetRoadmapTaskLogsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetRoadmapTaskLogsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetRoadmapTaskLogsOK creates a GetRoadmapTaskLogsOK with default headers values +func NewGetRoadmapTaskLogsOK() *GetRoadmapTaskLogsOK { + return &GetRoadmapTaskLogsOK{} +} + +/*GetRoadmapTaskLogsOK handles this case with default header values. + +OK +*/ +type GetRoadmapTaskLogsOK struct { + Payload models.Logs +} + +func (o *GetRoadmapTaskLogsOK) Error() string { + return fmt.Sprintf("[GET /roadmap/{taskId}/logs][%d] getRoadmapTaskLogsOK %+v", 200, o.Payload) +} + +func (o *GetRoadmapTaskLogsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_roadmap_task_parameters.go b/clients/slppclient/operations/get_roadmap_task_parameters.go new file mode 100644 index 0000000..708cd8d --- /dev/null +++ b/clients/slppclient/operations/get_roadmap_task_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetRoadmapTaskParams creates a new GetRoadmapTaskParams object +// with the default values initialized. +func NewGetRoadmapTaskParams() *GetRoadmapTaskParams { + var () + return &GetRoadmapTaskParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetRoadmapTaskParamsWithTimeout creates a new GetRoadmapTaskParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetRoadmapTaskParamsWithTimeout(timeout time.Duration) *GetRoadmapTaskParams { + var () + return &GetRoadmapTaskParams{ + + timeout: timeout, + } +} + +// NewGetRoadmapTaskParamsWithContext creates a new GetRoadmapTaskParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetRoadmapTaskParamsWithContext(ctx context.Context) *GetRoadmapTaskParams { + var () + return &GetRoadmapTaskParams{ + + Context: ctx, + } +} + +/*GetRoadmapTaskParams contains all the parameters to send to the API endpoint +for the get roadmap task operation typically these are written to a http.Request +*/ +type GetRoadmapTaskParams struct { + + /*TaskID*/ + TaskID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get roadmap task params +func (o *GetRoadmapTaskParams) WithTimeout(timeout time.Duration) *GetRoadmapTaskParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get roadmap task params +func (o *GetRoadmapTaskParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get roadmap task params +func (o *GetRoadmapTaskParams) WithContext(ctx context.Context) *GetRoadmapTaskParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get roadmap task params +func (o *GetRoadmapTaskParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithTaskID adds the taskID to the get roadmap task params +func (o *GetRoadmapTaskParams) WithTaskID(taskID string) *GetRoadmapTaskParams { + o.SetTaskID(taskID) + return o +} + +// SetTaskID adds the taskId to the get roadmap task params +func (o *GetRoadmapTaskParams) SetTaskID(taskID string) { + o.TaskID = taskID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetRoadmapTaskParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param taskId + if err := r.SetPathParam("taskId", o.TaskID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_roadmap_task_responses.go b/clients/slppclient/operations/get_roadmap_task_responses.go new file mode 100644 index 0000000..b24269e --- /dev/null +++ b/clients/slppclient/operations/get_roadmap_task_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetRoadmapTaskReader is a Reader for the GetRoadmapTask structure. +type GetRoadmapTaskReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetRoadmapTaskReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetRoadmapTaskOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetRoadmapTaskOK creates a GetRoadmapTaskOK with default headers values +func NewGetRoadmapTaskOK() *GetRoadmapTaskOK { + return &GetRoadmapTaskOK{} +} + +/*GetRoadmapTaskOK handles this case with default header values. + +OK +*/ +type GetRoadmapTaskOK struct { + Payload *models.Task +} + +func (o *GetRoadmapTaskOK) Error() string { + return fmt.Sprintf("[GET /roadmap/{taskId}][%d] getRoadmapTaskOK %+v", 200, o.Payload) +} + +func (o *GetRoadmapTaskOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Task) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_tasklist_parameters.go b/clients/slppclient/operations/get_tasklist_parameters.go new file mode 100644 index 0000000..44a3481 --- /dev/null +++ b/clients/slppclient/operations/get_tasklist_parameters.go @@ -0,0 +1,114 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetTasklistParams creates a new GetTasklistParams object +// with the default values initialized. +func NewGetTasklistParams() *GetTasklistParams { + + return &GetTasklistParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetTasklistParamsWithTimeout creates a new GetTasklistParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetTasklistParamsWithTimeout(timeout time.Duration) *GetTasklistParams { + + return &GetTasklistParams{ + + timeout: timeout, + } +} + +// NewGetTasklistParamsWithContext creates a new GetTasklistParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetTasklistParamsWithContext(ctx context.Context) *GetTasklistParams { + + return &GetTasklistParams{ + + Context: ctx, + } +} + +// NewGetTasklistParamsWithHTTPClient creates a new GetTasklistParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewGetTasklistParamsWithHTTPClient(client *http.Client) *GetTasklistParams { + + return &GetTasklistParams{ + HTTPClient: client, + } +} + +/*GetTasklistParams contains all the parameters to send to the API endpoint +for the get tasklist operation typically these are written to a http.Request +*/ +type GetTasklistParams struct { + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the get tasklist params +func (o *GetTasklistParams) WithTimeout(timeout time.Duration) *GetTasklistParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get tasklist params +func (o *GetTasklistParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get tasklist params +func (o *GetTasklistParams) WithContext(ctx context.Context) *GetTasklistParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get tasklist params +func (o *GetTasklistParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get tasklist params +func (o *GetTasklistParams) WithHTTPClient(client *http.Client) *GetTasklistParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get tasklist params +func (o *GetTasklistParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WriteToRequest writes these params to a swagger request +func (o *GetTasklistParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_tasklist_responses.go b/clients/slppclient/operations/get_tasklist_responses.go new file mode 100644 index 0000000..3b76fdc --- /dev/null +++ b/clients/slppclient/operations/get_tasklist_responses.go @@ -0,0 +1,65 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetTasklistReader is a Reader for the GetTasklist structure. +type GetTasklistReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetTasklistReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetTasklistOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetTasklistOK creates a GetTasklistOK with default headers values +func NewGetTasklistOK() *GetTasklistOK { + return &GetTasklistOK{} +} + +/*GetTasklistOK handles this case with default header values. + +OK +*/ +type GetTasklistOK struct { + Payload models.Tasklist +} + +func (o *GetTasklistOK) Error() string { + return fmt.Sprintf("[GET /tasklist][%d] getTasklistOK %+v", 200, o.Payload) +} + +func (o *GetTasklistOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_tasklist_task_error_parameters.go b/clients/slppclient/operations/get_tasklist_task_error_parameters.go new file mode 100644 index 0000000..0b6a486 --- /dev/null +++ b/clients/slppclient/operations/get_tasklist_task_error_parameters.go @@ -0,0 +1,134 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetTasklistTaskErrorParams creates a new GetTasklistTaskErrorParams object +// with the default values initialized. +func NewGetTasklistTaskErrorParams() *GetTasklistTaskErrorParams { + var () + return &GetTasklistTaskErrorParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetTasklistTaskErrorParamsWithTimeout creates a new GetTasklistTaskErrorParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetTasklistTaskErrorParamsWithTimeout(timeout time.Duration) *GetTasklistTaskErrorParams { + var () + return &GetTasklistTaskErrorParams{ + + timeout: timeout, + } +} + +// NewGetTasklistTaskErrorParamsWithContext creates a new GetTasklistTaskErrorParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetTasklistTaskErrorParamsWithContext(ctx context.Context) *GetTasklistTaskErrorParams { + var () + return &GetTasklistTaskErrorParams{ + + Context: ctx, + } +} + +// NewGetTasklistTaskErrorParamsWithHTTPClient creates a new GetTasklistTaskErrorParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewGetTasklistTaskErrorParamsWithHTTPClient(client *http.Client) *GetTasklistTaskErrorParams { + var () + return &GetTasklistTaskErrorParams{ + HTTPClient: client, + } +} + +/*GetTasklistTaskErrorParams contains all the parameters to send to the API endpoint +for the get tasklist task error operation typically these are written to a http.Request +*/ +type GetTasklistTaskErrorParams struct { + + /*TaskID*/ + TaskID string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the get tasklist task error params +func (o *GetTasklistTaskErrorParams) WithTimeout(timeout time.Duration) *GetTasklistTaskErrorParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get tasklist task error params +func (o *GetTasklistTaskErrorParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get tasklist task error params +func (o *GetTasklistTaskErrorParams) WithContext(ctx context.Context) *GetTasklistTaskErrorParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get tasklist task error params +func (o *GetTasklistTaskErrorParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get tasklist task error params +func (o *GetTasklistTaskErrorParams) WithHTTPClient(client *http.Client) *GetTasklistTaskErrorParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get tasklist task error params +func (o *GetTasklistTaskErrorParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithTaskID adds the taskID to the get tasklist task error params +func (o *GetTasklistTaskErrorParams) WithTaskID(taskID string) *GetTasklistTaskErrorParams { + o.SetTaskID(taskID) + return o +} + +// SetTaskID adds the taskId to the get tasklist task error params +func (o *GetTasklistTaskErrorParams) SetTaskID(taskID string) { + o.TaskID = taskID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetTasklistTaskErrorParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + // path param taskId + if err := r.SetPathParam("taskId", o.TaskID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_tasklist_task_error_responses.go b/clients/slppclient/operations/get_tasklist_task_error_responses.go new file mode 100644 index 0000000..00c6c50 --- /dev/null +++ b/clients/slppclient/operations/get_tasklist_task_error_responses.go @@ -0,0 +1,67 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetTasklistTaskErrorReader is a Reader for the GetTasklistTaskError structure. +type GetTasklistTaskErrorReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetTasklistTaskErrorReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetTasklistTaskErrorOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetTasklistTaskErrorOK creates a GetTasklistTaskErrorOK with default headers values +func NewGetTasklistTaskErrorOK() *GetTasklistTaskErrorOK { + return &GetTasklistTaskErrorOK{} +} + +/*GetTasklistTaskErrorOK handles this case with default header values. + +OK +*/ +type GetTasklistTaskErrorOK struct { + Payload *models.Error +} + +func (o *GetTasklistTaskErrorOK) Error() string { + return fmt.Sprintf("[GET /tasklist/{taskId}/error][%d] getTasklistTaskErrorOK %+v", 200, o.Payload) +} + +func (o *GetTasklistTaskErrorOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_tasklist_task_logs_parameters.go b/clients/slppclient/operations/get_tasklist_task_logs_parameters.go new file mode 100644 index 0000000..929e629 --- /dev/null +++ b/clients/slppclient/operations/get_tasklist_task_logs_parameters.go @@ -0,0 +1,134 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetTasklistTaskLogsParams creates a new GetTasklistTaskLogsParams object +// with the default values initialized. +func NewGetTasklistTaskLogsParams() *GetTasklistTaskLogsParams { + var () + return &GetTasklistTaskLogsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetTasklistTaskLogsParamsWithTimeout creates a new GetTasklistTaskLogsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetTasklistTaskLogsParamsWithTimeout(timeout time.Duration) *GetTasklistTaskLogsParams { + var () + return &GetTasklistTaskLogsParams{ + + timeout: timeout, + } +} + +// NewGetTasklistTaskLogsParamsWithContext creates a new GetTasklistTaskLogsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetTasklistTaskLogsParamsWithContext(ctx context.Context) *GetTasklistTaskLogsParams { + var () + return &GetTasklistTaskLogsParams{ + + Context: ctx, + } +} + +// NewGetTasklistTaskLogsParamsWithHTTPClient creates a new GetTasklistTaskLogsParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewGetTasklistTaskLogsParamsWithHTTPClient(client *http.Client) *GetTasklistTaskLogsParams { + var () + return &GetTasklistTaskLogsParams{ + HTTPClient: client, + } +} + +/*GetTasklistTaskLogsParams contains all the parameters to send to the API endpoint +for the get tasklist task logs operation typically these are written to a http.Request +*/ +type GetTasklistTaskLogsParams struct { + + /*TaskID*/ + TaskID string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the get tasklist task logs params +func (o *GetTasklistTaskLogsParams) WithTimeout(timeout time.Duration) *GetTasklistTaskLogsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get tasklist task logs params +func (o *GetTasklistTaskLogsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get tasklist task logs params +func (o *GetTasklistTaskLogsParams) WithContext(ctx context.Context) *GetTasklistTaskLogsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get tasklist task logs params +func (o *GetTasklistTaskLogsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get tasklist task logs params +func (o *GetTasklistTaskLogsParams) WithHTTPClient(client *http.Client) *GetTasklistTaskLogsParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get tasklist task logs params +func (o *GetTasklistTaskLogsParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithTaskID adds the taskID to the get tasklist task logs params +func (o *GetTasklistTaskLogsParams) WithTaskID(taskID string) *GetTasklistTaskLogsParams { + o.SetTaskID(taskID) + return o +} + +// SetTaskID adds the taskId to the get tasklist task logs params +func (o *GetTasklistTaskLogsParams) SetTaskID(taskID string) { + o.TaskID = taskID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetTasklistTaskLogsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + // path param taskId + if err := r.SetPathParam("taskId", o.TaskID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_tasklist_task_logs_responses.go b/clients/slppclient/operations/get_tasklist_task_logs_responses.go new file mode 100644 index 0000000..3601ccf --- /dev/null +++ b/clients/slppclient/operations/get_tasklist_task_logs_responses.go @@ -0,0 +1,65 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetTasklistTaskLogsReader is a Reader for the GetTasklistTaskLogs structure. +type GetTasklistTaskLogsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetTasklistTaskLogsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetTasklistTaskLogsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetTasklistTaskLogsOK creates a GetTasklistTaskLogsOK with default headers values +func NewGetTasklistTaskLogsOK() *GetTasklistTaskLogsOK { + return &GetTasklistTaskLogsOK{} +} + +/*GetTasklistTaskLogsOK handles this case with default header values. + +OK +*/ +type GetTasklistTaskLogsOK struct { + Payload models.Logs +} + +func (o *GetTasklistTaskLogsOK) Error() string { + return fmt.Sprintf("[GET /tasklist/{taskId}/logs][%d] getTasklistTaskLogsOK %+v", 200, o.Payload) +} + +func (o *GetTasklistTaskLogsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_tasklist_task_parameters.go b/clients/slppclient/operations/get_tasklist_task_parameters.go new file mode 100644 index 0000000..7cdec24 --- /dev/null +++ b/clients/slppclient/operations/get_tasklist_task_parameters.go @@ -0,0 +1,134 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetTasklistTaskParams creates a new GetTasklistTaskParams object +// with the default values initialized. +func NewGetTasklistTaskParams() *GetTasklistTaskParams { + var () + return &GetTasklistTaskParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetTasklistTaskParamsWithTimeout creates a new GetTasklistTaskParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetTasklistTaskParamsWithTimeout(timeout time.Duration) *GetTasklistTaskParams { + var () + return &GetTasklistTaskParams{ + + timeout: timeout, + } +} + +// NewGetTasklistTaskParamsWithContext creates a new GetTasklistTaskParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetTasklistTaskParamsWithContext(ctx context.Context) *GetTasklistTaskParams { + var () + return &GetTasklistTaskParams{ + + Context: ctx, + } +} + +// NewGetTasklistTaskParamsWithHTTPClient creates a new GetTasklistTaskParams object +// with the default values initialized, and the ability to set a custom HTTPClient for a request +func NewGetTasklistTaskParamsWithHTTPClient(client *http.Client) *GetTasklistTaskParams { + var () + return &GetTasklistTaskParams{ + HTTPClient: client, + } +} + +/*GetTasklistTaskParams contains all the parameters to send to the API endpoint +for the get tasklist task operation typically these are written to a http.Request +*/ +type GetTasklistTaskParams struct { + + /*TaskID*/ + TaskID string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithTimeout adds the timeout to the get tasklist task params +func (o *GetTasklistTaskParams) WithTimeout(timeout time.Duration) *GetTasklistTaskParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get tasklist task params +func (o *GetTasklistTaskParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get tasklist task params +func (o *GetTasklistTaskParams) WithContext(ctx context.Context) *GetTasklistTaskParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get tasklist task params +func (o *GetTasklistTaskParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get tasklist task params +func (o *GetTasklistTaskParams) WithHTTPClient(client *http.Client) *GetTasklistTaskParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get tasklist task params +func (o *GetTasklistTaskParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithTaskID adds the taskID to the get tasklist task params +func (o *GetTasklistTaskParams) WithTaskID(taskID string) *GetTasklistTaskParams { + o.SetTaskID(taskID) + return o +} + +// SetTaskID adds the taskId to the get tasklist task params +func (o *GetTasklistTaskParams) SetTaskID(taskID string) { + o.TaskID = taskID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetTasklistTaskParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + // path param taskId + if err := r.SetPathParam("taskId", o.TaskID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_tasklist_task_responses.go b/clients/slppclient/operations/get_tasklist_task_responses.go new file mode 100644 index 0000000..558d053 --- /dev/null +++ b/clients/slppclient/operations/get_tasklist_task_responses.go @@ -0,0 +1,67 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetTasklistTaskReader is a Reader for the GetTasklistTask structure. +type GetTasklistTaskReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetTasklistTaskReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetTasklistTaskOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetTasklistTaskOK creates a GetTasklistTaskOK with default headers values +func NewGetTasklistTaskOK() *GetTasklistTaskOK { + return &GetTasklistTaskOK{} +} + +/*GetTasklistTaskOK handles this case with default header values. + +OK +*/ +type GetTasklistTaskOK struct { + Payload *models.Task +} + +func (o *GetTasklistTaskOK) Error() string { + return fmt.Sprintf("[GET /tasklist/{taskId}][%d] getTasklistTaskOK %+v", 200, o.Payload) +} + +func (o *GetTasklistTaskOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.Task) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_version_parameters.go b/clients/slppclient/operations/get_version_parameters.go new file mode 100644 index 0000000..be56b59 --- /dev/null +++ b/clients/slppclient/operations/get_version_parameters.go @@ -0,0 +1,108 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetVersionParams creates a new GetVersionParams object +// with the default values initialized. +func NewGetVersionParams() *GetVersionParams { + var () + return &GetVersionParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetVersionParamsWithTimeout creates a new GetVersionParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetVersionParamsWithTimeout(timeout time.Duration) *GetVersionParams { + var () + return &GetVersionParams{ + + timeout: timeout, + } +} + +// NewGetVersionParamsWithContext creates a new GetVersionParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetVersionParamsWithContext(ctx context.Context) *GetVersionParams { + var () + return &GetVersionParams{ + + Context: ctx, + } +} + +/*GetVersionParams contains all the parameters to send to the API endpoint +for the get version operation typically these are written to a http.Request +*/ +type GetVersionParams struct { + + /*VersionID*/ + VersionID string + + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get version params +func (o *GetVersionParams) WithTimeout(timeout time.Duration) *GetVersionParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get version params +func (o *GetVersionParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get version params +func (o *GetVersionParams) WithContext(ctx context.Context) *GetVersionParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get version params +func (o *GetVersionParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithVersionID adds the versionID to the get version params +func (o *GetVersionParams) WithVersionID(versionID string) *GetVersionParams { + o.SetVersionID(versionID) + return o +} + +// SetVersionID adds the versionId to the get version params +func (o *GetVersionParams) SetVersionID(versionID string) { + o.VersionID = versionID +} + +// WriteToRequest writes these params to a swagger request +func (o *GetVersionParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + // path param versionId + if err := r.SetPathParam("versionId", o.VersionID); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_version_responses.go b/clients/slppclient/operations/get_version_responses.go new file mode 100644 index 0000000..8ec2e5b --- /dev/null +++ b/clients/slppclient/operations/get_version_responses.go @@ -0,0 +1,65 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetVersionReader is a Reader for the GetVersion structure. +type GetVersionReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetVersionReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetVersionOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetVersionOK creates a GetVersionOK with default headers values +func NewGetVersionOK() *GetVersionOK { + return &GetVersionOK{} +} + +/*GetVersionOK handles this case with default header values. + +OK +*/ +type GetVersionOK struct { + Payload *models.ComponentVersion +} + +func (o *GetVersionOK) Error() string { + return fmt.Sprintf("[GET /versions/{versionId}][%d] getVersionOK %+v", 200, o.Payload) +} + +func (o *GetVersionOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(models.ComponentVersion) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/get_versions_parameters.go b/clients/slppclient/operations/get_versions_parameters.go new file mode 100644 index 0000000..c70c81a --- /dev/null +++ b/clients/slppclient/operations/get_versions_parameters.go @@ -0,0 +1,88 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "time" + + "golang.org/x/net/context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + + strfmt "github.com/go-openapi/strfmt" +) + +// NewGetVersionsParams creates a new GetVersionsParams object +// with the default values initialized. +func NewGetVersionsParams() *GetVersionsParams { + + return &GetVersionsParams{ + + timeout: cr.DefaultTimeout, + } +} + +// NewGetVersionsParamsWithTimeout creates a new GetVersionsParams object +// with the default values initialized, and the ability to set a timeout on a request +func NewGetVersionsParamsWithTimeout(timeout time.Duration) *GetVersionsParams { + + return &GetVersionsParams{ + + timeout: timeout, + } +} + +// NewGetVersionsParamsWithContext creates a new GetVersionsParams object +// with the default values initialized, and the ability to set a context for a request +func NewGetVersionsParamsWithContext(ctx context.Context) *GetVersionsParams { + + return &GetVersionsParams{ + + Context: ctx, + } +} + +/*GetVersionsParams contains all the parameters to send to the API endpoint +for the get versions operation typically these are written to a http.Request +*/ +type GetVersionsParams struct { + timeout time.Duration + Context context.Context +} + +// WithTimeout adds the timeout to the get versions params +func (o *GetVersionsParams) WithTimeout(timeout time.Duration) *GetVersionsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get versions params +func (o *GetVersionsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get versions params +func (o *GetVersionsParams) WithContext(ctx context.Context) *GetVersionsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get versions params +func (o *GetVersionsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WriteToRequest writes these params to a swagger request +func (o *GetVersionsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + r.SetTimeout(o.timeout) + var res []error + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/clients/slppclient/operations/get_versions_responses.go b/clients/slppclient/operations/get_versions_responses.go new file mode 100644 index 0000000..de79faa --- /dev/null +++ b/clients/slppclient/operations/get_versions_responses.go @@ -0,0 +1,63 @@ +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// GetVersionsReader is a Reader for the GetVersions structure. +type GetVersionsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetVersionsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + + case 200: + result := NewGetVersionsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + + default: + return nil, runtime.NewAPIError("unknown error", response, response.Code()) + } +} + +// NewGetVersionsOK creates a GetVersionsOK with default headers values +func NewGetVersionsOK() *GetVersionsOK { + return &GetVersionsOK{} +} + +/*GetVersionsOK handles this case with default header values. + +OK +*/ +type GetVersionsOK struct { + Payload models.Versions +} + +func (o *GetVersionsOK) Error() string { + return fmt.Sprintf("[GET /versions][%d] getVersionsOK %+v", 200, o.Payload) +} + +func (o *GetVersionsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/clients/slppclient/operations/operations_client.go b/clients/slppclient/operations/operations_client.go new file mode 100644 index 0000000..978a159 --- /dev/null +++ b/clients/slppclient/operations/operations_client.go @@ -0,0 +1,378 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package operations + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "github.com/go-openapi/runtime" + + strfmt "github.com/go-openapi/strfmt" +) + +// New creates a new operations API client. +func New(transport runtime.ClientTransport, formats strfmt.Registry) *Client { + return &Client{transport: transport, formats: formats} +} + +/* +Client for operations API +*/ +type Client struct { + transport runtime.ClientTransport + formats strfmt.Registry +} + +/* +ExecuteAction Trigger the action specified by the proviced actionId (Mandatory) +*/ +func (a *Client) ExecuteAction(params *ExecuteActionParams, authInfo runtime.ClientAuthInfoWriter) (*ExecuteActionNoContent, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewExecuteActionParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "ExecuteAction", + Method: "POST", + PathPattern: "/actions/{actionId}", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &ExecuteActionReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*ExecuteActionNoContent), nil + +} + +/* +GetAction get action API +*/ +func (a *Client) GetAction(params *GetActionParams, authInfo runtime.ClientAuthInfoWriter) (*GetActionOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetActionParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetAction", + Method: "GET", + PathPattern: "/actions/{actionId}", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetActionReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*GetActionOK), nil + +} + +/* +GetActions All currently available actions. At least the 'ABORT' action must be supported by all SL process. Except of this the collection is dynamic and context dependent! (Mandatory) +*/ +func (a *Client) GetActions(params *GetActionsParams, authInfo runtime.ClientAuthInfoWriter) (*GetActionsOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetActionsParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetActions", + Method: "GET", + PathPattern: "/actions", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetActionsReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*GetActionsOK), nil + +} + +/* +GetError get error API +*/ +func (a *Client) GetError(params *GetErrorParams, authInfo runtime.ClientAuthInfoWriter) (*GetErrorOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetErrorParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetError", + Method: "GET", + PathPattern: "/error", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetErrorReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*GetErrorOK), nil + +} + +/* +GetLog get log API +*/ +func (a *Client) GetLog(params *GetLogParams, authInfo runtime.ClientAuthInfoWriter) (*GetLogOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetLogParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetLog", + Method: "GET", + PathPattern: "/logs/{logId}", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetLogReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*GetLogOK), nil + +} + +/* +GetLogContent get log content API +*/ +func (a *Client) GetLogContent(params *GetLogContentParams, authInfo runtime.ClientAuthInfoWriter) (*GetLogContentOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetLogContentParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetLogContent", + Method: "GET", + PathPattern: "/logs/{logId}/content", + ProducesMediaTypes: []string{"text/plain"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetLogContentReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*GetLogContentOK), nil + +} + +/* +GetLogs All logs of the process instance +*/ +func (a *Client) GetLogs(params *GetLogsParams, authInfo runtime.ClientAuthInfoWriter) (*GetLogsOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetLogsParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetLogs", + Method: "GET", + PathPattern: "/logs", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetLogsReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*GetLogsOK), nil + +} + +/* +GetMetadata Metadata, relevant to this SL process (Mandatory) +*/ +func (a *Client) GetMetadata(params *GetMetadataParams, authInfo runtime.ClientAuthInfoWriter) (*GetMetadataOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetMetadataParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetMetadata", + Method: "GET", + PathPattern: "/metadata", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetMetadataReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*GetMetadataOK), nil + +} + +/* +GetTasklist Complete list of the tasks of the running process with actual runtime information in the correct order +*/ +func (a *Client) GetTasklist(params *GetTasklistParams, authInfo runtime.ClientAuthInfoWriter) (*GetTasklistOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetTasklistParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetTasklist", + Method: "GET", + PathPattern: "/tasklist", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetTasklistReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*GetTasklistOK), nil + +} + +/* +GetTasklistTask get tasklist task API +*/ +func (a *Client) GetTasklistTask(params *GetTasklistTaskParams, authInfo runtime.ClientAuthInfoWriter) (*GetTasklistTaskOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetTasklistTaskParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetTasklistTask", + Method: "GET", + PathPattern: "/tasklist/{taskId}", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetTasklistTaskReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*GetTasklistTaskOK), nil + +} + +/* +GetTasklistTaskError get tasklist task error API +*/ +func (a *Client) GetTasklistTaskError(params *GetTasklistTaskErrorParams, authInfo runtime.ClientAuthInfoWriter) (*GetTasklistTaskErrorOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetTasklistTaskErrorParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetTasklistTaskError", + Method: "GET", + PathPattern: "/tasklist/{taskId}/error", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetTasklistTaskErrorReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*GetTasklistTaskErrorOK), nil + +} + +/* +GetTasklistTaskLogs get tasklist task logs API +*/ +func (a *Client) GetTasklistTaskLogs(params *GetTasklistTaskLogsParams, authInfo runtime.ClientAuthInfoWriter) (*GetTasklistTaskLogsOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetTasklistTaskLogsParams() + } + + result, err := a.transport.Submit(&runtime.ClientOperation{ + ID: "GetTasklistTaskLogs", + Method: "GET", + PathPattern: "/tasklist/{taskId}/logs", + ProducesMediaTypes: []string{"application/xml"}, + ConsumesMediaTypes: []string{"application/xml"}, + Schemes: []string{"http", "https"}, + Params: params, + Reader: &GetTasklistTaskLogsReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + }) + if err != nil { + return nil, err + } + return result.(*GetTasklistTaskLogsOK), nil + +} + +// SetTransport changes the transport on the client +func (a *Client) SetTransport(transport runtime.ClientTransport) { + a.transport = transport +} diff --git a/clients/slppclient/retryable_slpp_client.go b/clients/slppclient/retryable_slpp_client.go new file mode 100644 index 0000000..fb6ee20 --- /dev/null +++ b/clients/slppclient/retryable_slpp_client.go @@ -0,0 +1,99 @@ +package slppclient + +import ( + "net/http" + "time" + + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// RetryableSlppClient represents a client for the SLPP protocol +type RetryableSlppClient struct { + SlppClient SlppClientOperations + MaxRetriesCount int + RetryInterval time.Duration +} + +// NewRetryableSlppClient creates a new retryable SLPP client +func NewRetryableSlppClient(host, org, space, serviceID, processID string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) SlppClientOperations { + slppClient := NewSlppClient(host, org, space, serviceID, processID, rt, jar, tokenFactory) + return RetryableSlppClient{slppClient, 3, time.Second * 3} +} + +// GetMetadata retrieves the SLPP metadata +func (c RetryableSlppClient) GetMetadata() (*models.Metadata, error) { + getMetadataCb := func() (interface{}, error) { + return c.SlppClient.GetMetadata() + } + resp, err := baseclient.CallWithRetry(getMetadataCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(*models.Metadata), err +} + +// GetLogs retrieves all process logs +func (c RetryableSlppClient) GetLogs() (models.Logs, error) { + getLogsCb := func() (interface{}, error) { + return c.SlppClient.GetLogs() + } + resp, err := baseclient.CallWithRetry(getLogsCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(models.Logs), err +} + +// GetLogContent retrieves the content of the specified logs +func (c RetryableSlppClient) GetLogContent(logID string) (string, error) { + getLogContentCb := func() (interface{}, error) { + return c.SlppClient.GetLogContent(logID) + } + resp, err := baseclient.CallWithRetry(getLogContentCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(string), err +} + +//GetTasklist retrieves the tasklist for the current process +func (c RetryableSlppClient) GetTasklist() (models.Tasklist, error) { + getTasklistCb := func() (interface{}, error) { + return c.SlppClient.GetTasklist() + } + resp, err := baseclient.CallWithRetry(getTasklistCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(models.Tasklist), err +} + +//GetTasklistTask retrieves concrete task by taskID +func (c RetryableSlppClient) GetTasklistTask(taskID string) (*models.Task, error) { + getTasklistTaskCb := func() (interface{}, error) { + return c.SlppClient.GetTasklistTask(taskID) + } + resp, err := baseclient.CallWithRetry(getTasklistTaskCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(*models.Task), err +} + +//GetServiceID returns serviceID +func (c RetryableSlppClient) GetServiceID() string { + return c.SlppClient.GetServiceID() +} + +//GetError retrieves the current client error +func (c RetryableSlppClient) GetError() (*models.Error, error) { + getErrorCb := func() (interface{}, error) { + return c.SlppClient.GetError() + } + resp, err := baseclient.CallWithRetry(getErrorCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(*models.Error), err +} + +//ExecuteAction executes an action specified with actionID +func (c RetryableSlppClient) ExecuteAction(actionID string) error { + executeActionCb := func() (interface{}, error) { + return nil, c.SlppClient.ExecuteAction(actionID) + } + _, err := baseclient.CallWithRetry(executeActionCb, c.MaxRetriesCount, c.RetryInterval) + return err +} + +//GetActions retrieves the list of available actions for the current process +func (c RetryableSlppClient) GetActions() (models.Actions, error) { + getActionsCb := func() (interface{}, error) { + return c.SlppClient.GetActions() + } + resp, err := baseclient.CallWithRetry(getActionsCb, c.MaxRetriesCount, c.RetryInterval) + return resp.(models.Actions), err +} diff --git a/clients/slppclient/retryable_slpp_client_test.go b/clients/slppclient/retryable_slpp_client_test.go new file mode 100644 index 0000000..aba5d67 --- /dev/null +++ b/clients/slppclient/retryable_slpp_client_test.go @@ -0,0 +1,399 @@ +package slppclient_test + +import ( + "encoding/xml" + "net/http" + "net/http/cookiejar" + "time" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + "github.com/SAP/cf-mta-plugin/testutil" +) + +var _ = Describe("RetryableSlppClient", func() { + expectedRetriesCount := 4 + + Describe("GetMetadata", func() { + Context("with valid metadata returned by the backend", func() { + It("should return the metadata returned by the backend", func() { + client := newRetryableSlppClient(200, testutil.SlppMetadataResult) + result, err := client.GetMetadata() + testutil.ExpectNoErrorAndResult(err, result, &testutil.SlppMetadataResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlppClient(404, nil) + result, err := client.GetMetadata() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(500, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetMetadata() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(502, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetMetadata() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("GetLogs", func() { + Context("with valid process logs returned by the backend", func() { + It("should return the process logs returned by the backend", func() { + client := newRetryableSlppClient(200, testutil.LogsResult) + result, err := client.GetLogs() + testutil.ExpectNoErrorAndResult(err, result, testutil.LogsResult) + }) + }) + Context("with an empty content returned by the backend", func() { + It("should return empty process logs", func() { + client := newRetryableSlppClient(200, nil) + result, err := client.GetLogs() + testutil.ExpectNoErrorAndResult(err, result, + models.Logs{XMLName: xml.Name{Space: "", Local: ""}, Logs: nil}) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlppClient(400, nil) + result, err := client.GetLogs() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(500, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetLogs() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(502, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetLogs() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("GetLogContent", func() { + Context("with valid process log content returned by the backend", func() { + It("should return the process log content returned by the backend", func() { + client := newRetryableSlppClient(200, testutil.LogContent) + result, err := client.GetLogContent(testutil.LogID) + testutil.ExpectNoErrorAndResult(err, result, testutil.LogContent) + }) + }) + Context("with an empty content returned by the backend", func() { + It("should return empty process log content", func() { + client := newRetryableSlppClient(200, nil) + result, err := client.GetLogContent(testutil.LogID) + testutil.ExpectNoErrorAndResult(err, result, "") + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlppClient(400, nil) + result, err := client.GetLogContent(testutil.LogID) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(500, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetLogContent(testutil.LogID) + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(502, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetLogContent(testutil.LogID) + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("GetTasklist", func() { + Context("with valid tasklist returned by the backend", func() { + It("should return the tasklist returned by the backend", func() { + client := newRetryableSlppClient(200, testutil.TasklistResult) + result, err := client.GetTasklist() + testutil.ExpectNoErrorAndResult(err, result, testutil.TasklistResult) + }) + }) + Context("with an empty content returned by the backend", func() { + It("should return empty tasklist", func() { + client := newRetryableSlppClient(200, nil) + result, err := client.GetTasklist() + testutil.ExpectNoErrorAndResult(err, result, models.Tasklist{}) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlppClient(400, nil) + result, err := client.GetTasklist() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(500, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetTasklist() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(502, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetTasklist() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("GetTasklistTask", func() { + Context("with valid task returned by the backend", func() { + It("should return the task returned by the backend", func() { + client := newRetryableSlppClient(200, &testutil.TaskResult) + result, err := client.GetTasklistTask(testutil.ServiceID) + testutil.ExpectNoErrorAndResult(err, result, &testutil.TaskResult) + }) + }) + Context("with an empty content returned by the backend", func() { + It("should return empty task", func() { + client := newRetryableSlppClient(200, nil) + result, err := client.GetTasklistTask(testutil.ServiceID) + testutil.ExpectNoErrorAndResult(err, result, &models.Task{}) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlppClient(400, nil) + result, err := client.GetTasklistTask(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(500, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetTasklistTask(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(502, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetTasklistTask(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("GetError", func() { + Context("with valid client error returned by the backend", func() { + It("should return the client error returned by the backend", func() { + client := newRetryableSlppClient(200, testutil.ErrorResult) + result, err := client.GetError() + testutil.ExpectNoErrorAndResult(err, result, testutil.ErrorResult) + }) + }) + Context("with an empty content returned by the backend", func() { + It("should return empty client error", func() { + client := newRetryableSlppClient(200, nil) + result, err := client.GetError() + testutil.ExpectNoErrorAndResult(err, result, &models.Error{}) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newRetryableSlppClient(400, nil) + result, err := client.GetError() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(500, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetError() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(502, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + result, err := retryableSlppClient.GetError() + testutil.ExpectErrorAndZeroResult(err, result) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) + + Describe("ExecuteAction", func() { + Context("with success returned by the backend", func() { + It("should not return any errors", func() { + client := newRetryableSlppClient(204, nil) + err := client.ExecuteAction(testutil.ActionID) + testutil.ExpectNoError(err) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error", func() { + client := newRetryableSlppClient(400, nil) + err := client.ExecuteAction(testutil.ActionID) + testutil.ExpectError(err) + }) + }) + Context("with an 500 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(500, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + err := retryableSlppClient.ExecuteAction(testutil.ActionID) + testutil.ExpectError(err) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + Context("with an 502 server error returned by the backend", func() { + It("should return the error, zero result and retry expectedRetriesCount times", func() { + client := newRetryableSlppClient(502, nil) + retryableSlppClient := client.(slppclient.RetryableSlppClient) + err := retryableSlppClient.ExecuteAction(testutil.ActionID) + testutil.ExpectError(err) + mockSlppClient := retryableSlppClient.SlppClient.(*MockSlppClient) + Expect(mockSlppClient.GetRetriesCount()).To(Equal(expectedRetriesCount)) + }) + }) + }) +}) + +func newRetryableSlppClient(statusCode int, v interface{}) slppclient.SlppClientOperations { + tokenFactory := baseclient.NewCustomTokenFactory("test-token") + cookieJar, _ := cookiejar.New(nil) + roundTripper := testutil.NewCustomTransport(statusCode, v) + return NewMockRetryableSlppClient("http://localhost:1000", "test-org", "test-space", testutil.ServiceID, testutil.ProcessID, + roundTripper, cookieJar, tokenFactory) +} + +// NewMockRetryableSlppClient creates a new retryable REST client +func NewMockRetryableSlppClient(host, org, space, serviceID, processID string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) slppclient.SlppClientOperations { + slppClient := NewMockSlppClient(host, org, space, serviceID, processID, rt, jar, tokenFactory) + return slppclient.RetryableSlppClient{SlppClient: slppClient, MaxRetriesCount: 3, RetryInterval: time.Microsecond * 1} +} + +// MockSlppClient represents a client for the SLPP protocol +type MockSlppClient struct { + slppClient slppclient.SlppClientOperations + retriesCount int +} + +// NewMockSlppClient creates a new SLPP client +func NewMockSlppClient(host, org, space, serviceID, processID string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) slppclient.SlppClientOperations { + slppClient := slppclient.NewSlppClient(host, org, space, serviceID, processID, rt, jar, tokenFactory) + return &MockSlppClient{slppClient, 0} +} + +// GetMetadata retrieves the SLPP metadata +func (c *MockSlppClient) GetMetadata() (*models.Metadata, error) { + c.retriesCount++ + return c.slppClient.GetMetadata() +} + +// GetLogs retrieves all process logs +func (c *MockSlppClient) GetLogs() (models.Logs, error) { + c.retriesCount++ + return c.slppClient.GetLogs() +} + +// GetLogContent retrieves the content of the specified logs +func (c *MockSlppClient) GetLogContent(logID string) (string, error) { + c.retriesCount++ + return c.slppClient.GetLogContent(logID) +} + +//GetTasklist retrieves the tasklist for the current process +func (c *MockSlppClient) GetTasklist() (models.Tasklist, error) { + c.retriesCount++ + return c.slppClient.GetTasklist() +} + +//GetTasklistTask retrieves concrete task by taskID +func (c *MockSlppClient) GetTasklistTask(taskID string) (*models.Task, error) { + c.retriesCount++ + return c.slppClient.GetTasklistTask(taskID) +} + +//GetServiceID returns serviceID +func (c *MockSlppClient) GetServiceID() string { + c.retriesCount++ + return c.slppClient.GetServiceID() +} + +//GetError retrieves the current client error +func (c *MockSlppClient) GetError() (*models.Error, error) { + c.retriesCount++ + return c.slppClient.GetError() +} + +//ExecuteAction executes an action specified with actionID +func (c *MockSlppClient) ExecuteAction(actionID string) error { + c.retriesCount++ + return c.slppClient.ExecuteAction(actionID) +} + +//GetActions retrieves the list of available actions for the current process +func (c *MockSlppClient) GetActions() (models.Actions, error) { + c.retriesCount++ + return c.slppClient.GetActions() +} + +// GetRetriesCount returns retries count +func (c *MockSlppClient) GetRetriesCount() int { + return c.retriesCount +} diff --git a/clients/slppclient/slpp_client.go b/clients/slppclient/slpp_client.go new file mode 100644 index 0000000..6368d75 --- /dev/null +++ b/clients/slppclient/slpp_client.go @@ -0,0 +1,167 @@ +package slppclient + +import ( + "context" + "net/http" + + "github.com/go-openapi/strfmt" + + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" + "github.com/SAP/cf-mta-plugin/clients/slppclient/operations" +) + +// SlppClient represents a client for the SLPP protocol +type SlppClient struct { + baseclient.BaseClient + Client *Slpp + ServiceID string +} + +// NewSlppClient creates a new SLPP client +func NewSlppClient(host, org, space, serviceID, processID string, rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) SlppClientOperations { + t := baseclient.NewHTTPTransport(host, getSlppURL(org, space, serviceID, processID), rt, jar) + client := New(t, strfmt.Default) + return SlppClient{baseclient.BaseClient{TokenFactory: tokenFactory}, client, serviceID} + +} + +// GetMetadata retrieves the SLPP metadata +func (c SlppClient) GetMetadata() (*models.Metadata, error) { + params := &operations.GetMetadataParams{ + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return nil, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetMetadata(params, token) + if err != nil { + return nil, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +// GetLogs retrieves all process logs +func (c SlppClient) GetLogs() (models.Logs, error) { + params := &operations.GetLogsParams{ + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return models.Logs{}, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetLogs(params, token) + if err != nil { + return models.Logs{}, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +// GetLogContent retrieves the content of the specified logs +func (c SlppClient) GetLogContent(logID string) (string, error) { + params := &operations.GetLogContentParams{ + LogID: logID, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return "", baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetLogContent(params, token) + if err != nil { + return "", baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +//GetTasklist retrieves the tasklist for the current process +func (c SlppClient) GetTasklist() (models.Tasklist, error) { + params := &operations.GetTasklistParams{ + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return models.Tasklist{}, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetTasklist(params, token) + if err != nil { + return models.Tasklist{}, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +//GetTasklistTask retrieves concrete task by taskID +func (c SlppClient) GetTasklistTask(taskID string) (*models.Task, error) { + params := &operations.GetTasklistTaskParams{ + TaskID: taskID, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return nil, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetTasklistTask(params, token) + if err != nil { + return nil, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +//GetServiceID returns serviceID +func (c SlppClient) GetServiceID() string { + return c.ServiceID +} + +//GetError retrieves the current client error +func (c SlppClient) GetError() (*models.Error, error) { + params := &operations.GetErrorParams{ + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return nil, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetError(params, token) + if err != nil { + return nil, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +//ExecuteAction executes an action specified with actionID +func (c SlppClient) ExecuteAction(actionID string) error { + params := &operations.ExecuteActionParams{ + ActionID: actionID, + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return baseclient.NewClientError(err) + } + _, err = c.Client.Operations.ExecuteAction(params, token) + if err != nil { + return baseclient.NewClientError(err) + } + return nil +} + +//GetActions retrieves the list of available actions for the current process +func (c SlppClient) GetActions() (models.Actions, error) { + params := &operations.GetActionsParams{ + Context: context.TODO(), + } + token, err := c.TokenFactory.NewToken() + if err != nil { + return models.Actions{}, baseclient.NewClientError(err) + } + resp, err := c.Client.Operations.GetActions(params, token) + if err != nil { + return models.Actions{}, baseclient.NewClientError(err) + } + return resp.Payload, nil +} + +func getSlppURL(org, space, serviceID, processID string) string { + return "slprot/" + org + "/" + space + "/slp/runs/" + serviceID + "/" + processID +} diff --git a/clients/slppclient/slpp_client_operations.go b/clients/slppclient/slpp_client_operations.go new file mode 100644 index 0000000..da248cb --- /dev/null +++ b/clients/slppclient/slpp_client_operations.go @@ -0,0 +1,18 @@ +package slppclient + +import ( + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// SlppClientOperations is an interface having all SlppClient operations +type SlppClientOperations interface { + GetMetadata() (*models.Metadata, error) + GetLogs() (models.Logs, error) + GetLogContent(logID string) (string, error) + GetTasklist() (models.Tasklist, error) + GetTasklistTask(taskID string) (*models.Task, error) + GetServiceID() string + GetError() (*models.Error, error) + ExecuteAction(actionID string) error + GetActions() (models.Actions, error) +} diff --git a/clients/slppclient/slpp_client_test.go b/clients/slppclient/slpp_client_test.go new file mode 100644 index 0000000..e3b4e13 --- /dev/null +++ b/clients/slppclient/slpp_client_test.go @@ -0,0 +1,178 @@ +package slppclient_test + +import ( + "encoding/xml" + "net/http/cookiejar" + + . "github.com/onsi/ginkgo" + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + models "github.com/SAP/cf-mta-plugin/clients/models" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + "github.com/SAP/cf-mta-plugin/testutil" +) + +var _ = Describe("SlppClient", func() { + + Describe("GetMetadata", func() { + Context("with valid metadata returned by the backend", func() { + It("should return the metadata returned by the backend", func() { + client := newSlppClient(200, testutil.SlppMetadataResult) + result, err := client.GetMetadata() + testutil.ExpectNoErrorAndResult(err, result, &testutil.SlppMetadataResult) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlppClient(404, nil) + result, err := client.GetMetadata() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("GetLogs", func() { + Context("with valid process logs returned by the backend", func() { + It("should return the process logs returned by the backend", func() { + client := newSlppClient(200, testutil.LogsResult) + result, err := client.GetLogs() + testutil.ExpectNoErrorAndResult(err, result, testutil.LogsResult) + }) + }) + Context("with an empty content returned by the backend", func() { + It("should return empty process logs", func() { + client := newSlppClient(200, nil) + result, err := client.GetLogs() + testutil.ExpectNoErrorAndResult(err, result, + models.Logs{XMLName: xml.Name{Space: "", Local: ""}, Logs: nil}) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlppClient(400, nil) + result, err := client.GetLogs() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("GetLogContent", func() { + Context("with valid process log content returned by the backend", func() { + It("should return the process log content returned by the backend", func() { + client := newSlppClient(200, testutil.LogContent) + result, err := client.GetLogContent(testutil.LogID) + testutil.ExpectNoErrorAndResult(err, result, testutil.LogContent) + }) + }) + Context("with an empty content returned by the backend", func() { + It("should return empty process log content", func() { + client := newSlppClient(200, nil) + result, err := client.GetLogContent(testutil.LogID) + testutil.ExpectNoErrorAndResult(err, result, "") + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlppClient(400, nil) + result, err := client.GetLogContent(testutil.LogID) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("GetTasklist", func() { + Context("with valid tasklist returned by the backend", func() { + It("should return the tasklist returned by the backend", func() { + client := newSlppClient(200, testutil.TasklistResult) + result, err := client.GetTasklist() + testutil.ExpectNoErrorAndResult(err, result, testutil.TasklistResult) + }) + }) + Context("with an empty content returned by the backend", func() { + It("should return empty tasklist", func() { + client := newSlppClient(200, nil) + result, err := client.GetTasklist() + testutil.ExpectNoErrorAndResult(err, result, models.Tasklist{}) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlppClient(400, nil) + result, err := client.GetTasklist() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("GetTasklistTask", func() { + Context("with valid task returned by the backend", func() { + It("should return the task returned by the backend", func() { + client := newSlppClient(200, &testutil.TaskResult) + result, err := client.GetTasklistTask(testutil.ServiceID) + testutil.ExpectNoErrorAndResult(err, result, &testutil.TaskResult) + }) + }) + Context("with an empty content returned by the backend", func() { + It("should return empty tasklist", func() { + client := newSlppClient(200, nil) + result, err := client.GetTasklistTask(testutil.ServiceID) + testutil.ExpectNoErrorAndResult(err, result, &models.Task{}) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlppClient(400, nil) + result, err := client.GetTasklistTask(testutil.ServiceID) + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("GetError", func() { + Context("with valid client error returned by the backend", func() { + It("should return the client error returned by the backend", func() { + client := newSlppClient(200, testutil.ErrorResult) + result, err := client.GetError() + testutil.ExpectNoErrorAndResult(err, result, testutil.ErrorResult) + }) + }) + Context("with an empty content returned by the backend", func() { + It("should return empty client error", func() { + client := newSlppClient(200, nil) + result, err := client.GetError() + testutil.ExpectNoErrorAndResult(err, result, &models.Error{}) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error and a zero result", func() { + client := newSlppClient(400, nil) + result, err := client.GetError() + testutil.ExpectErrorAndZeroResult(err, result) + }) + }) + }) + + Describe("ExecuteAction", func() { + Context("with success returned by the backend", func() { + It("should not return any errors", func() { + client := newSlppClient(204, nil) + err := client.ExecuteAction(testutil.ActionID) + testutil.ExpectNoError(err) + }) + }) + Context("with an error returned by the backend", func() { + It("should return the error", func() { + client := newSlppClient(400, nil) + err := client.ExecuteAction(testutil.ActionID) + testutil.ExpectError(err) + }) + }) + }) +}) + +func newSlppClient(statusCode int, v interface{}) slppclient.SlppClientOperations { + tokenFactory := baseclient.NewCustomTokenFactory("test-token") + cookieJar, _ := cookiejar.New(nil) + roundTripper := testutil.NewCustomTransport(statusCode, v) + return slppclient.NewSlppClient("http://localhost:1000", "test-org", "test-space", testutil.ServiceID, testutil.ProcessID, + roundTripper, cookieJar, tokenFactory) +} diff --git a/clients/slppclient/slppclient_suite_test.go b/clients/slppclient/slppclient_suite_test.go new file mode 100644 index 0000000..cadae6c --- /dev/null +++ b/clients/slppclient/slppclient_suite_test.go @@ -0,0 +1,13 @@ +package slppclient_test + +import ( + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "testing" +) + +func TestSlppclient(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "Slppclient Suite") +} diff --git a/clients/swagger/rest.yaml b/clients/swagger/rest.yaml new file mode 100644 index 0000000..4b03f67 --- /dev/null +++ b/clients/swagger/rest.yaml @@ -0,0 +1,243 @@ +swagger: "2.0" +info: + version: 1.2.1 + title: MTA Deployer REST Protocol +host: example.com +basePath: /rest/ +securityDefinitions: + basic: + type: basic + oauth2: + type: oauth2 + tokenUrl: https://uaa.bosh-lite.com/oauth/token + flow: password + scopes: {} +security: + - basic: [] + - oauth2: [] +schemes: + - http + - https +consumes: + - application/xml +produces: + - application/xml +paths: + /operations: + get: + operationId: GetOperations + responses: + 200: + description: OK + schema: + $ref: "#/definitions/operations" + parameters: + - $ref: "#/parameters/last" + - $ref: "#/parameters/status" + /operations/{processId}: + get: + operationId: GetOperation + responses: + 200: + description: OK + schema: + $ref: "#/definitions/operation" + parameters: + - $ref: "#/parameters/processId" + /components: + get: + operationId: GetComponents + responses: + 200: + description: OK + schema: + $ref: "#/definitions/components" + /components/{mtaId}: + get: + operationId: GetMta + responses: + 200: + description: OK + schema: + $ref: "#/definitions/mta" + parameters: + - $ref: "#/parameters/mtaId" + /configuration-entries/purge: + post: + operationId: PurgeConfiguration + responses: + 204: + description: OK + parameters: + - $ref: "#/parameters/org" + - $ref: "#/parameters/space" +parameters: + processId: + name: processId + in: path + required: true + type: string + mtaId: + name: mtaId + in: path + required: true + type: string + last: + name: last + in: query + required: false + type: string + status: + name: status + in: query + required: false + type: array + items: + type: string + collectionFormat: multi + org: + name: org + in: query + required: true + type: string + space: + name: space + in: query + required: true + type: string +definitions: + operations: + type: array + items: + $ref: "#/definitions/operation" + xml: + name: ongoing-operations + wrapped: true + operation: + type: object + required: + - process-id + - process-type + - started-at + - space-id + - user + - state + - acquired-lock + properties: + process-id: + type: string + process-type: + $ref: "#/definitions/process_type" + started-at: + type: string + space-id: + type: string + mta-id: + type: string + user: + type: string + state: + $ref: "#/definitions/slp_task_state_enum" + acquired-lock: + type: boolean + xml: + name: ongoing-operation + components: + type: object + required: + - mtas + - standaloneApps + properties: + mtas: + type: array + items: + $ref: "#/definitions/mta" + xml: + wrapped: true + standaloneApps: + type: array + items: + type: string + xml: + name: standaloneApp + xml: + wrapped: true + mta: + type: object + required: + - metadata + - modules + - services + properties: + metadata: + type: object + required: + - id + - version + properties: + id: + type: string + version: + type: string + modules: + type: array + items: + type: object + required: + - moduleName + - appName + - services + - providedDependencies + properties: + moduleName: + type: string + appName: + type: string + services: + type: array + items: + type: string + xml: + name: service + xml: + wrapped: true + providedDependencies: + type: array + items: + type: string + xml: + name: providedDependency + xml: + wrapped: true + xml: + name: module + xml: + wrapped: true + services: + type: array + items: + type: string + xml: + name: service + xml: + wrapped: true + # Simple types + process_type: + type: string + enum: + - deploy + - undeploy + - blue-green-deploy + slp_task_state_enum: + type: string + enum: + - SLP_TASK_STATE_INITIAL + - SLP_TASK_STATE_RUNNING + - SLP_TASK_STATE_ERROR + - SLP_TASK_STATE_DIALOG + - SLP_TASK_STATE_FINISHED + - SLP_TASK_STATE_ABORTED + - SLP_TASK_STATE_SKIPPED + - SLP_TASK_STATE_ACTION_REQUIRED + - SLP_TASK_STATE_BREAKPOINT + - SLP_TASK_STATE_STOPPED diff --git a/clients/testutil/checks.go b/clients/testutil/checks.go new file mode 100644 index 0000000..11222c9 --- /dev/null +++ b/clients/testutil/checks.go @@ -0,0 +1,20 @@ +package testutil + +import ( + "testing" + + "github.com/go-openapi/runtime" + "github.com/stretchr/testify/assert" +) + +func CheckSuccess(t *testing.T, expected interface{}, actual interface{}) { + assert.IsType(t, expected, actual) + assert.EqualValues(t, expected, actual) +} + +func CheckError(t *testing.T, err error, opName string, status int, res interface{}) { + assert.IsType(t, (*runtime.APIError)(nil), err) + assert.Equal(t, opName, err.(*runtime.APIError).OperationName) + assert.Equal(t, status, err.(*runtime.APIError).Code) + assert.Nil(t, res) +} diff --git a/clients/testutil/server.go b/clients/testutil/server.go new file mode 100644 index 0000000..9e9636d --- /dev/null +++ b/clients/testutil/server.go @@ -0,0 +1,240 @@ +package testutil + +import ( + "bytes" + "io/ioutil" + "net/http" + "net/http/httptest" + "strings" + + "github.com/go-openapi/runtime" +) + +// NewGetXMLOKServer creates a new server that responds to GET requests on the specified path +// and accepting application/xml with 200 OK and the specified payload, and to all other +// requests with 400 Bad Request. +func NewGetXMLOKServer(path string, payload []byte) *httptest.Server { + return newServer(newStandardHandlerFunc(http.MethodGet, path, runtime.XMLMime, http.StatusOK, payload, nil, nil)) +} + +// NewGetXMLOAuthOKServer creates a new server that responds to GET requests on the specified path, +// accepting application/xml, and having the specified OAuth token with 200 OK and the specified +// payload, and to all other requests with 400 Bad Request. +func NewGetXMLOAuthOKServer(path string, token string, payload []byte) *httptest.Server { + return newServer(newStandardHandlerFunc(http.MethodGet, path, runtime.XMLMime, http.StatusOK, payload, + []requestChecker{oauthChecker{token}}, nil)) +} + +// NewPostXMLOKServer creates a new server that responds to POST requests on the specified path, +// accepting application/xml, and having content type also application/xml and the specified +// body with 200 OK and the specified payload, and to all other requests with 400 Bad Request. +func NewPostXMLOKServer(path string, body []byte, payload []byte) *httptest.Server { + return newServer(newStandardHandlerFunc(http.MethodPost, path, runtime.XMLMime, http.StatusOK, payload, + []requestChecker{bodyChecker{runtime.XMLMime, body}}, nil)) +} + +// NewPostFileXMLOKServer creates a new server that responds to POST requests on the specified path, +// accepting application/xml, and having content type multipart/form-data and the specified +// file key and content with 200 OK and the specified payload, and to all other requests with +// 400 Bad Request. +func NewPostFileXMLOKServer(path string, key string, content []byte, payload []byte) *httptest.Server { + return newServer(newStandardHandlerFunc(http.MethodPost, path, runtime.XMLMime, http.StatusOK, payload, + []requestChecker{fileChecker{key, content}}, nil)) +} + +// NewDeleteNoContentServer creates a new server that responds to DELETE requests on the +// specified path with 204 No Content, and to all other requests with 400 Bad Request. +func NewDeleteNoContentServer(path string) *httptest.Server { + return newServer(newStandardHandlerFunc(http.MethodDelete, path, "", http.StatusNoContent, nil, nil, nil)) +} + +// NewGetXMLOKDeleteNoContentCsrfServer creates a new composite server that responds to +// GET and DELETE requests on the specified path and implements a CSRF protection mechanism. +func NewGetXMLOKDeleteNoContentCsrfServer(path string, payload []byte) *httptest.Server { + ch := csrfCheckerHandler{"dummy"} + return newServer( + newStandardHandlerFunc(http.MethodGet, path, runtime.XMLMime, http.StatusOK, payload, nil, []responseHandler{ch}), + newStandardHandlerFunc(http.MethodDelete, path, "", http.StatusNoContent, nil, []requestChecker{ch}, nil), + ) +} + +// NewStatusServer creates a new server that responds to all requests with the specified status and +// no payload. +func NewStatusServer(status int) *httptest.Server { + return httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { + rw.WriteHeader(status) + })) +} + +type handlerFunc func(rw http.ResponseWriter, req *http.Request) bool + +type requestChecker interface { + check(req *http.Request) (bool, error) +} + +type responseHandler interface { + handle(rw http.ResponseWriter) error +} + +func newServer(funcs ...handlerFunc) *httptest.Server { + return httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { + for _, f := range funcs { + if f(rw, req) { + return + } + } + rw.WriteHeader(http.StatusBadRequest) + })) +} + +func newStandardHandlerFunc(method, path, accept string, status int, payload []byte, + checkers []requestChecker, handlers []responseHandler) handlerFunc { + return newHandlerFunc( + append([]requestChecker{standardChecker{method, path, accept}}, checkers...), + append(handlers, standardHandler{status, accept, payload}), + ) +} + +func newHandlerFunc(checkers []requestChecker, handlers []responseHandler) handlerFunc { + return func(rw http.ResponseWriter, req *http.Request) bool { + ok, err := checkRequest(req, checkers) + if err != nil { + handleError(rw, err) + return true + } + if !ok { + return false + } + err = handleResponse(rw, handlers) + if err != nil { + handleError(rw, err) + return true + } + return true + } +} + +func handleError(rw http.ResponseWriter, err error) { + rw.WriteHeader(http.StatusInternalServerError) + rw.Write([]byte(err.Error())) +} + +func checkRequest(req *http.Request, checkers []requestChecker) (bool, error) { + if checkers != nil { + for _, c := range checkers { + ok, err := c.check(req) + if err != nil { + return false, err + } + if !ok { + return false, nil + } + } + } + return true, nil +} + +func handleResponse(rw http.ResponseWriter, handlers []responseHandler) error { + if handlers != nil { + for _, h := range handlers { + err := h.handle(rw) + if err != nil { + return err + } + } + } + return nil +} + +type standardChecker struct { + method string + path string + accept string +} + +func (c standardChecker) check(req *http.Request) (bool, error) { + return req.Method == c.method && + req.URL.Path == c.path && + (c.accept == "" || req.Header.Get(runtime.HeaderAccept) == c.accept), nil +} + +type standardHandler struct { + status int + contentType string + payload []byte +} + +func (h standardHandler) handle(rw http.ResponseWriter) error { + if h.contentType != "" { + rw.Header().Add(runtime.HeaderContentType, h.contentType) + } + rw.WriteHeader(h.status) + if h.payload != nil { + _, err := rw.Write(h.payload) + if err != nil { + return err + } + } + return nil +} + +type oauthChecker struct { + token string +} + +func (c oauthChecker) check(req *http.Request) (bool, error) { + return req.Header.Get("Authorization") == "Bearer "+c.token, nil +} + +type bodyChecker struct { + contentType string + body []byte +} + +func (c bodyChecker) check(req *http.Request) (bool, error) { + if req.Header.Get(runtime.HeaderContentType) != c.contentType { + return false, nil + } + body, err := ioutil.ReadAll(req.Body) + if err != nil { + return false, err + } + return bytes.Equal(body, c.body), nil +} + +type fileChecker struct { + key string + content []byte +} + +func (c fileChecker) check(req *http.Request) (bool, error) { + if !strings.HasPrefix(req.Header.Get(runtime.HeaderContentType), runtime.MultipartFormMime) { + return false, nil + } + file, _, err := req.FormFile(c.key) + if err != nil { + return false, err + } + buf := new(bytes.Buffer) + _, err = buf.ReadFrom(file) + if err != nil { + return false, err + } + return bytes.Equal(buf.Bytes(), c.content), nil +} + +const csrfHeader = "X-CSRF-TOKEN" + +type csrfCheckerHandler struct { + token string +} + +func (ch csrfCheckerHandler) check(req *http.Request) (bool, error) { + return req.Header.Get(csrfHeader) == ch.token, nil +} + +func (ch csrfCheckerHandler) handle(rw http.ResponseWriter) error { + rw.Header().Add("X-Csrf-Header", csrfHeader) + rw.Header().Add("X-Csrf-Token", ch.token) + return nil +} diff --git a/commands/abort_action.go b/commands/abort_action.go new file mode 100644 index 0000000..fd5cb3f --- /dev/null +++ b/commands/abort_action.go @@ -0,0 +1,26 @@ +package commands + +import ( + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + "github.com/SAP/cf-mta-plugin/ui" + "github.com/cloudfoundry/cli/cf/terminal" +) + +// AbortAction represents action abort +type AbortAction struct{} + +// Execute aborts operation with the specified process id +func (a *AbortAction) Execute(processID, commandName string, slppClient slppclient.SlppClientOperations) ExecutionStatus { + + // Ensure the session is not expired + EnsureSlppSession(slppClient) + + ui.Say("Aborting multi-target app operation with id %s...", terminal.EntityNameColor(processID)) + err := slppClient.ExecuteAction("abort") + if err != nil { + ui.Failed("Could not abort multi-target app operation with id %s: %s", terminal.EntityNameColor(processID), err) + return Failure + } + ui.Ok() + return Success +} diff --git a/commands/action.go b/commands/action.go new file mode 100644 index 0000000..9100bac --- /dev/null +++ b/commands/action.go @@ -0,0 +1,24 @@ +package commands + +import slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + +// Action interface representing actions to be excuted on processes +type Action interface { + Execute(processID, commandName string, slppClient slppclient.SlppClientOperations) ExecutionStatus +} + +// GetActionToExecute returns the action to execute specified with action id +func GetActionToExecute(actionID string) Action { + switch actionID { + case "abort": + return &AbortAction{} + case "retry": + return &RetryAction{} + case "monitor": + return &MonitorAction{} + case "resume": + return &ResumeAction{} + } + + return nil +} diff --git a/commands/action_test.go b/commands/action_test.go new file mode 100644 index 0000000..ce1ff98 --- /dev/null +++ b/commands/action_test.go @@ -0,0 +1,113 @@ +package commands_test + +import ( + "fmt" + + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + "github.com/SAP/cf-mta-plugin/clients/slppclient/fakes" + "github.com/SAP/cf-mta-plugin/commands" + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/SAP/cf-mta-plugin/ui" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("Actions", func() { + const processID = "test-process-id" + const commandName = "deploy" + const actionID = "abort" + var slppClient slppclient.SlppClientOperations + var action commands.Action + var oc = testutil.NewUIOutputCapturer() + var ex = testutil.NewUIExpector() + + BeforeEach(func() { + ui.DisableTerminalOutput(true) + }) + + Describe("AbortAction", func() { + Describe("ExecuteAction", func() { + BeforeEach(func() { + action = &commands.AbortAction{} + slppClient = fakes.NewFakeSlppClientBuilder(). + GetMetadata(&testutil.SlppMetadataResult, nil). + ExecuteAction("abort", nil).Build() + }) + Context("with no error returned from backend", func() { + It("should abort the process and exit with zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return action.Execute(processID, commandName, slppClient).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, []string{"Aborting multi-target app operation with id test-process-id...\n", "OK\n"}) + }) + }) + Context("with an error returned from backend", func() { + It("should return error and exit with non-zero status", func() { + slppClient = fakes.NewFakeSlppClientBuilder(). + GetMetadata(&testutil.SlppMetadataResult, nil). + ExecuteAction("abort", fmt.Errorf("test-error")).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return action.Execute(processID, commandName, slppClient).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not abort multi-target app operation with id test-process-id: test-error", 1) + }) + }) + }) + }) + + Describe("RetryAction", func() { + Describe("ExecuteAction", func() { + BeforeEach(func() { + action = &commands.RetryAction{} + slppClient = fakes.NewFakeSlppClientBuilder(). + GetMetadata(&testutil.SlppMetadataResult, nil). + ExecuteAction("retry", nil). + GetTasklistTask(&testutil.TaskResult, nil). + Build() + }) + Context("with no error returned from backend", func() { + It("should retry the process and exit with zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return action.Execute(processID, commandName, slppClient).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, []string{"Retrying multi-target app operation with id test-process-id...\n", "OK\n", + "Monitoring process execution...\n", "Process finished.\n"}) + }) + }) + Context("with an error returned from backend", func() { + It("should return error and exit with non-zero status", func() { + slppClient = fakes.NewFakeSlppClientBuilder(). + GetMetadata(&testutil.SlppMetadataResult, nil). + ExecuteAction("retry", fmt.Errorf("test-error")). + GetTasklistTask(&testutil.TaskResult, nil). + Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return action.Execute(processID, commandName, slppClient).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not retry multi-target app operation with id test-process-id: test-error", 1) + }) + }) + }) + }) + + Describe("GetActionToExecute", func() { + Context("with correct action id", func() { + It("should return abort action to execute", func() { + actionToExecute := commands.GetActionToExecute("abort") + Expect(actionToExecute).NotTo(BeNil()) + Expect(actionToExecute).To(Equal(&commands.AbortAction{})) + }) + It("should return retry action to execute", func() { + actionToExecute := commands.GetActionToExecute("retry") + Expect(actionToExecute).NotTo(BeNil()) + Expect(actionToExecute).To(Equal(&commands.RetryAction{})) + }) + }) + Context("with incorrect action id", func() { + It("should return nil", func() { + actionToExecute := commands.GetActionToExecute("test") + Expect(actionToExecute).To(BeNil()) + }) + }) + }) +}) diff --git a/commands/base_command.go b/commands/base_command.go new file mode 100644 index 0000000..844e5f4 --- /dev/null +++ b/commands/base_command.go @@ -0,0 +1,532 @@ +package commands + +import ( + "crypto/tls" + "errors" + "flag" + "fmt" + "io/ioutil" + "net/http" + "net/http/cookiejar" + "net/url" + "os" + "sort" + "strings" + "unicode" + + "github.com/SAP/cf-mta-plugin/clients" + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/csrf" + "github.com/SAP/cf-mta-plugin/clients/models" + restclient "github.com/SAP/cf-mta-plugin/clients/restclient" + slmpclient "github.com/SAP/cf-mta-plugin/clients/slmpclient" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + "github.com/SAP/cf-mta-plugin/log" + "github.com/SAP/cf-mta-plugin/ui" + "github.com/cloudfoundry/cli/cf/terminal" + "github.com/cloudfoundry/cli/plugin" + "github.com/cloudfoundry/cli/plugin/models" +) + +const ( + // DeployServiceURLEnv is the deploy service URL environment variable + DeployServiceURLEnv = "DEPLOY_SERVICE_URL" + deployServiceURLOpt = "u" + operationIDOpt = "i" + actionOpt = "a" + forceOpt = "f" + deleteServicesOpt = "delete-services" + deleteServiceBrokersOpt = "delete-service-brokers" + noRestartSubscribedAppsOpt = "no-restart-subscribed-apps" + noFailOnMissingPermissionsOpt = "do-not-fail-on-missing-permissions" +) + +// BaseCommand represents a base command +type BaseCommand struct { + name string + cliConnection plugin.CliConnection + transport http.RoundTripper + jar http.CookieJar + clientFactory clients.ClientFactory + tokenFactory baseclient.TokenFactory +} + +// Initialize initializes the command with the specified name and CLI connection +func (c *BaseCommand) Initialize(name string, cliConnection plugin.CliConnection) { + log.Tracef("Initializing command '%s'\n", name) + c.InitializeAll(name, cliConnection, newTransport(), newCookieJar(), &defaultClientFactory{}, NewDefaultTokenFactory(cliConnection)) +} + +// InitializeAll initializes the command with the specified name, CLI connection, transport and cookie jar. +func (c *BaseCommand) InitializeAll(name string, cliConnection plugin.CliConnection, + transport http.RoundTripper, jar http.CookieJar, clientFactory clients.ClientFactory, tokenFactory baseclient.TokenFactory) { + c.name = name + c.cliConnection = cliConnection + c.transport = transport + c.jar = jar + c.clientFactory = clientFactory + c.tokenFactory = tokenFactory +} + +// Usage reports incorrect command usage +func (c *BaseCommand) Usage(message string) { + ui.Say(terminal.FailureColor("FAILED")) + ui.Say("Incorrect usage. %s\n", message) + _, err := c.cliConnection.CliCommand("help", c.name) + if err != nil { + ui.Failed("Could not display help: %s", err) + } +} + +// CreateFlags creates a flag set to be used for parsing command arguments +func (c *BaseCommand) CreateFlags(host *string) (*flag.FlagSet, error) { + flags := flag.NewFlagSet(c.name, flag.ContinueOnError) + deployServiceURL, err := c.GetDeployServiceURL() + if err != nil { + return nil, err + } + flags.StringVar(host, "u", deployServiceURL, "") + flags.SetOutput(ioutil.Discard) + return flags, nil +} + +// ParseFlags parses the flags and checks for wrong arguments and missing required flags +func (c *BaseCommand) ParseFlags(args []string, positionalArgNames []string, flags *flag.FlagSet, + required map[string]bool) error { + // Check for missing positional arguments + positionalArgsCount := len(positionalArgNames) + if len(args) < positionalArgsCount { + return fmt.Errorf(fmt.Sprintf("Missing positional argument '%s'.", positionalArgNames[len(args)])) + } + for i := 0; i < positionalArgsCount; i++ { + if flags.Lookup(strings.Replace(args[i], "-", "", 1)) != nil { + return fmt.Errorf("Missing positional argument '%s'.", positionalArgNames[i]) + } + } + + // Parse the arguments + err := flags.Parse(args[positionalArgsCount:]) + if err != nil { + return errors.New("Unknown or wrong flag.") + } + + // Check for wrong arguments + if flags.NArg() > 0 { + return errors.New("Wrong arguments.") + } + + var missingRequiredOptions []string + // Check for missing required flags + flags.VisitAll(func(f *flag.Flag) { + log.Traceln(f.Name, f.Value) + if required[f.Name] && f.Value.String() == "" { + missingRequiredOptions = append(missingRequiredOptions, f.Name) + } + }) + if len(missingRequiredOptions) != 0 { + return fmt.Errorf("Missing required options '%v'.", missingRequiredOptions) + } + return nil +} + +// ContainsSpecificOptions checks if the argument list contains all the specific options +func ContainsSpecificOptions(flags *flag.FlagSet, args []string, specificOptions map[string]string) (bool, error) { + var matchedOptions int + for _, arg := range args { + optionFlag := flags.Lookup(strings.Replace(arg, "-", "", 1)) + if optionFlag != nil && specificOptions[optionFlag.Name] == arg { + matchedOptions++ + } + } + + // TODO: Move this validation to the ParseFlags function. + if matchedOptions > 0 && matchedOptions < len(specificOptions) { + var keys []string + for key := range specificOptions { + keys = append(keys, key) + } + sort.Strings(keys) + return false, fmt.Errorf("All the %s options should be specified together", strings.Join(keys, " ")) + } + + return matchedOptions == len(specificOptions), nil +} + +// NewSlmpClient creates a new SLMP client +func (c *BaseCommand) NewSlmpClient(host string) (slmpclient.SlmpClientOperations, error) { + space, err := c.GetSpace() + if err != nil { + return nil, err + } + org, err := c.GetOrg() + if err != nil { + return nil, err + } + slppClient := c.clientFactory.NewSlmpClient(host, org.Name, space.Name, c.transport, c.jar, c.tokenFactory) + return slppClient, nil +} + +// NewSlppClient creates a new SLPP client for the specified service ID and process ID +func (c *BaseCommand) NewSlppClient(host, serviceID, processID string) (slppclient.SlppClientOperations, error) { + space, err := c.GetSpace() + if err != nil { + return nil, err + } + org, err := c.GetOrg() + if err != nil { + return nil, err + } + slmpClient := c.clientFactory.NewSlppClient(host, org.Name, space.Name, serviceID, processID, c.transport, c.jar, c.tokenFactory) + return slmpClient, nil +} + +// NewRestClient creates a new MTA deployer REST client +func (c *BaseCommand) NewRestClient(host string) (restclient.RestClientOperations, error) { + space, err := c.GetSpace() + if err != nil { + return nil, err + } + org, err := c.GetOrg() + if err != nil { + return nil, err + } + restClient := c.clientFactory.NewRestClient(host, org.Name, space.Name, c.transport, c.jar, c.tokenFactory) + return restClient, nil +} + +type Context struct { + Username string + Org string + Space string +} + +func (c *BaseCommand) GetContext() (Context, error) { + username, err := c.GetUsername() + if err != nil { + return Context{}, err + } + org, err := c.GetOrg() + if err != nil { + return Context{}, err + } + space, err := c.GetSpace() + if err != nil { + return Context{}, err + } + return Context{Org: org.Name, Space: space.Name, Username: username}, nil +} + +// GetOrg gets the current org name from the CLI connection +func (c *BaseCommand) GetOrg() (plugin_models.Organization, error) { + org, err := c.cliConnection.GetCurrentOrg() + if err != nil { + return plugin_models.Organization{}, fmt.Errorf("Could not get current org: %s", err) + } + if org.Name == "" { + return plugin_models.Organization{}, fmt.Errorf("No org and space targeted, use '%s' to target an org and a space", terminal.CommandColor("cf target -o ORG -s SPACE")) + } + return org, nil +} + +// GetSpace gets the current space name from the CLI connection +func (c *BaseCommand) GetSpace() (plugin_models.Space, error) { + space, err := c.cliConnection.GetCurrentSpace() + if err != nil { + return plugin_models.Space{}, fmt.Errorf("Could not get current space: %s", err) + } + + if space.Name == "" || space.Guid == "" { + return plugin_models.Space{}, fmt.Errorf("No space targeted, use '%s' to target a space", terminal.CommandColor("cf target -s")) + } + return space, nil +} + +// GetUsername gets the username from the CLI connection +func (c *BaseCommand) GetUsername() (string, error) { + username, err := c.cliConnection.Username() + if err != nil { + return "", fmt.Errorf("Could not get username: %s", err) + } + if username == "" { + return "", fmt.Errorf("Not logged in. Use '%s' to log in.", terminal.CommandColor("cf login")) + } + return username, nil +} + +// GetDeployServiceURL returns the deploy service URL +func (c *BaseCommand) GetDeployServiceURL() (string, error) { + deployServiceURL := os.Getenv(DeployServiceURLEnv) + if deployServiceURL == "" { + apiEndpoint, err := c.cliConnection.ApiEndpoint() + if err != nil { + return "", fmt.Errorf("Could not get API endpoint: %s", err) + } + if apiEndpoint == "" { + return "", fmt.Errorf("No api endpoint set. Use '%s' to set an endpoint.", terminal.CommandColor("cf api")) + } + url, err := url.Parse(apiEndpoint) + if err != nil { + return "", fmt.Errorf("Could not parse API endpoint %s: %s", terminal.EntityNameColor(apiEndpoint), err) + } + if strings.HasPrefix(url.Host, "api.cf.") { + deployServiceURL = "deploy-service.cfapps" + url.Host[6:] + } else if strings.HasPrefix(url.Host, "api.") { + deployServiceURL = "deploy-service" + url.Host[3:] + } + } + return deployServiceURL, nil +} + +// EnsureSlmpSession checks twice slmp metadata in order to recreate session if it is expired +func EnsureSlmpSession(slmpClient slmpclient.SlmpClientOperations) error { + var err error + err = CheckSlmpMetadata(slmpClient) + if err != nil { + return err + } + err = CheckSlmpMetadata(slmpClient) + if err != nil { + return err + } + return nil +} + +// CheckSlmpMetadata retrieves the SLMP metadata and checks if the SLMP version is a supported one +func CheckSlmpMetadata(slmpClient slmpclient.SlmpClientOperations) error { + metadata, err := slmpClient.GetMetadata() + if err != nil { + return fmt.Errorf("Could not get SLMP metadata: %s", err) + } + if metadata.Slmpversion != "1.2.0" { + return fmt.Errorf("Unsupported SLMP version %s", terminal.EntityNameColor(metadata.Slmpversion)) + } + return nil +} + +// EnsureSlppSession checks twice slpp metadata in order to recreate session if it is expired +func EnsureSlppSession(slppClient slppclient.SlppClientOperations) error { + var err error + err = CheckSlppMetadata(slppClient) + if err != nil { + return err + } + err = CheckSlppMetadata(slppClient) + if err != nil { + return err + } + return nil +} + +// CheckSlppMetadata retrieves the SLPP metadata and checks if the SLPP version is a supported one +func CheckSlppMetadata(slppClient slppclient.SlppClientOperations) error { + metadata, err := slppClient.GetMetadata() + if err != nil { + return fmt.Errorf("Could not get SLPP metadata: %s", err) + } + if metadata.Slppversion != "1.2.0" { + return fmt.Errorf("Unsupported SLPP version %s", terminal.EntityNameColor(metadata.Slppversion)) + } + return nil +} + +// GetServiceID returns the service ID of the process with the specified process ID. +// If such a process is not found, returns an empty string. +func GetServiceID(processID string, slmpClient slmpclient.SlmpClientOperations) (string, error) { + // Get process + process, err := slmpClient.GetProcess(processID) + if err != nil { + clientError := err.(*baseclient.ClientError) + if clientError.Code == 404 { + return "", fmt.Errorf("Multi-target app operation with id %s not found", processID) + } + return "", fmt.Errorf("Failed to get process: %s", err) + } + return process.Service.String(), nil +} + +// ExecuteAction executes the action over the process specified with operationID +func (c *BaseCommand) ExecuteAction(operationID, actionID, host string, serviceID ServiceID) ExecutionStatus { + // Create REST client + restClient, err := c.NewRestClient(host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // find ongoing operation by the specified operationID + ongoingOperation, err := c.findOngoingOperationByID(operationID, serviceID.ProcessType(), restClient) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + if ongoingOperation == nil { + ui.Failed("Multi-target app operation with id %s not found", terminal.EntityNameColor(operationID)) + return Failure + } + + // Create SLPP client for the found ongoing operation + slppClient, err := c.getSlppClientForOperation(host, ongoingOperation) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Finds the action specified with the actionID + action := GetActionToExecute(actionID) + if action == nil { + ui.Failed("Invalid action %s", terminal.EntityNameColor(actionID)) + return Failure + } + // Executes the action specified with actionID + return action.Execute(operationID, c.name, slppClient) +} + +// CheckOngoingOperation checks for ongoing operation for mta with the specified id and tries to abort it +func (c *BaseCommand) CheckOngoingOperation(mtaID string, host string, force bool) (bool, error) { + // Create REST client + restClient, err := c.NewRestClient(host) + if err != nil { + return false, err + } + + // Check if there is an ongoing operation for this MTA ID + ongoingOperation, err := c.findOngoingOperation(mtaID, restClient) + if err != nil { + return false, err + } + if ongoingOperation != nil { + slppClient, err := c.getSlppClientForOperation(host, ongoingOperation) + if err != nil { + return false, err + } + + // Abort the conflict process if confirmed by the user + if c.shouldAbortConflictingOperation(mtaID, force) { + action := GetActionToExecute("abort") + status := action.Execute(*ongoingOperation.ProcessID, c.name, slppClient) + if status == Failure { + return false, nil + } + } else { + ui.Warn("%s cancelled", capitalizeFirst(string(ongoingOperation.ProcessType))) + return false, nil + } + } + + return true, nil +} + +func (c *BaseCommand) getSlppClientForOperation(host string, ongoingOperation *models.Operation) (slppclient.SlppClientOperations, error) { + // Create SLPP client for the conflicting process + serviceID, err := ToServiceID(ongoingOperation.ProcessType) + if err != nil { + return nil, fmt.Errorf("Could not compute service ID from an ongoing operation's process type: %s", err.Error()) + } + slppClient, err := c.NewSlppClient(host, serviceID.String(), *ongoingOperation.ProcessID) + if err != nil { + return nil, err + } + + err = CheckSlppMetadata(slppClient) + if err != nil { + return nil, err + } + + return slppClient, nil +} + +func (c *BaseCommand) findOngoingOperationByID(processID string, processType models.ProcessType, restClient restclient.RestClientOperations) (*models.Operation, error) { + ongoingOperations, err := restClient.GetOperations(nil, nil) + if err != nil { + return nil, fmt.Errorf("Could not get ongoing operation with id %s: %s", terminal.EntityNameColor(processID), err) + } + + for _, ongoingOperation := range ongoingOperations.Operations { + if *ongoingOperation.ProcessID == processID && ongoingOperation.ProcessType == processType { + return ongoingOperation, nil + } + } + return nil, nil +} + +// FindOngoingOperation finds ongoing operation for mta with the specified id +func (c *BaseCommand) findOngoingOperation(mtaID string, restClient restclient.RestClientOperations) (*models.Operation, error) { + ongoingOperations, err := restClient.GetOperations(nil, nil) + if err != nil { + return nil, fmt.Errorf("Could not get ongoing operations for multi-target app %s: %s", terminal.EntityNameColor(mtaID), err) + } + for _, ongoingOperation := range ongoingOperations.Operations { + isConflicting, err := c.isConflicting(ongoingOperation, mtaID) + if err != nil { + return nil, err + } + if isConflicting { + return ongoingOperation, nil + } + } + return nil, nil +} + +func (c *BaseCommand) isConflicting(operation *models.Operation, mtaID string) (bool, error) { + space, err := c.GetSpace() + if err != nil { + return false, err + } + return operation.MtaID == mtaID && *operation.SpaceID == space.Guid && *operation.AcquiredLock, nil +} + +func (c *BaseCommand) shouldAbortConflictingOperation(mtaID string, force bool) bool { + if force { + return true + } + return ui.Confirm("There is an ongoing operation for multi-target app %s. Do you want to abort it? (y/n)", + terminal.EntityNameColor(mtaID)) +} + +func newTransport() http.RoundTripper { + csrfx := csrf.Csrf{Header: "", Token: ""} + // TODO Make sure SSL verification is only skipped if the CLI is configured this way + httpTransport := http.DefaultTransport.(*http.Transport) + httpTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true} + return csrf.Transport{Transport: httpTransport, Csrf: &csrfx} +} + +func newCookieJar() http.CookieJar { + jar, err := cookiejar.New(nil) + if err != nil { + panic(fmt.Sprintf("Could not create cookie jar: %s", err)) + } + return jar +} + +type defaultClientFactory struct{} + +func (d *defaultClientFactory) NewSlmpClient(host, org, space string, + rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) slmpclient.SlmpClientOperations { + return slmpclient.NewRetryableSlmpClient(host, org, space, rt, jar, tokenfactory) +} + +func (d *defaultClientFactory) NewSlppClient(host, org, space, serviceID, processID string, + rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) slppclient.SlppClientOperations { + return slppclient.NewRetryableSlppClient(host, org, space, serviceID, processID, rt, jar, tokenfactory) +} + +func (d *defaultClientFactory) NewRestClient(host, org, space string, + rt http.RoundTripper, jar http.CookieJar, tokenfactory baseclient.TokenFactory) restclient.RestClientOperations { + return restclient.NewRetryableRestClient(host, org, space, rt, jar, tokenfactory) +} + +func getTokenValue(tokenString string) string { + // TODO(ivan): check whether there are >1 elements + return strings.Fields(tokenString)[1] +} + +func capitalizeFirst(s string) string { + if s == "" { + return s + } + a := []rune(s) + a[0] = unicode.ToUpper(a[0]) + return string(a) +} diff --git a/commands/base_command_test.go b/commands/base_command_test.go new file mode 100644 index 0000000..d88b6bf --- /dev/null +++ b/commands/base_command_test.go @@ -0,0 +1,320 @@ +package commands_test + +// +import ( + "fmt" + "net/http" + "os" + + "github.com/cloudfoundry/cli/cf/terminal" + + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" + fakes "github.com/SAP/cf-mta-plugin/clients/restclient/fakes" + slmpfake "github.com/SAP/cf-mta-plugin/clients/slmpclient/fakes" + slppfake "github.com/SAP/cf-mta-plugin/clients/slppclient/fakes" + "github.com/SAP/cf-mta-plugin/commands" + cmd_fakes "github.com/SAP/cf-mta-plugin/commands/fakes" + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/SAP/cf-mta-plugin/ui" + plugin_fakes "github.com/cloudfoundry/cli/plugin/fakes" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("BaseCommand", func() { + const org = "test-org" + const space = "test-space" + const user = "test-user" + + var fakeCliConnection *plugin_fakes.FakeCliConnection + var command *commands.BaseCommand + var oc = testutil.NewUIOutputCapturer() + var ex = testutil.NewUIExpector() + + fakeSlmpClientBuilder := slmpfake.NewFakeSlmpClientBuilder() + fakeSlppClientBuilder := slppfake.NewFakeSlppClientBuilder() + testTokenFactory := commands.NewTestTokenFactory(fakeCliConnection) + + BeforeEach(func() { + ui.DisableTerminalOutput(true) + command = &commands.BaseCommand{} + fakeCliConnection = cmd_fakes.NewFakeCliConnectionBuilder(). + CurrentOrg("test-org-guid", org, nil). + CurrentSpace("test-space-guid", space, nil). + Username(user, nil). + AccessToken("bearer test-token", nil). + APIEndpoint("https://api.test.ondemand.com", nil).Build() + + }) + + Describe("CheckSlmpMetadata", func() { + Context("with valid SLMP metadata returned by the backend", func() { + It("should not exit or report any errors", func() { + client := fakeSlmpClientBuilder.GetMetadata(&testutil.SlmpMetadataResult, nil).Build() + Expect(commands.CheckSlmpMetadata(client)).Should(Succeed()) + }) + }) + Context("with invalid SLMP metadata returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + client := fakeSlmpClientBuilder.GetMetadata(testutil.GetSlmpMetadata("invalid-version"), nil).Build() + Expect(commands.CheckSlmpMetadata(client)).Should(MatchError(fmt.Errorf("Unsupported SLMP version %s", terminal.EntityNameColor("invalid-version")))) + }) + }) + Context("with an error returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + client := fakeSlmpClientBuilder.GetMetadata(nil, fmt.Errorf("unknown error (status 500)")).Build() + Expect(commands.CheckSlmpMetadata(client)).Should(MatchError("Could not get SLMP metadata: unknown error (status 500)")) + }) + }) + }) + + Describe("CheckSlppMetadata", func() { + Context("with valid SLPP metadata returned by the backend", func() { + It("should not exit or report any errors", func() { + client := fakeSlppClientBuilder.GetMetadata(&testutil.SlppMetadataResult, nil).GetTasklistTask(&testutil.TaskResult, nil).Build() + Expect(commands.CheckSlppMetadata(client)).Should(Succeed()) + }) + }) + Context("with invalid SLPP metadata returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + client := fakeSlppClientBuilder.GetMetadata(testutil.GetSlppMetadata("invalid-version"), nil).Build() + Expect(commands.CheckSlppMetadata(client)).Should(MatchError(fmt.Errorf("Unsupported SLPP version %s", terminal.EntityNameColor("invalid-version")))) + }) + }) + Context("with an error returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + client := fakeSlppClientBuilder.GetMetadata(nil, fmt.Errorf("unknown error (status 500)")).Build() + Expect(commands.CheckSlppMetadata(client)).Should(MatchError("Could not get SLPP metadata: unknown error (status 500)")) + }) + }) + }) + + Describe("GetServiceID", func() { + Context("with valid services and processes returned by the backend", func() { + It("should not exit or report any errors", func() { + client := fakeSlmpClientBuilder. + GetProcess(testutil.ProcessID, &testutil.ProcessResult, nil).Build() + Expect(commands.GetServiceID(testutil.ProcessID, client)).Should(Equal(testutil.ServiceID)) + }) + }) + Context("with an error returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + var clientError = baseclient.NewClientError(testutil.ClientError) + client := fakeSlmpClientBuilder.GetProcess(testutil.ProcessID, nil, clientError).Build() + _, err := commands.GetServiceID(testutil.ProcessID, client) + Expect(err).Should(MatchError("Multi-target app operation with id 111 not found")) + }) + }) + }) + + Describe("GetOrg", func() { + Context("with valid org returned by the CLI connection", func() { + It("should not exit or report any errors", func() { + command.Initialize("test", fakeCliConnection) + o, err := command.GetOrg() + Expect(err).ShouldNot(HaveOccurred()) + Expect(o.Name).To(Equal(org)) + }) + }) + Context("with no org returned by the CLI connection", func() { + It("should print an error and exit with a non-zero status", func() { + fakeCliConnection := cmd_fakes.NewFakeCliConnectionBuilder(). + CurrentOrg("", "", nil).Build() + command.Initialize("test", fakeCliConnection) + _, err := command.GetOrg() + Expect(err).To(MatchError(fmt.Errorf("No org and space targeted, use '%s' to target an org and a space", terminal.CommandColor("cf target -o ORG -s SPACE")))) + }) + }) + }) + + Describe("GetSpace", func() { + Context("with valid space returned by the CLI connection", func() { + It("should not exit or report any errors", func() { + command.Initialize("test", fakeCliConnection) + s, err := command.GetSpace() + Expect(err).ShouldNot(HaveOccurred()) + Expect(s.Name).To(Equal(space)) + }) + }) + Context("with no space returned by the CLI connection", func() { + It("should print an error and exit with a non-zero status", func() { + fakeCliConnection := cmd_fakes.NewFakeCliConnectionBuilder(). + CurrentSpace("", "", nil).Build() + command.Initialize("test", fakeCliConnection) + _, err := command.GetSpace() + Expect(err).To(MatchError(fmt.Errorf("No space targeted, use '%s' to target a space", terminal.CommandColor("cf target -s")))) + }) + }) + }) + + Describe("GetUsername", func() { + Context("with valid username returned by the CLI connection", func() { + It("should not exit or report any errors", func() { + command.Initialize("test", fakeCliConnection) + Expect(command.GetUsername()).To(Equal(user)) + }) + }) + Context("with no space returned by the CLI connection", func() { + It("should print an error and exit with a non-zero status", func() { + fakeCliConnection := cmd_fakes.NewFakeCliConnectionBuilder(). + Username("", nil).Build() + command.Initialize("test", fakeCliConnection) + _, err := command.GetUsername() + Expect(err).To(MatchError(fmt.Errorf("Not logged in. Use '%s' to log in.", terminal.CommandColor("cf login")))) + }) + }) + }) + + Describe("GetDeployServiceHost", func() { + Context("with an environment variable", func() { + BeforeEach(func() { + os.Setenv("DEPLOY_SERVICE_URL", "test") + }) + It("should return the deploy service host set in the environment", func() { + command.Initialize("test", fakeCliConnection) + Expect(command.GetDeployServiceURL()).To(Equal("test")) + }) + AfterEach(func() { + os.Clearenv() + }) + }) + Context("with valid API endpoint returned by the CLI connection", func() { + It("should return the deploy service host constructed from the API endpoint", func() { + command.Initialize("test", fakeCliConnection) + Expect(command.GetDeployServiceURL()).To(Equal("deploy-service.test.ondemand.com")) + }) + }) + Context("with no API endpoint returned by the CLI connection", func() { + It("should print an error and exit with a non-zero status", func() { + fakeCliConnection := cmd_fakes.NewFakeCliConnectionBuilder(). + APIEndpoint("", nil).Build() + command.Initialize("test", fakeCliConnection) + _, err := command.GetDeployServiceURL() + Expect(err).To(MatchError(fmt.Errorf("No api endpoint set. Use '%s' to set an endpoint.", terminal.CommandColor("cf api")))) + }) + }) + }) + + Describe("CheckOngoingOperation", func() { + var wasAborted bool + var err error + var mtaID string + var ongoingOperationToReturn *models.Operation + + var fakeRestClientBuilder *fakes.FakeRestClientBuilder + var testClientFactory *commands.TestClientFactory + + BeforeEach(func() { + mtaID = "mtaId" + ongoingOperationToReturn = testutil.GetOperation("test", "test-space-guid", mtaID, "deploy", "SLP_TASK_STATE_ERROR", true) + + fakeRestClientBuilder = fakes.NewFakeRestClientBuilder() + testClientFactory = commands.NewTestClientFactory(fakeSlmpClientBuilder.Build(), fakeSlppClientBuilder.Build(), fakeRestClientBuilder.Build()) + + testClientFactory.RestClient = fakeRestClientBuilder. + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{ongoingOperationToReturn}), nil).Build() + testClientFactory.SlppClient = fakeSlppClientBuilder. + GetMetadata(&testutil.SlppMetadataResult, nil).Build() + + command.InitializeAll("test", fakeCliConnection, testutil.NewCustomTransport(http.StatusOK, nil), nil, testClientFactory, testTokenFactory) + }) + Context("with valid ongoing operations", func() { + It("should abort and exit with zero status", func() { + output := oc.CaptureOutput(func() { + wasAborted, err = command.CheckOngoingOperation(mtaID, "test-host", true) + }) + Expect(err).ShouldNot(HaveOccurred()) + Expect(wasAborted).To(BeTrue()) + Expect(output).To(Equal([]string{"Aborting multi-target app operation with id test...\n", "OK\n"})) + }) + }) + Context("with one ongoing operation which does not have an MTA ID", func() { + It("should exit with zero status", func() { + nonConflictingOperation := testutil.GetOperation("111", "space-guid", "", "deploy", "SLP_TASK_STATE_ERROR", false) + testClientFactory.RestClient = fakeRestClientBuilder. + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{nonConflictingOperation}), nil).Build() + wasAborted, err = command.CheckOngoingOperation(mtaID, "test-host", true) + Expect(err).ShouldNot(HaveOccurred()) + Expect(wasAborted).To(BeTrue()) + }) + }) + Context("with no ongoing operations", func() { + It("should exit with zero status", func() { + testClientFactory.RestClient = fakeRestClientBuilder. + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{}), nil).Build() + wasAborted, err = command.CheckOngoingOperation(mtaID, "test-host", true) + Expect(err).ShouldNot(HaveOccurred()) + Expect(wasAborted).To(BeTrue()) + }) + }) + Context("with valid ongoing operations and no force option specified", func() { + It("should exit with non-zero status", func() { + output := oc.CaptureOutput(func() { + wasAborted, err = command.CheckOngoingOperation(mtaID, "test-host", false) + }) + Expect(err).ShouldNot(HaveOccurred()) + Expect(wasAborted).To(BeFalse()) + Expect(output).To(Equal([]string{"", + "There is an ongoing operation for multi-target app mtaId. Do you want to abort it? (y/n)> ", + "Deploy cancelled\n"})) + }) + }) + }) + + Describe("ExecuteAction", func() { + var ongoingOperationToReturn *models.Operation + fakeRestClientBuilder := fakes.NewFakeRestClientBuilder() + testClientfactory := commands.NewTestClientFactory(fakeSlmpClientBuilder.Build(), fakeSlppClientBuilder.Build(), fakeRestClientBuilder.Build()) + BeforeEach(func() { + ongoingOperationToReturn = testutil.GetOperation("test-process-id", "test-space-guid", "test", "deploy", "SLP_TASK_STATE_ERROR", true) + testClientfactory.RestClient = fakeRestClientBuilder. + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{ongoingOperationToReturn}), nil).Build() + testClientfactory.SlppClient = fakeSlppClientBuilder. + GetMetadata(&testutil.SlppMetadataResult, nil). + GetTasklist(testutil.TasklistResult, nil). + ExecuteAction("abort", nil). + ExecuteAction("retry", nil).Build() + command.InitializeAll("test", fakeCliConnection, testutil.NewCustomTransport(200, nil), nil, testClientfactory, testTokenFactory) + }) + Context("with valid process id and valid action id", func() { + It("should abort and exit with zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.ExecuteAction("test-process-id", "abort", "test-host", commands.DeployServiceID).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, []string{"Aborting multi-target app operation with id test-process-id...\n", "OK\n"}) + }) + }) + Context("with non-valid process id and valid action id", func() { + It("should return error and exit with non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.ExecuteAction("not-valid-process-id", "abort", "test-host", commands.DeployServiceID).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Multi-target app operation with id not-valid-process-id not found", 0) + }) + }) + + Context("with valid process id and invalid action id", func() { + It("should return error and exit with non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.ExecuteAction("test-process-id", "not-existing-action", "test-host", commands.DeployServiceID).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Invalid action not-existing-action", 0) + }) + }) + + Context("with valid process id and valid action id", func() { + It("should retry the process and exit with zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.ExecuteAction("test-process-id", "retry", "test-host", commands.DeployServiceID).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, []string{"Retrying multi-target app operation with id test-process-id...\n", "OK\n", + "Monitoring process execution...\n", "Process finished.\n"}) + }) + }) + }) +}) + +func newClientError(code int, status, description string) error { + return &baseclient.ClientError{Code: code, Status: status, Description: description} +} diff --git a/commands/blue_green_deploy_command.go b/commands/blue_green_deploy_command.go new file mode 100644 index 0000000..1347696 --- /dev/null +++ b/commands/blue_green_deploy_command.go @@ -0,0 +1,77 @@ +package commands + +import ( + "flag" + "strconv" + + "github.com/SAP/cf-mta-plugin/util" + "github.com/cloudfoundry/cli/plugin" +) + +const noConfirmOpt = "no-confirm" + +// BlueGreenDeployCommand is a command for blue green deployment of MTAs. +type BlueGreenDeployCommand struct { + DeployCommand +} + +// NewBlueGreenDeployCommand creates a new BlueGreenDeployCommand. +func NewBlueGreenDeployCommand() *BlueGreenDeployCommand { + return &BlueGreenDeployCommand{DeployCommand{BaseCommand{}, BgDeployServiceID, blueGreenDeployCommandFlagsDefiner(), blueGreenDeployProcessParametersSetter()}} +} + +// GetPluginCommand returns more information for the blue green deploy command. +func (c *BlueGreenDeployCommand) GetPluginCommand() plugin.Command { + return plugin.Command{ + Name: "bg-deploy", + HelpText: "Deploy a multi-target app using blue-green deployment", + UsageDetails: plugin.Usage{ + Usage: `Deploy a multi-target app using blue-green deployment + cf bg-deploy MTA [-e EXT_DESCRIPTOR[,...]] [-t TIMEOUT] [--version-rule VERSION_RULE] [-u URL] [-f] [--no-start] [--use-namespaces] [--no-namespaces-for-services] [--delete-services] [--delete-service-keys] [--delete-service-brokers] [--keep-files] [--no-restart-subscribed-apps] [--no-confirm] [--do-not-fail-on-missing-permissions] + + Perform action on an active deploy operation + cf deploy -i OPERATION_ID -a ACTION [-u URL]`, + Options: map[string]string{ + extDescriptorsOpt: "Extension descriptors", + deployServiceURLOpt: "Deploy service URL, by default 'deploy-service.'", + timeoutOpt: "Start timeout in seconds", + versionRuleOpt: "Version rule (HIGHER, SAME_HIGHER, ALL)", + operationIDOpt: "Active deploy operation id", + actionOpt: "Action to perform on active deploy operation (abort, retry, monitor)", + forceOpt: "Force deploy without confirmation for aborting conflicting processes", + util.GetShortOption(noStartOpt): "Do not start apps", + util.GetShortOption(useNamespacesOpt): "Use namespaces in app and service names", + util.GetShortOption(noNamespacesForServicesOpt): "Do not use namespaces in service names", + util.GetShortOption(deleteServicesOpt): "Recreate changed services / delete discontinued services", + util.GetShortOption(deleteServiceKeysOpt): "Delete existing service keys and apply the new ones", + util.GetShortOption(deleteServiceBrokersOpt): "Delete discontinued service brokers", + util.GetShortOption(keepFilesOpt): "Keep files used for deployment", + util.GetShortOption(noRestartSubscribedAppsOpt): "Do not restart subscribed apps, updated during the deployment", + util.GetShortOption(noConfirmOpt): "Do not require confirmation for deleting the previously deployed MTA apps", + util.GetShortOption(noFailOnMissingPermissionsOpt): "Do not fail on missing permissions for admin operations", + }, + }, + } +} + +// ServiceID returns the service ID of the processes started by DeployCommand +func (c *BlueGreenDeployCommand) ServiceID() ServiceID { + return BgDeployServiceID +} + +// BlueGreenDeployCommandFlagsDefiner returns a new CommandFlagsDefiner. +func blueGreenDeployCommandFlagsDefiner() CommandFlagsDefiner { + return func(flags *flag.FlagSet) map[string]interface{} { + optionValues := deployCommandFlagsDefiner()(flags) + optionValues[noConfirmOpt] = flags.Bool(noConfirmOpt, false, "") + return optionValues + } +} + +// BlueGreenDeployProcessParametersSetter returns a new ProcessParametersSetter. +func blueGreenDeployProcessParametersSetter() ProcessParametersSetter { + return func(optionValues map[string]interface{}, processBuilder *util.ProcessBuilder) { + deployProcessParametersSetter()(optionValues, processBuilder) + processBuilder.Parameter("noConfirm", strconv.FormatBool(GetBoolOpt(noConfirmOpt, optionValues))) + } +} diff --git a/commands/command.go b/commands/command.go new file mode 100644 index 0000000..0fedcce --- /dev/null +++ b/commands/command.go @@ -0,0 +1,12 @@ +package commands + +import ( + "github.com/cloudfoundry/cli/plugin" +) + +// Command is an interface that should be implemented by all commands +type Command interface { + GetPluginCommand() plugin.Command + Initialize(name string, cliConnection plugin.CliConnection) + Execute(args []string) ExecutionStatus +} diff --git a/commands/commands_suite_test.go b/commands/commands_suite_test.go new file mode 100644 index 0000000..d58417b --- /dev/null +++ b/commands/commands_suite_test.go @@ -0,0 +1,13 @@ +package commands_test + +import ( + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "testing" +) + +func TestCommands(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "Commands Suite") +} diff --git a/commands/default_token_factory.go b/commands/default_token_factory.go new file mode 100644 index 0000000..357ef4b --- /dev/null +++ b/commands/default_token_factory.go @@ -0,0 +1,73 @@ +package commands + +import ( + "errors" + "fmt" + "time" + + "github.com/cloudfoundry/cli/plugin" + "github.com/dgrijalva/jwt-go" + "github.com/go-openapi/runtime" + "github.com/go-openapi/runtime/client" +) + +// DefaultTokenFactory factory for retrieving tokens +type DefaultTokenFactory struct { + cliConnection plugin.CliConnection + cachedToken string + cachedTokenTime int64 +} + +// NewDefaultTokenFactory creates default token factory +func NewDefaultTokenFactory(cliConnection plugin.CliConnection) *DefaultTokenFactory { + return &DefaultTokenFactory{ + cliConnection: cliConnection, + } +} + +// NewToken retrives outh token +func (t *DefaultTokenFactory) NewToken() (runtime.ClientAuthInfoWriter, error) { + var expirationTime int64 + if t.cachedToken != "" { + var err error + expirationTime, err = getTokenExpirationTime(t.cachedToken) + if err != nil { + return nil, err + } + } + currentTimeInSeconds := time.Now().Unix() + expirationTime = (expirationTime - currentTimeInSeconds) / 2 + if currentTimeInSeconds-t.cachedTokenTime >= expirationTime { + tokenString, err := t.cliConnection.AccessToken() + if err != nil { + return nil, fmt.Errorf("Could not get access token: %s", err) + } + t.cachedTokenTime = currentTimeInSeconds + t.cachedToken = getTokenValue(tokenString) + } + return client.BearerToken(t.cachedToken), nil +} + +func getTokenExpirationTime(tokenString string) (int64, error) { + // Parse jwt token string + parser := jwt.Parser{ + SkipClaimsValidation: true, + } + token, err := parser.Parse(tokenString, func(token *jwt.Token) (interface{}, error) { + return token, nil + }) + + if err != nil && err.Error() != "key is of invalid type" { + return 0, err + } + + // Try to get token expiration time + claims, ok := token.Claims.(jwt.MapClaims) + if !ok { + return 0, errors.New("Could not read token claims") + } + if value, ok := claims["exp"]; ok { + return int64(value.(float64)), nil + } + return 0, errors.New("Could not get token exipiration time") +} diff --git a/commands/deploy_command.go b/commands/deploy_command.go new file mode 100644 index 0000000..8adfa1c --- /dev/null +++ b/commands/deploy_command.go @@ -0,0 +1,323 @@ +package commands + +import ( + "flag" + "os" + "path/filepath" + "strconv" + "strings" + + "github.com/SAP/cf-mta-plugin/clients/models" + "github.com/SAP/cf-mta-plugin/log" + "github.com/SAP/cf-mta-plugin/ui" + "github.com/SAP/cf-mta-plugin/util" + "github.com/cloudfoundry/cli/cf/terminal" + "github.com/cloudfoundry/cli/plugin" +) + +const ( + extDescriptorsOpt = "e" + timeoutOpt = "t" + versionRuleOpt = "version-rule" + noStartOpt = "no-start" + useNamespacesOpt = "use-namespaces" + noNamespacesForServicesOpt = "no-namespaces-for-services" + deleteServiceKeysOpt = "delete-service-keys" + keepFilesOpt = "keep-files" +) + +var reportedProgressMessages []string + +// DeployCommand is a command for deploying an MTA archive +type DeployCommand struct { + BaseCommand + serviceID ServiceID + commandFlagsDefiner CommandFlagsDefiner + processParametersSetter ProcessParametersSetter +} + +// NewDeployCommand creates a new deploy command. +func NewDeployCommand() *DeployCommand { + return &DeployCommand{BaseCommand{}, DeployServiceID, deployCommandFlagsDefiner(), deployProcessParametersSetter()} +} + +// GetPluginCommand returns the plugin command details +func (c *DeployCommand) GetPluginCommand() plugin.Command { + return plugin.Command{ + Name: "deploy", + HelpText: "Deploy a new multi-target app or sync changes to an existing one", + UsageDetails: plugin.Usage{ + Usage: `Deploy a multi-target app archive + cf deploy MTA [-e EXT_DESCRIPTOR[,...]] [-t TIMEOUT] [--version-rule VERSION_RULE] [-u URL] [-f] [--no-start] [--use-namespaces] [--no-namespaces-for-services] [--delete-services] [--delete-service-keys] [--delete-service-brokers] [--keep-files] [--no-restart-subscribed-apps] [--do-not-fail-on-missing-permissions] + + Perform action on an active deploy operation + cf deploy -i OPERATION_ID -a ACTION [-u URL]`, + Options: map[string]string{ + extDescriptorsOpt: "Extension descriptors", + deployServiceURLOpt: "Deploy service URL, by default 'deploy-service.'", + timeoutOpt: "Start timeout in seconds", + versionRuleOpt: "Version rule (HIGHER, SAME_HIGHER, ALL)", + operationIDOpt: "Active deploy operation id", + actionOpt: "Action to perform on active deploy operation (abort, retry, monitor)", + forceOpt: "Force deploy without confirmation for aborting conflicting processes", + util.GetShortOption(noStartOpt): "Do not start apps", + util.GetShortOption(useNamespacesOpt): "Use namespaces in app and service names", + util.GetShortOption(noNamespacesForServicesOpt): "Do not use namespaces in service names", + util.GetShortOption(deleteServicesOpt): "Recreate changed services / delete discontinued services", + util.GetShortOption(deleteServiceKeysOpt): "Delete existing service keys and apply the new ones", + util.GetShortOption(deleteServiceBrokersOpt): "Delete discontinued service brokers", + util.GetShortOption(keepFilesOpt): "Keep files used for deployment", + util.GetShortOption(noRestartSubscribedAppsOpt): "Do not restart subscribed apps, updated during the deployment", + util.GetShortOption(noFailOnMissingPermissionsOpt): "Do not fail on missing permissions for admin operations", + }, + }, + } +} + +// CommandFlagsDefiner is a function used during the execution of the deploy +// command. It defines the flags supported by the comman,d and returns a map +// containing pointers to the parsed flags. +type CommandFlagsDefiner func(flag *flag.FlagSet) map[string]interface{} + +// ProcessParametersSetter is a function that sets the startup parameters for +// the deploy process. It takes them from the list of parsed flags. +type ProcessParametersSetter func(options map[string]interface{}, processBuilder *util.ProcessBuilder) + +// DeployCommandFlagsDefiner returns a new CommandFlagsDefiner. +func deployCommandFlagsDefiner() CommandFlagsDefiner { + return func(flags *flag.FlagSet) map[string]interface{} { + optionValues := make(map[string]interface{}) + optionValues[extDescriptorsOpt] = flags.String(extDescriptorsOpt, "", "") + optionValues[operationIDOpt] = flags.String(operationIDOpt, "", "") + optionValues[actionOpt] = flags.String(actionOpt, "", "") + optionValues[forceOpt] = flags.Bool(forceOpt, false, "") + optionValues[timeoutOpt] = flags.String(timeoutOpt, "", "") + optionValues[versionRuleOpt] = flags.String(versionRuleOpt, "", "") + optionValues[deleteServicesOpt] = flags.Bool(deleteServicesOpt, false, "") + optionValues[noStartOpt] = flags.Bool(noStartOpt, false, "") + optionValues[useNamespacesOpt] = flags.Bool(useNamespacesOpt, false, "") + optionValues[noNamespacesForServicesOpt] = flags.Bool(noNamespacesForServicesOpt, false, "") + optionValues[deleteServiceKeysOpt] = flags.Bool(deleteServiceKeysOpt, false, "") + optionValues[deleteServiceBrokersOpt] = flags.Bool(deleteServiceBrokersOpt, false, "") + optionValues[keepFilesOpt] = flags.Bool(keepFilesOpt, false, "") + optionValues[noRestartSubscribedAppsOpt] = flags.Bool(noRestartSubscribedAppsOpt, false, "") + optionValues[noFailOnMissingPermissionsOpt] = flags.Bool(noFailOnMissingPermissionsOpt, false, "") + return optionValues + } +} + +// DeployProcessParametersSetter returns a new ProcessParametersSetter. +func deployProcessParametersSetter() ProcessParametersSetter { + return func(optionValues map[string]interface{}, processBuilder *util.ProcessBuilder) { + processBuilder.Parameter("deleteServiceKeys", strconv.FormatBool(GetBoolOpt(deleteServiceKeysOpt, optionValues))) + processBuilder.Parameter("deleteServices", strconv.FormatBool(GetBoolOpt(deleteServicesOpt, optionValues))) + processBuilder.Parameter("noStart", strconv.FormatBool(GetBoolOpt(noStartOpt, optionValues))) + processBuilder.Parameter("useNamespaces", strconv.FormatBool(GetBoolOpt(useNamespacesOpt, optionValues))) + processBuilder.Parameter("useNamespacesForServices", strconv.FormatBool(!GetBoolOpt(noNamespacesForServicesOpt, optionValues))) + processBuilder.Parameter("deleteServiceBrokers", strconv.FormatBool(GetBoolOpt(deleteServiceBrokersOpt, optionValues))) + processBuilder.Parameter("startTimeout", GetStringOpt(timeoutOpt, optionValues)) + processBuilder.Parameter("versionRule", GetStringOpt(versionRuleOpt, optionValues)) + processBuilder.Parameter("keepFiles", strconv.FormatBool(GetBoolOpt(keepFilesOpt, optionValues))) + processBuilder.Parameter("noRestartSubscribedApps", strconv.FormatBool(GetBoolOpt(noRestartSubscribedAppsOpt, optionValues))) + processBuilder.Parameter("noFailOnMissingPermissions", strconv.FormatBool(GetBoolOpt(noFailOnMissingPermissionsOpt, optionValues))) + } +} + +// GetBoolOpt gets and dereferences the pointer identified by the specified name. +func GetBoolOpt(name string, optionValues map[string]interface{}) bool { + return *optionValues[name].(*bool) +} + +// GetStringOpt gets and dereferences the pointer identified by the specified name. +func GetStringOpt(name string, optionValues map[string]interface{}) string { + return *optionValues[name].(*string) +} + +// GetUintOpt gets and dereferences the pointer identified by the specified name. +func GetUintOpt(name string, optionValues map[string]interface{}) uint { + return *optionValues[name].(*uint) +} + +// Execute executes the command +func (c *DeployCommand) Execute(args []string) ExecutionStatus { + log.Tracef("Executing command '"+c.name+"': args: '%v'\n", args) + + var host string + + // Parse command arguments and check for required options + flags, err := c.CreateFlags(&host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + optionValues := c.commandFlagsDefiner(flags) + shouldExecuteActionOnExistingProcess, err := ContainsSpecificOptions(flags, args, map[string]string{"i": "-i", "a": "-a"}) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + var positionalArgNames []string + if !shouldExecuteActionOnExistingProcess { + positionalArgNames = []string{"MTA"} + } + err = c.ParseFlags(args, positionalArgNames, flags, nil) + if err != nil { + c.Usage(err.Error()) + return Failure + } + + extDescriptors := GetStringOpt(extDescriptorsOpt, optionValues) + operationID := GetStringOpt(operationIDOpt, optionValues) + action := GetStringOpt(actionOpt, optionValues) + force := GetBoolOpt(forceOpt, optionValues) + + context, err := c.GetContext() + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + if operationID != "" || action != "" { + return c.ExecuteAction(operationID, action, host, c.serviceID) + } + + mtaArchive := args[0] + + // Print initial message + ui.Say("Deploying multi-target app archive %s in org %s / space %s as %s...", + terminal.EntityNameColor(mtaArchive), terminal.EntityNameColor(context.Org), + terminal.EntityNameColor(context.Space), terminal.EntityNameColor(context.Username)) + + // Get the full path of the MTA archive + mtaArchivePath, err := filepath.Abs(mtaArchive) + if err != nil { + ui.Failed("Could not get absolute path of file '%s'", mtaArchive) + return Failure + } + + // TODO: Check if the MTA archive is a directory or a file + + // Get the full paths of the extension descriptors + var extDescriptorPaths []string + if extDescriptors != "" { + extDescriptorFiles := strings.Split(extDescriptors, ",") + for _, extDescriptorFile := range extDescriptorFiles { + extDescriptorPath, err := filepath.Abs(extDescriptorFile) + if err != nil { + ui.Failed("Could not get absolute path of file '%s'", extDescriptorFile) + return Failure + } + extDescriptorPaths = append(extDescriptorPaths, extDescriptorPath) + } + } + + // Extract mta id from archive file + mtaID, err := util.GetMtaIDFromArchive(mtaArchivePath) + if os.IsNotExist(err) { + ui.Failed("Could not find file %s", terminal.EntityNameColor(mtaArchivePath)) + return Failure + } else if err != nil { + ui.Failed("Could not get MTA id from deployment descriptor: %s", err) + return Failure + } + + // Check for an ongoing operation for this MTA ID and abort it + wasAborted, err := c.CheckOngoingOperation(mtaID, host, force) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + if !wasAborted { + return Failure + } + + // Create SLMP client + slmpClient, err := c.NewSlmpClient(host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Check SLMP metadata + err = CheckSlmpMetadata(slmpClient) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Upload the MTA archive file + mtaArchiveUploader := NewFileUploader(c.serviceID.String(), []string{mtaArchivePath}, slmpClient) + uploadedMtaArchives, status := mtaArchiveUploader.UploadFiles() + if status == Failure { + return Failure + } + var uploadedArchivePartIds []string + for _, uploadedMtaArchivePart := range uploadedMtaArchives { + uploadedArchivePartIds = append(uploadedArchivePartIds, *uploadedMtaArchivePart.ID) + } + + // Recreate the slmp client to ensure that the token is recreated + slmpClient, err = c.NewSlmpClient(host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Upload the extension descriptor files + var uploadedExtDescriptorIDs []string + if len(extDescriptorPaths) != 0 { + extDescriptorsUploader := NewFileUploader(c.serviceID.String(), extDescriptorPaths, slmpClient) + uploadedExtDescriptors, status := extDescriptorsUploader.UploadFiles() + if status == Failure { + return Failure + } + for _, uploadedExtDescriptor := range uploadedExtDescriptors { + uploadedExtDescriptorIDs = append(uploadedExtDescriptorIDs, *uploadedExtDescriptor.ID) + } + } + + ui.Say("Starting deployment process...") + + // Build the process instance + processBuilder := util.NewProcessBuilder() + processBuilder.ServiceID(c.serviceID.String()) + processBuilder.Parameter("appArchiveId", strings.Join(uploadedArchivePartIds, ",")) + processBuilder.Parameter("mtaExtDescriptorId", strings.Join(uploadedExtDescriptorIDs, ",")) + processBuilder.Parameter("targetPlatform", context.Org+" "+context.Space) + c.processParametersSetter(optionValues, processBuilder) + process := processBuilder.Build() + + // Ensure that the session is not expired + err = EnsureSlmpSession(slmpClient) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Create the new process + createdProcess, err := slmpClient.CreateServiceProcess(c.serviceID.String(), process) + if err != nil { + ui.Failed("Could not create process for service %s: %s", terminal.EntityNameColor(c.serviceID.String()), err) + return Failure + } + ui.Ok() + + processID := createdProcess.ID + // Create SLPP client + slppClient, err := c.NewSlppClient(host, c.serviceID.String(), processID) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Check SLPP metadata + err = CheckSlppMetadata(slppClient) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Monitor the process execution + monitorExecutor := NewExecutionMonitor(processID, c.name, slppClient, []*models.ProgressMessage{}) + return monitorExecutor.Monitor() +} diff --git a/commands/deploy_command_test.go b/commands/deploy_command_test.go new file mode 100644 index 0000000..1d0b787 --- /dev/null +++ b/commands/deploy_command_test.go @@ -0,0 +1,350 @@ +package commands_test + +import ( + "fmt" + "os" + "path/filepath" + "strings" + + plugin_fakes "github.com/cloudfoundry/cli/plugin/fakes" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/SAP/cf-mta-plugin/clients/models" + restfake "github.com/SAP/cf-mta-plugin/clients/restclient/fakes" + slmpfake "github.com/SAP/cf-mta-plugin/clients/slmpclient/fakes" + slppfake "github.com/SAP/cf-mta-plugin/clients/slppclient/fakes" + "github.com/SAP/cf-mta-plugin/commands" + cmd_fakes "github.com/SAP/cf-mta-plugin/commands/fakes" + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/SAP/cf-mta-plugin/ui" + "github.com/SAP/cf-mta-plugin/util" +) + +var _ = Describe("DeployCommand", func() { + Describe("Execute", func() { + const org = "test-org" + const space = "test-space" + const user = "test-user" + const testFilesLocation = "../test_resources/commands/" + const testArchive = "mtaArchive.mtar" + const mtaArchivePath = testFilesLocation + testArchive + const extDescriptorPath = testFilesLocation + "extDescriptor.mtaext" + + var name string + var cliConnection *plugin_fakes.FakeCliConnection + var slmpClient *slmpfake.FakeSlmpClientOperations + var slppClient *slppfake.FakeSlppClientOperations + var restClient *restfake.FakeRestClientOperations + var testClientFactory *commands.TestClientFactory + var command *commands.DeployCommand + var oc = testutil.NewUIOutputCapturer() + var ex = testutil.NewUIExpector() + + var fullMtaArchivePath, _ = filepath.Abs(mtaArchivePath) + var fullExtDescriptorPath, _ = filepath.Abs(extDescriptorPath) + + var getLinesForAbortingProcess = func() []string { + return []string{ + "Aborting multi-target app operation with id test-process-id...\n", + "OK\n", + } + } + + var getOutputLines = func(extDescriptor, processAborted bool) []string { + lines := []string{} + lines = append(lines, + "Deploying multi-target app archive "+mtaArchivePath+" in org "+org+" / space "+space+" as "+user+"...\n") + if processAborted { + lines = append(lines, + "Aborting multi-target app operation with id process-id...\n", + "OK\n", + ) + } + lines = append(lines, + "Uploading 1 files...\n", + " "+fullMtaArchivePath+"\n", + "OK\n") + if extDescriptor { + lines = append(lines, + "Uploading 1 files...\n", + " "+fullExtDescriptorPath+"\n", + "OK\n") + } + lines = append(lines, + "Starting deployment process...\n", + "OK\n", + "Monitoring process execution...\n", + "Process finished.\n") + return lines + } + + var getProcessParameters = func(additional bool) map[string]string { + params := map[string]string{ + "appArchiveId": "mtaArchive.mtar", + "targetPlatform": "test-org test-space", + "failOnCrashed": "false", + } + if additional { + params["deleteServices"] = "true" + params["keepFiles"] = "true" + params["noStart"] = "true" + } + return params + } + + var getFile = func(path string) (*os.File, *models.File) { + file, _ := os.Open(path) + digest, _ := util.ComputeFileChecksum(path, "MD5") + f := testutil.GetFile("xs2-deploy", *file, strings.ToUpper(digest)) + return file, f + } + + var expectProcessParameters = func(expectedParameters map[string]string, processParameters models.ProcessParameters) { + for _, processParameter := range processParameters.Parameters { + if expectedParameters[*processParameter.ID] != "" { + Expect(processParameter.Value).To(Equal(expectedParameters[*processParameter.ID])) + } + } + } + + BeforeEach(func() { + ui.DisableTerminalOutput(true) + name = command.GetPluginCommand().Name + cliConnection = cmd_fakes.NewFakeCliConnectionBuilder(). + CurrentOrg("test-org-guid", org, nil). + CurrentSpace("test-space-guid", space, nil). + Username(user, nil). + AccessToken("bearer test-token", nil). + APIEndpoint("https://api.test.ondemand.com", nil).Build() + mtaArchiveFile, mtaArchive := getFile(mtaArchivePath) + defer mtaArchiveFile.Close() + extDescriptorFile, extDescriptor := getFile(extDescriptorPath) + defer extDescriptorFile.Close() + slmpClient = slmpfake.NewFakeSlmpClientBuilder(). + GetMetadata(&testutil.SlmpMetadataResult, nil). + GetService("xs2-deploy", testutil.GetService("xs2-deploy", "Deploy", []*models.Parameter{testutil.GetParameter("mtaArchiveId")}), nil). + GetServiceFiles("xs2-deploy", testutil.FilesResult, nil). + CreateServiceFile("xs2-deploy", mtaArchiveFile, testutil.GetFiles([]*models.File{mtaArchive}), nil). + CreateServiceFile("xs2-deploy", extDescriptorFile, testutil.GetFiles([]*models.File{extDescriptor}), nil). + CreateServiceProcess("", nil, &testutil.ProcessResult, nil).Build() + slppClient = slppfake.NewFakeSlppClientBuilder(). + GetMetadata(&testutil.SlppMetadataResult, nil). + GetTasklistTask(&testutil.TaskResult, nil). + GetLogContent(testutil.LogID, testutil.LogContent, nil).Build() + restClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.OperationsResult, nil).Build() + testClientFactory = commands.NewTestClientFactory(slmpClient, slppClient, restClient) + command = commands.NewDeployCommand() + testTokenFactory := commands.NewTestTokenFactory(cliConnection) + command.InitializeAll(name, cliConnection, testutil.NewCustomTransport(200, nil), nil, testClientFactory, testTokenFactory) + }) + + // unknown flag - error + Context("with an unknown flag", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"x", "-l"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Unknown or wrong flag.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // wrong arguments - error + Context("with wrong arguments", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"x", "y", "z"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Wrong arguments.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // no arguments - error + Context("with no arguments", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Missing positional argument 'MTA'.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // no MTA argument - error + Context("with no MTA argument", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-e", "test.mtaext"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Missing positional argument 'MTA'.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // non-existing MTA archive - error + Context("with a non-existing mta archive", func() { + It("should print a file not found error and exit with a non-zero status", func() { + const fileName = "non-existing-mtar.mtar" + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{fileName}).ToInt() + }) + abs, _ := filepath.Abs(fileName) + ex.ExpectFailureOnLine(status, output, "Could not find file "+abs, 1) + }) + }) + + // TODO: can't connect to backend - error + + // TODO: backend returns an an error response - error + + // existing MTA archive - success + Context("with an existing mta archive", func() { + It("should upload 1 file and start the deployment process", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{mtaArchivePath}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(false, false)) + serviceID, process := slmpClient.CreateServiceProcessArgsForCall(0) + Expect(serviceID).To(Equal("xs2-deploy")) + expectProcessParameters(getProcessParameters(false), process.Parameters) + }) + }) + + // existing MTA archive and an extension descriptor - success + Context("with an existing mta archive and an extension descriptor", func() { + It("should upload 2 files and start the deployment process", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{mtaArchivePath, "-e", extDescriptorPath}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(true, false)) + serviceID, process := slmpClient.CreateServiceProcessArgsForCall(0) + Expect(serviceID).To(Equal("xs2-deploy")) + expectProcessParameters(getProcessParameters(false), process.Parameters) + }) + }) + + // existing MTA archive and additional options - success + Context("with an existing mta archive and some options", func() { + It("should upload 1 file and start the deployment process", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{mtaArchivePath, "-f", "-delete-services", "-no-start", "-keep-files", "-do-not-fail-on-missing-permissions"}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(false, false)) + serviceID, process := slmpClient.CreateServiceProcessArgsForCall(0) + Expect(serviceID).To(Equal("xs2-deploy")) + expectProcessParameters(getProcessParameters(true), process.Parameters) + }) + }) + + // non-existing ongoing operations - success + Context("with correct mta id from archive and no ongoing operations", func() { + It("should not try to abort confliction operations", func() { + testClientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{mtaArchivePath}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(false, false)) + serviceID, process := slmpClient.CreateServiceProcessArgsForCall(0) + Expect(serviceID).To(Equal("xs2-deploy")) + expectProcessParameters(getProcessParameters(false), process.Parameters) + }) + }) + + // existing ongoing operations and force option not supplied - success + Context("with correct mta id from archive, with ongoing operations provided and no force option", func() { + It("should not try to abort confliction operations", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{mtaArchivePath}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(false, false)) + serviceID, process := slmpClient.CreateServiceProcessArgsForCall(0) + Expect(serviceID).To(Equal("xs2-deploy")) + expectProcessParameters(getProcessParameters(false), process.Parameters) + }) + }) + + // existing ongoing operations and force option supplied - success + Context("with correct mta id from archive, with ongoing operations provided and with force option", func() { + It("should try to abort confliction operations", func() { + testClientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{testutil.GetOperation("process-id", "test-space-guid", "test", "deploy", "SLP_TASK_STATE_ERROR", true)}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{mtaArchivePath, "-f"}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(false, true)) + serviceID, process := slmpClient.CreateServiceProcessArgsForCall(0) + Expect(serviceID).To(Equal("xs2-deploy")) + expectProcessParameters(getProcessParameters(false), process.Parameters) + }) + }) + Context("with an error returned from getting ongoing operations", func() { + It("should display error and exit witn non-zero status", func() { + testClientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{}), fmt.Errorf("test-error-from backend")).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{mtaArchivePath}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not get ongoing operation", 1) + }) + }) + + Context("with non-valid operation id and action id provided", func() { + It("should return error and exit with non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", "test", "-a", "abort"}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Multi-target app operation with id test not found", 0) + }) + }) + Context("with valid operation id and non-valid action id provided", func() { + It("should return error and exit with non-zero status", func() { + testClientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{ + testutil.GetOperation("test-process-id", "test-space", "test-mta-id", "deploy", "SLP_TASK_STATE_ERROR", true), + }), nil).Build() + testClientFactory.SlppClient = slppfake.NewFakeSlppClientBuilder(). + GetMetadata(&testutil.SlppMetadataResult, nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", "test-process-id", "-a", "test"}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Invalid action test", 0) + }) + }) + Context("with valid operation id and no action id provided", func() { + It("should return error and exit with non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", "test-process-id"}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "All the a i options should be specified together", 0) + }) + }) + + Context("with valid action id and no operation id provided", func() { + It("should return error and exit with non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-a", "abort"}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "All the a i options should be specified together", 0) + }) + }) + + Context("with valid operation id and valid action id provided", func() { + It("should execute action on the process specified with process id and exit with zero status", func() { + testClientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{ + testutil.GetOperation("test-process-id", "test-space", "test-mta-id", "deploy", "SLP_TASK_STATE_ERROR", true), + }), nil).Build() + testClientFactory.SlppClient = slppfake.NewFakeSlppClientBuilder(). + GetMetadata(&testutil.SlppMetadataResult, nil). + ExecuteAction("test", nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", "test-process-id", "-a", "abort"}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getLinesForAbortingProcess()) + }) + }) + }) +}) diff --git a/commands/download_mta_op_logs_command.go b/commands/download_mta_op_logs_command.go new file mode 100644 index 0000000..73029de --- /dev/null +++ b/commands/download_mta_op_logs_command.go @@ -0,0 +1,177 @@ +package commands + +import ( + "fmt" + "io/ioutil" + "os" + "path/filepath" + "strings" + + "github.com/cloudfoundry/cli/cf/terminal" + "github.com/cloudfoundry/cli/plugin" + "github.com/SAP/cf-mta-plugin/log" + "github.com/SAP/cf-mta-plugin/ui" +) + +const ( + defaultDownloadDirPrefix string = "mta-op-" +) + +// DownloadMtaOperationLogsCommand is a command for retrieving the logs of an MTA operation +type DownloadMtaOperationLogsCommand struct { + BaseCommand +} + +// GetPluginCommand returns the plugin command details +func (c *DownloadMtaOperationLogsCommand) GetPluginCommand() plugin.Command { + return plugin.Command{ + Name: "download-mta-op-logs", + Alias: "dmol", + HelpText: "Download logs of multi-target app operation", + UsageDetails: plugin.Usage{ + Usage: "cf download-mta-op-logs -i OPERATION_ID [-d DIRECTORY] [-u URL]", + Options: map[string]string{ + "i": "Operation id", + "d": "Directory to download logs, by default '" + defaultDownloadDirPrefix + "/'", + "u": "Deploy service URL, by default 'deploy-service.'", + }, + }, + } +} + +// Execute executes the command +func (c *DownloadMtaOperationLogsCommand) Execute(args []string) ExecutionStatus { + log.Tracef("Executing command '"+c.name+"': args: '%v'\n", args) + + var host string + var operationID string + var downloadDirName string + + // Parse command arguments and check for required options + flags, err := c.CreateFlags(&host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + flags.StringVar(&operationID, "i", "", "") + flags.StringVar(&downloadDirName, "d", "", "") + err = c.ParseFlags(args, nil, flags, map[string]bool{"i": true}) + if err != nil { + c.Usage(err.Error()) + return Failure + } + + // Set the download directory if not specified + if downloadDirName == "" { + downloadDirName = defaultDownloadDirPrefix + operationID + "/" + } + + context, err := c.GetContext() + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Print initial message + ui.Say("Downloading logs of multi-target app operation with id %s in org %s / space %s as %s...", + terminal.EntityNameColor(operationID), terminal.EntityNameColor(context.Org), + terminal.EntityNameColor(context.Space), terminal.EntityNameColor(context.Username)) + + // Create new SLMP client + slmpClient, err := c.NewSlmpClient(host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Check SLMP metadata + err = CheckSlmpMetadata(slmpClient) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Get the service ID for the specified operation ID + serviceID, err := GetServiceID(operationID, slmpClient) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Create new SLPP client + slppClient, err := c.NewSlppClient(host, serviceID, operationID) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Check SLPP metadata + err = CheckSlppMetadata(slppClient) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Download all logs + downloadedLogs := make(map[string]*string) + logs, err := slppClient.GetLogs() + if err != nil { + ui.Failed("Could not get process logs: %s", err) + return Failure + } + for _, logx := range logs.Logs { + content, err := slppClient.GetLogContent(*logx.ID) + if err != nil { + ui.Failed("Could not get content of log %s: %s", terminal.EntityNameColor(*logx.ID), err) + return Failure + } + downloadedLogs[*logx.ID] = &content + } + ui.Ok() + + // Create the download directory + downloadDir, err := createDownloadDirectory(downloadDirName) + if err != nil { + ui.Failed("Could not create download directory %s: %s", terminal.EntityNameColor(downloadDirName), err) + return Failure + } + + // Get all logs and save their contents to the download directory + ui.Say("Saving logs to %s...", terminal.EntityNameColor(downloadDir)) + for logID, content := range downloadedLogs { + err = saveLogContent(downloadDir, logID, content) + if err != nil { + ui.Failed("Could not save log %s: %s", terminal.EntityNameColor(logID), err) + return Failure + } + } + ui.Ok() + return Success +} + +func createDownloadDirectory(downloadDirName string) (string, error) { + // Check if directory name ends with the os specific path separator + if !strings.HasSuffix(downloadDirName, string(os.PathSeparator)) { + //If there is no os specific path separator, put it at the end of the direcotry name + downloadDirName = downloadDirName + string(os.PathSeparator) + } + + // Check if the directory already exists + if stat, _ := os.Stat(downloadDirName); stat != nil { + return "", fmt.Errorf("File or directory already exists.") + } + + // Create the directory + err := os.MkdirAll(downloadDirName, 0755) + if err != nil { + return "", nil + } + + // Return the absolute path of the directory + return filepath.Abs(filepath.Dir(downloadDirName)) +} + +func saveLogContent(downloadDir, logID string, content *string) error { + ui.Say(" %s", logID) + return ioutil.WriteFile(downloadDir+"/"+logID, []byte(*content), 0644) +} diff --git a/commands/download_mta_op_logs_command_test.go b/commands/download_mta_op_logs_command_test.go new file mode 100644 index 0000000..7325ec0 --- /dev/null +++ b/commands/download_mta_op_logs_command_test.go @@ -0,0 +1,264 @@ +package commands_test + +import ( + "fmt" + "io/ioutil" + "os" + "runtime" + + plugin_fakes "github.com/cloudfoundry/cli/plugin/fakes" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" + restfake "github.com/SAP/cf-mta-plugin/clients/restclient/fakes" + slmpfake "github.com/SAP/cf-mta-plugin/clients/slmpclient/fakes" + slppfake "github.com/SAP/cf-mta-plugin/clients/slppclient/fakes" + "github.com/SAP/cf-mta-plugin/commands" + cmd_fakes "github.com/SAP/cf-mta-plugin/commands/fakes" + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/SAP/cf-mta-plugin/ui" +) + +var _ = Describe("DownloadMtaOperationLogsCommand", func() { + Describe("Execute", func() { + const org = "test-org" + const space = "test-space" + const user = "test-user" + + var name string + var cliConnection *plugin_fakes.FakeCliConnection + var slmpClient *slmpfake.FakeSlmpClientOperations + var slppClient *slppfake.FakeSlppClientOperations + var restClient *restfake.FakeRestClientOperations + var clientFactory *commands.TestClientFactory + var command *commands.DownloadMtaOperationLogsCommand + var oc = testutil.NewUIOutputCapturer() + var ex = testutil.NewUIExpector() + + var getOutputLines = func(dir string) []string { + wd, _ := os.Getwd() + return []string{ + fmt.Sprintf("Downloading logs of multi-target app operation with id %s in org %s / space %s as %s...\n", + testutil.ProcessID, org, space, user), + "OK\n", + fmt.Sprintf("Saving logs to %s"+string(os.PathSeparator)+"%s...\n", wd, dir), + fmt.Sprintf(" %s\n", testutil.LogID), + "OK\n", + } + } + + var expectDirWithLog = func(dir string) { + Expect(exists(dir)).To(Equal(true)) + Expect(exists(dir + "/" + testutil.LogID)).To(Equal(true)) + Expect(contentOf(dir + "/" + testutil.LogID)).To(Equal(testutil.LogContent)) + } + + BeforeEach(func() { + ui.DisableTerminalOutput(true) + name = command.GetPluginCommand().Name + cliConnection = cmd_fakes.NewFakeCliConnectionBuilder(). + CurrentOrg("test-org-guid", org, nil). + CurrentSpace("test-space-guid", space, nil). + Username(user, nil). + AccessToken("bearer test-token", nil). + APIEndpoint("https://api.test.ondemand.com", nil).Build() + slmpClient = slmpfake.NewFakeSlmpClientBuilder(). + GetMetadata(&testutil.SlmpMetadataResult, nil). + GetProcess(testutil.ProcessID, &testutil.ProcessResult, nil).Build() + slppClient = slppfake.NewFakeSlppClientBuilder(). + GetMetadata(&testutil.SlppMetadataResult, nil). + GetLogs(testutil.LogsResult, nil). + GetLogContent(testutil.LogID, testutil.LogContent, nil).Build() + restClient = restfake.NewFakeRestClientBuilder().Build() + clientFactory = commands.NewTestClientFactory(slmpClient, slppClient, restClient) + command = &commands.DownloadMtaOperationLogsCommand{} + testTokenFactory := commands.NewTestTokenFactory(cliConnection) + command.InitializeAll(name, cliConnection, testutil.NewCustomTransport(200, nil), nil, clientFactory, testTokenFactory) + }) + + // unknown flag - error + Context("with an unknown flag", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-a"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Unknown or wrong flag.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // wrong arguments - error + Context("with wrong arguments", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"x", "y", "z"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Wrong arguments.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // no arguments - error + Context("with no arguments", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Missing required options '[i]'.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // can't connect to backend - error + Context("when can't connect to backend", func() { + const host = "x" + It("should print an error and exit with a non-zero status", func() { + clientFactory.SlmpClient = slmpfake.NewFakeSlmpClientBuilder(). + GetMetadata(nil, fmt.Errorf("Get https://%s/slprot/test/test/slp/metadata: dial tcp: lookup %s: no such host", host, host)).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", testutil.ProcessID, "-u", host}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not get SLMP metadata:", 1) + }) + }) + + // backend returns an an error response (GetMetadata) - error + Context("with an error response returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + clientFactory.SlmpClient = slmpfake.NewFakeSlmpClientBuilder(). + GetMetadata(nil, fmt.Errorf("unknown error (status 404)")).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", testutil.ProcessID}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not get SLMP metadata:", 1) + }) + }) + + // non-existing process id - error + Context("with a non-existing process id", func() { + It("should print an error and exit with a non-zero status", func() { + var clientError = baseclient.NewClientError(testutil.ClientError) + clientFactory.SlmpClient = slmpfake.NewFakeSlmpClientBuilder(). + GetProcess("test", nil, clientError). + GetMetadata(&testutil.SlmpMetadataResult, nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", "test"}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Multi-target app operation with id test not found", 1) + Expect(exists("mta-op-test")).To(Equal(false)) + }) + }) + + // existing process id, backend returns an error response (GetLogs) - error + Context("with an existing process id and an error response returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + clientFactory.SlppClient = slppfake.NewFakeSlppClientBuilder(). + GetMetadata(&testutil.SlppMetadataResult, nil). + GetLogs(models.Logs{}, fmt.Errorf("unknown error (status 500)")).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", testutil.ProcessID}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not get process logs:", 1) + Expect(exists("mta-op-" + testutil.ProcessID)).To(Equal(false)) + }) + }) + + // existing process id, backend returns an error response (GetLogContent) - error + Context("with an existing process id and an error response returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + fakeSlppClient := slppfake.NewFakeSlppClientBuilder(). + GetMetadata(&testutil.SlppMetadataResult, nil). + GetLogs(testutil.LogsResult, nil). + GetLogContent("", "", fmt.Errorf("unknown error (status 500)")).Build() + clientFactory.SlppClient = fakeSlppClient + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", testutil.ProcessID}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, fmt.Sprintf("Could not get content of log %s:", testutil.LogID), 1) + Expect(fakeSlppClient.GetLogContentArgsForCall(0)).To(Equal(testutil.LogID)) + Expect(exists("mta-op-" + testutil.ProcessID)).To(Equal(false)) + }) + }) + + // existing process id - success + Context("with an existing process id", func() { + const dir = "mta-op-" + testutil.ProcessID + It("should download the logs for the current process and exit with zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", testutil.ProcessID}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(dir)) + expectDirWithLog(dir) + }) + AfterEach(func() { + os.RemoveAll(dir) + }) + }) + + // existing process id and existing directory - error + Context("with an existing process id and an existing directory", func() { + const customDir string = "test" + BeforeEach(func() { + os.Mkdir(customDir, 0755) + }) + It("should print an error and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", testutil.ProcessID, "-d", customDir}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, fmt.Sprintf("Could not create download directory %s:", customDir), 2) + }) + AfterEach(func() { + os.RemoveAll(customDir) + }) + }) + + if runtime.GOOS != "windows" { + // existing process id and a directory that can't be written to - error + Context("with an existing process id and a directory that can't be written to", func() { + const customDir string = "test" + BeforeEach(func() { + os.Mkdir(customDir, 0000) + }) + It("should print an error and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", testutil.ProcessID, "-d", customDir + "/subdir"}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, fmt.Sprintf("Could not save log %s:", testutil.LogID), 4) + }) + AfterEach(func() { + os.Chmod(customDir, 0755) + os.RemoveAll(customDir) + }) + }) + } + + // existing process id and non-existing directory - success + Context("with an existing process id and a non-existing directory", func() { + const customDir string = "test-non-existing" + It("should create the directory, download the logs for the current process and exit with zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-i", testutil.ProcessID, "-d", customDir}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(customDir)) + expectDirWithLog(customDir) + }) + AfterEach(func() { + os.RemoveAll(customDir) + }) + }) + }) +}) + +func contentOf(fileName string) string { + content, _ := ioutil.ReadFile(fileName) + return string(content) +} + +func exists(dirName string) bool { + _, err := os.Stat(dirName) + if err == nil { + return true + } + return false +} diff --git a/commands/execution_monitor.go b/commands/execution_monitor.go new file mode 100644 index 0000000..2e75da7 --- /dev/null +++ b/commands/execution_monitor.go @@ -0,0 +1,139 @@ +package commands + +import ( + "strconv" + "time" + + "github.com/cloudfoundry/cli/cf/terminal" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + "github.com/SAP/cf-mta-plugin/ui" + "github.com/SAP/cf-mta-plugin/util" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +const consoleOffset = " " + +//ExecutionMonitor monitors execution of a process +type ExecutionMonitor struct { + slppClient slppclient.SlppClientOperations + reportedProgressMessages map[int]bool + processID string + commandName string +} + +//NewExecutionMonitor creates a new execution monitor +func NewExecutionMonitor(processID, commandName string, slppClient slppclient.SlppClientOperations, reportedProgressMessages []*models.ProgressMessage) *ExecutionMonitor { + return &ExecutionMonitor{ + slppClient: slppClient, + reportedProgressMessages: getProgressMessagesIds(reportedProgressMessages), + processID: processID, + commandName: commandName, + } +} + +func getProgressMessagesIds(reportedProgressMessages []*models.ProgressMessage) map[int]bool { + result := make(map[int]bool) + for _, progressMessage := range reportedProgressMessages { + idNum, _ := strconv.Atoi(*progressMessage.ID) + result[idNum] = true + } + return result +} + +//Monitor monitors current state of the execution +func (m *ExecutionMonitor) Monitor() ExecutionStatus { + ui.Say("Monitoring process execution...") + + for { + processTask, err := m.slppClient.GetTasklistTask(m.slppClient.GetServiceID()) + if err != nil { + ui.Failed("Could not get task: %s", err) + return Failure + } + if processTask.Type != models.SlpTaskTypeSlpTaskTypePROCESS { + ui.Failed("The SLP task must be a Process task") + return Failure + } + m.reportProgressMessages(*processTask) + switch processTask.Status { + case models.SlpTaskStateSlpTaskStateRUNNING: + time.Sleep(2000) + case models.SlpTaskStateSlpTaskStateFINISHED: + ui.Say("Process finished.") + return Success + case models.SlpTaskStateSlpTaskStateABORTED: + ui.Say("Process was aborted.") + return Failure + case models.SlpTaskStateSlpTaskStateERROR: + clientError, err := m.slppClient.GetError() + if err != nil { + ui.Failed("Could not get client error: %s", err) + return Failure + } + ui.Say("Process failed: %s", clientError.Description) + m.reportAvaiableActions() + m.reportCommandForDownloadOfProcessLogs() + return Failure + case models.SlpTaskStateSlpTaskStateACTIONREQUIRED, models.SlpTaskStateSlpTaskStateDIALOG: + ui.Say("Process has entered validation phase. After testing your new deployment you can resume or abort the process.") + m.reportAvaiableActions() + ui.Say("Hint: Use the '--no-confirm' option of the bg-deploy command to skip this phase.") + return Success + default: + ui.Failed("Process is in illegal state %s.", terminal.EntityNameColor(string(processTask.Status))) + return Failure + } + } + ui.Failed("Error during process monitoring") + return Failure +} + +func (m *ExecutionMonitor) reportAvaiableActions() { + actions, _ := m.slppClient.GetActions() + actionsList := actions.Actions + for i := 0; i < len(actionsList); i++ { + m.reportAvailableAction(*actionsList[i]) + } +} + +func (m *ExecutionMonitor) reportCommandForDownloadOfProcessLogs() { + downloadProcessLogsCommand := DownloadMtaOperationLogsCommand{} + commandBuilder := util.NewCfCommandStringBuilder() + commandBuilder.SetName(downloadProcessLogsCommand.GetPluginCommand().Alias) + commandBuilder.AddOption(operationIDOpt, m.processID) + ui.Say("Use \"%s\" to download the logs of the process", commandBuilder.Build()) +} + +func (m *ExecutionMonitor) reportAvailableAction(action models.Action) { + commandBuilder := util.NewCfCommandStringBuilder() + commandBuilder.SetName(m.commandName) + commandBuilder.AddOption(operationIDOpt, m.processID) + commandBuilder.AddOption(actionOpt, *action.ID) + ui.Say("Use \"%s\" to %s the process.", commandBuilder.Build(), *action.ID) +} + +func (m *ExecutionMonitor) reportProgressMessages(task models.Task) { + for _, progressMessage := range task.ProgressMessages.ProgressMessages { + m.reportProgressMessage(progressMessage) + } +} + +func (m *ExecutionMonitor) reportProgressMessage(progressMessage *models.ProgressMessage) { + idNum, _ := strconv.Atoi(*progressMessage.ID) + if m.reportedProgressMessages[idNum] { + return + } + + m.reportedProgressMessages[idNum] = true + ui.Say("%s%s", consoleOffset, *progressMessage.Message) +} + +func contains(slice []string, element string) bool { + for _, sliceElement := range slice { + if sliceElement == element { + return true + } + } + return false +} diff --git a/commands/execution_monitor_test.go b/commands/execution_monitor_test.go new file mode 100644 index 0000000..e30784b --- /dev/null +++ b/commands/execution_monitor_test.go @@ -0,0 +1,207 @@ +package commands_test + +import ( + "fmt" + + . "github.com/onsi/ginkgo" + "github.com/SAP/cf-mta-plugin/clients/models" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + fakes "github.com/SAP/cf-mta-plugin/clients/slppclient/fakes" + "github.com/SAP/cf-mta-plugin/commands" + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/SAP/cf-mta-plugin/ui" +) + +var _ = Describe("ExecutionMonitor", func() { + Describe("Monitor", func() { + var monitor *commands.ExecutionMonitor + var client slppclient.SlppClientOperations + processID := "1234" + commandName := "deploy" + var oc = testutil.NewUIOutputCapturer() + var ex = testutil.NewUIExpector() + + fakeSlppClientBuilder := fakes.NewFakeSlppClientBuilder() + + var getOutputLines = func(processStatus models.SlpTaskState, errorMessage string, progressMessages []string) []string { + var lines []string + lines = append(lines, "Monitoring process execution...\n") + if len(progressMessages) > 0 { + lines = append(lines, progressMessages...) + } + switch processStatus { + case models.SlpTaskStateSlpTaskStateFINISHED: + lines = append(lines, "Process finished.\n") + case models.SlpTaskStateSlpTaskStateABORTED: + lines = append(lines, "Process was aborted.\n") + case models.SlpTaskStateSlpTaskStateACTIONREQUIRED, models.SlpTaskStateSlpTaskStateDIALOG: + lines = append(lines, "Process has entered validation phase. After testing your new deployment you can resume or abort the process.\n") + lines = append(lines, fmt.Sprintf("Use \"cf %s -i %s -a resume\" to resume the process.\n", commandName, processID)) + lines = append(lines, fmt.Sprintf("Use \"cf %s -i %s -a abort\" to abort the process.\n", commandName, processID)) + lines = append(lines, "Hint: Use the '--no-confirm' option of the bg-deploy command to skip this phase.\n") + default: + lines = append(lines, fmt.Sprintf("Process is in illegal state %s.", processStatus)) + } + + if errorMessage != "" { + lines = append(lines, fmt.Sprintf("Process failed: %s\n", errorMessage)) + lines = append(lines, fmt.Sprintf("Use \"cf %s -i %s -a retry\" to retry the process.\n", commandName, processID)) + lines = append(lines, fmt.Sprintf("Use \"cf %s -i %s -a abort\" to abort the process.\n", commandName, processID)) + } + return lines + } + + BeforeEach(func() { + ui.DisableTerminalOutput(true) + }) + + Context("with no process task in the tasklist", func() { + It("should return error", func() { + tasklist := testutil.GetTaskList(testutil.GetTask("test-type", "test-state", []*models.ProgressMessage{})) + client = fakeSlppClientBuilder. + GetTasklistTask(tasklist.Tasks[0], nil). + Build() + monitor = commands.NewExecutionMonitor(processID, commandName, client, []*models.ProgressMessage{}) + output, status := oc.CaptureOutputAndStatus(func() int { + return monitor.Monitor().ToInt() + }) + ex.ExpectFailureOnLine(status, output, "The SLP task must be a Process task", 1) + }) + }) + + Context("with process task in state aborted and no progress messages in the tasklist", func() { + It("should print info message and exit with zero status", func() { + tasklist := testutil.GetTaskList(testutil.GetTask(models.SlpTaskTypeSlpTaskTypePROCESS, models.SlpTaskStateSlpTaskStateABORTED, []*models.ProgressMessage{})) + client = fakeSlppClientBuilder. + GetTasklistTask(tasklist.Tasks[0], nil).Build() + monitor = commands.NewExecutionMonitor(processID, commandName, client, []*models.ProgressMessage{}) + output, status := oc.CaptureOutputAndStatus(func() int { + return monitor.Monitor().ToInt() + }) + ex.ExpectFailure(status, output, "Process was aborted.") + }) + }) + Context("with process task in state error and no progress messages in the tasklist", func() { + It("should return error and exit with non-zero status", func() { + tasklist := testutil.GetTaskList(testutil.GetTask(models.SlpTaskTypeSlpTaskTypePROCESS, models.SlpTaskStateSlpTaskStateERROR, []*models.ProgressMessage{})) + client = fakeSlppClientBuilder. + GetTasklistTask(tasklist.Tasks[0], nil). + GetError(testutil.ErrorResult, nil).GetActions(testutil.Actions, nil).Build() + monitor = commands.NewExecutionMonitor(processID, commandName, client, []*models.ProgressMessage{}) + output, status := oc.CaptureOutputAndStatus(func() int { + return monitor.Monitor().ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Use \"cf deploy -i 1234 -a abort\" to abort the process.\n", 2) + }) + }) + Context("with process task in illegal state and no progress messages in the tasklist", func() { + It("should return error and exit with non-zero status", func() { + tasklist := testutil.GetTaskList(testutil.GetTask(models.SlpTaskTypeSlpTaskTypePROCESS, "slp.task.state.NON-EXISTING", []*models.ProgressMessage{})) + client = fakeSlppClientBuilder.GetTasklistTask(tasklist.Tasks[0], nil).Build() + monitor = commands.NewExecutionMonitor(processID, commandName, client, []*models.ProgressMessage{}) + output, status := oc.CaptureOutputAndStatus(func() int { + return monitor.Monitor().ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Process is in illegal state slp.task.state.NON-EXISTING", 1) + }) + }) + Context("with process task in state finished and no progress messages in the tasklist", func() { + It("should print info message and exit with zero status", func() { + const processStatus = models.SlpTaskStateSlpTaskStateFINISHED + tasklist := testutil.GetTaskList(testutil.GetTask(models.SlpTaskTypeSlpTaskTypePROCESS, processStatus, []*models.ProgressMessage{})) + client = fakeSlppClientBuilder.GetTasklistTask(tasklist.Tasks[0], nil).Build() + monitor = commands.NewExecutionMonitor(processID, commandName, client, []*models.ProgressMessage{}) + output, status := oc.CaptureOutputAndStatus(func() int { + return monitor.Monitor().ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(processStatus, "", []string{})) + }) + }) + + Context("with process task in state finished and progress messages with non-repeating ids in the tasklist", func() { + It("should print all progress messages and exit with zero status", func() { + const processStatus = models.SlpTaskStateSlpTaskStateFINISHED + tasklist := testutil.GetTaskList(testutil.GetTask(models.SlpTaskTypeSlpTaskTypePROCESS, processStatus, []*models.ProgressMessage{ + testutil.GetProgressMessage("1", "test-message-1"), + testutil.GetProgressMessage("2", "test-message-2"), + testutil.GetProgressMessage("3", "test-message-3"), + })) + client = fakeSlppClientBuilder.GetTasklistTask(tasklist.Tasks[0], nil).Build() + monitor = commands.NewExecutionMonitor(processID, commandName, client, []*models.ProgressMessage{}) + output, status := oc.CaptureOutputAndStatus(func() int { + return monitor.Monitor().ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(processStatus, "", []string{" test-message-1\n", " test-message-2\n", " test-message-3\n"})) + }) + }) + Context("with process task in state finished and progress messages with repeating ids in the tasklist", func() { + It("should print progress messages and exit with zero status", func() { + const processStatus = models.SlpTaskStateSlpTaskStateFINISHED + tasklist := testutil.GetTaskList(testutil.GetTask(models.SlpTaskTypeSlpTaskTypePROCESS, processStatus, []*models.ProgressMessage{ + testutil.GetProgressMessage("1", "test-message-1"), + testutil.GetProgressMessage("1", "test-message-2"), + testutil.GetProgressMessage("3", "test-message-3"), + testutil.GetProgressMessage("4", "test-message-4"), + })) + client = fakeSlppClientBuilder.GetTasklistTask(tasklist.Tasks[0], nil).Build() + monitor = commands.NewExecutionMonitor(processID, commandName, client, []*models.ProgressMessage{}) + output, status := oc.CaptureOutputAndStatus(func() int { + return monitor.Monitor().ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(processStatus, "", []string{" test-message-1\n", " test-message-3\n", " test-message-4\n"})) + }) + }) + Context("with process task in state finished and progress messages with non-repeating ids in the tasklist and already reported progress messages", func() { + It("should print progress messages and exit with zero status", func() { + const processStatus = models.SlpTaskStateSlpTaskStateFINISHED + tasklist := testutil.GetTaskList(testutil.GetTask(models.SlpTaskTypeSlpTaskTypePROCESS, processStatus, []*models.ProgressMessage{ + testutil.GetProgressMessage("1", "test-message-1"), + testutil.GetProgressMessage("2", "test-message-2"), + testutil.GetProgressMessage("3", "test-message-3"), + testutil.GetProgressMessage("4", "test-message-4"), + })) + client = fakeSlppClientBuilder.GetTasklistTask(tasklist.Tasks[0], nil).Build() + monitor = commands.NewExecutionMonitor(processID, commandName, client, []*models.ProgressMessage{ + testutil.GetProgressMessage("1", "test-message-1"), + testutil.GetProgressMessage("2", "test-message-2")}) + output, status := oc.CaptureOutputAndStatus(func() int { + return monitor.Monitor().ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(processStatus, "", []string{" test-message-3\n", " test-message-4\n"})) + }) + }) + Context("with process task in state finished and already reported progress messages which are not part of the reported progressmessages", func() { + It("should print progress messages and exit with zero status", func() { + const processStatus = models.SlpTaskStateSlpTaskStateFINISHED + client = fakeSlppClientBuilder. + GetTasklist(testutil.GetTaskList(testutil.GetTask(models.SlpTaskTypeSlpTaskTypePROCESS, processStatus, []*models.ProgressMessage{ + testutil.GetProgressMessage("1", "test-message-1"), + testutil.GetProgressMessage("2", "test-message-2"), + testutil.GetProgressMessage("3", "test-message-3"), + testutil.GetProgressMessage("4", "test-message-4"), + })), nil).Build() + monitor = commands.NewExecutionMonitor(processID, commandName, client, []*models.ProgressMessage{ + testutil.GetProgressMessage("5", "test-message-5"), + testutil.GetProgressMessage("6", "test-message-6")}) + output, status := oc.CaptureOutputAndStatus(func() int { + return monitor.Monitor().ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(processStatus, "", []string{" test-message-1\n", " test-message-2\n", " test-message-3\n", " test-message-4\n"})) + }) + }) + Context("with process task in state action required", func() { + It("should print progress messages and exit with zero status", func() { + const processStatus = models.SlpTaskStateSlpTaskStateACTIONREQUIRED + tasklist := testutil.GetTaskList(testutil.GetTask(models.SlpTaskTypeSlpTaskTypePROCESS, processStatus, []*models.ProgressMessage{})) + client = fakeSlppClientBuilder. + GetTasklistTask(tasklist.Tasks[0], nil). + GetActions(testutil.BlueGreenActions, nil).Build() + monitor = commands.NewExecutionMonitor(processID, commandName, client, []*models.ProgressMessage{}) + output, status := oc.CaptureOutputAndStatus(func() int { + return monitor.Monitor().ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(processStatus, "", []string{})) + }) + }) + }) +}) diff --git a/commands/execution_status.go b/commands/execution_status.go new file mode 100644 index 0000000..e3b9e1a --- /dev/null +++ b/commands/execution_status.go @@ -0,0 +1,12 @@ +package commands + +type ExecutionStatus int + +const ( + Success ExecutionStatus = 0 + Failure ExecutionStatus = 1 +) + +func (status ExecutionStatus) ToInt() int { + return int(status) +} diff --git a/commands/fakes/fake_action.go b/commands/fakes/fake_action.go new file mode 100644 index 0000000..524bfce --- /dev/null +++ b/commands/fakes/fake_action.go @@ -0,0 +1,58 @@ +// This file was generated by counterfeiter +package fakes + +import ( + "sync" + + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + "github.com/SAP/cf-mta-plugin/commands" +) + +type FakeAction struct { + ExecuteStub func(processID, commandName string, slppClient slppclient.SlppClientOperations) commands.ExecutionStatus + executeMutex sync.RWMutex + executeArgsForCall []struct { + processID string + commandName string + slppClient slppclient.SlppClientOperations + } + executeReturns struct { + result1 commands.ExecutionStatus + } +} + +func (fake *FakeAction) Execute(processID string, commandName string, slppClient slppclient.SlppClientOperations) commands.ExecutionStatus { + fake.executeMutex.Lock() + fake.executeArgsForCall = append(fake.executeArgsForCall, struct { + processID string + commandName string + slppClient slppclient.SlppClientOperations + }{processID, commandName, slppClient}) + fake.executeMutex.Unlock() + if fake.ExecuteStub != nil { + return fake.ExecuteStub(processID, commandName, slppClient) + } else { + return fake.executeReturns.result1 + } +} + +func (fake *FakeAction) ExecuteCallCount() int { + fake.executeMutex.RLock() + defer fake.executeMutex.RUnlock() + return len(fake.executeArgsForCall) +} + +func (fake *FakeAction) ExecuteArgsForCall(i int) (string, string, slppclient.SlppClientOperations) { + fake.executeMutex.RLock() + defer fake.executeMutex.RUnlock() + return fake.executeArgsForCall[i].processID, fake.executeArgsForCall[i].commandName, fake.executeArgsForCall[i].slppClient +} + +func (fake *FakeAction) ExecuteReturns(result1 commands.ExecutionStatus) { + fake.ExecuteStub = nil + fake.executeReturns = struct { + result1 commands.ExecutionStatus + }{result1} +} + +var _ commands.Action = new(FakeAction) diff --git a/commands/fakes/fake_cli_connection_builder.go b/commands/fakes/fake_cli_connection_builder.go new file mode 100644 index 0000000..b59c05e --- /dev/null +++ b/commands/fakes/fake_cli_connection_builder.go @@ -0,0 +1,58 @@ +package fakes + +import ( + "github.com/cloudfoundry/cli/plugin/fakes" + plugin_models "github.com/cloudfoundry/cli/plugin/models" +) + +// FakeCliConnectionBuilder is a builder of FakeCliConnection instances +type FakeCliConnectionBuilder struct { + cliConn fakes.FakeCliConnection +} + +// NewFakeCliConnectionBuilder creates a new builder +func NewFakeCliConnectionBuilder() *FakeCliConnectionBuilder { + return &FakeCliConnectionBuilder{} +} + +func (b *FakeCliConnectionBuilder) CurrentOrg(guid, name string, err error) *FakeCliConnectionBuilder { + org := plugin_models.Organization{OrganizationFields: plugin_models.OrganizationFields{Guid: guid, Name: name}} + b.cliConn.GetCurrentOrgReturns(org, err) + return b +} + +func (b *FakeCliConnectionBuilder) CurrentSpace(guid, name string, err error) *FakeCliConnectionBuilder { + space := plugin_models.Space{SpaceFields: plugin_models.SpaceFields{Guid: guid, Name: name}} + b.cliConn.GetCurrentSpaceReturns(space, err) + return b +} + +func (b *FakeCliConnectionBuilder) Username(username string, err error) *FakeCliConnectionBuilder { + b.cliConn.UsernameReturns(username, err) + return b +} + +func (b *FakeCliConnectionBuilder) AccessToken(token string, err error) *FakeCliConnectionBuilder { + b.cliConn.AccessTokenReturns(token, err) + return b +} + +func (b *FakeCliConnectionBuilder) APIEndpoint(apiURL string, err error) *FakeCliConnectionBuilder { + b.cliConn.ApiEndpointReturns(apiURL, err) + return b +} + +func (b *FakeCliConnectionBuilder) GetApp(name string, app plugin_models.GetAppModel, err error) *FakeCliConnectionBuilder { + b.cliConn.GetAppReturns(app, err) // TODO + return b +} + +func (b *FakeCliConnectionBuilder) GetService(name string, service plugin_models.GetService_Model, err error) *FakeCliConnectionBuilder { + b.cliConn.GetServiceReturns(service, err) // TODO + return b +} + +// Build builds a FakeCliConnection instance +func (b *FakeCliConnectionBuilder) Build() *fakes.FakeCliConnection { + return &b.cliConn +} diff --git a/commands/fakes/fake_command.go b/commands/fakes/fake_command.go new file mode 100644 index 0000000..9294121 --- /dev/null +++ b/commands/fakes/fake_command.go @@ -0,0 +1,115 @@ +// This file was generated by counterfeiter +package fakes + +import ( + "sync" + + "github.com/SAP/cf-mta-plugin/commands" + + "github.com/cloudfoundry/cli/plugin" +) + +type FakeCommand struct { + GetPluginCommandStub func() plugin.Command + getPluginCommandMutex sync.RWMutex + getPluginCommandArgsForCall []struct{} + getPluginCommandReturns struct { + result1 plugin.Command + } + InitializeStub func(name string, cliConnection plugin.CliConnection) + initializeMutex sync.RWMutex + initializeArgsForCall []struct { + name string + cliConnection plugin.CliConnection + } + ExecuteStub func(args []string) commands.ExecutionStatus + executeMutex sync.RWMutex + executeArgsForCall []struct { + args []string + } + executeReturns struct { + result1 commands.ExecutionStatus + } +} + +func (fake *FakeCommand) GetPluginCommand() plugin.Command { + fake.getPluginCommandMutex.Lock() + fake.getPluginCommandArgsForCall = append(fake.getPluginCommandArgsForCall, struct{}{}) + fake.getPluginCommandMutex.Unlock() + if fake.GetPluginCommandStub != nil { + return fake.GetPluginCommandStub() + } else { + return fake.getPluginCommandReturns.result1 + } +} + +func (fake *FakeCommand) GetPluginCommandCallCount() int { + fake.getPluginCommandMutex.RLock() + defer fake.getPluginCommandMutex.RUnlock() + return len(fake.getPluginCommandArgsForCall) +} + +func (fake *FakeCommand) GetPluginCommandReturns(result1 plugin.Command) { + fake.GetPluginCommandStub = nil + fake.getPluginCommandReturns = struct { + result1 plugin.Command + }{result1} +} + +func (fake *FakeCommand) Initialize(name string, cliConnection plugin.CliConnection) { + fake.initializeMutex.Lock() + fake.initializeArgsForCall = append(fake.initializeArgsForCall, struct { + name string + cliConnection plugin.CliConnection + }{name, cliConnection}) + fake.initializeMutex.Unlock() + if fake.InitializeStub != nil { + fake.InitializeStub(name, cliConnection) + } +} + +func (fake *FakeCommand) InitializeCallCount() int { + fake.initializeMutex.RLock() + defer fake.initializeMutex.RUnlock() + return len(fake.initializeArgsForCall) +} + +func (fake *FakeCommand) InitializeArgsForCall(i int) (string, plugin.CliConnection) { + fake.initializeMutex.RLock() + defer fake.initializeMutex.RUnlock() + return fake.initializeArgsForCall[i].name, fake.initializeArgsForCall[i].cliConnection +} + +func (fake *FakeCommand) Execute(args []string) commands.ExecutionStatus { + fake.executeMutex.Lock() + fake.executeArgsForCall = append(fake.executeArgsForCall, struct { + args []string + }{args}) + fake.executeMutex.Unlock() + if fake.ExecuteStub != nil { + return fake.ExecuteStub(args) + } else { + return fake.executeReturns.result1 + } +} + +func (fake *FakeCommand) ExecuteCallCount() int { + fake.executeMutex.RLock() + defer fake.executeMutex.RUnlock() + return len(fake.executeArgsForCall) +} + +func (fake *FakeCommand) ExecuteArgsForCall(i int) []string { + fake.executeMutex.RLock() + defer fake.executeMutex.RUnlock() + return fake.executeArgsForCall[i].args +} + +func (fake *FakeCommand) ExecuteReturns(result1 commands.ExecutionStatus) { + fake.ExecuteStub = nil + fake.executeReturns = struct { + result1 commands.ExecutionStatus + }{result1} +} + +var _ commands.Command = new(FakeCommand) diff --git a/commands/file_uploader.go b/commands/file_uploader.go new file mode 100644 index 0000000..775f2e3 --- /dev/null +++ b/commands/file_uploader.go @@ -0,0 +1,247 @@ +package commands + +import ( + "fmt" + "os" + "path/filepath" + "strings" + + "github.com/cloudfoundry/cli/cf/terminal" + + slmpclient "github.com/SAP/cf-mta-plugin/clients/slmpclient" + "github.com/SAP/cf-mta-plugin/log" + "github.com/SAP/cf-mta-plugin/ui" + "github.com/SAP/cf-mta-plugin/util" + + "github.com/SAP/cf-mta-plugin/clients/models" + "golang.org/x/sync/errgroup" +) + +const ( + ServiceVersion1_0 = "1.0" + ServiceVersion1_1 = "1.1" +) + +//FileUploader uploads files for the service with the specified service ID +type FileUploader struct { + serviceID string + files []string + slmpClient slmpclient.SlmpClientOperations +} + +//NewFileUploader creates a new file uploader for the specified service ID, files, and SLMP client +func NewFileUploader(serviceID string, files []string, slmpClient slmpclient.SlmpClientOperations) *FileUploader { + return &FileUploader{ + serviceID: serviceID, + files: files, + slmpClient: slmpClient, + } +} + +//UploadFiles uploads the files +func (f *FileUploader) UploadFiles() ([]*models.File, ExecutionStatus) { + log.Tracef("Uploading files '%v'\n", f.files) + + // Get all files that are already uploaded + serviceFiles, err := f.slmpClient.GetServiceFiles(f.serviceID) + if err != nil { + ui.Failed("Could not get files for service %s: %s", terminal.EntityNameColor(f.serviceID), err) + return nil, Failure + } + + // Determine which files to uplaod + filesToUpload := []os.File{} + alreadyUploadedFiles := []*models.File{} + for _, file := range f.files { + // Check if the file exists + fileInfo, err := os.Stat(file) + if os.IsNotExist(err) { + ui.Failed("Could not find file %s", terminal.EntityNameColor(file)) + return nil, Failure + } else if err != nil { + ui.Failed("Could not get information for file %s", terminal.EntityNameColor(file)) + return nil, Failure + } + + // Check if the files is already uploaded + if !isFileAlreadyUploaded(file, fileInfo, serviceFiles, &alreadyUploadedFiles) { + // If not, add it to the list of uploaded files + fileToUpload, err := os.Open(file) + defer fileToUpload.Close() + if err != nil { + ui.Failed("Could not open file %s", terminal.EntityNameColor(file)) + return nil, Failure + } + filesToUpload = append(filesToUpload, *fileToUpload) + } + } + + // If there are new files to upload, upload them + uploadedFiles := []*models.File{} + uploadedFiles = append(uploadedFiles, alreadyUploadedFiles...) + if len(filesToUpload) != 0 { + ui.Say("Uploading %d files...", len(filesToUpload)) + + // Iterate over all files to be uploaded + for _, fileToUpload := range filesToUpload { + // Print the full path of the file + fullPath, err := filepath.Abs(fileToUpload.Name()) + if err != nil { + ui.Failed("Could not get absolute path of file %s", terminal.EntityNameColor(fileToUpload.Name())) + return nil, Failure + } + ui.Say(" " + fullPath) + + // Recreate the session if it is expired + EnsureSlmpSession(f.slmpClient) + + // Upload the file + shouldUploadInChunks, err := f.shouldUploadInChunks() + if err != nil { + ui.Failed("Could not get versions for service %s", terminal.EntityNameColor(f.serviceID), err) + return nil, Failure + } + + uploaded, err := f.upload(shouldUploadInChunks, fileToUpload, fullPath) + if err != nil { + ui.Failed("Could not upload file %s", terminal.EntityNameColor(fileToUpload.Name())) + return nil, Failure + } + uploadedFiles = append(uploadedFiles, uploaded...) + } + ui.Ok() + } + return uploadedFiles, Success +} + +func (f *FileUploader) upload(shouldUploadInChunks bool, fileToUpload os.File, filePath string) ([]*models.File, error) { + if shouldUploadInChunks { + // upload files in chunks + return uploadInChunks(filePath, fileToUpload, f.serviceID, f.slmpClient) + } + + //upload normally + file, err := uploadFile(&fileToUpload, fileToUpload.Name(), f.serviceID, f.slmpClient) + return []*models.File{file}, err +} + +func (f *FileUploader) shouldUploadInChunks() (bool, error) { + serviceVersions, err := f.slmpClient.GetServiceVersions(f.serviceID) + if err != nil { + return false, err + + } + baseServiceVersion := getBaseServiceVersion(serviceVersions.ComponentVersions) + return baseServiceVersion == ServiceVersion1_1, nil +} + +func getBaseServiceVersion(serviceVersions []*models.ComponentVersion) string { + baseServiceVersion := ServiceVersion1_0 + for _, version := range serviceVersions { + if *version.Version == ServiceVersion1_1 { + return ServiceVersion1_1 + } + } + return baseServiceVersion +} + +func uploadInChunks(fullPath string, fileToUpload os.File, serviceID string, slmpClient slmpclient.SlmpClientOperations) ([]*models.File, error) { + // Upload the file + fileToUploadParts, err := util.SplitFile(fullPath) + if err != nil { + return nil, fmt.Errorf("Could not process file %q: %v", fullPath, err) + } + defer attemptToRemoveFileParts(fileToUploadParts) + + var uploaderGroup errgroup.Group + uploadedFilesChannel := make(chan *models.File) + defer close(uploadedFilesChannel) + for _, fileToUploadPart := range fileToUploadParts { + filePart, err := os.Open(fileToUploadPart) + if err != nil { + return nil, fmt.Errorf("Could not open file part %s of file %s", filePart.Name(), fullPath) + } + uploaderGroup.Go(func() error { + file, err := uploadFilePart(filePart, fileToUpload.Name(), serviceID, slmpClient) + if err != nil { + return err + } + uploadedFilesChannel <- file + return nil + }) + } + uploadedFileParts := []*models.File{} + var retrieverGroup errgroup.Group + retrieverGroup.Go(func() error { + for uploadedFile := range uploadedFilesChannel { + uploadedFileParts = append(uploadedFileParts, uploadedFile) + if len(uploadedFileParts) == len(fileToUploadParts) { + break + } + } + return nil + }) + + err = uploaderGroup.Wait() + if err != nil { + return nil, err + } + err = retrieverGroup.Wait() + if err != nil { + return nil, err + } + return uploadedFileParts, nil +} + +func attemptToRemoveFileParts(fileParts []string) { + // If more than one file parts exists, then remove them. + // If there is only one, then this is the archive itself + if len(fileParts) > 1 { + for _, filePart := range fileParts { + filePartAbsPath, err := filepath.Abs(filePart) + if err != nil { + ui.Warn("Error retrieving absolute file path of %q", filePart) + } + err = os.Remove(filePartAbsPath) + if err != nil { + ui.Warn("Error cleaning up temporary files") + } + } + } +} + +func uploadFilePart(filePart *os.File, baseFileName string, serviceID string, client slmpclient.SlmpClientOperations) (*models.File, error) { + return uploadFile(filePart, baseFileName, serviceID, client) +} + +func uploadFile(file *os.File, baseFileName string, serviceID string, client slmpclient.SlmpClientOperations) (*models.File, error) { + createdFiles, err := client.CreateServiceFile(serviceID, *file) + defer file.Close() + if err != nil || len(createdFiles.Files) == 0 { + return nil, fmt.Errorf("Could not create file %s for service %s: %s", terminal.EntityNameColor(baseFileName), terminal.EntityNameColor(serviceID), err) + } + return createdFiles.Files[0], nil +} + +func isFileAlreadyUploaded(newFilePath string, fileInfo os.FileInfo, oldFiles models.Files, alreadyUploadedFiles *[]*models.File) bool { + newFileDigests := make(map[string]string) + for _, oldFile := range oldFiles.Files { + if *oldFile.FileName != fileInfo.Name() { + continue + } + if newFileDigests[oldFile.DigestAlgorithm] == "" { + digest, err := util.ComputeFileChecksum(newFilePath, oldFile.DigestAlgorithm) + if err != nil { + ui.Failed("Could not compute digest of file %s: %s", terminal.EntityNameColor(newFilePath), err) + } + newFileDigests[oldFile.DigestAlgorithm] = strings.ToUpper(digest) + } + if newFileDigests[oldFile.DigestAlgorithm] == oldFile.Digest { + *alreadyUploadedFiles = append(*alreadyUploadedFiles, oldFile) + ui.Say("Previously uploaded file %s with same digest detected, new upload will be skipped.", + terminal.EntityNameColor(fileInfo.Name())) + return true + } + } + return false +} diff --git a/commands/file_uploader_test.go b/commands/file_uploader_test.go new file mode 100644 index 0000000..0a1e351 --- /dev/null +++ b/commands/file_uploader_test.go @@ -0,0 +1,156 @@ +package commands_test + +import ( + "errors" + "os" + "path/filepath" + "strings" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/SAP/cf-mta-plugin/clients/models" + "github.com/SAP/cf-mta-plugin/clients/slmpclient/fakes" + "github.com/SAP/cf-mta-plugin/commands" + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/SAP/cf-mta-plugin/ui" + "github.com/SAP/cf-mta-plugin/util" +) + +var _ = Describe("FileUploader", func() { + Describe("UploadFiles", func() { + const testFileName = "test.mtar" + + var fileUploader *commands.FileUploader + var testFile *os.File + var testFileAbsolutePath string + var testFileDigest string + var oc = testutil.NewUIOutputCapturer() + var ex = testutil.NewUIExpector() + + fakeSlmpClientBuilder := fakes.NewFakeSlmpClientBuilder() + + BeforeEach(func() { + ui.DisableTerminalOutput(true) + testFile, _ = os.Create(testFileName) + testFileAbsolutePath, _ = filepath.Abs(testFile.Name()) + testFileDigest, _ = util.ComputeFileChecksum(testFileAbsolutePath, "MD5") + testFileDigest = strings.ToUpper(testFileDigest) + }) + var uploadedFiles []*models.File + var status commands.ExecutionStatus + Context("with non-existing service files and no files to upload", func() { + It("should return no uploaded files", func() { + client := fakeSlmpClientBuilder.GetServiceFiles("xs2-deploy", models.Files{}, nil).Build() + + output := oc.CaptureOutput(func() { + fileUploader = commands.NewFileUploader("xs2-deploy", []string{}, client) + uploadedFiles, status = fileUploader.UploadFiles() + }) + ex.ExpectSuccess(status.ToInt(), output) + Expect(uploadedFiles).To(Equal([]*models.File{})) + }) + }) + + Context("with existing service files and no files to upload", func() { + It("should return no uploaded files", func() { + client := fakeSlmpClientBuilder.GetServiceFiles("xs2-deploy", testutil.FilesResult, nil).Build() + var uploadedFiles []*models.File + output := oc.CaptureOutput(func() { + fileUploader = commands.NewFileUploader("xs2-deploy", []string{}, client) + uploadedFiles, status = fileUploader.UploadFiles() + }) + ex.ExpectSuccess(status.ToInt(), output) + Expect(uploadedFiles).To(Equal([]*models.File{})) + }) + }) + + Context("with non-existing service files and one file to upload", func() { + It("should return the uploaded file", func() { + files := []*models.File{testutil.GetFile("xs2-deploy", *testFile, testFileDigest)} + client := fakeSlmpClientBuilder. + GetMetadata(&testutil.SlmpMetadataResult, nil). + GetServiceFiles("xs2-deploy", models.Files{}, nil). + CreateServiceFile("xs2-deploy", testFile, testutil.GetFiles(files), nil).Build() + var uploadedFiles []*models.File + output := oc.CaptureOutput(func() { + fileUploader = commands.NewFileUploader("xs2-deploy", []string{testFileAbsolutePath}, client) + uploadedFiles, status = fileUploader.UploadFiles() + }) + Expect(len(uploadedFiles)).To(Equal(1)) + fullPath, _ := filepath.Abs(testFile.Name()) + ex.ExpectSuccessWithOutput(status.ToInt(), output, []string{ + "Uploading 1 files...\n", + " " + fullPath + "\n", + "OK\n", + }) + Expect(uploadedFiles).To(Equal(files)) + }) + }) + + Context("with existing service files and one file to upload", func() { + It("should display a message that the file upload will be skipped", func() { + files := []*models.File{testutil.GetFile("xs2-deploy", *testFile, testFileDigest)} + client := fakeSlmpClientBuilder. + GetServiceFiles("xs2-deploy", testutil.FilesResult, nil). + CreateServiceFile("xs2-deploy", testFile, testutil.GetFiles(files), nil).Build() + var uploadedFiles []*models.File + output := oc.CaptureOutput(func() { + fileUploader = commands.NewFileUploader("xs2-deploy", []string{testFileAbsolutePath}, client) + uploadedFiles, status = fileUploader.UploadFiles() + }) + ex.ExpectSuccessWithOutput(status.ToInt(), output, []string{ + "Previously uploaded file test.mtar with same digest detected, new upload will be skipped.\n"}) + Expect(len(uploadedFiles)).To(Equal(1)) + Expect(uploadedFiles).To(Equal(files)) + }) + }) + + Context("with non-existing service files and one file to upload and service versions returned from the backend", func() { + It("should return the uploaded file", func() { + files := []*models.File{testutil.GetFile("xs2-deploy", *testFile, testFileDigest)} + client := fakeSlmpClientBuilder. + GetMetadata(&testutil.SlmpMetadataResult, nil). + GetServiceFiles("xs2-deploy", models.Files{}, nil). + CreateServiceFile("xs2-deploy", testFile, testutil.GetFiles(files), nil). + GetServiceVersions("xs2-deploy", testutil.ServiceVersion1_1, nil).Build() + var uploadedFiles []*models.File + output := oc.CaptureOutput(func() { + fileUploader = commands.NewFileUploader("xs2-deploy", []string{testFileAbsolutePath}, client) + uploadedFiles, status = fileUploader.UploadFiles() + }) + Expect(len(uploadedFiles)).To(Equal(1)) + fullPath, _ := filepath.Abs(testFile.Name()) + ex.ExpectSuccessWithOutput(status.ToInt(), output, []string{ + "Uploading 1 files...\n", + " " + fullPath + "\n", + "OK\n", + }) + Expect(uploadedFiles).To(Equal(files)) + }) + }) + + Context("with error returned from the backend", func() { + It("should return the uploaded file", func() { + // files := []*models.File{testutil.GetFile("xs2-deploy", *testFile, testFileDigest)} + client := fakeSlmpClientBuilder. + GetMetadata(&testutil.SlmpMetadataResult, nil). + GetServiceFiles("xs2-deploy", models.Files{}, nil). + CreateServiceFile("xs2-deploy", testFile, models.Files{}, errors.New("Unexpected error from the backend")). + GetServiceVersions("xs2-deploy", testutil.ServiceVersion1_1, nil).Build() + var uploadedFiles []*models.File + output := oc.CaptureOutput(func() { + fileUploader = commands.NewFileUploader("xs2-deploy", []string{testFileAbsolutePath}, client) + uploadedFiles, status = fileUploader.UploadFiles() + }) + // Expect(len(uploadedFiles)).To(Equal(1)) + // fullPath, _ := filepath.Abs(testFile.Name()) + ex.ExpectFailureOnLine(status.ToInt(), output, "Could not upload file "+testFileAbsolutePath, 2) + // Expect(uploadedFiles).To(Equal(files)) + }) + }) + + AfterEach(func() { + os.RemoveAll(testFileName) + }) + }) +}) diff --git a/commands/monitor_action.go b/commands/monitor_action.go new file mode 100644 index 0000000..86ea27d --- /dev/null +++ b/commands/monitor_action.go @@ -0,0 +1,21 @@ +package commands + +import ( + "github.com/cloudfoundry/cli/cf/terminal" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + "github.com/SAP/cf-mta-plugin/ui" +) + +// MonitorAction monitors process execution +type MonitorAction struct{} + +// Execute executes monitor action on process with the specified id +func (a *MonitorAction) Execute(processID, commandName string, slppClient slppclient.SlppClientOperations) ExecutionStatus { + progressMessages, err := getReportedProgressMessages(slppClient) + if err != nil { + ui.Failed("Could not get the already reported progress messages for process %s: %s", terminal.EntityNameColor(processID), err) + } + + monitor := NewExecutionMonitor(processID, commandName, slppClient, progressMessages) + return monitor.Monitor() +} diff --git a/commands/mta_command.go b/commands/mta_command.go new file mode 100644 index 0000000..935f61c --- /dev/null +++ b/commands/mta_command.go @@ -0,0 +1,146 @@ +package commands + +import ( + "fmt" + "strconv" + "strings" + + "github.com/cloudfoundry/cli/cf/formatters" + "github.com/cloudfoundry/cli/cf/terminal" + "github.com/cloudfoundry/cli/plugin" + "github.com/cloudfoundry/cli/plugin/models" + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/log" + "github.com/SAP/cf-mta-plugin/ui" + "github.com/SAP/cf-mta-plugin/util" +) + +// MtaCommand is a command for listing a deployed MTA +type MtaCommand struct { + BaseCommand +} + +// GetPluginCommand returns the plugin command details +func (c *MtaCommand) GetPluginCommand() plugin.Command { + return plugin.Command{ + Name: "mta", + HelpText: "Display health and status for a multi-target app", + UsageDetails: plugin.Usage{ + Usage: "cf mta MTA_ID [-u URL]", + Options: map[string]string{ + "u": "Deploy service URL, by default 'deploy-service.'", + }, + }, + } +} + +// Execute executes the command +func (c *MtaCommand) Execute(args []string) ExecutionStatus { + log.Tracef("Executing command '"+c.name+"': args: '%v'\n", args) + + var host string + + // Parse command arguments and check for required options + flags, err := c.CreateFlags(&host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + err = c.ParseFlags(args, []string{"MTA_ID"}, flags, nil) + if err != nil { + c.Usage(err.Error()) + return Failure + } + + mtaID := args[0] + + context, err := c.GetContext() + if err != nil { + c.Usage(err.Error()) + return Failure + } + + // Print initial message + ui.Say("Showing health and status for multi-target app %s in org %s / space %s as %s...", + terminal.EntityNameColor(mtaID), terminal.EntityNameColor(context.Org), + terminal.EntityNameColor(context.Space), terminal.EntityNameColor(context.Username)) + + // Create new REST client + restClient, err := c.NewRestClient(host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Get the MTA + mta, err := restClient.GetMta(mtaID) + if err != nil { + ce, ok := err.(*baseclient.ClientError) + // TODO(ivan): This is crap. It should be changed. + if ok && ce.Code == 404 && strings.Contains(fmt.Sprint(ce.Description), mtaID) { + ui.Failed("Multi-target app %s not found", terminal.EntityNameColor(mtaID)) + return Failure + } + ui.Failed("Could not get multi-target app %s: %s", terminal.EntityNameColor(mtaID), err) + return Failure + + } + ui.Ok() + + // Display information about all apps and services + ui.Say("Version: %s", util.GetMtaVersionAsString(mta)) + ui.Say("\nApps:") + table := ui.Table([]string{"name", "requested state", "instances", "memory", "disk", "urls"}) + serviceApps := make(map[string][]string) + for _, mtaModule := range mta.Modules.Modules { + app, err := c.cliConnection.GetApp(*mtaModule.AppName) + if err != nil { + ui.Failed("Could not get app %s: %s", terminal.EntityNameColor(*mtaModule.AppName), err) + return Failure + } + table.Add(app.Name, app.State, getInstances(app), size(app.Memory), size(app.DiskQuota), getRoutes(app)) + for _, service := range app.Services { + serviceApps[service.Name] = append(serviceApps[service.Name], app.Name) + } + } + table.Print() + if len(mta.Services.Services) > 0 { + ui.Say("\nServices:") + table := ui.Table([]string{"name", "service", "plan", "bound apps", "last operation"}) + for _, serviceName := range mta.Services.Services { + service, err := c.cliConnection.GetService(serviceName) + if err != nil { + ui.Failed("Could not get service %s: %s", terminal.EntityNameColor(serviceName), err) + return Failure + } + table.Add(service.Name, service.ServiceOffering.Name, service.ServicePlan.Name, + getBoundApps(service, serviceApps), getLastOperation(service)) + } + table.Print() + } + return Success +} + +func size(n int64) string { + return formatters.ByteSize(n * formatters.MEGABYTE) +} + +func getInstances(app plugin_models.GetAppModel) string { + return strconv.Itoa(app.RunningInstances) + "/" + strconv.Itoa(app.InstanceCount) +} + +func getRoutes(app plugin_models.GetAppModel) string { + var urls []string + for _, route := range app.Routes { + urls = append(urls, route.Host+"."+route.Domain.Name) + } + return strings.Join(urls, ", ") +} + +func getBoundApps(service plugin_models.GetService_Model, serviceApps map[string][]string) string { + return strings.Join(serviceApps[service.Name], ", ") +} + +func getLastOperation(service plugin_models.GetService_Model) string { + return service.LastOperation.Type + " " + service.LastOperation.State +} diff --git a/commands/mta_command_test.go b/commands/mta_command_test.go new file mode 100644 index 0000000..40615ca --- /dev/null +++ b/commands/mta_command_test.go @@ -0,0 +1,205 @@ +package commands_test + +import ( + "fmt" + + plugin_fakes "github.com/cloudfoundry/cli/plugin/fakes" + "github.com/cloudfoundry/cli/plugin/models" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/SAP/cf-mta-plugin/clients/models" + restfake "github.com/SAP/cf-mta-plugin/clients/restclient/fakes" + "github.com/SAP/cf-mta-plugin/commands" + cmd_fakes "github.com/SAP/cf-mta-plugin/commands/fakes" + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/SAP/cf-mta-plugin/ui" +) + +var _ = Describe("MtaCommand", func() { + Describe("Execute", func() { + const org = "test-org" + const space = "test-space" + const user = "test-user" + + var name string + var cliConnection *plugin_fakes.FakeCliConnection + var clientFactory *commands.TestClientFactory + var command *commands.MtaCommand + var oc = testutil.NewUIOutputCapturer() + var ex = testutil.NewUIExpector() + + var getOutputLines = func(mtaID, version string, apps, services [][]string) []string { + lines := []string{} + lines = append(lines, + fmt.Sprintf("Showing health and status for multi-target app %s in org %s / space %s as %s...\n", mtaID, org, space, user)) + lines = append(lines, "OK\n") + lines = append(lines, fmt.Sprintf("Version: %s\n", version)) + lines = append(lines, "\nApps:\n") + lines = append(lines, testutil.GetTableOutputLines( + []string{"name", "requested state", "instances", "memory", "disk", "urls"}, apps)...) + if len(services) > 0 { + lines = append(lines, "\nServices:\n") + lines = append(lines, testutil.GetTableOutputLines( + []string{"name", "service", "plan", "bound apps", "last operation"}, services)...) + } + return lines + } + + BeforeEach(func() { + ui.DisableTerminalOutput(true) + name = command.GetPluginCommand().Name + cliConnection = cmd_fakes.NewFakeCliConnectionBuilder(). + CurrentOrg("test-org-guid", org, nil). + CurrentSpace("test-space-guid", space, nil). + Username(user, nil). + AccessToken("bearer test-token", nil). + APIEndpoint("https://api.test.ondemand.com", nil). + GetApp("", getGetAppModel("test-mta-module-1", "started", 1, 1, 512, 1024, "test-1", "bosh-lite.com", "test-service-1"), nil). + GetService("", getGetServiceModel("test-service-1", "test", "free", "create", "succeeded"), nil).Build() + restClient := restfake.NewFakeRestClientBuilder(). + GetMta("test", nil, nil).Build() + clientFactory = commands.NewTestClientFactory(nil, nil, restClient) + command = &commands.MtaCommand{} + testTokenFactory := commands.NewTestTokenFactory(cliConnection) + + command.InitializeAll(name, cliConnection, testutil.NewCustomTransport(200, nil), nil, clientFactory, testTokenFactory) + }) + + // wrong arguments - error + Context("with wrong arguments", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"x", "y", "z"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Wrong arguments.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // can't connect to backend - error + Context("when can't connect to backend", func() { + const host = "x" + It("should print an error and exit with a non-zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetMta("test", nil, fmt.Errorf("Get https://%s/rest/test/test/mta: dial tcp: lookup %s: no such host", host, host)).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test", "-u", host}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not get multi-target app test:", 1) + }) + }) + + // backend returns a "not found" response - error + Context("with an error response returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetMta("test", nil, newClientError(404, "404 Not Found", `MTA with id "test" does not exist`)).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test"}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Multi-target app test not found", 1) + }) + }) + + // backend returns a non-empty response - success + Context("with a non-empty response returned by the backend", func() { + It("should print a information about the deployed MTA and exit with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetMta("test-mta-id", testutil.GetMta("test-mta-id", "test-version", []*models.MtaModulesItems0{ + testutil.GetMtaModule("test-mta-module-1", []string{}, []string{})}, + []string{"test-service-1"}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test-mta-id"}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, + getOutputLines("test-mta-id", "test-version", + [][]string{[]string{"test-mta-module-1", "started", "1/1", "512M", "1G", "test-1.bosh-lite.com"}}, + [][]string{[]string{"test-service-1", "test", "free", "test-mta-module-1", "create succeeded"}})) + }) + }) + + // backend returns a non-empty response - success + Context("with a non-empty response without services returned by the backend", func() { + It("should print information about the deployed MTA and exit with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetMta("test-mta-id", testutil.GetMta("test-mta-id", "test-version", []*models.MtaModulesItems0{ + testutil.GetMtaModule("test-mta-module-1", []string{}, []string{})}, + []string{}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test-mta-id"}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, + getOutputLines("test-mta-id", "test-version", + [][]string{[]string{"test-mta-module-1", "started", "1/1", "512M", "1G", "test-1.bosh-lite.com"}}, + [][]string{})) + }) + }) + + // backend returns a non-empty response - success + Context("with a non-empty response with unknown MTA version", func() { + It("should print information about the deployed MTA and exit with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetMta("test-mta-id", testutil.GetMta("test-mta-id", "0.0.0-unknown", []*models.MtaModulesItems0{}, []string{}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test-mta-id"}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, + getOutputLines("test-mta-id", "?", [][]string{}, [][]string{})) + }) + }) + + // backend returns a non-empty response - success + Context("with a non-empty response without services and apps returned by the backend", func() { + It("should print information about the deployed MTA and exit with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetMta("test-mta-id", testutil.GetMta("test-mta-id", "test-version", []*models.MtaModulesItems0{}, []string{}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test-mta-id"}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, + getOutputLines("test-mta-id", "test-version", [][]string{}, [][]string{})) + }) + }) + }) +}) + +func getGetAppModel(name, state string, runningInstances, instanceCount int, + memory, diskQuota int64, host, domain, serviceName string) plugin_models.GetAppModel { + return plugin_models.GetAppModel{ + Name: name, + State: state, + RunningInstances: runningInstances, + InstanceCount: instanceCount, + Memory: memory, + DiskQuota: diskQuota, + Routes: []plugin_models.GetApp_RouteSummary{ + plugin_models.GetApp_RouteSummary{ + Host: host, + Domain: plugin_models.GetApp_DomainFields{ + Name: domain, + }, + }, + }, + Services: []plugin_models.GetApp_ServiceSummary{ + plugin_models.GetApp_ServiceSummary{ + Name: serviceName, + }, + }, + } +} + +func getGetServiceModel(name, offering, plan, opType, opState string) plugin_models.GetService_Model { + return plugin_models.GetService_Model{ + Name: name, + ServiceOffering: plugin_models.GetService_ServiceFields{ + Name: offering, + }, + ServicePlan: plugin_models.GetService_ServicePlan{ + Name: plan, + }, + LastOperation: plugin_models.GetService_LastOperation{ + Type: opType, + State: opState, + }, + } +} diff --git a/commands/mta_operations_command.go b/commands/mta_operations_command.go new file mode 100644 index 0000000..e717b05 --- /dev/null +++ b/commands/mta_operations_command.go @@ -0,0 +1,142 @@ +package commands + +import ( + "strconv" + "strings" + + "github.com/cloudfoundry/cli/cf/terminal" + "github.com/cloudfoundry/cli/plugin" + "github.com/SAP/cf-mta-plugin/clients/models" + restclient "github.com/SAP/cf-mta-plugin/clients/restclient" + "github.com/SAP/cf-mta-plugin/log" + "github.com/SAP/cf-mta-plugin/ui" + "github.com/SAP/cf-mta-plugin/util" +) + +// MtaOperationsCommand is a command for listing all mta operations +type MtaOperationsCommand struct { + BaseCommand +} + +// GetPluginCommand returns the plugin command details +func (c *MtaOperationsCommand) GetPluginCommand() plugin.Command { + return plugin.Command{ + Name: "mta-ops", + HelpText: "List multi-target app operations", + UsageDetails: plugin.Usage{ + Usage: "cf mta-ops [-u URL] [--last NUM] [--all]", + Options: map[string]string{ + "u": "Deploy service URL, by default 'deploy-service.'", + util.GetShortOption("last"): "List last NUM operations", + util.GetShortOption("all"): "List all operations, not just the active ones", + }, + }, + } +} + +// Execute executes the command +func (c *MtaOperationsCommand) Execute(args []string) ExecutionStatus { + log.Tracef("Executing command '"+c.name+"': args: '%v'\n", args) + + var host string + var last uint + var all bool + + // Parse command arguments and check for required options + flags, err := c.CreateFlags(&host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + flags.UintVar(&last, "last", 0, "") + flags.BoolVar(&all, "all", false, "") + err = c.ParseFlags(args, nil, flags, nil) + if err != nil { + c.Usage(err.Error()) + return Failure + } + + context, err := c.GetContext() + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + printInitialMessage(context, all, last) + + // Create new REST client + restClient, err := c.NewRestClient(host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Get ongoing operations + operationsToPrint, err := getOperationsToPrint(restClient, last, all) + if err != nil { + ui.Failed("Could not get multi-target app operations: %s", err) + return Failure + } + ui.Ok() + + if len(operationsToPrint) > 0 { + table := ui.Table([]string{"id", "type", "mta id", "status", "started at", "started by"}) + for _, operation := range operationsToPrint { + var mtaid string = operation.MtaID + if operation.MtaID == "" { + mtaid = "N/A" + } + table.Add(*operation.ProcessID, string(operation.ProcessType), mtaid, getStatus(operation.State), *operation.StartedAt, *operation.User) + } + table.Print() + } else { + ui.Say("No multi-target app operations found") + } + return Success +} + +func printInitialMessage(context Context, all bool, last uint) { + var initialMessage string + if all { + initialMessage = "Getting all multi-target app operations in org %[2]s / space %[3]s as %[4]s..." + } else if last == 1 { + initialMessage = "Getting last multi-target app operation in org %[2]s / space %[3]s as %[4]s..." + } else if last != 0 { + initialMessage = "Getting last %[1]d multi-target app operations in org %[2]s / space %[3]s as %[4]s..." + } else { + initialMessage = "Getting active multi-target app operations in org %[2]s / space %[3]s as %[4]s..." + } + ui.Say(initialMessage, last, terminal.EntityNameColor(context.Org), terminal.EntityNameColor(context.Space), + terminal.EntityNameColor(context.Username)) +} + +func getOperationsToPrint(restClient restclient.RestClientOperations, last uint, all bool) ([]*models.Operation, error) { + var ops models.Operations + var err error + if all { + // Get all operations + ops, err = restClient.GetOperations(nil, nil) + } else { + if last == 0 { + // Get operations in active state + ops, err = restClient.GetOperations(nil, activeStatesList) + } else { + // Get last requested operations + requestedOperationsCount := strconv.Itoa(int(last)) + ops, err = restClient.GetOperations(&requestedOperationsCount, nil) + } + } + if err != nil { + return []*models.Operation{}, err + } + return ops.Operations, nil +} + +var activeStatesList = []string{"SLP_TASK_STATE_RUNNING", "SLP_TASK_STATE_ERROR", "SLP_TASK_STATE_DIALOG", "SLP_TASK_STATE_ACTION_REQUIRED", "SLP_TASK_STATE_BREAKPOINT"} + +func getStatus(state models.SlpTaskStateEnum) string { + if strings.HasPrefix(string(state), "SLP_TASK_STATE_") { + return string(state[len("SLP_TASK_STATE_"):]) + } + return string(state) +} diff --git a/commands/mta_operations_command_test.go b/commands/mta_operations_command_test.go new file mode 100644 index 0000000..c26847c --- /dev/null +++ b/commands/mta_operations_command_test.go @@ -0,0 +1,327 @@ +package commands_test + +import ( + "fmt" + + plugin_fakes "github.com/cloudfoundry/cli/plugin/fakes" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/SAP/cf-mta-plugin/clients/models" + restfake "github.com/SAP/cf-mta-plugin/clients/restclient/fakes" + "github.com/SAP/cf-mta-plugin/commands" + cmd_fakes "github.com/SAP/cf-mta-plugin/commands/fakes" + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/SAP/cf-mta-plugin/ui" +) + +var _ = Describe("MtaOperationsCommand", func() { + Describe("Execute", func() { + const org = "test-org" + const space = "test-space" + const user = "test-user" + + var name string + var cliConnection *plugin_fakes.FakeCliConnection + var clientFactory *commands.TestClientFactory + var command *commands.MtaOperationsCommand + var oc = testutil.NewUIOutputCapturer() + var ex = testutil.NewUIExpector() + + var getOutputLines = func(operationsDetails [][]string) []string { + lines := []string{} + if len(operationsDetails) > 0 { + lines = append(lines, testutil.GetTableOutputLines([]string{"id", "type", "mta id", "status", "started at", "started by"}, operationsDetails)...) + } else { + lines = append(lines, "No multi-target app operations found\n") + } + + return lines + } + + BeforeEach(func() { + ui.DisableTerminalOutput(true) + name = command.GetPluginCommand().Name + cliConnection = cmd_fakes.NewFakeCliConnectionBuilder(). + CurrentOrg("test-org-guid", org, nil). + CurrentSpace("test-space-guid", space, nil). + Username(user, nil). + AccessToken("bearer test-token", nil). + APIEndpoint("https://api.test.ondemand.com", nil).Build() + restClient := restfake.NewFakeRestClientBuilder(). + GetMta("test", nil, nil).Build() + clientFactory = commands.NewTestClientFactory(nil, nil, restClient) + command = &commands.MtaOperationsCommand{} + testTokenFactory := commands.NewTestTokenFactory(cliConnection) + command.InitializeAll(name, cliConnection, testutil.NewCustomTransport(200, nil), nil, clientFactory, testTokenFactory) + }) + + Context("with an unknown flag", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-a"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Unknown or wrong flag.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // wrong arguments - error + Context("with wrong arguments", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"x", "y", "z"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Wrong arguments.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // can't connect to backend - error + Context("when can't connect to backend", func() { + const host = "x" + It("should print an error and exit with a non-zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, models.Operations{}, fmt.Errorf("Get https://%s/rest/test/test/mta: dial tcp: lookup %s: no such host", host, host)).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-u", host}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not get multi-target app operations:", 1) + }) + }) + + // backend returns an an error response - error + Context("with an error response returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, models.Operations{}, fmt.Errorf("unknown error (status 404)")).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not get multi-target app operations:", 1) + }) + }) + + Context("with empty response returned by the backend", func() { + It("should print info and return with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, models.Operations{}, nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + expectedOutput := getOutputLines([][]string{}) + expectedOutput = append([]string{ + "Getting active multi-target app operations in org test-org / space test-space as test-user...\n", + "OK\n", + }, expectedOutput...) + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + Context("with non-empty response returned by the backend", func() { + It("should print info and return with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{&testutil.OperationResult}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + expectedOutput := getOutputLines([][]string{ + []string{"111", "deploy", "test", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + }) + expectedOutput = append([]string{ + "Getting active multi-target app operations in org test-org / space test-space as test-user...\n", + "OK\n", + }, expectedOutput...) + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + Context("with non-empty response returned by the backend containing a nil value for MTA ID", func() { + It("should print info and return with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{ + testutil.GetOperation("111", "test-space", "", "deploy", "SLP_TASK_STATE_ERROR", false)}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + expectedOutput := getOutputLines([][]string{ + []string{"111", "deploy", "N/A", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + }) + expectedOutput = append([]string{ + "Getting active multi-target app operations in org test-org / space test-space as test-user...\n", + "OK\n", + }, expectedOutput...) + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + Context("with more than 1 operations returned by the backend", func() { + It("should print info and return with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{ + testutil.GetOperation("test-1", "test-space", "test-mta-1", "deploy", "SLP_TASK_STATE_ERROR", true), + testutil.GetOperation("test-2", "test-space", "test-mta-2", "deploy", "SLP_TASK_STATE_ERROR", false), + }), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + expectedOutput := getOutputLines([][]string{ + []string{"test-1", "deploy", "test-mta-1", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + []string{"test-2", "deploy", "test-mta-2", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + }) + expectedOutput = append([]string{ + "Getting active multi-target app operations in org test-org / space test-space as test-user...\n", + "OK\n", + }, expectedOutput...) + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + Context("with more than 1 operations returned by the backend and last option provided", func() { + It("should print the info of the last 2 operations and return with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(&[]string{"2"}[0], nil, testutil.GetOperations([]*models.Operation{ + testutil.GetOperation("test-1", "test-space", "test-mta-1", "deploy", "SLP_TASK_STATE_ERROR", true), + testutil.GetOperation("test-2", "test-space", "test-mta-2", "deploy", "SLP_TASK_STATE_ERROR", false), + testutil.GetOperation("test-3", "test-space", "test-mta-3", "deploy", "SLP_TASK_STATE_ERROR", false), + }), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-last", "2"}).ToInt() + }) + expectedOutput := getOutputLines([][]string{ + []string{"test-2", "deploy", "test-mta-2", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + []string{"test-3", "deploy", "test-mta-3", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + }) + expectedOutput = append([]string{ + "Getting last 2 multi-target app operations in org test-org / space test-space as test-user...\n", + "OK\n", + }, expectedOutput...) + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + Context("with more than 1 operations returned by the backend and last option provided", func() { + It("should print the info for all of the operations and return with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(&[]string{"10"}[0], nil, testutil.GetOperations([]*models.Operation{ + testutil.GetOperation("test-1", "test-space", "test-mta-1", "deploy", "SLP_TASK_STATE_ERROR", true), + testutil.GetOperation("test-2", "test-space", "test-mta-2", "deploy", "SLP_TASK_STATE_ERROR", false), + testutil.GetOperation("test-3", "test-space", "test-mta-3", "deploy", "SLP_TASK_STATE_ERROR", false), + }), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-last", "10"}).ToInt() + }) + expectedOutput := getOutputLines([][]string{ + []string{"test-1", "deploy", "test-mta-1", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + []string{"test-2", "deploy", "test-mta-2", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + []string{"test-3", "deploy", "test-mta-3", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + }) + expectedOutput = append([]string{ + "Getting last 10 multi-target app operations in org test-org / space test-space as test-user...\n", + "OK\n", + }, expectedOutput...) + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + Context("with more than 1 operations returned by the backend and last option provided", func() { + It("should print the info for the last operation and return with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(&[]string{"10"}[0], nil, testutil.GetOperations([]*models.Operation{ + testutil.GetOperation("test-1", "test-space", "test-mta-1", "deploy", "SLP_TASK_STATE_ERROR", true), + testutil.GetOperation("test-2", "test-space", "test-mta-2", "deploy", "SLP_TASK_STATE_ERROR", false), + testutil.GetOperation("test-3", "test-space", "test-mta-3", "deploy", "SLP_TASK_STATE_ERROR", false), + }), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-last", "1"}).ToInt() + }) + expectedOutput := getOutputLines([][]string{ + []string{"test-1", "deploy", "test-mta-1", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + []string{"test-2", "deploy", "test-mta-2", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + []string{"test-3", "deploy", "test-mta-3", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + }) + expectedOutput = append([]string{ + "Getting last multi-target app operation in org test-org / space test-space as test-user...\n", + "OK\n", + }, expectedOutput...) + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + Context("with empty response returned by the backend and last option provided", func() { + It("should print the info for all of the operations and return with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(&[]string{"10"}[0], nil, models.Operations{}, nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-last", "10"}).ToInt() + }) + expectedOutput := getOutputLines([][]string{}) + expectedOutput = append([]string{ + "Getting last 10 multi-target app operations in org test-org / space test-space as test-user...\n", + "OK\n", + }, expectedOutput...) + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + Context("with more than 1 operations returned by the backend and no options provided", func() { + It("should print the info for operations in active state and return with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(&[]string{"10"}[0], nil, testutil.GetOperations([]*models.Operation{ + testutil.GetOperation("test-1", "test-space", "test-mta-1", "deploy", "SLP_TASK_STATE_ERROR", true), + testutil.GetOperation("test-2", "test-space", "test-mta-2", "deploy", "SLP_TASK_STATE_RUNNING", false), + testutil.GetOperation("test-3", "test-space", "test-mta-3", "deploy", "SLP_TASK_STATE_ERROR", false), + }), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + expectedOutput := getOutputLines([][]string{ + []string{"test-1", "deploy", "test-mta-1", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + []string{"test-2", "deploy", "test-mta-2", "RUNNING", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + []string{"test-3", "deploy", "test-mta-3", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + }) + expectedOutput = append([]string{ + "Getting active multi-target app operations in org test-org / space test-space as test-user...\n", + "OK\n", + }, expectedOutput...) + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + Context("with more than 1 operations returned by the backend and no options provided", func() { + It("should print the info for operations in active state, not include operations in finished state and return with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, []string{"SLP_TASK_STATE_ERROR", "SLP_TASK_STATE_RUNNING"}, testutil.GetOperations([]*models.Operation{ + testutil.GetOperation("test-1", "test-space", "test-mta-1", "deploy", "SLP_TASK_STATE_ERROR", true), + testutil.GetOperation("test-2", "test-space", "test-mta-2", "deploy", "SLP_TASK_STATE_RUNNING", false), + testutil.GetOperation("test-3", "test-space", "test-mta-3", "deploy", "SLP_TASK_STATE_FINISHED", false), + }), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + expectedOutput := getOutputLines([][]string{ + []string{"test-1", "deploy", "test-mta-1", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + []string{"test-2", "deploy", "test-mta-2", "RUNNING", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + }) + expectedOutput = append([]string{ + "Getting active multi-target app operations in org test-org / space test-space as test-user...\n", + "OK\n", + }, expectedOutput...) + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + Context("with more than 1 operations returned by the backend and all option provided", func() { + It("should print the info for operations in active and finished state and return with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{ + testutil.GetOperation("test-1", "test-space", "test-mta-1", "deploy", "SLP_TASK_STATE_ERROR", true), + testutil.GetOperation("test-2", "test-space", "test-mta-2", "deploy", "SLP_TASK_STATE_RUNNING", false), + testutil.GetOperation("test-3", "test-space", "test-mta-3", "deploy", "SLP_TASK_STATE_FINISHED", false), + }), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-all"}).ToInt() + }) + expectedOutput := getOutputLines([][]string{ + []string{"test-1", "deploy", "test-mta-1", "ERROR", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + []string{"test-2", "deploy", "test-mta-2", "RUNNING", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + []string{"test-3", "deploy", "test-mta-3", "FINISHED", "2016-03-04T14:23:24.521Z[Etc/UTC]", "admin"}, + }) + expectedOutput = append([]string{ + "Getting all multi-target app operations in org test-org / space test-space as test-user...\n", + "OK\n", + }, expectedOutput...) + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + }) +}) diff --git a/commands/mtas_command.go b/commands/mtas_command.go new file mode 100644 index 0000000..35d6d3f --- /dev/null +++ b/commands/mtas_command.go @@ -0,0 +1,85 @@ +package commands + +import ( + "github.com/cloudfoundry/cli/cf/terminal" + "github.com/cloudfoundry/cli/plugin" + "github.com/SAP/cf-mta-plugin/log" + "github.com/SAP/cf-mta-plugin/ui" + "github.com/SAP/cf-mta-plugin/util" +) + +// MtasCommand is a command for listing all deployed MTAs +type MtasCommand struct { + BaseCommand +} + +// GetPluginCommand returns the plugin command details +func (c *MtasCommand) GetPluginCommand() plugin.Command { + return plugin.Command{ + Name: "mtas", + HelpText: "List all multi-target apps", + UsageDetails: plugin.Usage{ + Usage: "cf mtas [-u URL]", + Options: map[string]string{ + "u": "Deploy service URL, by default 'deploy-service.'", + }, + }, + } +} + +// Execute executes the command +func (c *MtasCommand) Execute(args []string) ExecutionStatus { + log.Tracef("Executing command '"+c.name+"': args: '%v'\n", args) + + var host string + + // Parse command arguments and check for required options + flags, err := c.CreateFlags(&host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + err = c.ParseFlags(args, nil, flags, nil) + if err != nil { + c.Usage(err.Error()) + return Failure + } + + context, err := c.GetContext() + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Print initial message + ui.Say("Getting multi-target apps in org %s / space %s as %s...", + terminal.EntityNameColor(context.Org), terminal.EntityNameColor(context.Space), terminal.EntityNameColor(context.Username)) + + // Create new REST client + restClient, err := c.NewRestClient(host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Get all deployed components + components, err := restClient.GetComponents() + if err != nil { + ui.Failed("Could not get deployed components: %s", err) + return Failure + } + ui.Ok() + + // Print all deployed MTAs + mtas := components.Mtas.Mtas + if len(mtas) > 0 { + table := ui.Table([]string{"mta id", "version"}) + for _, mta := range mtas { + table.Add(*mta.Metadata.ID, util.GetMtaVersionAsString(mta)) + } + table.Print() + } else { + ui.Say("No multi-target apps found") + } + return Success +} diff --git a/commands/mtas_command_test.go b/commands/mtas_command_test.go new file mode 100644 index 0000000..cf6fcae --- /dev/null +++ b/commands/mtas_command_test.go @@ -0,0 +1,152 @@ +package commands_test + +import ( + "fmt" + + plugin_fakes "github.com/cloudfoundry/cli/plugin/fakes" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/SAP/cf-mta-plugin/clients/models" + restfake "github.com/SAP/cf-mta-plugin/clients/restclient/fakes" + "github.com/SAP/cf-mta-plugin/commands" + cmd_fakes "github.com/SAP/cf-mta-plugin/commands/fakes" + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/SAP/cf-mta-plugin/ui" +) + +var _ = Describe("MtasCommand", func() { + Describe("Execute", func() { + const org = "test-org" + const space = "test-space" + const user = "test-user" + + var name string + var cliConnection *plugin_fakes.FakeCliConnection + var clientFactory *commands.TestClientFactory + var command *commands.MtasCommand + var oc = testutil.NewUIOutputCapturer() + var ex = testutil.NewUIExpector() + var testTokenFactory *commands.TestTokenFactory + + var getOutputLines = func(mtas [][]string) []string { + lines := []string{} + lines = append(lines, + fmt.Sprintf("Getting multi-target apps in org %s / space %s as %s...\n", org, space, user)) + lines = append(lines, "OK\n") + if mtas != nil { + lines = append(lines, testutil.GetTableOutputLines([]string{"mta id", "version"}, mtas)...) + } else { + lines = append(lines, "No multi-target apps found\n") + } + return lines + } + + BeforeEach(func() { + ui.DisableTerminalOutput(true) + name = command.GetPluginCommand().Name + cliConnection = cmd_fakes.NewFakeCliConnectionBuilder(). + CurrentOrg("test-org-guid", org, nil). + CurrentSpace("test-space-guid", space, nil). + Username(user, nil). + AccessToken("bearer test-token", nil). + APIEndpoint("https://api.test.ondemand.com", nil).Build() + clientFactory = commands.NewTestClientFactory(nil, nil, nil) + command = &commands.MtasCommand{} + testTokenFactory = commands.NewTestTokenFactory(cliConnection) + command.InitializeAll(name, cliConnection, testutil.NewCustomTransport(200, nil), nil, clientFactory, testTokenFactory) + }) + + // unknown flag - error + Context("with an unknown flag", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-a"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Unknown or wrong flag.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // wrong arguments - error + Context("with wrong arguments", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"x", "y", "z"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Wrong arguments.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // can't connect to backend - error + Context("when can't connect to backend", func() { + const host = "x" + It("should print an error and exit with a non-zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetComponents(nil, fmt.Errorf("Get https://%s/rest/test/test/components: dial tcp: lookup %s: no such host", host, host)).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-u", host}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not get deployed components:", 1) + }) + }) + + // backend returns an an error response - error + Context("with an error response returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetComponents(nil, fmt.Errorf("unknown error (status 404)")).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not get deployed components:", 1) + }) + }) + + // backend returns an empty response - success + Context("with an empty response returned by the backend", func() { + It("should print a message and exit with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetComponents(testutil.GetComponents([]*models.Mta{}, []string{}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(nil)) + }) + }) + + // backend returns a non-empty response - success + Context("with a non-empty response returned by the backend containing an unknown MTA version", func() { + It("should print a table with all deployed MTAs and exit with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetComponents(testutil.GetComponents( + []*models.Mta{testutil.GetMta("org.cloudfoundry.samples.music", "0.0.0-unknown", + []*models.MtaModulesItems0{testutil.GetMtaModule("spring-music", []string{"postgresql"}, []string{})}, + []string{"postgresql"})}, + []string{}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, + getOutputLines([][]string{[]string{"org.cloudfoundry.samples.music", "?"}})) + }) + }) + + // backend returns a non-empty response - success + Context("with a non-empty response returned by the backend", func() { + It("should print a table with all deployed MTAs and exit with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetComponents(testutil.GetComponents( + []*models.Mta{testutil.GetMta("org.cloudfoundry.samples.music", "1.0", + []*models.MtaModulesItems0{testutil.GetMtaModule("spring-music", []string{"postgresql"}, []string{})}, + []string{"postgresql"})}, + []string{}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, + getOutputLines([][]string{[]string{"org.cloudfoundry.samples.music", "1.0"}})) + }) + }) + }) +}) diff --git a/commands/purge_config_command.go b/commands/purge_config_command.go new file mode 100644 index 0000000..466b41a --- /dev/null +++ b/commands/purge_config_command.go @@ -0,0 +1,81 @@ +package commands + +import ( + "github.com/cloudfoundry/cli/cf/terminal" + "github.com/cloudfoundry/cli/plugin" + "github.com/SAP/cf-mta-plugin/log" + "github.com/SAP/cf-mta-plugin/ui" +) + +type PurgeConfigCommand struct { + BaseCommand +} + +func (c *PurgeConfigCommand) GetPluginCommand() plugin.Command { + return plugin.Command{ + Name: "purge-mta-config", + HelpText: "Purge no longer valid configuration entries", + UsageDetails: plugin.Usage{ + Usage: "cf purge-mta-config [-u URL]", + Options: map[string]string{ + deployServiceURLOpt: "Deploy service URL, by default 'deploy-service.'", + }, + }, + } +} + +func (c *PurgeConfigCommand) Execute(args []string) ExecutionStatus { + log.Tracef("Executing command %q with args %v\n", c.name, args) + + var host string + flags, err := c.CreateFlags(&host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + err = c.ParseFlags(args, nil, flags, nil) + if err != nil { + c.Usage(err.Error()) + return Failure + } + + context, err := c.GetContext() + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + ui.Say("Purging configuration entries in org %s / space %s as %s", + terminal.EntityNameColor(context.Org), + terminal.EntityNameColor(context.Space), + terminal.EntityNameColor(context.Username)) + + rc, err := c.NewRestClient(host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + if _, err := rc.GetComponents(); err != nil { + c.reportError(err) + return Failure + } + // TODO: Why do the same thing twice? + if _, err := rc.GetComponents(); err != nil { + c.reportError(err) + return Failure + } + + // TODO(ivan): the basePath construction for the rest client should + // be part of each API call, not once when the client is created. + rc = c.clientFactory.NewRestClient(host, "", "", c.transport, c.jar, c.tokenFactory) + if err := rc.PurgeConfiguration(context.Org, context.Space); err != nil { + c.reportError(err) + return Failure + } + ui.Ok() + return Success +} + +func (c *PurgeConfigCommand) reportError(err error) { + ui.Failed("Could not purge configuration: %v\n", err) +} diff --git a/commands/purge_config_command_test.go b/commands/purge_config_command_test.go new file mode 100644 index 0000000..644670f --- /dev/null +++ b/commands/purge_config_command_test.go @@ -0,0 +1,102 @@ +package commands_test + +import ( + "fmt" + + plugin_fakes "github.com/cloudfoundry/cli/plugin/fakes" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/SAP/cf-mta-plugin/clients/models" + restfake "github.com/SAP/cf-mta-plugin/clients/restclient/fakes" + "github.com/SAP/cf-mta-plugin/commands" + cmd_fakes "github.com/SAP/cf-mta-plugin/commands/fakes" + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/SAP/cf-mta-plugin/ui" +) + +var _ = Describe("PurgeConfigCommand", func() { + + Describe("Execute", func() { + const ( + org = "test-org" + space = "test-space" + user = "test-user" + ) + + var name string + var cliConnection *plugin_fakes.FakeCliConnection + var clientFactory *commands.TestClientFactory + var command *commands.PurgeConfigCommand + var testTokenFactory *commands.TestTokenFactory + + var oc testutil.OutputCapturer + var ex testutil.Expector + + BeforeEach(func() { + ui.DisableTerminalOutput(true) + name = "purge-mta-config" + cliConnection = cmd_fakes.NewFakeCliConnectionBuilder(). + CurrentOrg("test-org-guid", org, nil). + CurrentSpace("test-space-guid", space, nil). + Username(user, nil). + AccessToken("bearer test-token", nil). + APIEndpoint("https://api.test.ondemand.com", nil).Build() + + testTokenFactory = commands.NewTestTokenFactory(cliConnection) + clientFactory = commands.NewTestClientFactory(nil, nil, nil) + + command = &commands.PurgeConfigCommand{} + command.InitializeAll(name, cliConnection, testutil.NewCustomTransport(200, nil), nil, clientFactory, testTokenFactory) + + oc = testutil.NewUIOutputCapturer() + ex = testutil.NewUIExpector() + }) + + Context("with an unknown flag", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-a"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Unknown or wrong flag.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + Context("with wrong arguments", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"x", "y", "z"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Wrong arguments.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + Context("with an error response returned by the backend", func() { + It("should print an error and exit with a non-zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetComponents(nil, fmt.Errorf("unknown error (status 404)")).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Could not purge configuration", 1) + }) + }) + + Context("with an success response returned by the backend", func() { + It("should print a message and exit with zero status", func() { + clientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetComponents(testutil.GetComponents([]*models.Mta{}, []string{}), nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + expectedOutput := []string{ + "Purging configuration entries in org test-org / space test-space as test-user\n", + "OK\n", + } + ex.ExpectSuccessWithOutput(status, output, expectedOutput) + }) + }) + + }) +}) diff --git a/commands/resume_action.go b/commands/resume_action.go new file mode 100644 index 0000000..5a61cf7 --- /dev/null +++ b/commands/resume_action.go @@ -0,0 +1,33 @@ +package commands + +import ( + "github.com/cloudfoundry/cli/cf/terminal" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + "github.com/SAP/cf-mta-plugin/ui" +) + +// ResumeAction retries the process with the specified id +type ResumeAction struct{} + +// Execute executes resume action on process with the specified id +func (a *ResumeAction) Execute(processID, commandName string, slppClient slppclient.SlppClientOperations) ExecutionStatus { + + // Ensure session is not expired + EnsureSlppSession(slppClient) + + progressMessages, err := getReportedProgressMessages(slppClient) + if err != nil { + ui.Failed("Could not get the already reported progress messages for process %s: %s", terminal.EntityNameColor(processID), err) + } + + ui.Say("Resuming multi-target app operation with id %s...", terminal.EntityNameColor(processID)) + err = slppClient.ExecuteAction("resume") + if err != nil { + ui.Failed("Could not resume multi-target app operation with id %s: %s", terminal.EntityNameColor(processID), err) + return Failure + } + ui.Ok() + + monitor := NewExecutionMonitor(processID, commandName, slppClient, progressMessages) + return monitor.Monitor() +} diff --git a/commands/retry_action.go b/commands/retry_action.go new file mode 100644 index 0000000..2860faf --- /dev/null +++ b/commands/retry_action.go @@ -0,0 +1,43 @@ +package commands + +import ( + "github.com/cloudfoundry/cli/cf/terminal" + "github.com/SAP/cf-mta-plugin/clients/models" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" + "github.com/SAP/cf-mta-plugin/ui" +) + +// RetryAction retries the process with the specified id +type RetryAction struct{} + +// Execute executes retry action on process with the specified id +func (a *RetryAction) Execute(processID, commandName string, slppClient slppclient.SlppClientOperations) ExecutionStatus { + + // Ensure session is not expired + EnsureSlppSession(slppClient) + + progressMessages, err := getReportedProgressMessages(slppClient) + if err != nil { + ui.Failed("Could not get the already reported progress messages for process %s: %s", terminal.EntityNameColor(processID), err) + } + + ui.Say("Retrying multi-target app operation with id %s...", terminal.EntityNameColor(processID)) + err = slppClient.ExecuteAction("retry") + if err != nil { + ui.Failed("Could not retry multi-target app operation with id %s: %s", terminal.EntityNameColor(processID), err) + return Failure + } + ui.Ok() + + monitor := NewExecutionMonitor(processID, commandName, slppClient, progressMessages) + return monitor.Monitor() +} + +func getReportedProgressMessages(slppClient slppclient.SlppClientOperations) ([]*models.ProgressMessage, error) { + processTaskID := slppClient.GetServiceID() + processTask, err := slppClient.GetTasklistTask(processTaskID) + if err != nil { + return []*models.ProgressMessage{}, err + } + return processTask.ProgressMessages.ProgressMessages, nil +} diff --git a/commands/service_id.go b/commands/service_id.go new file mode 100644 index 0000000..5a1e674 --- /dev/null +++ b/commands/service_id.go @@ -0,0 +1,40 @@ +package commands + +import ( + "fmt" + + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// ServiceID is an 'enum' representing the service IDs supported by the deploy +// service backend. +type ServiceID int + +const ( + DeployServiceID ServiceID = iota + UndeployServiceID + BgDeployServiceID +) + +var processTypes = []models.ProcessType{"deploy", "undeploy", "blue-green-deploy"} + +var serviceIDs = []string{"xs2-deploy", "xs2-undeploy", "xs2-bg-deploy"} + +// ToServiceID returns the service ID corresponding to the given process type. +func ToServiceID(processType models.ProcessType) (ServiceID, error) { + for i, value := range processTypes { + if value == processType { + return ServiceID(i), nil + } + } + return DeployServiceID, fmt.Errorf("Unknown process type: %s", processType) +} + +// ProcessType returns the process type corresponding to the given service ID. +func (serviceID ServiceID) ProcessType() models.ProcessType { + return processTypes[serviceID] +} + +func (serviceID ServiceID) String() string { + return serviceIDs[serviceID] +} diff --git a/commands/test.mtar b/commands/test.mtar new file mode 100644 index 0000000..e69de29 diff --git a/commands/test_client_factory.go b/commands/test_client_factory.go new file mode 100644 index 0000000..d2bfda0 --- /dev/null +++ b/commands/test_client_factory.go @@ -0,0 +1,40 @@ +package commands + +import ( + "net/http" + + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + restclient "github.com/SAP/cf-mta-plugin/clients/restclient" + slmpclient "github.com/SAP/cf-mta-plugin/clients/slmpclient" + slppclient "github.com/SAP/cf-mta-plugin/clients/slppclient" +) + +type TestClientFactory struct { + SlmpClient slmpclient.SlmpClientOperations + SlppClient slppclient.SlppClientOperations + RestClient restclient.RestClientOperations +} + +func NewTestClientFactory(slmpClient slmpclient.SlmpClientOperations, slppClient slppclient.SlppClientOperations, + restClient restclient.RestClientOperations) *TestClientFactory { + return &TestClientFactory{ + SlmpClient: slmpClient, + SlppClient: slppClient, + RestClient: restClient, + } +} + +func (f *TestClientFactory) NewSlmpClient(host, org, space string, + rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) slmpclient.SlmpClientOperations { + return f.SlmpClient +} + +func (f *TestClientFactory) NewSlppClient(host, org, space, serviceID, processID string, + rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) slppclient.SlppClientOperations { + return f.SlppClient +} + +func (f *TestClientFactory) NewRestClient(host, org, space string, + rt http.RoundTripper, jar http.CookieJar, tokenFactory baseclient.TokenFactory) restclient.RestClientOperations { + return f.RestClient +} diff --git a/commands/test_token_factory.go b/commands/test_token_factory.go new file mode 100644 index 0000000..256f8f5 --- /dev/null +++ b/commands/test_token_factory.go @@ -0,0 +1,22 @@ +package commands + +import ( + "github.com/cloudfoundry/cli/plugin/fakes" + "github.com/go-openapi/runtime" + "github.com/SAP/cf-mta-plugin/testutil" +) + +type TestTokenFactory struct { + FakeCliConnection *fakes.FakeCliConnection +} + +func NewTestTokenFactory(fakeCliConnection *fakes.FakeCliConnection) *TestTokenFactory { + return &TestTokenFactory{ + FakeCliConnection: fakeCliConnection, + } +} + +func (f *TestTokenFactory) NewToken() (runtime.ClientAuthInfoWriter, error) { + tokenString, _ := f.FakeCliConnection.AccessToken() + return testutil.NewCustomBearerToken(tokenString), nil +} diff --git a/commands/undeploy_command.go b/commands/undeploy_command.go new file mode 100644 index 0000000..8fe28b3 --- /dev/null +++ b/commands/undeploy_command.go @@ -0,0 +1,194 @@ +package commands + +import ( + "fmt" + "strconv" + "strings" + + "github.com/cloudfoundry/cli/cf/terminal" + "github.com/cloudfoundry/cli/plugin" + baseclient "github.com/SAP/cf-mta-plugin/clients/baseclient" + "github.com/SAP/cf-mta-plugin/clients/models" + "github.com/SAP/cf-mta-plugin/log" + "github.com/SAP/cf-mta-plugin/ui" + "github.com/SAP/cf-mta-plugin/util" +) + +//UndeployCommand is a command for undeploying MTAs +type UndeployCommand struct { + BaseCommand +} + +// GetPluginCommand returns the plugin command details +func (c *UndeployCommand) GetPluginCommand() plugin.Command { + return plugin.Command{ + Name: "undeploy", + HelpText: "Undeploy a multi-target app", + UsageDetails: plugin.Usage{ + Usage: `Undeploy a multi-target app + cf undeploy MTA_ID [-u URL] [-f] [--delete-services] [--delete-service-brokers] [--no-restart-subscribed-apps] [--do-not-fail-on-missing-permissions] + + Perform action on an active undeploy operation + cf undeploy -i OPERATION_ID -a ACTION [-u URL]`, + Options: map[string]string{ + deployServiceURLOpt: "Deploy service URL, by default 'deploy-service.'", + operationIDOpt: "Active undeploy operation id", + actionOpt: "Action to perform on the active undeploy operation (abort, retry, monitor)", + forceOpt: "Force undeploy without confirmation", + util.GetShortOption(deleteServicesOpt): "Delete services", + util.GetShortOption(deleteServiceBrokersOpt): "Delete service brokers", + util.GetShortOption(noRestartSubscribedAppsOpt): "Do not restart subscribed apps, updated during the undeployment", + util.GetShortOption(noFailOnMissingPermissionsOpt): "Do not fail on missing permissions for admin operations", + }, + }, + } +} + +// ServiceID returns the service ID of the processes started by UndeployCommand +func (c *UndeployCommand) ServiceID() ServiceID { + return UndeployServiceID +} + +// Execute executes the command +func (c *UndeployCommand) Execute(args []string) ExecutionStatus { + log.Tracef("Executing command '"+c.name+"': args: '%v'\n", args) + + var serviceID = c.ServiceID() + + var host string + var operationID string + var actionID string + var force bool + var deleteServices bool + var noRestartSubscribedApps bool + var deleteServiceBrokers bool + var noFailOnMissingPermissions bool + flags, err := c.CreateFlags(&host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + flags.BoolVar(&force, forceOpt, false, "") + flags.StringVar(&operationID, operationIDOpt, "", "") + flags.StringVar(&actionID, actionOpt, "", "") + flags.BoolVar(&deleteServices, deleteServicesOpt, false, "") + flags.BoolVar(&noRestartSubscribedApps, noRestartSubscribedAppsOpt, false, "") + flags.BoolVar(&deleteServiceBrokers, deleteServiceBrokersOpt, false, "") + flags.BoolVar(&noFailOnMissingPermissions, noFailOnMissingPermissionsOpt, false, "") + shouldExecuteActionOnExistingProcess, _ := ContainsSpecificOptions(flags, args, map[string]string{"i": "-i", "a": "-a"}) + var positionalArgNames []string + if !shouldExecuteActionOnExistingProcess { + positionalArgNames = []string{"MTA_ID"} + } + err = c.ParseFlags(args, positionalArgNames, flags, nil) + if err != nil { + c.Usage(err.Error()) + return Failure + } + + context, err := c.GetContext() + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + if operationID != "" || actionID != "" { + return c.ExecuteAction(operationID, actionID, host, serviceID) + } + + mtaID := args[0] + if !force && !ui.Confirm("Really undeploy multi-target app %s? (y/n)", terminal.EntityNameColor(mtaID)) { + ui.Warn("Undeploy cancelled") + return Failure + } + + // Print initial message + ui.Say("Undeploying multi-target app %s in org %s / space %s as %s...", + terminal.EntityNameColor(mtaID), terminal.EntityNameColor(context.Org), + terminal.EntityNameColor(context.Space), terminal.EntityNameColor(context.Username)) + + // Create rest client + restClient, err := c.NewRestClient(host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Check if a deployed MTA with the specified ID exists + _, err = restClient.GetMta(mtaID) + if err != nil { + ce, ok := err.(*baseclient.ClientError) + // TODO(ivan): This is crap. Expecting the error message returned by a + // remote component to decide what to print ot the user based on a + // simple Contains method is not sane. + if ok && ce.Code == 404 && strings.Contains(fmt.Sprint(ce.Description), mtaID) { + ui.Failed("Multi-target app %s not found", terminal.EntityNameColor(mtaID)) + return Failure + } + ui.Failed("Could not get multi-target app %s: %s", terminal.EntityNameColor(mtaID), err) + return Failure + + } + + // Check for an ongoing operation for this MTA ID and abort it + wasAborted, err := c.CheckOngoingOperation(mtaID, host, force) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + if !wasAborted { + return Failure + } + + // Create SLMP client + slmpClient, err := c.NewSlmpClient(host) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Check SLMP metadata + err = CheckSlmpMetadata(slmpClient) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + ui.Say("Starting undeployment process...") + + processBuilder := util.NewProcessBuilder() + processBuilder.ServiceID(serviceID.String()) + processBuilder.Parameter("mtaId", mtaID) + processBuilder.Parameter("noRestartSubscribedApps", strconv.FormatBool(noRestartSubscribedApps)) + processBuilder.Parameter("deleteServices", strconv.FormatBool(deleteServices)) + processBuilder.Parameter("deleteServiceBrokers", strconv.FormatBool(deleteServiceBrokers)) + processBuilder.Parameter("noFailOnMissingPermissions", strconv.FormatBool(noFailOnMissingPermissions)) + process := processBuilder.Build() + + // Create the new process + createdProcess, err := slmpClient.CreateServiceProcess(serviceID.String(), process) + if err != nil { + ui.Failed("Could not create process for service %s: %s", terminal.EntityNameColor(serviceID.String()), err) + return Failure + } + ui.Ok() + + processID := createdProcess.ID + // Create SLPP client + slppClient, err := c.NewSlppClient(host, serviceID.String(), processID) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Check SLPP metadata + err = CheckSlppMetadata(slppClient) + if err != nil { + ui.Failed(err.Error()) + return Failure + } + + // Monitor process execution + monitor := NewExecutionMonitor(processID, c.name, slppClient, []*models.ProgressMessage{}) + return monitor.Monitor() +} diff --git a/commands/undeploy_command_test.go b/commands/undeploy_command_test.go new file mode 100644 index 0000000..2f3554f --- /dev/null +++ b/commands/undeploy_command_test.go @@ -0,0 +1,198 @@ +package commands_test + +import ( + plugin_fakes "github.com/cloudfoundry/cli/plugin/fakes" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/SAP/cf-mta-plugin/clients/models" + restfake "github.com/SAP/cf-mta-plugin/clients/restclient/fakes" + slmpfake "github.com/SAP/cf-mta-plugin/clients/slmpclient/fakes" + slppfake "github.com/SAP/cf-mta-plugin/clients/slppclient/fakes" + "github.com/SAP/cf-mta-plugin/commands" + cmd_fakes "github.com/SAP/cf-mta-plugin/commands/fakes" + "github.com/SAP/cf-mta-plugin/testutil" +) + +var _ = Describe("UndeployCommand", func() { + Describe("Execute", func() { + const org = "test-org" + const space = "test-space" + const user = "test-user" + const mtaID = "test" + + var name string + var cliConnection *plugin_fakes.FakeCliConnection + var slmpClient *slmpfake.FakeSlmpClientOperations + var slppClient *slppfake.FakeSlppClientOperations + var restClient *restfake.FakeRestClientOperations + var testClientFactory *commands.TestClientFactory + var mta *models.Mta + var command *commands.UndeployCommand + var oc = testutil.NewUIOutputCapturer() + var ex = testutil.NewUIExpector() + + var getOutputLines = func(processAborted bool, actionID, processID string) []string { + lines := []string{} + lines = append(lines, + "Undeploying multi-target app "+mtaID+" in org "+org+" / space "+space+" as "+user+"...\n") + if processAborted { + lines = append(lines, + "Aborting multi-target app operation with id test...\n", + "OK\n") + } + lines = append(lines, + "Starting undeployment process...\n", + "OK\n", + "Monitoring process execution...\n", + "Process finished.\n") + return lines + } + + var getProcessParameters = func(additional bool) map[string]string { + params := map[string]string{ + "mtaId": "test", + } + if additional { + params["noRestartSubscribedApps"] = "true" + params["deleteServices"] = "true" + params["deleteServiceBrokers"] = "true" + } + return params + } + + var expectProcessParameters = func(expectedParameters map[string]string, processParameters models.ProcessParameters) { + for _, processParameter := range processParameters.Parameters { + if expectedParameters[*processParameter.ID] != "" { + Expect(processParameter.Value).To(Equal(expectedParameters[*processParameter.ID])) + } + } + } + + BeforeEach(func() { + // ui.DisableTerminalOutput(true) + name = command.GetPluginCommand().Name + cliConnection = cmd_fakes.NewFakeCliConnectionBuilder(). + CurrentOrg("test-org-guid", org, nil). + CurrentSpace("test-space-guid", space, nil). + Username(user, nil). + AccessToken("bearer test-token", nil). + APIEndpoint("https://api.test.ondemand.com", nil).Build() + slmpClient = slmpfake.NewFakeSlmpClientBuilder(). + GetMetadata(&testutil.SlmpMetadataResult, nil). + GetService("xs2-undeploy", testutil.GetService("xs2-undeploy", "Undeploy", []*models.Parameter{testutil.GetParameter("mtaId")}), nil). + CreateServiceProcess("", nil, &testutil.ProcessResult, nil).Build() + slppClient = slppfake.NewFakeSlppClientBuilder(). + GetMetadata(&testutil.SlppMetadataResult, nil). + GetTasklistTask(&testutil.TaskResult, nil).Build() + mtaModule := testutil.GetMtaModule("test-module", []string{}, []string{}) + mta = testutil.GetMta("test", "test-version", []*models.MtaModulesItems0{mtaModule}, []string{"test-mta-services"}) + restClient = restfake.NewFakeRestClientBuilder(). + GetMta("test", mta, nil). + GetMta("test-non-existing-id", nil, newClientError(404, "404 Not Found", `MTA with id "test-non-existing-id" does not exist`)). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{testutil.GetOperation("test", "test-space-guid", "test", "undeploy", "SLP_TASK_STATE_ERROR", true)}), nil).Build() + testClientFactory = commands.NewTestClientFactory(slmpClient, slppClient, restClient) + command = &commands.UndeployCommand{} + testTokenFactory := commands.NewTestTokenFactory(cliConnection) + command.InitializeAll(name, cliConnection, testutil.NewCustomTransport(200, nil), nil, testClientFactory, testTokenFactory) + }) + + // unknown flag - error + Context("with an unknown flag", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test-mta-id", "-unknown-flag"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Unknown or wrong flag.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // wrong arguments - error + Context("with wrong arguments", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test-mta-id", "y", "z"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Wrong arguments.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // no arguments - error + Context("with no arguments", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Missing positional argument 'MTA_ID'.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // no MTA argument - error + Context("with no mta id argument", func() { + It("should print incorrect usage, call cf help, and exit with a non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"-f"}).ToInt() + }) + ex.ExpectFailure(status, output, "Incorrect usage. Missing positional argument 'MTA_ID'.") + Expect(cliConnection.CliCommandArgsForCall(0)).To(Equal([]string{"help", name})) + }) + }) + + // non-existing MTA_ID - failure + Context("with an incorrect mta id provided", func() { + It("should display error and exit with non-zero status", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test-non-existing-id", "-f"}).ToInt() + }) + ex.ExpectFailureOnLine(status, output, "Multi-target app test-non-existing-id not found", 1) + }) + }) + + // existing MTA_ID and force option - failure + Context("with an correct mta id provided and ongoing operation found and force option provided", func() { + It("should try to abort the conflicting process", func() { + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test", "-f"}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(true, "abort", "test")) + serviceID, process := slmpClient.CreateServiceProcessArgsForCall(0) + Expect(serviceID).To(Equal("xs2-undeploy")) + expectProcessParameters(getProcessParameters(false), process.Parameters) + }) + }) + + // existing MTA_ID and no ongoing operations - failure + Context("with an correct mta id provided and no ongoing operations", func() { + It("should proceed without trying to abort conflicting process", func() { + testClientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{}), nil). + GetMta("test", mta, nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test", "-f"}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(false, "", "")) + serviceID, process := slmpClient.CreateServiceProcessArgsForCall(0) + Expect(serviceID).To(Equal("xs2-undeploy")) + expectProcessParameters(getProcessParameters(false), process.Parameters) + }) + }) + + // existing MTA_ID and no ongoing operations - failure + Context("with an correct mta id provided and no ongoing operations and more options provided", func() { + It("should proceed without trying to abort conflicting process", func() { + testClientFactory.RestClient = restfake.NewFakeRestClientBuilder(). + GetOperations(nil, nil, testutil.GetOperations([]*models.Operation{}), nil). + GetMta("test", mta, nil).Build() + output, status := oc.CaptureOutputAndStatus(func() int { + return command.Execute([]string{"test", "-delete-services", "-no-restart-subscribed-apps", "-delete-service-brokers", "-do-not-fail-on-missing-permissions", "-f"}).ToInt() + }) + ex.ExpectSuccessWithOutput(status, output, getOutputLines(false, "", "")) + serviceID, process := slmpClient.CreateServiceProcessArgsForCall(0) + Expect(serviceID).To(Equal("xs2-undeploy")) + expectProcessParameters(getProcessParameters(true), process.Parameters) + }) + }) + }) +}) diff --git a/go-binary/go1.8.1.linux-amd64.tar.gz b/go-binary/go1.8.1.linux-amd64.tar.gz new file mode 100644 index 0000000..778e0b7 Binary files /dev/null and b/go-binary/go1.8.1.linux-amd64.tar.gz differ diff --git a/log/log.go b/log/log.go new file mode 100644 index 0000000..a86d9f1 --- /dev/null +++ b/log/log.go @@ -0,0 +1,80 @@ +package log + +import ( + "fmt" + "os" +) + +var Debug = (os.Getenv("DEBUG") == "1") + +type Exiter interface { + Exit(status int) +} + +type DefaultExiter struct { +} + +func (e DefaultExiter) Exit(status int) { + os.Exit(status) +} + +var exiter Exiter = DefaultExiter{} + +// TODO Handle concurrent access correctly +func GetExiter() Exiter { + return exiter +} + +// TODO Handle concurrent access correctly +func SetExiter(e Exiter) { + exiter = e +} + +func Exit(status int) { + exiter.Exit(status) +} + +func Fatal(v ...interface{}) { + Print(v...) + exiter.Exit(1) +} + +func Fatalf(format string, v ...interface{}) { + Printf(format, v...) + exiter.Exit(1) +} + +func Fatalln(v ...interface{}) { + Println(v...) + exiter.Exit(1) +} + +func Print(v ...interface{}) { + fmt.Print(v...) +} + +func Printf(format string, v ...interface{}) { + fmt.Printf(format, v...) +} + +func Println(v ...interface{}) { + fmt.Println(v...) +} + +func Trace(v ...interface{}) { + if Debug { + Print(v...) + } +} + +func Tracef(format string, v ...interface{}) { + if Debug { + Printf(format, v...) + } +} + +func Traceln(v ...interface{}) { + if Debug { + Println(v...) + } +} diff --git a/mta_plugin.go b/mta_plugin.go new file mode 100644 index 0000000..f5a4a4f --- /dev/null +++ b/mta_plugin.go @@ -0,0 +1,94 @@ +package main + +import ( + "fmt" + "io/ioutil" + defaultlog "log" + "os" + "strconv" + "strings" + + "github.com/SAP/cf-mta-plugin/commands" + "github.com/SAP/cf-mta-plugin/log" + "github.com/cloudfoundry/cli/plugin" +) + +// Version is the version of the CLI plugin. It is injected on linking time. +var Version string = "0.0.0" + +// MtaPlugin represents a cf CLI plugin for executing operations on MTAs +type MtaPlugin struct{} + +// Commands contains the commands supported by this plugin +var Commands = []commands.Command{ + commands.NewDeployCommand(), + commands.NewBlueGreenDeployCommand(), + &commands.MtasCommand{}, + &commands.DownloadMtaOperationLogsCommand{}, + &commands.UndeployCommand{}, + &commands.MtaCommand{}, + &commands.MtaOperationsCommand{}, + &commands.PurgeConfigCommand{}, +} + +// Run runs this plugin +func (p *MtaPlugin) Run(cliConnection plugin.CliConnection, args []string) { + disableStdOut() + command, err := findCommand(args[0]) + if err != nil { + log.Fatalln(err) + } + command.Initialize(command.GetPluginCommand().Name, cliConnection) + status := command.Execute(args[1:]) + if status == commands.Failure { + os.Exit(1) + } +} + +// GetMetadata returns the metadata of this plugin +func (p *MtaPlugin) GetMetadata() plugin.PluginMetadata { + metadata := plugin.PluginMetadata{ + Name: "MtaPlugin", + Version: parseSemver(Version), + MinCliVersion: plugin.VersionType{Major: 6, Minor: 7, Build: 0}, + } + for _, command := range Commands { + metadata.Commands = append(metadata.Commands, command.GetPluginCommand()) + } + return metadata +} + +func main() { + plugin.Start(new(MtaPlugin)) +} + +func disableStdOut() { + defaultlog.SetFlags(0) + defaultlog.SetOutput(ioutil.Discard) +} + +func findCommand(name string) (commands.Command, error) { + for _, command := range Commands { + pluginCommand := command.GetPluginCommand() + if pluginCommand.Name == name || pluginCommand.Alias == name { + return command, nil + } + } + return nil, fmt.Errorf("Could not find command with name '%s'", name) +} + +func parseSemver(version string) plugin.VersionType { + mmb := strings.Split(version, ".") + if len(mmb) != 3 { + panic("invalid version: " + version) + } + major, _ := strconv.Atoi(mmb[0]) + minor, _ := strconv.Atoi(mmb[1]) + build, _ := strconv.Atoi(mmb[2]) + + return plugin.VersionType{ + Major: major, + Minor: minor, + Build: build, + } +} diff --git a/production-services/build-service/config.yml b/production-services/build-service/config.yml new file mode 100644 index 0000000..ba3bb91 --- /dev/null +++ b/production-services/build-service/config.yml @@ -0,0 +1,14 @@ +defaultRuntime: linuxx86_64 +defaultTemplate: all +realm: deploy-service + +templates: + - Template: all + +variants: + - Variant: linuxx86_64 + runtime: linuxx86_64 +branches: + - Branch: master + variants: + - linuxx86_64 diff --git a/test_resources/commands/extDescriptor.mtaext b/test_resources/commands/extDescriptor.mtaext new file mode 100644 index 0000000..abe8fa7 --- /dev/null +++ b/test_resources/commands/extDescriptor.mtaext @@ -0,0 +1,3 @@ +_schema-version: "2.0.0" +ID: test-mta-ext +extends: test \ No newline at end of file diff --git a/test_resources/commands/mtaArchive.mtar b/test_resources/commands/mtaArchive.mtar new file mode 100644 index 0000000..7b9b278 Binary files /dev/null and b/test_resources/commands/mtaArchive.mtar differ diff --git a/test_resources/util/mtaArchiveNoDescriptor.mtar b/test_resources/util/mtaArchiveNoDescriptor.mtar new file mode 100644 index 0000000..8ca094b Binary files /dev/null and b/test_resources/util/mtaArchiveNoDescriptor.mtar differ diff --git a/testutil/exiter.go b/testutil/exiter.go new file mode 100644 index 0000000..87711a6 --- /dev/null +++ b/testutil/exiter.go @@ -0,0 +1,51 @@ +package testutil + +import ( + io_helpers "github.com/cloudfoundry/cli/testhelpers/io" + "github.com/SAP/cf-mta-plugin/ui" +) + +type OutputCapturer interface { + CaptureOutputAndStatus(block func() int) ([]string, int) + CaptureOutput(block func()) []string +} + +type StdoutOutputCapturer struct{} + +func NewStdoutOutputCapturer() OutputCapturer { + return &StdoutOutputCapturer{} +} + +func (oc *StdoutOutputCapturer) CaptureOutput(block func()) []string { + return io_helpers.CaptureOutput(block) +} + +func (oc *StdoutOutputCapturer) CaptureOutputAndStatus(block func() int) ([]string, int) { + var status int + output := io_helpers.CaptureOutput(func() { + status = block() + }) + return output, status +} + +type UIOutputCapturer struct{} + +func NewUIOutputCapturer() OutputCapturer { + return &UIOutputCapturer{} +} + +func (oc *UIOutputCapturer) CaptureOutput(block func()) []string { + bucket := []string{} + ui.SetOutputBucket(&bucket) + block() + return bucket +} + +func (oc *UIOutputCapturer) CaptureOutputAndStatus(block func() int) ([]string, int) { + bucket := []string{} + ui.SetOutputBucket(&bucket) + status := block() + return bucket, status +} + +var defaultOutputCapturer = NewStdoutOutputCapturer() diff --git a/testutil/expector.go b/testutil/expector.go new file mode 100644 index 0000000..747ed0e --- /dev/null +++ b/testutil/expector.go @@ -0,0 +1,106 @@ +package testutil + +import ( + . "github.com/onsi/gomega" +) + +type Expector interface { + ExpectNoError(err error) + ExpectNoErrorAndResult(err error, result, expectedResult interface{}) + ExpectError(err error) + ExpectErrorAndZeroResult(err error, result interface{}) + ExpectSuccess(status int, output []string) + ExpectSuccessWithOutput(status int, output, expectedOutput []string) + ExpectSuccessAndResult(status int, output []string, result, expectedResult interface{}) + ExpectFailure(status int, output []string, message string) + ExpectFailureOnLine(status int, output []string, message string, line int) +} + +type BaseExpector struct{} + +func (ex *BaseExpector) ExpectNoError(err error) { + Expect(err).ToNot(HaveOccurred()) +} + +func (ex *BaseExpector) ExpectNoErrorAndResult(err error, result, expectedResult interface{}) { + ex.ExpectNoError(err) + Expect(result).To(Equal(expectedResult)) +} + +func (ex *BaseExpector) ExpectError(err error) { + Expect(err).To(HaveOccurred()) +} + +func (ex *BaseExpector) ExpectErrorAndZeroResult(err error, result interface{}) { + Expect(err).To(HaveOccurred()) + Expect(result).To(BeZero()) +} + +type UIExpector struct{ BaseExpector } + +func NewUIExpector() Expector { + return &UIExpector{} +} + +func (ex *UIExpector) ExpectSuccess(status int, output []string) { + ex.ExpectSuccessWithOutput(status, output, []string{}) +} + +func (ex *UIExpector) ExpectSuccessWithOutput(status int, output, expectedOutput []string) { + Expect(status).To(BeZero()) + Expect(output).To(Equal(expectedOutput)) +} + +func (ex *UIExpector) ExpectSuccessAndResult(status int, output []string, result, expectedResult interface{}) { + ex.ExpectSuccess(status, output) + Expect(result).To(Equal(expectedResult)) +} + +func (ex *UIExpector) ExpectFailure(status int, output []string, message string) { + ex.ExpectFailureOnLine(status, output, message, 0) +} + +func (ex *UIExpector) ExpectFailureOnLine(status int, output []string, message string, line int) { + Expect(status).NotTo(BeZero()) + Expect(output[line+1]).To(ContainSubstring(message)) + // Expect(output[line]).To(Equal("FAILED\n")) + +} + +var defaultExpector = NewUIExpector() + +func ExpectNoError(err error) { + defaultExpector.ExpectNoError(err) +} + +func ExpectNoErrorAndResult(err error, result, expectedResult interface{}) { + defaultExpector.ExpectNoErrorAndResult(err, result, expectedResult) +} + +func ExpectError(err error) { + defaultExpector.ExpectError(err) +} + +func ExpectErrorAndZeroResult(err error, result interface{}) { + defaultExpector.ExpectErrorAndZeroResult(err, result) +} + +func ExpectSuccess(status int, output []string) { + defaultExpector.ExpectSuccess(status, output) +} + +func ExpectSuccessWithOutput(status int, output, expectedOutput []string) { + defaultExpector.ExpectSuccessWithOutput(status, output, expectedOutput) +} + +func ExpectSuccessAndResult(status int, output []string, result, expectedResult interface{}) { + defaultExpector.ExpectSuccessAndResult(status, output, result, expectedResult) +} + +func ExpectFailure(status int, output []string, message string) { + defaultExpector.ExpectFailure(status, output, message) +} + +func ExpectFailureOnLine(status int, output []string, message string, line int) { + defaultExpector.ExpectFailureOnLine(status, output, message, line) +} diff --git a/testutil/test_results.go b/testutil/test_results.go new file mode 100644 index 0000000..9fd29f6 --- /dev/null +++ b/testutil/test_results.go @@ -0,0 +1,407 @@ +package testutil + +import ( + "encoding/xml" + "io" + "os" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + "github.com/SAP/cf-mta-plugin/clients/models" +) + +const xmlns string = "http://www.sap.com/lmsl/slp" + +const Version = "1.2.0" +const ServiceID = "xs2-undeploy" +const ProcessID = "111" +const LogID = "MAIN_LOG" +const LogContent = "test-test-test" +const ActionID = "slp.action.ABORT" +const MtaID = "org.cloudfoundry.samples.music" + +var SlmpMetadataResult = models.Metadata{ + XMLName: xml.Name{Space: xmlns, Local: "Metadata"}, + Slmpversion: Version, +} + +var SlppMetadataResult = models.Metadata{ + XMLName: xml.Name{Space: xmlns, Local: "Metadata"}, + Slppversion: Version, +} + +var ServicesResult = models.Services{ + XMLName: xml.Name{Space: xmlns, Local: "services"}, + Services: []*models.Service{&ServiceResult}, +} + +var ServiceResult = models.Service{ + XMLName: xml.Name{Space: xmlns, Local: "Service"}, + ID: uriptr(strfmt.URI(ServiceID)), + Processes: uriptr(strfmt.URI("services/" + ServiceID + "/processes")), + Parameters: models.ServiceParameters{ + Parameters: []*models.Parameter{&ParameterResult}, + }, + Files: strfmt.URI("services/" + ServiceID + "/files"), + Versions: strfmt.URI("services/" + ServiceID + "/versions"), + Slppversion: strptr(Version), + DisplayName: "Undeploy", + Description: "Undeploy", +} + +var ParameterResult = models.Parameter{ + XMLName: xml.Name{Space: xmlns, Local: "Parameter"}, + ID: strptr("mtaId"), + Type: models.SlpParameterType("slp.parameter.type.SCALAR"), + Required: true, +} + +var ProcessesResult = models.Processes{ + XMLName: xml.Name{Space: xmlns, Local: "processes"}, + Processes: []*models.Process{&ProcessResult}, +} + +var ProcessResult = models.Process{ + XMLName: xml.Name{Space: xmlns, Local: "Process"}, + ID: ProcessID, + Service: uriptr(strfmt.URI(ServiceID)), + Status: "slp.process.state.FINISHED", + RootURL: strfmt.URI("runs/" + ServiceID + "/" + ProcessID), + DisplayName: "Undeploy", + Description: "Undeploy", +} + +var LogsResult = models.Logs{ + XMLName: xml.Name{Space: xmlns, Local: "logs"}, + Logs: []*models.Log{&LogResult}, +} + +var LogResult = models.Log{ + XMLName: xml.Name{Space: xmlns, Local: "Log"}, + ID: strptr(LogID), + Content: uriptr(strfmt.URI("logs/" + LogID + "/content")), + Format: &models.SlpLogFormat{ + SlpLogFormatEnum: "slp.log.format.TEXT", + }, +} + +var OperationsResult = models.Operations{ + XMLName: xml.Name{Local: "ongoing-operations"}, + Operations: []*models.Operation{&OperationResult}, +} + +var OperationResult = models.Operation{ + XMLName: xml.Name{Local: "ongoing-operation"}, + ProcessID: strptr(ProcessID), + ProcessType: models.ProcessType("deploy"), + StartedAt: strptr("2016-03-04T14:23:24.521Z[Etc/UTC]"), + SpaceID: strptr("5bea6497-6d70-4a31-9ad2-1ac64a520f8f"), + User: strptr("admin"), + State: models.SlpTaskStateEnum("SLP_TASK_STATE_ERROR"), + AcquiredLock: nil, + MtaID: "test", +} + +var ComponentsResult = models.Components{ + XMLName: xml.Name{Local: "components"}, + Mtas: models.ComponentsMtas{ + Mtas: []*models.Mta{&MtaResult}, + }, + StandaloneApps: models.ComponentsStandaloneApps{ + StandaloneApps: []string{"deploy-service"}, + }, +} + +var MtaResult = models.Mta{ + XMLName: xml.Name{Local: "mta"}, + Metadata: &models.MtaMetadata{ + ID: strptr(MtaID), + Version: strptr("1.0"), + }, + Modules: models.MtaModules{ + Modules: []*models.MtaModulesItems0{ + &models.MtaModulesItems0{ + ModuleName: strptr("spring-music"), + AppName: strptr("spring-music"), + Services: models.MtaModulesItems0Services{ + Services: []string{"postgresql"}, + }, + ProvidedDependencies: models.MtaModulesItems0ProvidedDependencies{ + ProvidedDependencies: []string{"spring-music"}, + }, + }, + }, + }, + Services: models.MtaServices{ + Services: []string{"postgresql"}, + }, +} + +var TasklistResult = models.Tasklist{ + XMLName: xml.Name{Space: xmlns, Local: "tasklist"}, + Tasks: []*models.Task{&TaskResult}, +} + +var TaskResult = models.Task{ + XMLName: xml.Name{Space: xmlns, Local: "Task"}, + ID: strptr("startEvent"), + Type: models.SlpTaskType("slp.task.type.PROCESS"), + Status: models.SlpTaskState("slp.task.state.FINISHED"), + Parent: "roadmap_prepare", + Progress: 100, + RefreshRate: 10, + DisplayName: "Start", + Description: "Start", + ProgressMessages: models.TaskProgressMessages{ + ProgressMessages: nil, + }, +} + +var ErrorResult = &models.Error{ + XMLName: xml.Name{Space: xmlns, Local: "Error"}, + ID: strptr("test-id"), + Code: strptr("401"), + DisplayName: strptr("Test display name"), + Description: "Test description", +} + +var FilesResult = models.Files{ + XMLName: xml.Name{Space: xmlns, Local: "files"}, + Files: []*models.File{&FileResult}, +} + +type RuntimeResponse struct { + code int + message string +} + +func (r RuntimeResponse) Code() int { + return r.code +} + +func (r RuntimeResponse) Message() string { + return r.message +} + +func (r RuntimeResponse) GetHeader(header string) string { + return "" +} + +func (r RuntimeResponse) Body() io.ReadCloser { + return nil +} + +var notFoundResponse = RuntimeResponse{ + code: 404, + message: "Process with id 404 not found", +} + +var ClientError = &runtime.APIError{ + OperationName: "Getting process", + Response: notFoundResponse, + Code: 404, +} + +//D41D8CD98F00B204E9800998ECF8427E -> MD5 hash for empty file +var FileResult = models.File{ + XMLName: xml.Name{Space: xmlns, Local: "File"}, + ID: strptr("test.mtar"), + FilePath: "xs2-deploy", + Digest: "D41D8CD98F00B204E9800998ECF8427E", + FileName: strptr("test.mtar"), + DigestAlgorithm: "MD5", +} + +var Actions = models.Actions{ + XMLName: xml.Name{Space: xmlns, Local: "actions"}, + Actions: []*models.Action{&RetryAction, &AbortAction}, +} + +var BlueGreenActions = models.Actions{ + XMLName: xml.Name{Space: xmlns, Local: "actions"}, + Actions: []*models.Action{&ResumeAction, &AbortAction}, +} + +var RetryAction = models.Action{ + XMLName: xml.Name{Space: xmlns, Local: "Action"}, + ID: strptr("retry"), +} + +var AbortAction = models.Action{ + XMLName: xml.Name{Space: xmlns, Local: "Action"}, + ID: strptr("abort"), +} + +var ResumeAction = models.Action{ + XMLName: xml.Name{Space: xmlns, Local: "Action"}, + ID: strptr("resume"), +} + +var ServiceVersion1_1 = models.Versions{ + XMLName: xml.Name{Space: xmlns, Local: "Versions"}, + ComponentVersions: []*models.ComponentVersion{&models.ComponentVersion{Version: strptr("1.1")}}, +} + +func GetSlmpMetadata(version string) *models.Metadata { + return &models.Metadata{ + XMLName: xml.Name{Space: xmlns, Local: "Metadata"}, + Slmpversion: version, + } +} + +func GetSlppMetadata(version string) *models.Metadata { + return &models.Metadata{ + XMLName: xml.Name{Space: xmlns, Local: "Metadata"}, + Slppversion: version, + } +} + +func GetService(id, displayName string, parameters []*models.Parameter) *models.Service { + return &models.Service{ + XMLName: xml.Name{Space: xmlns, Local: "Service"}, + ID: uriptr(strfmt.URI(id)), + Processes: uriptr(strfmt.URI("services/" + id + "/processes")), + Parameters: models.ServiceParameters{ + Parameters: parameters, + }, + Files: strfmt.URI("services/" + strfmt.URI(id) + "/files"), + Versions: strfmt.URI("services/" + strfmt.URI(id) + "/versions"), + Slppversion: strptr(Version), + DisplayName: displayName, + Description: displayName, + } +} + +func GetParameter(id string) *models.Parameter { + return &models.Parameter{ + XMLName: xml.Name{Space: xmlns, Local: "Parameter"}, + ID: strptr(id), + Type: models.SlpParameterType("slp.parameter.type.SCALAR"), + Required: true, + } +} + +func GetFiles(files []*models.File) models.Files { + return models.Files{ + XMLName: xml.Name{Space: xmlns, Local: "files"}, + Files: files, + } +} + +func GetFile(serviceID string, file os.File, digest string) *models.File { + stat, _ := os.Stat(file.Name()) + return &models.File{ + XMLName: xml.Name{Space: xmlns, Local: "File"}, + ID: strptr(stat.Name()), + FilePath: serviceID, + FileName: strptr(stat.Name()), + Digest: digest, + DigestAlgorithm: "MD5", + } +} + +func GetComponents(mtas []*models.Mta, standaloneApps []string) *models.Components { + return &models.Components{ + XMLName: xml.Name{Local: "components"}, + Mtas: models.ComponentsMtas{ + Mtas: mtas, + }, + StandaloneApps: models.ComponentsStandaloneApps{ + StandaloneApps: standaloneApps, + }, + } +} + +func GetOperations(operations []*models.Operation) models.Operations { + return models.Operations{ + XMLName: xml.Name{Local: "ongoing-operations"}, + Operations: operations, + } +} + +func GetOperation(processID, spaceID string, mtaID string, processType models.ProcessType, state string, acquiredLock bool) *models.Operation { + return &models.Operation{ + XMLName: xml.Name{Local: "ongoing-operation"}, + ProcessID: strptr(processID), + ProcessType: models.ProcessType(processType), + StartedAt: strptr("2016-03-04T14:23:24.521Z[Etc/UTC]"), + SpaceID: strptr(spaceID), + User: strptr("admin"), + State: models.SlpTaskStateEnum(models.SlpTaskStateEnum(state)), + AcquiredLock: boolptr(acquiredLock), + MtaID: mtaID, + } +} + +func GetMta(id, version string, modules []*models.MtaModulesItems0, services []string) *models.Mta { + return &models.Mta{ + XMLName: xml.Name{Local: "mta"}, + Metadata: &models.MtaMetadata{ + ID: strptr(id), + Version: strptr(version), + }, + Modules: models.MtaModules{ + Modules: modules, + }, + Services: models.MtaServices{ + Services: services, + }, + } +} + +func GetMtaModule(name string, services []string, providedDependencies []string) *models.MtaModulesItems0 { + return &models.MtaModulesItems0{ + ModuleName: strptr(name), + AppName: strptr(name), + Services: models.MtaModulesItems0Services{ + Services: services, + }, + ProvidedDependencies: models.MtaModulesItems0ProvidedDependencies{ + ProvidedDependencies: providedDependencies, + }, + } +} + +func GetTaskList(task models.Task) models.Tasklist { + return models.Tasklist{ + XMLName: xml.Name{Space: xmlns, Local: "tasklist"}, + Tasks: []*models.Task{&task}, + } +} + +func GetTask(taskType models.SlpTaskType, state models.SlpTaskState, progressMessages []*models.ProgressMessage) models.Task { + return models.Task{ + XMLName: xml.Name{Space: xmlns, Local: "Task"}, + ID: strptr("startEvent"), + Type: taskType, + Status: state, + Parent: "roadmap_prepare", + Progress: 100, + RefreshRate: 10, + DisplayName: "Start", + Description: "Start", + ProgressMessages: models.TaskProgressMessages{ + ProgressMessages: progressMessages, + }, + } +} + +func GetProgressMessage(id, message string) *models.ProgressMessage { + return &models.ProgressMessage{ + XMLName: xml.Name{Space: "ProgressMessage"}, + ID: strptr(id), + Message: strptr(message), + } +} + +func uriptr(u strfmt.URI) *strfmt.URI { + return &u +} + +func strptr(s string) *string { + return &s +} + +func boolptr(b bool) *bool { + return &b +} diff --git a/testutil/transport.go b/testutil/transport.go new file mode 100644 index 0000000..e171f71 --- /dev/null +++ b/testutil/transport.go @@ -0,0 +1,46 @@ +package testutil + +import ( + "bytes" + "encoding/xml" + "io/ioutil" + "net/http" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + "github.com/SAP/cf-mta-plugin/clients/csrf" +) + +type roundTripperFunc func(*http.Request) (*http.Response, error) + +func (fn roundTripperFunc) RoundTrip(req *http.Request) (*http.Response, error) { + return fn(req) +} + +// NewCustomTransport creates a new custom transport to be used for testing +func NewCustomTransport(statusCode int, v interface{}) *csrf.Transport { + csrfx := csrf.Csrf{Header: "", Token: ""} + transport := roundTripperFunc(func(req *http.Request) (*http.Response, error) { + var resp http.Response + resp.StatusCode = statusCode + resp.Header = make(http.Header) + buf := bytes.NewBuffer(nil) + if v != nil { + resp.Header.Set("content-type", "application/xml") + enc := xml.NewEncoder(buf) + enc.Encode(v) + } + resp.Body = ioutil.NopCloser(buf) + return &resp, nil + }) + return &csrf.Transport{Transport: transport, Csrf: &csrfx} +} + +// NewCustomBearerToken creates a new bearer token to be used for testing +func NewCustomBearerToken(token string) runtime.ClientAuthInfoWriter { + return runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error { + r.SetHeaderParam("Authorization", "Bearer "+token) + return nil + }) +} diff --git a/testutil/ui.go b/testutil/ui.go new file mode 100644 index 0000000..5e12f11 --- /dev/null +++ b/testutil/ui.go @@ -0,0 +1,48 @@ +package testutil + +import "strings" + +func GetTableOutputLines(headers []string, rows [][]string) []string { + const padding = 3 + lines := []string{} + maxlen := make(map[int]int) + getMaxlen(headers, rows, maxlen) + lines = append(lines, getLine(headers, maxlen, padding)) + for _, row := range rows { + lines = append(lines, getLine(row, maxlen, padding)) + } + return lines +} + +func getLine(row []string, maxlen map[int]int, padding int) string { + var line string + for i := range row { + line = line + row[i] + strings.Repeat(" ", getSpaceCount(i, row, maxlen, padding)) + } + return line + "\n" +} + +func getSpaceCount(i int, row []string, maxlen map[int]int, padding int) int { + var count int + if i < len(row)-1 { + count = maxlen[i] - len(row[i]) + padding + } else { + count = padding + } + return count +} + +func getMaxlen(headers []string, rows [][]string, maxlen map[int]int) { + getRowMaxlen(headers, maxlen) + for _, row := range rows { + getRowMaxlen(row, maxlen) + } +} + +func getRowMaxlen(row []string, maxlen map[int]int) { + for i, col := range row { + if len(col) > maxlen[i] { + maxlen[i] = len(col) + } + } +} diff --git a/ui/ui.go b/ui/ui.go new file mode 100644 index 0000000..b060924 --- /dev/null +++ b/ui/ui.go @@ -0,0 +1,76 @@ +package ui + +import ( + "os" + + "github.com/cloudfoundry/cli/cf/i18n" + "github.com/cloudfoundry/cli/cf/terminal" +) + +var teePrinter *terminal.TeePrinter +var ui terminal.UI + +func init() { + i18n.T = func(translationID string, args ...interface{}) string { + return translationID + } + teePrinter = terminal.NewTeePrinter() + ui = terminal.NewUI(os.Stdin, teePrinter) + teePrinter.DisableTerminalOutput(false) +} + +func SetOutputBucket(bucket *[]string) { + teePrinter.SetOutputBucket(bucket) +} + +func ClearOutputBucket() { + teePrinter.SetOutputBucket(nil) +} + +func DisableTerminalOutput(disable bool) { + teePrinter.DisableTerminalOutput(disable) +} + +func PrintPaginator(rows []string, err error) { + ui.PrintPaginator(rows, err) +} + +func Say(message string, args ...interface{}) { + ui.Say(message, args...) +} + +func PrintCapturingNoOutput(message string, args ...interface{}) { + ui.PrintCapturingNoOutput(message, args...) +} + +func Warn(message string, args ...interface{}) { + ui.Warn(message, args...) +} + +func Ask(prompt string, args ...interface{}) (answer string) { + return ui.Ask(prompt, args...) +} + +func Confirm(message string, args ...interface{}) bool { + return ui.Confirm(message, args...) +} + +func Ok() { + ui.Ok() +} + +func Failed(message string, args ...interface{}) { + ui.Failed(message, args...) +} + +func PanicQuietly() { + ui.PanicQuietly() +} + +func LoadingIndication() { + ui.LoadingIndication() +} + +func Table(headers []string) terminal.Table { + return ui.Table(headers) +} diff --git a/util/archive_handler.go b/util/archive_handler.go new file mode 100644 index 0000000..16cad6a --- /dev/null +++ b/util/archive_handler.go @@ -0,0 +1,61 @@ +package util + +import ( + "archive/zip" + "errors" + "io/ioutil" + + "gopkg.in/yaml.v2" +) + +const defaultDescriptorLocation string = "META-INF/mtad.yaml" +const defaultDescriptorName string = "mtad.yaml" + +type mtaDescriptor struct { + SchemaVersion string `yaml:"_schema-version,omitempty"` + ID string `yaml:"ID,omitempty"` + Version string `yaml:"version,omitempty"` +} + +// GetMtaIDFromArchive retrieves MTA ID from MTA archive +func GetMtaIDFromArchive(mtaArchveFilePath string) (string, error) { + // Open the mta archive + mtaArchiveReader, err := zip.OpenReader(mtaArchveFilePath) + if err != nil { + return "", err + } + defer mtaArchiveReader.Close() + + for _, file := range mtaArchiveReader.File { + // Check for the mta descriptor + if file.Name == defaultDescriptorLocation { + + descriptorBytes, err := readZipFile(file) + if err != nil { + return "", err + } + + // Unmarshal the content of the temporary deployment descriptor into struct + var descriptor mtaDescriptor + err = yaml.Unmarshal(descriptorBytes, &descriptor) + if err != nil { + return "", err + } + + // Return the MTA ID extracted from the deployment descriptor, if it is set + if descriptor.ID != "" { + return descriptor.ID, nil + } + } + } + return "", errors.New("Could not get MTA id from archive") +} + +func readZipFile(file *zip.File) ([]byte, error) { + reader, err := file.Open() + if err != nil { + return nil, err + } + defer reader.Close() + return ioutil.ReadAll(reader) +} diff --git a/util/archive_handler_test.go b/util/archive_handler_test.go new file mode 100644 index 0000000..31f3bb1 --- /dev/null +++ b/util/archive_handler_test.go @@ -0,0 +1,41 @@ +package util + +import ( + "os" + "path/filepath" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("ArchiveHandler", func() { + Describe("GetMtaIDFromArchive", func() { + var mtaArchiveFilePath, _ = filepath.Abs("../test_resources/commands/mtaArchive.mtar") + Context("with valid mta archive", func() { + It("should extract and return the id from deployment descriptor", func() { + Expect(GetMtaIDFromArchive(mtaArchiveFilePath)).To(Equal("test")) + }) + }) + Context("with valid mta archive and no deployment descriptor provided", func() { + It("should return error", func() { + mtaArchiveFilePath, _ = filepath.Abs("../test_resources/util/mtaArchiveNoDescriptor.mtar") + _, err := GetMtaIDFromArchive(mtaArchiveFilePath) + Expect(err).To(MatchError("Could not get MTA id from archive")) + }) + }) + + Context("with invalid mta archive", func() { + BeforeEach(func() { + os.Create("test.mtar") + mtaArchiveFilePath, _ = filepath.Abs("test.mtar") + }) + It("should return error for not a valid zip archive", func() { + _, err := GetMtaIDFromArchive(mtaArchiveFilePath) + Expect(err).To(MatchError("zip: not a valid zip file")) + }) + AfterEach(func() { + os.Remove(mtaArchiveFilePath) + }) + }) + }) +}) diff --git a/util/builders.go b/util/builders.go new file mode 100644 index 0000000..0710fcc --- /dev/null +++ b/util/builders.go @@ -0,0 +1,37 @@ +package util + +import ( + "github.com/go-openapi/strfmt" + "github.com/SAP/cf-mta-plugin/clients/models" +) + +// ProcessBuilder a builder for models.Process instances +type ProcessBuilder struct { + process models.Process +} + +// NewProcessBuilder creates a new process builder +func NewProcessBuilder() *ProcessBuilder { + return &ProcessBuilder{} +} + +func (pb *ProcessBuilder) ServiceID(serviceID string) *ProcessBuilder { + uri := strfmt.URI(serviceID) + pb.process.Service = &uri + return pb +} + +// ProcessParameter adds a parameter to the process if it is set +func (pb *ProcessBuilder) Parameter(parameterID string, value string) *ProcessBuilder { + if value != "" { + scalarType := models.SlpParameterType("slp.parameter.type.SCALAR") + processParam := models.Parameter{ID: ¶meterID, Value: value, Type: scalarType} + pb.process.Parameters.Parameters = append(pb.process.Parameters.Parameters, &processParam) + } + return pb +} + +// Build builds the process +func (pb *ProcessBuilder) Build() *models.Process { + return &pb.process +} diff --git a/util/cf_command_builder.go b/util/cf_command_builder.go new file mode 100644 index 0000000..a24be9b --- /dev/null +++ b/util/cf_command_builder.go @@ -0,0 +1,83 @@ +package util + +import ( + "bytes" + "strings" +) + +// CfCommandStringBuilder ... +type CfCommandStringBuilder struct { + name string + args bytes.Buffer + opts bytes.Buffer +} + +const longOptionPrefix = "--" +const optionPrefix = "-" + +// NewCfCommandStringBuilder creates a new CfCommandStringBuilder +func NewCfCommandStringBuilder() *CfCommandStringBuilder { + return &CfCommandStringBuilder{} +} + +// SetName sets the name of the command that will be generated from the Build method +func (builder *CfCommandStringBuilder) SetName(name string) *CfCommandStringBuilder { + builder.name = name + return builder +} + +// AddBooleanOption adds a short boolean option to the command that will be generated from the Build method +func (builder *CfCommandStringBuilder) AddBooleanOption(option string) *CfCommandStringBuilder { + return builder.addBooleanOption(option, optionPrefix) +} + +// AddOption adds a short option to the command that will be generated from the Build method +func (builder *CfCommandStringBuilder) AddOption(option, value string) *CfCommandStringBuilder { + return builder.addOption(option, value, optionPrefix) +} + +func (builder *CfCommandStringBuilder) addBooleanOption(option, prefix string) *CfCommandStringBuilder { + builder.opts.WriteString(prefix) + builder.opts.WriteString(option) + builder.opts.WriteRune(' ') + return builder +} + +func (builder *CfCommandStringBuilder) addOption(option, value, prefix string) *CfCommandStringBuilder { + builder.opts.WriteString(prefix) + builder.opts.WriteString(option) + builder.opts.WriteRune(' ') + builder.opts.WriteString(value) + builder.opts.WriteRune(' ') + return builder +} + +// AddLongBooleanOption adds a long boolean option to the command that will be generated from the Build method +func (builder *CfCommandStringBuilder) AddLongBooleanOption(option string) *CfCommandStringBuilder { + return builder.addBooleanOption(option, longOptionPrefix) +} + +// AddLongOption adds a long option to the command that will be generated from the Build method +func (builder *CfCommandStringBuilder) AddLongOption(option, value string) *CfCommandStringBuilder { + return builder.addOption(option, value, longOptionPrefix) +} + +// AddArgument adds an argument to the command that will be generated from the Build method +func (builder *CfCommandStringBuilder) AddArgument(argument string) *CfCommandStringBuilder { + builder.args.WriteString(argument) + builder.args.WriteRune(' ') + return builder +} + +// Build generates a command string, in which the arguments always preceed the options +func (builder *CfCommandStringBuilder) Build() string { + var commandBuilder bytes.Buffer + + commandBuilder.WriteString("cf ") + commandBuilder.WriteString(builder.name) + commandBuilder.WriteRune(' ') + commandBuilder.WriteString(builder.args.String()) + commandBuilder.WriteString(builder.opts.String()) + + return strings.Trim(commandBuilder.String(), " ") +} diff --git a/util/cf_command_builder_test.go b/util/cf_command_builder_test.go new file mode 100644 index 0000000..99b96e5 --- /dev/null +++ b/util/cf_command_builder_test.go @@ -0,0 +1,44 @@ +package util_test + +import ( + . "github.com/SAP/cf-mta-plugin/util" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("CfCommandBuilder", func() { + Describe("Build", func() { + Context("with valid argument and options", func() { + It("should return a valid command", func() { + commandBuilder := NewCfCommandStringBuilder() + commandBuilder.SetName("deploy") + commandBuilder.AddArgument("jobscheduler.mtar") + commandBuilder.AddBooleanOption("f") + commandBuilder.AddOption("t", "100") + commandBuilder.AddLongBooleanOption("no-start") + commandBuilder.AddOption("p", "XSA") + commandBuilder.AddLongOption("schema-version", "3") + Expect(commandBuilder.Build()).To(Equal("cf deploy jobscheduler.mtar -f -t 100 --no-start -p XSA --schema-version 3")) + }) + }) + Context("with just options and no arguments", func() { + It("should return a valid command", func() { + commandBuilder := NewCfCommandStringBuilder() + commandBuilder.SetName("deploy") + commandBuilder.AddOption("i", "12345") + commandBuilder.AddOption("a", "abort") + Expect(commandBuilder.Build()).To(Equal("cf deploy -i 12345 -a abort")) + }) + }) + Context("with just arguments and no options", func() { + It("should return a valid command", func() { + commandBuilder := NewCfCommandStringBuilder() + commandBuilder.SetName("deploy") + commandBuilder.AddArgument("jobscheduler1.mtar") + commandBuilder.AddArgument("jobscheduler2.mtar") + Expect(commandBuilder.Build()).To(Equal("cf deploy jobscheduler1.mtar jobscheduler2.mtar")) + }) + }) + }) +}) diff --git a/util/cf_command_options_util.go b/util/cf_command_options_util.go new file mode 100644 index 0000000..bb24f27 --- /dev/null +++ b/util/cf_command_options_util.go @@ -0,0 +1,11 @@ +package util + +import "bytes" + +//GetShortOption ... +func GetShortOption(option string) string { + var opt bytes.Buffer + opt.WriteString(optionPrefix) + opt.WriteString(option) + return opt.String() +} diff --git a/util/digest.go b/util/digest.go new file mode 100644 index 0000000..25bb9a9 --- /dev/null +++ b/util/digest.go @@ -0,0 +1,43 @@ +package util + +import ( + "crypto/md5" + "crypto/sha1" + "crypto/sha256" + "crypto/sha512" + "encoding/hex" + "fmt" + "hash" + "io" + "os" + "strings" +) + +// ComputeFileChecksum computes the checksum of the specified file based on the specified algorithm +func ComputeFileChecksum(filePath, algorithm string) (string, error) { + var hash hash.Hash + switch strings.ToUpper(algorithm) { + case "MD5": + hash = md5.New() + case "SHA1": + hash = sha1.New() + case "SHA256": + hash = sha256.New() + case "SHA512": + hash = sha512.New() + default: + return "", fmt.Errorf("Unsupported digest algorithm %q", algorithm) + } + + file, err := os.Open(filePath) + if err != nil { + return "", err + } + defer file.Close() + + _, err = io.Copy(hash, file) + if err != nil { + return "", err + } + return hex.EncodeToString(hash.Sum(nil)), nil +} diff --git a/util/digest_test.go b/util/digest_test.go new file mode 100644 index 0000000..403c95f --- /dev/null +++ b/util/digest_test.go @@ -0,0 +1,54 @@ +package util_test + +import ( + "io/ioutil" + "os" + "path/filepath" + + "github.com/SAP/cf-mta-plugin/testutil" + "github.com/SAP/cf-mta-plugin/util" + + . "github.com/onsi/ginkgo" +) + +var _ = Describe("Digest", func() { + + Describe("ComputeFileChecksum", func() { + const testFileName = "test-file.txt" + + var testFilePath string + var testFile *os.File + + BeforeEach(func() { + testFile, _ = os.Create(testFileName) + testFilePath, _ = filepath.Abs(testFileName) + }) + + Context("with an unsupported digest alghoritm", func() { + It("should return an error", func() { + digest, err := util.ComputeFileChecksum(testFilePath, "unsupported-alghoritm-name") + testutil.ExpectErrorAndZeroResult(err, digest) + }) + }) + + Context("with a supported digest alghoritm and an empty file", func() { + It("should return the digest of the file", func() { + digest, err := util.ComputeFileChecksum(testFilePath, "MD5") + testutil.ExpectNoErrorAndResult(err, digest, "d41d8cd98f00b204e9800998ecf8427e") + }) + }) + + Context("with a supported digest alghoritm and a non-empty file", func() { + It("should calculate the digest of the file and exit with zero status", func() { + const testFileContent = "test file content" + ioutil.WriteFile(testFile.Name(), []byte(testFileContent), 0644) + digest, err := util.ComputeFileChecksum(testFilePath, "SHA1") + testutil.ExpectNoErrorAndResult(err, digest, "9032bbc224ed8b39183cb93b9a7447727ce67f9d") + }) + }) + + AfterEach(func() { + os.Remove(testFileName) + }) + }) +}) diff --git a/util/file_splitter.go b/util/file_splitter.go new file mode 100644 index 0000000..ec59332 --- /dev/null +++ b/util/file_splitter.go @@ -0,0 +1,65 @@ +package util + +import ( + "io" + "math" + "os" + "path/filepath" + "strconv" + + "github.com/pborman/uuid" +) + +func generateHash() string { + return uuid.New() +} + +// SplitFile ... +func SplitFile(filePath string) ([]string, error) { + file, err := os.Open(filePath) + + if err != nil { + return nil, err + } + + defer file.Close() + + fileInfo, _ := file.Stat() + + var fileSize = fileInfo.Size() + + const fileChunk = 45 * (1 << 20) // 45 MB + + // calculate total number of parts the file will be chunked into + + totalPartsNum := uint64(math.Ceil(float64(fileSize) / float64(fileChunk))) + + baseFileName := filepath.Base(filePath) + var fileParts []string + if totalPartsNum <= 1 { + return []string{filePath}, nil + } + partsTempDir := filepath.Join(os.TempDir(), generateHash()) + errCreatingTempDir := os.MkdirAll(partsTempDir, os.ModePerm) + if errCreatingTempDir != nil { + return nil, errCreatingTempDir + } + for i := uint64(0); i < totalPartsNum; i++ { + filePartName := baseFileName + ".part." + strconv.FormatUint(i, 10) + tempFile := filepath.Join(partsTempDir, filePartName) + filePart, err := os.Create(tempFile) + if err != nil { + return nil, err + } + defer filePart.Close() + + partSize := int64(math.Min(fileChunk, float64(fileSize-int64(i*fileChunk)))) + _, err = io.CopyN(filePart, file, partSize) + if err != nil { + return nil, err + } + + fileParts = append(fileParts, filePart.Name()) + } + return fileParts, nil +} diff --git a/util/mta_version_handler.go b/util/mta_version_handler.go new file mode 100644 index 0000000..b7e7034 --- /dev/null +++ b/util/mta_version_handler.go @@ -0,0 +1,17 @@ +package util + +import "github.com/SAP/cf-mta-plugin/clients/models" + +const unknownMtaVersion string = "0.0.0-unknown" + +// GetMtaVersionAsString returns an MTA's version as a string or "?" if the version is unknown. +func GetMtaVersionAsString(mta *models.Mta) string { + return getDefaultIfUnknown(*mta.Metadata.Version) +} + +func getDefaultIfUnknown(version string) string { + if version != unknownMtaVersion { + return version + } + return "?" +} diff --git a/util/test-file.txt b/util/test-file.txt new file mode 100644 index 0000000..2211df3 --- /dev/null +++ b/util/test-file.txt @@ -0,0 +1 @@ +test file content \ No newline at end of file diff --git a/util/test.mtar b/util/test.mtar new file mode 100644 index 0000000..e69de29 diff --git a/util/util_suite_test.go b/util/util_suite_test.go new file mode 100644 index 0000000..f712f1f --- /dev/null +++ b/util/util_suite_test.go @@ -0,0 +1,13 @@ +package util_test + +import ( + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "testing" +) + +func TestUtil(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "Utilities Suite") +} diff --git a/vendor/github.com/PuerkitoBio/purell/.gitignore b/vendor/github.com/PuerkitoBio/purell/.gitignore new file mode 100644 index 0000000..748e4c8 --- /dev/null +++ b/vendor/github.com/PuerkitoBio/purell/.gitignore @@ -0,0 +1,5 @@ +*.sublime-* +.DS_Store +*.swp +*.swo +tags diff --git a/vendor/github.com/PuerkitoBio/purell/.travis.yml b/vendor/github.com/PuerkitoBio/purell/.travis.yml new file mode 100644 index 0000000..facfc91 --- /dev/null +++ b/vendor/github.com/PuerkitoBio/purell/.travis.yml @@ -0,0 +1,7 @@ +language: go + +go: + - 1.4 + - 1.5 + - 1.6 + - tip diff --git a/vendor/github.com/PuerkitoBio/purell/LICENSE b/vendor/github.com/PuerkitoBio/purell/LICENSE new file mode 100644 index 0000000..4b9986d --- /dev/null +++ b/vendor/github.com/PuerkitoBio/purell/LICENSE @@ -0,0 +1,12 @@ +Copyright (c) 2012, Martin Angers +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +* Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/PuerkitoBio/purell/README.md b/vendor/github.com/PuerkitoBio/purell/README.md new file mode 100644 index 0000000..09e8a32 --- /dev/null +++ b/vendor/github.com/PuerkitoBio/purell/README.md @@ -0,0 +1,187 @@ +# Purell + +Purell is a tiny Go library to normalize URLs. It returns a pure URL. Pure-ell. Sanitizer and all. Yeah, I know... + +Based on the [wikipedia paper][wiki] and the [RFC 3986 document][rfc]. + +[![build status](https://secure.travis-ci.org/PuerkitoBio/purell.png)](http://travis-ci.org/PuerkitoBio/purell) + +## Install + +`go get github.com/PuerkitoBio/purell` + +## Changelog + +* **2016-11-14 (v1.1.0)** : IDN: Conform to RFC 5895: Fold character width (thanks to @beeker1121). +* **2016-07-27 (v1.0.0)** : Normalize IDN to ASCII (thanks to @zenovich). +* **2015-02-08** : Add fix for relative paths issue ([PR #5][pr5]) and add fix for unnecessary encoding of reserved characters ([see issue #7][iss7]). +* **v0.2.0** : Add benchmarks, Attempt IDN support. +* **v0.1.0** : Initial release. + +## Examples + +From `example_test.go` (note that in your code, you would import "github.com/PuerkitoBio/purell", and would prefix references to its methods and constants with "purell."): + +```go +package purell + +import ( + "fmt" + "net/url" +) + +func ExampleNormalizeURLString() { + if normalized, err := NormalizeURLString("hTTp://someWEBsite.com:80/Amazing%3f/url/", + FlagLowercaseScheme|FlagLowercaseHost|FlagUppercaseEscapes); err != nil { + panic(err) + } else { + fmt.Print(normalized) + } + // Output: http://somewebsite.com:80/Amazing%3F/url/ +} + +func ExampleMustNormalizeURLString() { + normalized := MustNormalizeURLString("hTTpS://someWEBsite.com:443/Amazing%fa/url/", + FlagsUnsafeGreedy) + fmt.Print(normalized) + + // Output: http://somewebsite.com/Amazing%FA/url +} + +func ExampleNormalizeURL() { + if u, err := url.Parse("Http://SomeUrl.com:8080/a/b/.././c///g?c=3&a=1&b=9&c=0#target"); err != nil { + panic(err) + } else { + normalized := NormalizeURL(u, FlagsUsuallySafeGreedy|FlagRemoveDuplicateSlashes|FlagRemoveFragment) + fmt.Print(normalized) + } + + // Output: http://someurl.com:8080/a/c/g?c=3&a=1&b=9&c=0 +} +``` + +## API + +As seen in the examples above, purell offers three methods, `NormalizeURLString(string, NormalizationFlags) (string, error)`, `MustNormalizeURLString(string, NormalizationFlags) (string)` and `NormalizeURL(*url.URL, NormalizationFlags) (string)`. They all normalize the provided URL based on the specified flags. Here are the available flags: + +```go +const ( + // Safe normalizations + FlagLowercaseScheme NormalizationFlags = 1 << iota // HTTP://host -> http://host, applied by default in Go1.1 + FlagLowercaseHost // http://HOST -> http://host + FlagUppercaseEscapes // http://host/t%ef -> http://host/t%EF + FlagDecodeUnnecessaryEscapes // http://host/t%41 -> http://host/tA + FlagEncodeNecessaryEscapes // http://host/!"#$ -> http://host/%21%22#$ + FlagRemoveDefaultPort // http://host:80 -> http://host + FlagRemoveEmptyQuerySeparator // http://host/path? -> http://host/path + + // Usually safe normalizations + FlagRemoveTrailingSlash // http://host/path/ -> http://host/path + FlagAddTrailingSlash // http://host/path -> http://host/path/ (should choose only one of these add/remove trailing slash flags) + FlagRemoveDotSegments // http://host/path/./a/b/../c -> http://host/path/a/c + + // Unsafe normalizations + FlagRemoveDirectoryIndex // http://host/path/index.html -> http://host/path/ + FlagRemoveFragment // http://host/path#fragment -> http://host/path + FlagForceHTTP // https://host -> http://host + FlagRemoveDuplicateSlashes // http://host/path//a///b -> http://host/path/a/b + FlagRemoveWWW // http://www.host/ -> http://host/ + FlagAddWWW // http://host/ -> http://www.host/ (should choose only one of these add/remove WWW flags) + FlagSortQuery // http://host/path?c=3&b=2&a=1&b=1 -> http://host/path?a=1&b=1&b=2&c=3 + + // Normalizations not in the wikipedia article, required to cover tests cases + // submitted by jehiah + FlagDecodeDWORDHost // http://1113982867 -> http://66.102.7.147 + FlagDecodeOctalHost // http://0102.0146.07.0223 -> http://66.102.7.147 + FlagDecodeHexHost // http://0x42660793 -> http://66.102.7.147 + FlagRemoveUnnecessaryHostDots // http://.host../path -> http://host/path + FlagRemoveEmptyPortSeparator // http://host:/path -> http://host/path + + // Convenience set of safe normalizations + FlagsSafe NormalizationFlags = FlagLowercaseHost | FlagLowercaseScheme | FlagUppercaseEscapes | FlagDecodeUnnecessaryEscapes | FlagEncodeNecessaryEscapes | FlagRemoveDefaultPort | FlagRemoveEmptyQuerySeparator + + // For convenience sets, "greedy" uses the "remove trailing slash" and "remove www. prefix" flags, + // while "non-greedy" uses the "add (or keep) the trailing slash" and "add www. prefix". + + // Convenience set of usually safe normalizations (includes FlagsSafe) + FlagsUsuallySafeGreedy NormalizationFlags = FlagsSafe | FlagRemoveTrailingSlash | FlagRemoveDotSegments + FlagsUsuallySafeNonGreedy NormalizationFlags = FlagsSafe | FlagAddTrailingSlash | FlagRemoveDotSegments + + // Convenience set of unsafe normalizations (includes FlagsUsuallySafe) + FlagsUnsafeGreedy NormalizationFlags = FlagsUsuallySafeGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagRemoveWWW | FlagSortQuery + FlagsUnsafeNonGreedy NormalizationFlags = FlagsUsuallySafeNonGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagAddWWW | FlagSortQuery + + // Convenience set of all available flags + FlagsAllGreedy = FlagsUnsafeGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator + FlagsAllNonGreedy = FlagsUnsafeNonGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator +) +``` + +For convenience, the set of flags `FlagsSafe`, `FlagsUsuallySafe[Greedy|NonGreedy]`, `FlagsUnsafe[Greedy|NonGreedy]` and `FlagsAll[Greedy|NonGreedy]` are provided for the similarly grouped normalizations on [wikipedia's URL normalization page][wiki]. You can add (using the bitwise OR `|` operator) or remove (using the bitwise AND NOT `&^` operator) individual flags from the sets if required, to build your own custom set. + +The [full godoc reference is available on gopkgdoc][godoc]. + +Some things to note: + +* `FlagDecodeUnnecessaryEscapes`, `FlagEncodeNecessaryEscapes`, `FlagUppercaseEscapes` and `FlagRemoveEmptyQuerySeparator` are always implicitly set, because internally, the URL string is parsed as an URL object, which automatically decodes unnecessary escapes, uppercases and encodes necessary ones, and removes empty query separators (an unnecessary `?` at the end of the url). So this operation cannot **not** be done. For this reason, `FlagRemoveEmptyQuerySeparator` (as well as the other three) has been included in the `FlagsSafe` convenience set, instead of `FlagsUnsafe`, where Wikipedia puts it. + +* The `FlagDecodeUnnecessaryEscapes` decodes the following escapes (*from -> to*): + - %24 -> $ + - %26 -> & + - %2B-%3B -> +,-./0123456789:; + - %3D -> = + - %40-%5A -> @ABCDEFGHIJKLMNOPQRSTUVWXYZ + - %5F -> _ + - %61-%7A -> abcdefghijklmnopqrstuvwxyz + - %7E -> ~ + + +* When the `NormalizeURL` function is used (passing an URL object), this source URL object is modified (that is, after the call, the URL object will be modified to reflect the normalization). + +* The *replace IP with domain name* normalization (`http://208.77.188.166/ → http://www.example.com/`) is obviously not possible for a library without making some network requests. This is not implemented in purell. + +* The *remove unused query string parameters* and *remove default query parameters* are also not implemented, since this is a very case-specific normalization, and it is quite trivial to do with an URL object. + +### Safe vs Usually Safe vs Unsafe + +Purell allows you to control the level of risk you take while normalizing an URL. You can aggressively normalize, play it totally safe, or anything in between. + +Consider the following URL: + +`HTTPS://www.RooT.com/toto/t%45%1f///a/./b/../c/?z=3&w=2&a=4&w=1#invalid` + +Normalizing with the `FlagsSafe` gives: + +`https://www.root.com/toto/tE%1F///a/./b/../c/?z=3&w=2&a=4&w=1#invalid` + +With the `FlagsUsuallySafeGreedy`: + +`https://www.root.com/toto/tE%1F///a/c?z=3&w=2&a=4&w=1#invalid` + +And with `FlagsUnsafeGreedy`: + +`http://root.com/toto/tE%1F/a/c?a=4&w=1&w=2&z=3` + +## TODOs + +* Add a class/default instance to allow specifying custom directory index names? At the moment, removing directory index removes `(^|/)((?:default|index)\.\w{1,4})$`. + +## Thanks / Contributions + +@rogpeppe +@jehiah +@opennota +@pchristopher1275 +@zenovich +@beeker1121 + +## License + +The [BSD 3-Clause license][bsd]. + +[bsd]: http://opensource.org/licenses/BSD-3-Clause +[wiki]: http://en.wikipedia.org/wiki/URL_normalization +[rfc]: http://tools.ietf.org/html/rfc3986#section-6 +[godoc]: http://go.pkgdoc.org/github.com/PuerkitoBio/purell +[pr5]: https://github.com/PuerkitoBio/purell/pull/5 +[iss7]: https://github.com/PuerkitoBio/purell/issues/7 diff --git a/vendor/github.com/PuerkitoBio/purell/purell.go b/vendor/github.com/PuerkitoBio/purell/purell.go new file mode 100644 index 0000000..645e1b7 --- /dev/null +++ b/vendor/github.com/PuerkitoBio/purell/purell.go @@ -0,0 +1,379 @@ +/* +Package purell offers URL normalization as described on the wikipedia page: +http://en.wikipedia.org/wiki/URL_normalization +*/ +package purell + +import ( + "bytes" + "fmt" + "net/url" + "regexp" + "sort" + "strconv" + "strings" + + "github.com/PuerkitoBio/urlesc" + "golang.org/x/net/idna" + "golang.org/x/text/unicode/norm" + "golang.org/x/text/width" +) + +// A set of normalization flags determines how a URL will +// be normalized. +type NormalizationFlags uint + +const ( + // Safe normalizations + FlagLowercaseScheme NormalizationFlags = 1 << iota // HTTP://host -> http://host, applied by default in Go1.1 + FlagLowercaseHost // http://HOST -> http://host + FlagUppercaseEscapes // http://host/t%ef -> http://host/t%EF + FlagDecodeUnnecessaryEscapes // http://host/t%41 -> http://host/tA + FlagEncodeNecessaryEscapes // http://host/!"#$ -> http://host/%21%22#$ + FlagRemoveDefaultPort // http://host:80 -> http://host + FlagRemoveEmptyQuerySeparator // http://host/path? -> http://host/path + + // Usually safe normalizations + FlagRemoveTrailingSlash // http://host/path/ -> http://host/path + FlagAddTrailingSlash // http://host/path -> http://host/path/ (should choose only one of these add/remove trailing slash flags) + FlagRemoveDotSegments // http://host/path/./a/b/../c -> http://host/path/a/c + + // Unsafe normalizations + FlagRemoveDirectoryIndex // http://host/path/index.html -> http://host/path/ + FlagRemoveFragment // http://host/path#fragment -> http://host/path + FlagForceHTTP // https://host -> http://host + FlagRemoveDuplicateSlashes // http://host/path//a///b -> http://host/path/a/b + FlagRemoveWWW // http://www.host/ -> http://host/ + FlagAddWWW // http://host/ -> http://www.host/ (should choose only one of these add/remove WWW flags) + FlagSortQuery // http://host/path?c=3&b=2&a=1&b=1 -> http://host/path?a=1&b=1&b=2&c=3 + + // Normalizations not in the wikipedia article, required to cover tests cases + // submitted by jehiah + FlagDecodeDWORDHost // http://1113982867 -> http://66.102.7.147 + FlagDecodeOctalHost // http://0102.0146.07.0223 -> http://66.102.7.147 + FlagDecodeHexHost // http://0x42660793 -> http://66.102.7.147 + FlagRemoveUnnecessaryHostDots // http://.host../path -> http://host/path + FlagRemoveEmptyPortSeparator // http://host:/path -> http://host/path + + // Convenience set of safe normalizations + FlagsSafe NormalizationFlags = FlagLowercaseHost | FlagLowercaseScheme | FlagUppercaseEscapes | FlagDecodeUnnecessaryEscapes | FlagEncodeNecessaryEscapes | FlagRemoveDefaultPort | FlagRemoveEmptyQuerySeparator + + // For convenience sets, "greedy" uses the "remove trailing slash" and "remove www. prefix" flags, + // while "non-greedy" uses the "add (or keep) the trailing slash" and "add www. prefix". + + // Convenience set of usually safe normalizations (includes FlagsSafe) + FlagsUsuallySafeGreedy NormalizationFlags = FlagsSafe | FlagRemoveTrailingSlash | FlagRemoveDotSegments + FlagsUsuallySafeNonGreedy NormalizationFlags = FlagsSafe | FlagAddTrailingSlash | FlagRemoveDotSegments + + // Convenience set of unsafe normalizations (includes FlagsUsuallySafe) + FlagsUnsafeGreedy NormalizationFlags = FlagsUsuallySafeGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagRemoveWWW | FlagSortQuery + FlagsUnsafeNonGreedy NormalizationFlags = FlagsUsuallySafeNonGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagAddWWW | FlagSortQuery + + // Convenience set of all available flags + FlagsAllGreedy = FlagsUnsafeGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator + FlagsAllNonGreedy = FlagsUnsafeNonGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator +) + +const ( + defaultHttpPort = ":80" + defaultHttpsPort = ":443" +) + +// Regular expressions used by the normalizations +var rxPort = regexp.MustCompile(`(:\d+)/?$`) +var rxDirIndex = regexp.MustCompile(`(^|/)((?:default|index)\.\w{1,4})$`) +var rxDupSlashes = regexp.MustCompile(`/{2,}`) +var rxDWORDHost = regexp.MustCompile(`^(\d+)((?:\.+)?(?:\:\d*)?)$`) +var rxOctalHost = regexp.MustCompile(`^(0\d*)\.(0\d*)\.(0\d*)\.(0\d*)((?:\.+)?(?:\:\d*)?)$`) +var rxHexHost = regexp.MustCompile(`^0x([0-9A-Fa-f]+)((?:\.+)?(?:\:\d*)?)$`) +var rxHostDots = regexp.MustCompile(`^(.+?)(:\d+)?$`) +var rxEmptyPort = regexp.MustCompile(`:+$`) + +// Map of flags to implementation function. +// FlagDecodeUnnecessaryEscapes has no action, since it is done automatically +// by parsing the string as an URL. Same for FlagUppercaseEscapes and FlagRemoveEmptyQuerySeparator. + +// Since maps have undefined traversing order, make a slice of ordered keys +var flagsOrder = []NormalizationFlags{ + FlagLowercaseScheme, + FlagLowercaseHost, + FlagRemoveDefaultPort, + FlagRemoveDirectoryIndex, + FlagRemoveDotSegments, + FlagRemoveFragment, + FlagForceHTTP, // Must be after remove default port (because https=443/http=80) + FlagRemoveDuplicateSlashes, + FlagRemoveWWW, + FlagAddWWW, + FlagSortQuery, + FlagDecodeDWORDHost, + FlagDecodeOctalHost, + FlagDecodeHexHost, + FlagRemoveUnnecessaryHostDots, + FlagRemoveEmptyPortSeparator, + FlagRemoveTrailingSlash, // These two (add/remove trailing slash) must be last + FlagAddTrailingSlash, +} + +// ... and then the map, where order is unimportant +var flags = map[NormalizationFlags]func(*url.URL){ + FlagLowercaseScheme: lowercaseScheme, + FlagLowercaseHost: lowercaseHost, + FlagRemoveDefaultPort: removeDefaultPort, + FlagRemoveDirectoryIndex: removeDirectoryIndex, + FlagRemoveDotSegments: removeDotSegments, + FlagRemoveFragment: removeFragment, + FlagForceHTTP: forceHTTP, + FlagRemoveDuplicateSlashes: removeDuplicateSlashes, + FlagRemoveWWW: removeWWW, + FlagAddWWW: addWWW, + FlagSortQuery: sortQuery, + FlagDecodeDWORDHost: decodeDWORDHost, + FlagDecodeOctalHost: decodeOctalHost, + FlagDecodeHexHost: decodeHexHost, + FlagRemoveUnnecessaryHostDots: removeUnncessaryHostDots, + FlagRemoveEmptyPortSeparator: removeEmptyPortSeparator, + FlagRemoveTrailingSlash: removeTrailingSlash, + FlagAddTrailingSlash: addTrailingSlash, +} + +// MustNormalizeURLString returns the normalized string, and panics if an error occurs. +// It takes an URL string as input, as well as the normalization flags. +func MustNormalizeURLString(u string, f NormalizationFlags) string { + result, e := NormalizeURLString(u, f) + if e != nil { + panic(e) + } + return result +} + +// NormalizeURLString returns the normalized string, or an error if it can't be parsed into an URL object. +// It takes an URL string as input, as well as the normalization flags. +func NormalizeURLString(u string, f NormalizationFlags) (string, error) { + parsed, err := url.Parse(u) + if err != nil { + return "", err + } + + if f&FlagLowercaseHost == FlagLowercaseHost { + parsed.Host = strings.ToLower(parsed.Host) + } + + // The idna package doesn't fully conform to RFC 5895 + // (https://tools.ietf.org/html/rfc5895), so we do it here. + // Taken from Go 1.8 cycle source, courtesy of bradfitz. + // TODO: Remove when (if?) idna package conforms to RFC 5895. + parsed.Host = width.Fold.String(parsed.Host) + parsed.Host = norm.NFC.String(parsed.Host) + if parsed.Host, err = idna.ToASCII(parsed.Host); err != nil { + return "", err + } + + return NormalizeURL(parsed, f), nil +} + +// NormalizeURL returns the normalized string. +// It takes a parsed URL object as input, as well as the normalization flags. +func NormalizeURL(u *url.URL, f NormalizationFlags) string { + for _, k := range flagsOrder { + if f&k == k { + flags[k](u) + } + } + return urlesc.Escape(u) +} + +func lowercaseScheme(u *url.URL) { + if len(u.Scheme) > 0 { + u.Scheme = strings.ToLower(u.Scheme) + } +} + +func lowercaseHost(u *url.URL) { + if len(u.Host) > 0 { + u.Host = strings.ToLower(u.Host) + } +} + +func removeDefaultPort(u *url.URL) { + if len(u.Host) > 0 { + scheme := strings.ToLower(u.Scheme) + u.Host = rxPort.ReplaceAllStringFunc(u.Host, func(val string) string { + if (scheme == "http" && val == defaultHttpPort) || (scheme == "https" && val == defaultHttpsPort) { + return "" + } + return val + }) + } +} + +func removeTrailingSlash(u *url.URL) { + if l := len(u.Path); l > 0 { + if strings.HasSuffix(u.Path, "/") { + u.Path = u.Path[:l-1] + } + } else if l = len(u.Host); l > 0 { + if strings.HasSuffix(u.Host, "/") { + u.Host = u.Host[:l-1] + } + } +} + +func addTrailingSlash(u *url.URL) { + if l := len(u.Path); l > 0 { + if !strings.HasSuffix(u.Path, "/") { + u.Path += "/" + } + } else if l = len(u.Host); l > 0 { + if !strings.HasSuffix(u.Host, "/") { + u.Host += "/" + } + } +} + +func removeDotSegments(u *url.URL) { + if len(u.Path) > 0 { + var dotFree []string + var lastIsDot bool + + sections := strings.Split(u.Path, "/") + for _, s := range sections { + if s == ".." { + if len(dotFree) > 0 { + dotFree = dotFree[:len(dotFree)-1] + } + } else if s != "." { + dotFree = append(dotFree, s) + } + lastIsDot = (s == "." || s == "..") + } + // Special case if host does not end with / and new path does not begin with / + u.Path = strings.Join(dotFree, "/") + if u.Host != "" && !strings.HasSuffix(u.Host, "/") && !strings.HasPrefix(u.Path, "/") { + u.Path = "/" + u.Path + } + // Special case if the last segment was a dot, make sure the path ends with a slash + if lastIsDot && !strings.HasSuffix(u.Path, "/") { + u.Path += "/" + } + } +} + +func removeDirectoryIndex(u *url.URL) { + if len(u.Path) > 0 { + u.Path = rxDirIndex.ReplaceAllString(u.Path, "$1") + } +} + +func removeFragment(u *url.URL) { + u.Fragment = "" +} + +func forceHTTP(u *url.URL) { + if strings.ToLower(u.Scheme) == "https" { + u.Scheme = "http" + } +} + +func removeDuplicateSlashes(u *url.URL) { + if len(u.Path) > 0 { + u.Path = rxDupSlashes.ReplaceAllString(u.Path, "/") + } +} + +func removeWWW(u *url.URL) { + if len(u.Host) > 0 && strings.HasPrefix(strings.ToLower(u.Host), "www.") { + u.Host = u.Host[4:] + } +} + +func addWWW(u *url.URL) { + if len(u.Host) > 0 && !strings.HasPrefix(strings.ToLower(u.Host), "www.") { + u.Host = "www." + u.Host + } +} + +func sortQuery(u *url.URL) { + q := u.Query() + + if len(q) > 0 { + arKeys := make([]string, len(q)) + i := 0 + for k, _ := range q { + arKeys[i] = k + i++ + } + sort.Strings(arKeys) + buf := new(bytes.Buffer) + for _, k := range arKeys { + sort.Strings(q[k]) + for _, v := range q[k] { + if buf.Len() > 0 { + buf.WriteRune('&') + } + buf.WriteString(fmt.Sprintf("%s=%s", k, urlesc.QueryEscape(v))) + } + } + + // Rebuild the raw query string + u.RawQuery = buf.String() + } +} + +func decodeDWORDHost(u *url.URL) { + if len(u.Host) > 0 { + if matches := rxDWORDHost.FindStringSubmatch(u.Host); len(matches) > 2 { + var parts [4]int64 + + dword, _ := strconv.ParseInt(matches[1], 10, 0) + for i, shift := range []uint{24, 16, 8, 0} { + parts[i] = dword >> shift & 0xFF + } + u.Host = fmt.Sprintf("%d.%d.%d.%d%s", parts[0], parts[1], parts[2], parts[3], matches[2]) + } + } +} + +func decodeOctalHost(u *url.URL) { + if len(u.Host) > 0 { + if matches := rxOctalHost.FindStringSubmatch(u.Host); len(matches) > 5 { + var parts [4]int64 + + for i := 1; i <= 4; i++ { + parts[i-1], _ = strconv.ParseInt(matches[i], 8, 0) + } + u.Host = fmt.Sprintf("%d.%d.%d.%d%s", parts[0], parts[1], parts[2], parts[3], matches[5]) + } + } +} + +func decodeHexHost(u *url.URL) { + if len(u.Host) > 0 { + if matches := rxHexHost.FindStringSubmatch(u.Host); len(matches) > 2 { + // Conversion is safe because of regex validation + parsed, _ := strconv.ParseInt(matches[1], 16, 0) + // Set host as DWORD (base 10) encoded host + u.Host = fmt.Sprintf("%d%s", parsed, matches[2]) + // The rest is the same as decoding a DWORD host + decodeDWORDHost(u) + } + } +} + +func removeUnncessaryHostDots(u *url.URL) { + if len(u.Host) > 0 { + if matches := rxHostDots.FindStringSubmatch(u.Host); len(matches) > 1 { + // Trim the leading and trailing dots + u.Host = strings.Trim(matches[1], ".") + if len(matches) > 2 { + u.Host += matches[2] + } + } + } +} + +func removeEmptyPortSeparator(u *url.URL) { + if len(u.Host) > 0 { + u.Host = rxEmptyPort.ReplaceAllString(u.Host, "") + } +} diff --git a/vendor/github.com/PuerkitoBio/urlesc/.travis.yml b/vendor/github.com/PuerkitoBio/urlesc/.travis.yml new file mode 100644 index 0000000..478630e --- /dev/null +++ b/vendor/github.com/PuerkitoBio/urlesc/.travis.yml @@ -0,0 +1,11 @@ +language: go + +go: + - 1.4 + - tip + +install: + - go build . + +script: + - go test -v diff --git a/vendor/github.com/PuerkitoBio/urlesc/LICENSE b/vendor/github.com/PuerkitoBio/urlesc/LICENSE new file mode 100644 index 0000000..7448756 --- /dev/null +++ b/vendor/github.com/PuerkitoBio/urlesc/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2012 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/PuerkitoBio/urlesc/README.md b/vendor/github.com/PuerkitoBio/urlesc/README.md new file mode 100644 index 0000000..bebe305 --- /dev/null +++ b/vendor/github.com/PuerkitoBio/urlesc/README.md @@ -0,0 +1,16 @@ +urlesc [![Build Status](https://travis-ci.org/PuerkitoBio/urlesc.png?branch=master)](https://travis-ci.org/PuerkitoBio/urlesc) [![GoDoc](http://godoc.org/github.com/PuerkitoBio/urlesc?status.svg)](http://godoc.org/github.com/PuerkitoBio/urlesc) +====== + +Package urlesc implements query escaping as per RFC 3986. + +It contains some parts of the net/url package, modified so as to allow +some reserved characters incorrectly escaped by net/url (see [issue 5684](https://github.com/golang/go/issues/5684)). + +## Install + + go get github.com/PuerkitoBio/urlesc + +## License + +Go license (BSD-3-Clause) + diff --git a/vendor/github.com/PuerkitoBio/urlesc/urlesc.go b/vendor/github.com/PuerkitoBio/urlesc/urlesc.go new file mode 100644 index 0000000..1b84624 --- /dev/null +++ b/vendor/github.com/PuerkitoBio/urlesc/urlesc.go @@ -0,0 +1,180 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package urlesc implements query escaping as per RFC 3986. +// It contains some parts of the net/url package, modified so as to allow +// some reserved characters incorrectly escaped by net/url. +// See https://github.com/golang/go/issues/5684 +package urlesc + +import ( + "bytes" + "net/url" + "strings" +) + +type encoding int + +const ( + encodePath encoding = 1 + iota + encodeUserPassword + encodeQueryComponent + encodeFragment +) + +// Return true if the specified character should be escaped when +// appearing in a URL string, according to RFC 3986. +func shouldEscape(c byte, mode encoding) bool { + // §2.3 Unreserved characters (alphanum) + if 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' { + return false + } + + switch c { + case '-', '.', '_', '~': // §2.3 Unreserved characters (mark) + return false + + // §2.2 Reserved characters (reserved) + case ':', '/', '?', '#', '[', ']', '@', // gen-delims + '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=': // sub-delims + // Different sections of the URL allow a few of + // the reserved characters to appear unescaped. + switch mode { + case encodePath: // §3.3 + // The RFC allows sub-delims and : @. + // '/', '[' and ']' can be used to assign meaning to individual path + // segments. This package only manipulates the path as a whole, + // so we allow those as well. That leaves only ? and # to escape. + return c == '?' || c == '#' + + case encodeUserPassword: // §3.2.1 + // The RFC allows : and sub-delims in + // userinfo. The parsing of userinfo treats ':' as special so we must escape + // all the gen-delims. + return c == ':' || c == '/' || c == '?' || c == '#' || c == '[' || c == ']' || c == '@' + + case encodeQueryComponent: // §3.4 + // The RFC allows / and ?. + return c != '/' && c != '?' + + case encodeFragment: // §4.1 + // The RFC text is silent but the grammar allows + // everything, so escape nothing but # + return c == '#' + } + } + + // Everything else must be escaped. + return true +} + +// QueryEscape escapes the string so it can be safely placed +// inside a URL query. +func QueryEscape(s string) string { + return escape(s, encodeQueryComponent) +} + +func escape(s string, mode encoding) string { + spaceCount, hexCount := 0, 0 + for i := 0; i < len(s); i++ { + c := s[i] + if shouldEscape(c, mode) { + if c == ' ' && mode == encodeQueryComponent { + spaceCount++ + } else { + hexCount++ + } + } + } + + if spaceCount == 0 && hexCount == 0 { + return s + } + + t := make([]byte, len(s)+2*hexCount) + j := 0 + for i := 0; i < len(s); i++ { + switch c := s[i]; { + case c == ' ' && mode == encodeQueryComponent: + t[j] = '+' + j++ + case shouldEscape(c, mode): + t[j] = '%' + t[j+1] = "0123456789ABCDEF"[c>>4] + t[j+2] = "0123456789ABCDEF"[c&15] + j += 3 + default: + t[j] = s[i] + j++ + } + } + return string(t) +} + +var uiReplacer = strings.NewReplacer( + "%21", "!", + "%27", "'", + "%28", "(", + "%29", ")", + "%2A", "*", +) + +// unescapeUserinfo unescapes some characters that need not to be escaped as per RFC3986. +func unescapeUserinfo(s string) string { + return uiReplacer.Replace(s) +} + +// Escape reassembles the URL into a valid URL string. +// The general form of the result is one of: +// +// scheme:opaque +// scheme://userinfo@host/path?query#fragment +// +// If u.Opaque is non-empty, String uses the first form; +// otherwise it uses the second form. +// +// In the second form, the following rules apply: +// - if u.Scheme is empty, scheme: is omitted. +// - if u.User is nil, userinfo@ is omitted. +// - if u.Host is empty, host/ is omitted. +// - if u.Scheme and u.Host are empty and u.User is nil, +// the entire scheme://userinfo@host/ is omitted. +// - if u.Host is non-empty and u.Path begins with a /, +// the form host/path does not add its own /. +// - if u.RawQuery is empty, ?query is omitted. +// - if u.Fragment is empty, #fragment is omitted. +func Escape(u *url.URL) string { + var buf bytes.Buffer + if u.Scheme != "" { + buf.WriteString(u.Scheme) + buf.WriteByte(':') + } + if u.Opaque != "" { + buf.WriteString(u.Opaque) + } else { + if u.Scheme != "" || u.Host != "" || u.User != nil { + buf.WriteString("//") + if ui := u.User; ui != nil { + buf.WriteString(unescapeUserinfo(ui.String())) + buf.WriteByte('@') + } + if h := u.Host; h != "" { + buf.WriteString(h) + } + } + if u.Path != "" && u.Path[0] != '/' && u.Host != "" { + buf.WriteByte('/') + } + buf.WriteString(escape(u.Path, encodePath)) + } + if u.RawQuery != "" { + buf.WriteByte('?') + buf.WriteString(u.RawQuery) + } + if u.Fragment != "" { + buf.WriteByte('#') + buf.WriteString(escape(u.Fragment, encodeFragment)) + } + return buf.String() +} diff --git a/vendor/github.com/asaskevich/govalidator/.travis.yml b/vendor/github.com/asaskevich/govalidator/.travis.yml new file mode 100644 index 0000000..e29f8ee --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/.travis.yml @@ -0,0 +1,14 @@ +language: go + +go: + - 1.1 + - 1.2 + - 1.3 + - 1.4 + - 1.5 + - 1.6 + - tip + +notifications: + email: + - bwatas@gmail.com diff --git a/vendor/github.com/asaskevich/govalidator/LICENSE b/vendor/github.com/asaskevich/govalidator/LICENSE new file mode 100644 index 0000000..2f9a31f --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Alex Saskevich + +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. \ No newline at end of file diff --git a/vendor/github.com/asaskevich/govalidator/README.md b/vendor/github.com/asaskevich/govalidator/README.md new file mode 100644 index 0000000..57d85fd --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/README.md @@ -0,0 +1,401 @@ +govalidator +=========== +[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/asaskevich/govalidator?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) [![GoDoc](https://godoc.org/github.com/asaskevich/govalidator?status.png)](https://godoc.org/github.com/asaskevich/govalidator) [![Coverage Status](https://img.shields.io/coveralls/asaskevich/govalidator.svg)](https://coveralls.io/r/asaskevich/govalidator?branch=master) [![wercker status](https://app.wercker.com/status/1ec990b09ea86c910d5f08b0e02c6043/s "wercker status")](https://app.wercker.com/project/bykey/1ec990b09ea86c910d5f08b0e02c6043) +[![Build Status](https://travis-ci.org/asaskevich/govalidator.svg?branch=master)](https://travis-ci.org/asaskevich/govalidator) + +A package of validators and sanitizers for strings, structs and collections. Based on [validator.js](https://github.com/chriso/validator.js). + +#### Installation +Make sure that Go is installed on your computer. +Type the following command in your terminal: + + go get github.com/asaskevich/govalidator + +or you can get specified release of the package with `gopkg.in`: + + go get gopkg.in/asaskevich/govalidator.v4 + +After it the package is ready to use. + + +#### Import package in your project +Add following line in your `*.go` file: +```go +import "github.com/asaskevich/govalidator" +``` +If you are unhappy to use long `govalidator`, you can do something like this: +```go +import ( + valid "github.com/asaskevich/govalidator" +) +``` + +#### Activate behavior to require all fields have a validation tag by default +`SetFieldsRequiredByDefault` causes validation to fail when struct fields do not include validations or are not explicitly marked as exempt (using `valid:"-"` or `valid:"email,optional"`). A good place to activate this is a package init function or the main() function. + +```go +import "github.com/asaskevich/govalidator" + +func init() { + govalidator.SetFieldsRequiredByDefault(true) +} +``` + +Here's some code to explain it: +```go +// this struct definition will fail govalidator.ValidateStruct() (and the field values do not matter): +type exampleStruct struct { + Name string `` + Email string `valid:"email"` +} + +// this, however, will only fail when Email is empty or an invalid email address: +type exampleStruct2 struct { + Name string `valid:"-"` + Email string `valid:"email"` +} + +// lastly, this will only fail when Email is an invalid email address but not when it's empty: +type exampleStruct2 struct { + Name string `valid:"-"` + Email string `valid:"email,optional"` +} +``` + +#### Recent breaking changes (see [#123](https://github.com/asaskevich/govalidator/pull/123)) +##### Custom validator function signature +A context was added as the second parameter, for structs this is the object being validated – this makes dependent validation possible. +```go +import "github.com/asaskevich/govalidator" + +// old signature +func(i interface{}) bool + +// new signature +func(i interface{}, o interface{}) bool +``` + +##### Adding a custom validator +This was changed to prevent data races when accessing custom validators. +```go +import "github.com/asaskevich/govalidator" + +// before +govalidator.CustomTypeTagMap["customByteArrayValidator"] = CustomTypeValidator(func(i interface{}, o interface{}) bool { + // ... +}) + +// after +govalidator.CustomTypeTagMap.Set("customByteArrayValidator", CustomTypeValidator(func(i interface{}, o interface{}) bool { + // ... +})) +``` + +#### List of functions: +```go +func Abs(value float64) float64 +func BlackList(str, chars string) string +func ByteLength(str string, params ...string) bool +func StringLength(str string, params ...string) bool +func StringMatches(s string, params ...string) bool +func CamelCaseToUnderscore(str string) string +func Contains(str, substring string) bool +func Count(array []interface{}, iterator ConditionIterator) int +func Each(array []interface{}, iterator Iterator) +func ErrorByField(e error, field string) string +func Filter(array []interface{}, iterator ConditionIterator) []interface{} +func Find(array []interface{}, iterator ConditionIterator) interface{} +func GetLine(s string, index int) (string, error) +func GetLines(s string) []string +func IsHost(s string) bool +func InRange(value, left, right float64) bool +func IsASCII(str string) bool +func IsAlpha(str string) bool +func IsAlphanumeric(str string) bool +func IsBase64(str string) bool +func IsByteLength(str string, min, max int) bool +func IsCreditCard(str string) bool +func IsDataURI(str string) bool +func IsDialString(str string) bool +func IsDNSName(str string) bool +func IsDivisibleBy(str, num string) bool +func IsEmail(str string) bool +func IsFilePath(str string) (bool, int) +func IsFloat(str string) bool +func IsFullWidth(str string) bool +func IsHalfWidth(str string) bool +func IsHexadecimal(str string) bool +func IsHexcolor(str string) bool +func IsIP(str string) bool +func IsIPv4(str string) bool +func IsIPv6(str string) bool +func IsISBN(str string, version int) bool +func IsISBN10(str string) bool +func IsISBN13(str string) bool +func IsISO3166Alpha2(str string) bool +func IsISO3166Alpha3(str string) bool +func IsInt(str string) bool +func IsJSON(str string) bool +func IsLatitude(str string) bool +func IsLongitude(str string) bool +func IsLowerCase(str string) bool +func IsMAC(str string) bool +func IsMongoID(str string) bool +func IsMultibyte(str string) bool +func IsNatural(value float64) bool +func IsNegative(value float64) bool +func IsNonNegative(value float64) bool +func IsNonPositive(value float64) bool +func IsNull(str string) bool +func IsNumeric(str string) bool +func IsPort(str string) bool +func IsPositive(value float64) bool +func IsPrintableASCII(str string) bool +func IsRGBcolor(str string) bool +func IsRequestURI(rawurl string) bool +func IsRequestURL(rawurl string) bool +func IsSSN(str string) bool +func IsSemver(str string) bool +func IsURL(str string) bool +func IsUTFDigit(str string) bool +func IsUTFLetter(str string) bool +func IsUTFLetterNumeric(str string) bool +func IsUTFNumeric(str string) bool +func IsUUID(str string) bool +func IsUUIDv3(str string) bool +func IsUUIDv4(str string) bool +func IsUUIDv5(str string) bool +func IsUpperCase(str string) bool +func IsVariableWidth(str string) bool +func IsWhole(value float64) bool +func LeftTrim(str, chars string) string +func Map(array []interface{}, iterator ResultIterator) []interface{} +func Matches(str, pattern string) bool +func NormalizeEmail(str string) (string, error) +func RemoveTags(s string) string +func ReplacePattern(str, pattern, replace string) string +func Reverse(s string) string +func RightTrim(str, chars string) string +func SafeFileName(str string) string +func Sign(value float64) float64 +func StripLow(str string, keepNewLines bool) string +func ToBoolean(str string) (bool, error) +func ToFloat(str string) (float64, error) +func ToInt(str string) (int64, error) +func ToJSON(obj interface{}) (string, error) +func ToString(obj interface{}) string +func Trim(str, chars string) string +func Truncate(str string, length int, ending string) string +func UnderscoreToCamelCase(s string) string +func ValidateStruct(s interface{}) (bool, error) +func WhiteList(str, chars string) string +type ConditionIterator +type Error +func (e Error) Error() string +type Errors +func (es Errors) Error() string +type ISO3166Entry +type Iterator +type ParamValidator +type ResultIterator +type UnsupportedTypeError +func (e *UnsupportedTypeError) Error() string +type Validator +``` + +#### Examples +###### IsURL +```go +println(govalidator.IsURL(`http://user@pass:domain.com/path/page`)) +``` +###### ToString +```go +type User struct { + FirstName string + LastName string +} + +str := govalidator.ToString(&User{"John", "Juan"}) +println(str) +``` +###### Each, Map, Filter, Count for slices +Each iterates over the slice/array and calls Iterator for every item +```go +data := []interface{}{1, 2, 3, 4, 5} +var fn govalidator.Iterator = func(value interface{}, index int) { + println(value.(int)) +} +govalidator.Each(data, fn) +``` +```go +data := []interface{}{1, 2, 3, 4, 5} +var fn govalidator.ResultIterator = func(value interface{}, index int) interface{} { + return value.(int) * 3 +} +_ = govalidator.Map(data, fn) // result = []interface{}{1, 6, 9, 12, 15} +``` +```go +data := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} +var fn govalidator.ConditionIterator = func(value interface{}, index int) bool { + return value.(int)%2 == 0 +} +_ = govalidator.Filter(data, fn) // result = []interface{}{2, 4, 6, 8, 10} +_ = govalidator.Count(data, fn) // result = 5 +``` +###### ValidateStruct [#2](https://github.com/asaskevich/govalidator/pull/2) +If you want to validate structs, you can use tag `valid` for any field in your structure. All validators used with this field in one tag are separated by comma. If you want to skip validation, place `-` in your tag. If you need a validator that is not on the list below, you can add it like this: +```go +govalidator.TagMap["duck"] = govalidator.Validator(func(str string) bool { + return str == "duck" +}) +``` +For completely custom validators (interface-based), see below. + +Here is a list of available validators for struct fields (validator - used function): +```go +"alpha": IsAlpha, +"alphanum": IsAlphanumeric, +"ascii": IsASCII, +"base64": IsBase64, +"creditcard": IsCreditCard, +"datauri": IsDataURI, +"dialstring": IsDialString, +"dns": IsDNSName, +"email": IsEmail, +"float": IsFloat, +"fullwidth": IsFullWidth, +"halfwidth": IsHalfWidth, +"hexadecimal": IsHexadecimal, +"hexcolor": IsHexcolor, +"host": IsHost, +"int": IsInt, +"ip": IsIP, +"ipv4": IsIPv4, +"ipv6": IsIPv6, +"isbn10": IsISBN10, +"isbn13": IsISBN13, +"json": IsJSON, +"latitude": IsLatitude, +"longitude": IsLongitude, +"lowercase": IsLowerCase, +"mac": IsMAC, +"multibyte": IsMultibyte, +"null": IsNull, +"numeric": IsNumeric, +"port": IsPort, +"printableascii": IsPrintableASCII, +"requri": IsRequestURI, +"requrl": IsRequestURL, +"rgbcolor": IsRGBcolor, +"ssn": IsSSN, +"semver": IsSemver, +"uppercase": IsUpperCase, +"url": IsURL, +"utfdigit": IsUTFDigit, +"utfletter": IsUTFLetter, +"utfletternum": IsUTFLetterNumeric, +"utfnumeric": IsUTFNumeric, +"uuid": IsUUID, +"uuidv3": IsUUIDv3, +"uuidv4": IsUUIDv4, +"uuidv5": IsUUIDv5, +"variablewidth": IsVariableWidth, +``` +Validators with parameters + +```go +"length(min|max)": ByteLength, +"matches(pattern)": StringMatches, +``` + +And here is small example of usage: +```go +type Post struct { + Title string `valid:"alphanum,required"` + Message string `valid:"duck,ascii"` + AuthorIP string `valid:"ipv4"` + Date string `valid:"-"` +} +post := &Post{ + Title: "My Example Post", + Message: "duck", + AuthorIP: "123.234.54.3", +} + +// Add your own struct validation tags +govalidator.TagMap["duck"] = govalidator.Validator(func(str string) bool { + return str == "duck" +}) + +result, err := govalidator.ValidateStruct(post) +if err != nil { + println("error: " + err.Error()) +} +println(result) +``` +###### WhiteList +```go +// Remove all characters from string ignoring characters between "a" and "z" +println(govalidator.WhiteList("a3a43a5a4a3a2a23a4a5a4a3a4", "a-z") == "aaaaaaaaaaaa") +``` + +###### Custom validation functions +Custom validation using your own domain specific validators is also available - here's an example of how to use it: +```go +import "github.com/asaskevich/govalidator" + +type CustomByteArray [6]byte // custom types are supported and can be validated + +type StructWithCustomByteArray struct { + ID CustomByteArray `valid:"customByteArrayValidator,customMinLengthValidator"` // multiple custom validators are possible as well and will be evaluated in sequence + Email string `valid:"email"` + CustomMinLength int `valid:"-"` +} + +govalidator.CustomTypeTagMap.Set("customByteArrayValidator", CustomTypeValidator(func(i interface{}, context interface{}) bool { + switch v := context.(type) { // you can type switch on the context interface being validated + case StructWithCustomByteArray: + // you can check and validate against some other field in the context, + // return early or not validate against the context at all – your choice + case SomeOtherType: + // ... + default: + // expecting some other type? Throw/panic here or continue + } + + switch v := i.(type) { // type switch on the struct field being validated + case CustomByteArray: + for _, e := range v { // this validator checks that the byte array is not empty, i.e. not all zeroes + if e != 0 { + return true + } + } + } + return false +})) +govalidator.CustomTypeTagMap.Set("customMinLengthValidator", CustomTypeValidator(func(i interface{}, context interface{}) bool { + switch v := context.(type) { // this validates a field against the value in another field, i.e. dependent validation + case StructWithCustomByteArray: + return len(v.ID) >= v.CustomMinLength + } + return false +})) +``` + +#### Notes +Documentation is available here: [godoc.org](https://godoc.org/github.com/asaskevich/govalidator). +Full information about code coverage is also available here: [govalidator on gocover.io](http://gocover.io/github.com/asaskevich/govalidator). + +#### Support +If you do have a contribution for the package feel free to put up a Pull Request or open Issue. + +#### Special thanks to [contributors](https://github.com/asaskevich/govalidator/graphs/contributors) +* [Daniel Lohse](https://github.com/annismckenzie) +* [Attila Oláh](https://github.com/attilaolah) +* [Daniel Korner](https://github.com/Dadie) +* [Steven Wilkin](https://github.com/stevenwilkin) +* [Deiwin Sarjas](https://github.com/deiwin) +* [Noah Shibley](https://github.com/slugmobile) +* [Nathan Davies](https://github.com/nathj07) +* [Matt Sanford](https://github.com/mzsanford) +* [Simon ccl1115](https://github.com/ccl1115) diff --git a/vendor/github.com/asaskevich/govalidator/arrays.go b/vendor/github.com/asaskevich/govalidator/arrays.go new file mode 100644 index 0000000..5bace26 --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/arrays.go @@ -0,0 +1,58 @@ +package govalidator + +// Iterator is the function that accepts element of slice/array and its index +type Iterator func(interface{}, int) + +// ResultIterator is the function that accepts element of slice/array and its index and returns any result +type ResultIterator func(interface{}, int) interface{} + +// ConditionIterator is the function that accepts element of slice/array and its index and returns boolean +type ConditionIterator func(interface{}, int) bool + +// Each iterates over the slice and apply Iterator to every item +func Each(array []interface{}, iterator Iterator) { + for index, data := range array { + iterator(data, index) + } +} + +// Map iterates over the slice and apply ResultIterator to every item. Returns new slice as a result. +func Map(array []interface{}, iterator ResultIterator) []interface{} { + var result = make([]interface{}, len(array)) + for index, data := range array { + result[index] = iterator(data, index) + } + return result +} + +// Find iterates over the slice and apply ConditionIterator to every item. Returns first item that meet ConditionIterator or nil otherwise. +func Find(array []interface{}, iterator ConditionIterator) interface{} { + for index, data := range array { + if iterator(data, index) { + return data + } + } + return nil +} + +// Filter iterates over the slice and apply ConditionIterator to every item. Returns new slice. +func Filter(array []interface{}, iterator ConditionIterator) []interface{} { + var result = make([]interface{}, 0) + for index, data := range array { + if iterator(data, index) { + result = append(result, data) + } + } + return result +} + +// Count iterates over the slice and apply ConditionIterator to every item. Returns count of items that meets ConditionIterator. +func Count(array []interface{}, iterator ConditionIterator) int { + count := 0 + for index, data := range array { + if iterator(data, index) { + count = count + 1 + } + } + return count +} diff --git a/vendor/github.com/asaskevich/govalidator/converter.go b/vendor/github.com/asaskevich/govalidator/converter.go new file mode 100644 index 0000000..737a1f1 --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/converter.go @@ -0,0 +1,49 @@ +package govalidator + +import ( + "encoding/json" + "fmt" + "strconv" +) + +// ToString convert the input to a string. +func ToString(obj interface{}) string { + res := fmt.Sprintf("%v", obj) + return string(res) +} + +// ToJSON convert the input to a valid JSON string +func ToJSON(obj interface{}) (string, error) { + res, err := json.Marshal(obj) + if err != nil { + res = []byte("") + } + return string(res), err +} + +// ToFloat convert the input string to a float, or 0.0 if the input is not a float. +func ToFloat(str string) (float64, error) { + res, err := strconv.ParseFloat(str, 64) + if err != nil { + res = 0.0 + } + return res, err +} + +// ToInt convert the input string to an integer, or 0 if the input is not an integer. +func ToInt(str string) (int64, error) { + res, err := strconv.ParseInt(str, 0, 64) + if err != nil { + res = 0 + } + return res, err +} + +// ToBoolean convert the input string to a boolean. +func ToBoolean(str string) (bool, error) { + res, err := strconv.ParseBool(str) + if err != nil { + res = false + } + return res, err +} diff --git a/vendor/github.com/asaskevich/govalidator/error.go b/vendor/github.com/asaskevich/govalidator/error.go new file mode 100644 index 0000000..280b1c4 --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/error.go @@ -0,0 +1,31 @@ +package govalidator + +// Errors is an array of multiple errors and conforms to the error interface. +type Errors []error + +// Errors returns itself. +func (es Errors) Errors() []error { + return es +} + +func (es Errors) Error() string { + var err string + for _, e := range es { + err += e.Error() + ";" + } + return err +} + +// Error encapsulates a name, an error and whether there's a custom error message or not. +type Error struct { + Name string + Err error + CustomErrorMessageExists bool +} + +func (e Error) Error() string { + if e.CustomErrorMessageExists { + return e.Err.Error() + } + return e.Name + ": " + e.Err.Error() +} diff --git a/vendor/github.com/asaskevich/govalidator/numerics.go b/vendor/github.com/asaskevich/govalidator/numerics.go new file mode 100644 index 0000000..737cd47 --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/numerics.go @@ -0,0 +1,57 @@ +package govalidator + +import "math" + +// Abs returns absolute value of number +func Abs(value float64) float64 { + return value * Sign(value) +} + +// Sign returns signum of number: 1 in case of value > 0, -1 in case of value < 0, 0 otherwise +func Sign(value float64) float64 { + if value > 0 { + return 1 + } else if value < 0 { + return -1 + } else { + return 0 + } +} + +// IsNegative returns true if value < 0 +func IsNegative(value float64) bool { + return value < 0 +} + +// IsPositive returns true if value > 0 +func IsPositive(value float64) bool { + return value > 0 +} + +// IsNonNegative returns true if value >= 0 +func IsNonNegative(value float64) bool { + return value >= 0 +} + +// IsNonPositive returns true if value <= 0 +func IsNonPositive(value float64) bool { + return value <= 0 +} + +// InRange returns true if value lies between left and right border +func InRange(value, left, right float64) bool { + if left > right { + left, right = right, left + } + return value >= left && value <= right +} + +// IsWhole returns true if value is whole number +func IsWhole(value float64) bool { + return Abs(math.Remainder(value, 1)) == 0 +} + +// IsNatural returns true if value is natural number (positive and whole) +func IsNatural(value float64) bool { + return IsWhole(value) && IsPositive(value) +} diff --git a/vendor/github.com/asaskevich/govalidator/patterns.go b/vendor/github.com/asaskevich/govalidator/patterns.go new file mode 100644 index 0000000..2aa41ab --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/patterns.go @@ -0,0 +1,91 @@ +package govalidator + +import "regexp" + +// Basic regular expressions for validating strings +const ( + Email string = "^(((([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+(\\.([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+)*)|((\\x22)((((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(([\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]|\\x21|[\\x23-\\x5b]|[\\x5d-\\x7e]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(\\([\\x01-\\x09\\x0b\\x0c\\x0d-\\x7f]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}]))))*(((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(\\x22)))@((([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])([a-zA-Z]|\\d|-|\\.|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.)+(([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])([a-zA-Z]|\\d|-|\\.|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.?$" + CreditCard string = "^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\d{3})\\d{11})$" + ISBN10 string = "^(?:[0-9]{9}X|[0-9]{10})$" + ISBN13 string = "^(?:[0-9]{13})$" + UUID3 string = "^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$" + UUID4 string = "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" + UUID5 string = "^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" + UUID string = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$" + Alpha string = "^[a-zA-Z]+$" + Alphanumeric string = "^[a-zA-Z0-9]+$" + Numeric string = "^[-+]?[0-9]+$" + Int string = "^(?:[-+]?(?:0|[1-9][0-9]*))$" + Float string = "^(?:[-+]?(?:[0-9]+))?(?:\\.[0-9]*)?(?:[eE][\\+\\-]?(?:[0-9]+))?$" + Hexadecimal string = "^[0-9a-fA-F]+$" + Hexcolor string = "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$" + RGBcolor string = "^rgb\\(\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*\\)$" + ASCII string = "^[\x00-\x7F]+$" + Multibyte string = "[^\x00-\x7F]" + FullWidth string = "[^\u0020-\u007E\uFF61-\uFF9F\uFFA0-\uFFDC\uFFE8-\uFFEE0-9a-zA-Z]" + HalfWidth string = "[\u0020-\u007E\uFF61-\uFF9F\uFFA0-\uFFDC\uFFE8-\uFFEE0-9a-zA-Z]" + Base64 string = "^(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{2}==|[A-Za-z0-9+\\/]{3}=|[A-Za-z0-9+\\/]{4})$" + PrintableASCII string = "^[\x20-\x7E]+$" + DataURI string = "^data:.+\\/(.+);base64$" + Latitude string = "^[-+]?([1-8]?\\d(\\.\\d+)?|90(\\.0+)?)$" + Longitude string = "^[-+]?(180(\\.0+)?|((1[0-7]\\d)|([1-9]?\\d))(\\.\\d+)?)$" + DNSName string = `^([a-zA-Z0-9]{1}[a-zA-Z0-9_-]{1,62}){1}(\.[a-zA-Z0-9]{1}[a-zA-Z0-9_-]{1,62})*$` + IP string = `(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))` + URLSchema string = `((ftp|tcp|udp|wss?|https?):\/\/)` + URLUsername string = `(\S+(:\S*)?@)` + Hostname string = `` + URLPath string = `((\/|\?|#)[^\s]*)` + URLPort string = `(:(\d{1,5}))` + URLIP string = `([1-9]\d?|1\d\d|2[01]\d|22[0-3])(\.(1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.([0-9]\d?|1\d\d|2[0-4]\d|25[0-4]))` + URLSubdomain string = `((www\.)|([a-zA-Z0-9]([-\.][a-zA-Z0-9]+)*))` + URL string = `^` + URLSchema + `?` + URLUsername + `?` + `((` + URLIP + `|(\[` + IP + `\])|(([a-zA-Z0-9]([a-zA-Z0-9-]+)?[a-zA-Z0-9]([-\.][a-zA-Z0-9]+)*)|(` + URLSubdomain + `?))?(([a-zA-Z\x{00a1}-\x{ffff}0-9]+-?-?)*[a-zA-Z\x{00a1}-\x{ffff}0-9]+)(?:\.([a-zA-Z\x{00a1}-\x{ffff}]{1,}))?))` + URLPort + `?` + URLPath + `?$` + SSN string = `^\d{3}[- ]?\d{2}[- ]?\d{4}$` + WinPath string = `^[a-zA-Z]:\\(?:[^\\/:*?"<>|\r\n]+\\)*[^\\/:*?"<>|\r\n]*$` + UnixPath string = `^((?:\/[a-zA-Z0-9\.\:]+(?:_[a-zA-Z0-9\:\.]+)*(?:\-[\:a-zA-Z0-9\.]+)*)+\/?)$` + Semver string = "^v?(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)(-(0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(\\.(0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\\+[0-9a-zA-Z-]+(\\.[0-9a-zA-Z-]+)*)?$" + tagName string = "valid" +) + +// Used by IsFilePath func +const ( + // Unknown is unresolved OS type + Unknown = iota + // Win is Windows type + Win + // Unix is *nix OS types + Unix +) + +var ( + rxEmail = regexp.MustCompile(Email) + rxCreditCard = regexp.MustCompile(CreditCard) + rxISBN10 = regexp.MustCompile(ISBN10) + rxISBN13 = regexp.MustCompile(ISBN13) + rxUUID3 = regexp.MustCompile(UUID3) + rxUUID4 = regexp.MustCompile(UUID4) + rxUUID5 = regexp.MustCompile(UUID5) + rxUUID = regexp.MustCompile(UUID) + rxAlpha = regexp.MustCompile(Alpha) + rxAlphanumeric = regexp.MustCompile(Alphanumeric) + rxNumeric = regexp.MustCompile(Numeric) + rxInt = regexp.MustCompile(Int) + rxFloat = regexp.MustCompile(Float) + rxHexadecimal = regexp.MustCompile(Hexadecimal) + rxHexcolor = regexp.MustCompile(Hexcolor) + rxRGBcolor = regexp.MustCompile(RGBcolor) + rxASCII = regexp.MustCompile(ASCII) + rxPrintableASCII = regexp.MustCompile(PrintableASCII) + rxMultibyte = regexp.MustCompile(Multibyte) + rxFullWidth = regexp.MustCompile(FullWidth) + rxHalfWidth = regexp.MustCompile(HalfWidth) + rxBase64 = regexp.MustCompile(Base64) + rxDataURI = regexp.MustCompile(DataURI) + rxLatitude = regexp.MustCompile(Latitude) + rxLongitude = regexp.MustCompile(Longitude) + rxDNSName = regexp.MustCompile(DNSName) + rxURL = regexp.MustCompile(URL) + rxSSN = regexp.MustCompile(SSN) + rxWinPath = regexp.MustCompile(WinPath) + rxUnixPath = regexp.MustCompile(UnixPath) + rxSemver = regexp.MustCompile(Semver) +) diff --git a/vendor/github.com/asaskevich/govalidator/types.go b/vendor/github.com/asaskevich/govalidator/types.go new file mode 100644 index 0000000..b715612 --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/types.go @@ -0,0 +1,378 @@ +package govalidator + +import ( + "reflect" + "regexp" + "sync" +) + +// Validator is a wrapper for a validator function that returns bool and accepts string. +type Validator func(str string) bool + +// CustomTypeValidator is a wrapper for validator functions that returns bool and accepts any type. +// The second parameter should be the context (in the case of validating a struct: the whole object being validated). +type CustomTypeValidator func(i interface{}, o interface{}) bool + +// ParamValidator is a wrapper for validator functions that accepts additional parameters. +type ParamValidator func(str string, params ...string) bool +type tagOptionsMap map[string]string + +// UnsupportedTypeError is a wrapper for reflect.Type +type UnsupportedTypeError struct { + Type reflect.Type +} + +// stringValues is a slice of reflect.Value holding *reflect.StringValue. +// It implements the methods to sort by string. +type stringValues []reflect.Value + +// ParamTagMap is a map of functions accept variants parameters +var ParamTagMap = map[string]ParamValidator{ + "length": ByteLength, + "stringlength": StringLength, + "matches": StringMatches, +} + +// ParamTagRegexMap maps param tags to their respective regexes. +var ParamTagRegexMap = map[string]*regexp.Regexp{ + "length": regexp.MustCompile("^length\\((\\d+)\\|(\\d+)\\)$"), + "stringlength": regexp.MustCompile("^stringlength\\((\\d+)\\|(\\d+)\\)$"), + "matches": regexp.MustCompile(`matches\(([^)]+)\)`), +} + +type customTypeTagMap struct { + validators map[string]CustomTypeValidator + + sync.RWMutex +} + +func (tm *customTypeTagMap) Get(name string) (CustomTypeValidator, bool) { + tm.RLock() + defer tm.RUnlock() + v, ok := tm.validators[name] + return v, ok +} + +func (tm *customTypeTagMap) Set(name string, ctv CustomTypeValidator) { + tm.Lock() + defer tm.Unlock() + tm.validators[name] = ctv +} + +// CustomTypeTagMap is a map of functions that can be used as tags for ValidateStruct function. +// Use this to validate compound or custom types that need to be handled as a whole, e.g. +// `type UUID [16]byte` (this would be handled as an array of bytes). +var CustomTypeTagMap = &customTypeTagMap{validators: make(map[string]CustomTypeValidator)} + +// TagMap is a map of functions, that can be used as tags for ValidateStruct function. +var TagMap = map[string]Validator{ + "email": IsEmail, + "url": IsURL, + "dialstring": IsDialString, + "requrl": IsRequestURL, + "requri": IsRequestURI, + "alpha": IsAlpha, + "utfletter": IsUTFLetter, + "alphanum": IsAlphanumeric, + "utfletternum": IsUTFLetterNumeric, + "numeric": IsNumeric, + "utfnumeric": IsUTFNumeric, + "utfdigit": IsUTFDigit, + "hexadecimal": IsHexadecimal, + "hexcolor": IsHexcolor, + "rgbcolor": IsRGBcolor, + "lowercase": IsLowerCase, + "uppercase": IsUpperCase, + "int": IsInt, + "float": IsFloat, + "null": IsNull, + "uuid": IsUUID, + "uuidv3": IsUUIDv3, + "uuidv4": IsUUIDv4, + "uuidv5": IsUUIDv5, + "creditcard": IsCreditCard, + "isbn10": IsISBN10, + "isbn13": IsISBN13, + "json": IsJSON, + "multibyte": IsMultibyte, + "ascii": IsASCII, + "printableascii": IsPrintableASCII, + "fullwidth": IsFullWidth, + "halfwidth": IsHalfWidth, + "variablewidth": IsVariableWidth, + "base64": IsBase64, + "datauri": IsDataURI, + "ip": IsIP, + "port": IsPort, + "ipv4": IsIPv4, + "ipv6": IsIPv6, + "dns": IsDNSName, + "host": IsHost, + "mac": IsMAC, + "latitude": IsLatitude, + "longitude": IsLongitude, + "ssn": IsSSN, + "semver": IsSemver, +} + +// ISO3166Entry stores country codes +type ISO3166Entry struct { + EnglishShortName string + FrenchShortName string + Alpha2Code string + Alpha3Code string + Numeric string +} + +//ISO3166List based on https://www.iso.org/obp/ui/#search/code/ Code Type "Officially Assigned Codes" +var ISO3166List = []ISO3166Entry{ + {"Afghanistan", "Afghanistan (l')", "AF", "AFG", "004"}, + {"Albania", "Albanie (l')", "AL", "ALB", "008"}, + {"Antarctica", "Antarctique (l')", "AQ", "ATA", "010"}, + {"Algeria", "Algérie (l')", "DZ", "DZA", "012"}, + {"American Samoa", "Samoa américaines (les)", "AS", "ASM", "016"}, + {"Andorra", "Andorre (l')", "AD", "AND", "020"}, + {"Angola", "Angola (l')", "AO", "AGO", "024"}, + {"Antigua and Barbuda", "Antigua-et-Barbuda", "AG", "ATG", "028"}, + {"Azerbaijan", "Azerbaïdjan (l')", "AZ", "AZE", "031"}, + {"Argentina", "Argentine (l')", "AR", "ARG", "032"}, + {"Australia", "Australie (l')", "AU", "AUS", "036"}, + {"Austria", "Autriche (l')", "AT", "AUT", "040"}, + {"Bahamas (the)", "Bahamas (les)", "BS", "BHS", "044"}, + {"Bahrain", "Bahreïn", "BH", "BHR", "048"}, + {"Bangladesh", "Bangladesh (le)", "BD", "BGD", "050"}, + {"Armenia", "Arménie (l')", "AM", "ARM", "051"}, + {"Barbados", "Barbade (la)", "BB", "BRB", "052"}, + {"Belgium", "Belgique (la)", "BE", "BEL", "056"}, + {"Bermuda", "Bermudes (les)", "BM", "BMU", "060"}, + {"Bhutan", "Bhoutan (le)", "BT", "BTN", "064"}, + {"Bolivia (Plurinational State of)", "Bolivie (État plurinational de)", "BO", "BOL", "068"}, + {"Bosnia and Herzegovina", "Bosnie-Herzégovine (la)", "BA", "BIH", "070"}, + {"Botswana", "Botswana (le)", "BW", "BWA", "072"}, + {"Bouvet Island", "Bouvet (l'Île)", "BV", "BVT", "074"}, + {"Brazil", "Brésil (le)", "BR", "BRA", "076"}, + {"Belize", "Belize (le)", "BZ", "BLZ", "084"}, + {"British Indian Ocean Territory (the)", "Indien (le Territoire britannique de l'océan)", "IO", "IOT", "086"}, + {"Solomon Islands", "Salomon (Îles)", "SB", "SLB", "090"}, + {"Virgin Islands (British)", "Vierges britanniques (les Îles)", "VG", "VGB", "092"}, + {"Brunei Darussalam", "Brunéi Darussalam (le)", "BN", "BRN", "096"}, + {"Bulgaria", "Bulgarie (la)", "BG", "BGR", "100"}, + {"Myanmar", "Myanmar (le)", "MM", "MMR", "104"}, + {"Burundi", "Burundi (le)", "BI", "BDI", "108"}, + {"Belarus", "Bélarus (le)", "BY", "BLR", "112"}, + {"Cambodia", "Cambodge (le)", "KH", "KHM", "116"}, + {"Cameroon", "Cameroun (le)", "CM", "CMR", "120"}, + {"Canada", "Canada (le)", "CA", "CAN", "124"}, + {"Cabo Verde", "Cabo Verde", "CV", "CPV", "132"}, + {"Cayman Islands (the)", "Caïmans (les Îles)", "KY", "CYM", "136"}, + {"Central African Republic (the)", "République centrafricaine (la)", "CF", "CAF", "140"}, + {"Sri Lanka", "Sri Lanka", "LK", "LKA", "144"}, + {"Chad", "Tchad (le)", "TD", "TCD", "148"}, + {"Chile", "Chili (le)", "CL", "CHL", "152"}, + {"China", "Chine (la)", "CN", "CHN", "156"}, + {"Taiwan (Province of China)", "Taïwan (Province de Chine)", "TW", "TWN", "158"}, + {"Christmas Island", "Christmas (l'Île)", "CX", "CXR", "162"}, + {"Cocos (Keeling) Islands (the)", "Cocos (les Îles)/ Keeling (les Îles)", "CC", "CCK", "166"}, + {"Colombia", "Colombie (la)", "CO", "COL", "170"}, + {"Comoros (the)", "Comores (les)", "KM", "COM", "174"}, + {"Mayotte", "Mayotte", "YT", "MYT", "175"}, + {"Congo (the)", "Congo (le)", "CG", "COG", "178"}, + {"Congo (the Democratic Republic of the)", "Congo (la République démocratique du)", "CD", "COD", "180"}, + {"Cook Islands (the)", "Cook (les Îles)", "CK", "COK", "184"}, + {"Costa Rica", "Costa Rica (le)", "CR", "CRI", "188"}, + {"Croatia", "Croatie (la)", "HR", "HRV", "191"}, + {"Cuba", "Cuba", "CU", "CUB", "192"}, + {"Cyprus", "Chypre", "CY", "CYP", "196"}, + {"Czech Republic (the)", "tchèque (la République)", "CZ", "CZE", "203"}, + {"Benin", "Bénin (le)", "BJ", "BEN", "204"}, + {"Denmark", "Danemark (le)", "DK", "DNK", "208"}, + {"Dominica", "Dominique (la)", "DM", "DMA", "212"}, + {"Dominican Republic (the)", "dominicaine (la République)", "DO", "DOM", "214"}, + {"Ecuador", "Équateur (l')", "EC", "ECU", "218"}, + {"El Salvador", "El Salvador", "SV", "SLV", "222"}, + {"Equatorial Guinea", "Guinée équatoriale (la)", "GQ", "GNQ", "226"}, + {"Ethiopia", "Éthiopie (l')", "ET", "ETH", "231"}, + {"Eritrea", "Érythrée (l')", "ER", "ERI", "232"}, + {"Estonia", "Estonie (l')", "EE", "EST", "233"}, + {"Faroe Islands (the)", "Féroé (les Îles)", "FO", "FRO", "234"}, + {"Falkland Islands (the) [Malvinas]", "Falkland (les Îles)/Malouines (les Îles)", "FK", "FLK", "238"}, + {"South Georgia and the South Sandwich Islands", "Géorgie du Sud-et-les Îles Sandwich du Sud (la)", "GS", "SGS", "239"}, + {"Fiji", "Fidji (les)", "FJ", "FJI", "242"}, + {"Finland", "Finlande (la)", "FI", "FIN", "246"}, + {"Åland Islands", "Åland(les Îles)", "AX", "ALA", "248"}, + {"France", "France (la)", "FR", "FRA", "250"}, + {"French Guiana", "Guyane française (la )", "GF", "GUF", "254"}, + {"French Polynesia", "Polynésie française (la)", "PF", "PYF", "258"}, + {"French Southern Territories (the)", "Terres australes françaises (les)", "TF", "ATF", "260"}, + {"Djibouti", "Djibouti", "DJ", "DJI", "262"}, + {"Gabon", "Gabon (le)", "GA", "GAB", "266"}, + {"Georgia", "Géorgie (la)", "GE", "GEO", "268"}, + {"Gambia (the)", "Gambie (la)", "GM", "GMB", "270"}, + {"Palestine, State of", "Palestine, État de", "PS", "PSE", "275"}, + {"Germany", "Allemagne (l')", "DE", "DEU", "276"}, + {"Ghana", "Ghana (le)", "GH", "GHA", "288"}, + {"Gibraltar", "Gibraltar", "GI", "GIB", "292"}, + {"Kiribati", "Kiribati", "KI", "KIR", "296"}, + {"Greece", "Grèce (la)", "GR", "GRC", "300"}, + {"Greenland", "Groenland (le)", "GL", "GRL", "304"}, + {"Grenada", "Grenade (la)", "GD", "GRD", "308"}, + {"Guadeloupe", "Guadeloupe (la)", "GP", "GLP", "312"}, + {"Guam", "Guam", "GU", "GUM", "316"}, + {"Guatemala", "Guatemala (le)", "GT", "GTM", "320"}, + {"Guinea", "Guinée (la)", "GN", "GIN", "324"}, + {"Guyana", "Guyana (le)", "GY", "GUY", "328"}, + {"Haiti", "Haïti", "HT", "HTI", "332"}, + {"Heard Island and McDonald Islands", "Heard-et-Îles MacDonald (l'Île)", "HM", "HMD", "334"}, + {"Holy See (the)", "Saint-Siège (le)", "VA", "VAT", "336"}, + {"Honduras", "Honduras (le)", "HN", "HND", "340"}, + {"Hong Kong", "Hong Kong", "HK", "HKG", "344"}, + {"Hungary", "Hongrie (la)", "HU", "HUN", "348"}, + {"Iceland", "Islande (l')", "IS", "ISL", "352"}, + {"India", "Inde (l')", "IN", "IND", "356"}, + {"Indonesia", "Indonésie (l')", "ID", "IDN", "360"}, + {"Iran (Islamic Republic of)", "Iran (République Islamique d')", "IR", "IRN", "364"}, + {"Iraq", "Iraq (l')", "IQ", "IRQ", "368"}, + {"Ireland", "Irlande (l')", "IE", "IRL", "372"}, + {"Israel", "Israël", "IL", "ISR", "376"}, + {"Italy", "Italie (l')", "IT", "ITA", "380"}, + {"Côte d'Ivoire", "Côte d'Ivoire (la)", "CI", "CIV", "384"}, + {"Jamaica", "Jamaïque (la)", "JM", "JAM", "388"}, + {"Japan", "Japon (le)", "JP", "JPN", "392"}, + {"Kazakhstan", "Kazakhstan (le)", "KZ", "KAZ", "398"}, + {"Jordan", "Jordanie (la)", "JO", "JOR", "400"}, + {"Kenya", "Kenya (le)", "KE", "KEN", "404"}, + {"Korea (the Democratic People's Republic of)", "Corée (la République populaire démocratique de)", "KP", "PRK", "408"}, + {"Korea (the Republic of)", "Corée (la République de)", "KR", "KOR", "410"}, + {"Kuwait", "Koweït (le)", "KW", "KWT", "414"}, + {"Kyrgyzstan", "Kirghizistan (le)", "KG", "KGZ", "417"}, + {"Lao People's Democratic Republic (the)", "Lao, République démocratique populaire", "LA", "LAO", "418"}, + {"Lebanon", "Liban (le)", "LB", "LBN", "422"}, + {"Lesotho", "Lesotho (le)", "LS", "LSO", "426"}, + {"Latvia", "Lettonie (la)", "LV", "LVA", "428"}, + {"Liberia", "Libéria (le)", "LR", "LBR", "430"}, + {"Libya", "Libye (la)", "LY", "LBY", "434"}, + {"Liechtenstein", "Liechtenstein (le)", "LI", "LIE", "438"}, + {"Lithuania", "Lituanie (la)", "LT", "LTU", "440"}, + {"Luxembourg", "Luxembourg (le)", "LU", "LUX", "442"}, + {"Macao", "Macao", "MO", "MAC", "446"}, + {"Madagascar", "Madagascar", "MG", "MDG", "450"}, + {"Malawi", "Malawi (le)", "MW", "MWI", "454"}, + {"Malaysia", "Malaisie (la)", "MY", "MYS", "458"}, + {"Maldives", "Maldives (les)", "MV", "MDV", "462"}, + {"Mali", "Mali (le)", "ML", "MLI", "466"}, + {"Malta", "Malte", "MT", "MLT", "470"}, + {"Martinique", "Martinique (la)", "MQ", "MTQ", "474"}, + {"Mauritania", "Mauritanie (la)", "MR", "MRT", "478"}, + {"Mauritius", "Maurice", "MU", "MUS", "480"}, + {"Mexico", "Mexique (le)", "MX", "MEX", "484"}, + {"Monaco", "Monaco", "MC", "MCO", "492"}, + {"Mongolia", "Mongolie (la)", "MN", "MNG", "496"}, + {"Moldova (the Republic of)", "Moldova , République de", "MD", "MDA", "498"}, + {"Montenegro", "Monténégro (le)", "ME", "MNE", "499"}, + {"Montserrat", "Montserrat", "MS", "MSR", "500"}, + {"Morocco", "Maroc (le)", "MA", "MAR", "504"}, + {"Mozambique", "Mozambique (le)", "MZ", "MOZ", "508"}, + {"Oman", "Oman", "OM", "OMN", "512"}, + {"Namibia", "Namibie (la)", "NA", "NAM", "516"}, + {"Nauru", "Nauru", "NR", "NRU", "520"}, + {"Nepal", "Népal (le)", "NP", "NPL", "524"}, + {"Netherlands (the)", "Pays-Bas (les)", "NL", "NLD", "528"}, + {"Curaçao", "Curaçao", "CW", "CUW", "531"}, + {"Aruba", "Aruba", "AW", "ABW", "533"}, + {"Sint Maarten (Dutch part)", "Saint-Martin (partie néerlandaise)", "SX", "SXM", "534"}, + {"Bonaire, Sint Eustatius and Saba", "Bonaire, Saint-Eustache et Saba", "BQ", "BES", "535"}, + {"New Caledonia", "Nouvelle-Calédonie (la)", "NC", "NCL", "540"}, + {"Vanuatu", "Vanuatu (le)", "VU", "VUT", "548"}, + {"New Zealand", "Nouvelle-Zélande (la)", "NZ", "NZL", "554"}, + {"Nicaragua", "Nicaragua (le)", "NI", "NIC", "558"}, + {"Niger (the)", "Niger (le)", "NE", "NER", "562"}, + {"Nigeria", "Nigéria (le)", "NG", "NGA", "566"}, + {"Niue", "Niue", "NU", "NIU", "570"}, + {"Norfolk Island", "Norfolk (l'Île)", "NF", "NFK", "574"}, + {"Norway", "Norvège (la)", "NO", "NOR", "578"}, + {"Northern Mariana Islands (the)", "Mariannes du Nord (les Îles)", "MP", "MNP", "580"}, + {"United States Minor Outlying Islands (the)", "Îles mineures éloignées des États-Unis (les)", "UM", "UMI", "581"}, + {"Micronesia (Federated States of)", "Micronésie (États fédérés de)", "FM", "FSM", "583"}, + {"Marshall Islands (the)", "Marshall (Îles)", "MH", "MHL", "584"}, + {"Palau", "Palaos (les)", "PW", "PLW", "585"}, + {"Pakistan", "Pakistan (le)", "PK", "PAK", "586"}, + {"Panama", "Panama (le)", "PA", "PAN", "591"}, + {"Papua New Guinea", "Papouasie-Nouvelle-Guinée (la)", "PG", "PNG", "598"}, + {"Paraguay", "Paraguay (le)", "PY", "PRY", "600"}, + {"Peru", "Pérou (le)", "PE", "PER", "604"}, + {"Philippines (the)", "Philippines (les)", "PH", "PHL", "608"}, + {"Pitcairn", "Pitcairn", "PN", "PCN", "612"}, + {"Poland", "Pologne (la)", "PL", "POL", "616"}, + {"Portugal", "Portugal (le)", "PT", "PRT", "620"}, + {"Guinea-Bissau", "Guinée-Bissau (la)", "GW", "GNB", "624"}, + {"Timor-Leste", "Timor-Leste (le)", "TL", "TLS", "626"}, + {"Puerto Rico", "Porto Rico", "PR", "PRI", "630"}, + {"Qatar", "Qatar (le)", "QA", "QAT", "634"}, + {"Réunion", "Réunion (La)", "RE", "REU", "638"}, + {"Romania", "Roumanie (la)", "RO", "ROU", "642"}, + {"Russian Federation (the)", "Russie (la Fédération de)", "RU", "RUS", "643"}, + {"Rwanda", "Rwanda (le)", "RW", "RWA", "646"}, + {"Saint Barthélemy", "Saint-Barthélemy", "BL", "BLM", "652"}, + {"Saint Helena, Ascension and Tristan da Cunha", "Sainte-Hélène, Ascension et Tristan da Cunha", "SH", "SHN", "654"}, + {"Saint Kitts and Nevis", "Saint-Kitts-et-Nevis", "KN", "KNA", "659"}, + {"Anguilla", "Anguilla", "AI", "AIA", "660"}, + {"Saint Lucia", "Sainte-Lucie", "LC", "LCA", "662"}, + {"Saint Martin (French part)", "Saint-Martin (partie française)", "MF", "MAF", "663"}, + {"Saint Pierre and Miquelon", "Saint-Pierre-et-Miquelon", "PM", "SPM", "666"}, + {"Saint Vincent and the Grenadines", "Saint-Vincent-et-les Grenadines", "VC", "VCT", "670"}, + {"San Marino", "Saint-Marin", "SM", "SMR", "674"}, + {"Sao Tome and Principe", "Sao Tomé-et-Principe", "ST", "STP", "678"}, + {"Saudi Arabia", "Arabie saoudite (l')", "SA", "SAU", "682"}, + {"Senegal", "Sénégal (le)", "SN", "SEN", "686"}, + {"Serbia", "Serbie (la)", "RS", "SRB", "688"}, + {"Seychelles", "Seychelles (les)", "SC", "SYC", "690"}, + {"Sierra Leone", "Sierra Leone (la)", "SL", "SLE", "694"}, + {"Singapore", "Singapour", "SG", "SGP", "702"}, + {"Slovakia", "Slovaquie (la)", "SK", "SVK", "703"}, + {"Viet Nam", "Viet Nam (le)", "VN", "VNM", "704"}, + {"Slovenia", "Slovénie (la)", "SI", "SVN", "705"}, + {"Somalia", "Somalie (la)", "SO", "SOM", "706"}, + {"South Africa", "Afrique du Sud (l')", "ZA", "ZAF", "710"}, + {"Zimbabwe", "Zimbabwe (le)", "ZW", "ZWE", "716"}, + {"Spain", "Espagne (l')", "ES", "ESP", "724"}, + {"South Sudan", "Soudan du Sud (le)", "SS", "SSD", "728"}, + {"Sudan (the)", "Soudan (le)", "SD", "SDN", "729"}, + {"Western Sahara*", "Sahara occidental (le)*", "EH", "ESH", "732"}, + {"Suriname", "Suriname (le)", "SR", "SUR", "740"}, + {"Svalbard and Jan Mayen", "Svalbard et l'Île Jan Mayen (le)", "SJ", "SJM", "744"}, + {"Swaziland", "Swaziland (le)", "SZ", "SWZ", "748"}, + {"Sweden", "Suède (la)", "SE", "SWE", "752"}, + {"Switzerland", "Suisse (la)", "CH", "CHE", "756"}, + {"Syrian Arab Republic", "République arabe syrienne (la)", "SY", "SYR", "760"}, + {"Tajikistan", "Tadjikistan (le)", "TJ", "TJK", "762"}, + {"Thailand", "Thaïlande (la)", "TH", "THA", "764"}, + {"Togo", "Togo (le)", "TG", "TGO", "768"}, + {"Tokelau", "Tokelau (les)", "TK", "TKL", "772"}, + {"Tonga", "Tonga (les)", "TO", "TON", "776"}, + {"Trinidad and Tobago", "Trinité-et-Tobago (la)", "TT", "TTO", "780"}, + {"United Arab Emirates (the)", "Émirats arabes unis (les)", "AE", "ARE", "784"}, + {"Tunisia", "Tunisie (la)", "TN", "TUN", "788"}, + {"Turkey", "Turquie (la)", "TR", "TUR", "792"}, + {"Turkmenistan", "Turkménistan (le)", "TM", "TKM", "795"}, + {"Turks and Caicos Islands (the)", "Turks-et-Caïcos (les Îles)", "TC", "TCA", "796"}, + {"Tuvalu", "Tuvalu (les)", "TV", "TUV", "798"}, + {"Uganda", "Ouganda (l')", "UG", "UGA", "800"}, + {"Ukraine", "Ukraine (l')", "UA", "UKR", "804"}, + {"Macedonia (the former Yugoslav Republic of)", "Macédoine (l'ex‑République yougoslave de)", "MK", "MKD", "807"}, + {"Egypt", "Égypte (l')", "EG", "EGY", "818"}, + {"United Kingdom of Great Britain and Northern Ireland (the)", "Royaume-Uni de Grande-Bretagne et d'Irlande du Nord (le)", "GB", "GBR", "826"}, + {"Guernsey", "Guernesey", "GG", "GGY", "831"}, + {"Jersey", "Jersey", "JE", "JEY", "832"}, + {"Isle of Man", "Île de Man", "IM", "IMN", "833"}, + {"Tanzania, United Republic of", "Tanzanie, République-Unie de", "TZ", "TZA", "834"}, + {"United States of America (the)", "États-Unis d'Amérique (les)", "US", "USA", "840"}, + {"Virgin Islands (U.S.)", "Vierges des États-Unis (les Îles)", "VI", "VIR", "850"}, + {"Burkina Faso", "Burkina Faso (le)", "BF", "BFA", "854"}, + {"Uruguay", "Uruguay (l')", "UY", "URY", "858"}, + {"Uzbekistan", "Ouzbékistan (l')", "UZ", "UZB", "860"}, + {"Venezuela (Bolivarian Republic of)", "Venezuela (République bolivarienne du)", "VE", "VEN", "862"}, + {"Wallis and Futuna", "Wallis-et-Futuna", "WF", "WLF", "876"}, + {"Samoa", "Samoa (le)", "WS", "WSM", "882"}, + {"Yemen", "Yémen (le)", "YE", "YEM", "887"}, + {"Zambia", "Zambie (la)", "ZM", "ZMB", "894"}, +} diff --git a/vendor/github.com/asaskevich/govalidator/utils.go b/vendor/github.com/asaskevich/govalidator/utils.go new file mode 100644 index 0000000..200b913 --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/utils.go @@ -0,0 +1,213 @@ +package govalidator + +import ( + "errors" + "fmt" + "html" + "path" + "regexp" + "strings" + "unicode" +) + +// Contains check if the string contains the substring. +func Contains(str, substring string) bool { + return strings.Contains(str, substring) +} + +// Matches check if string matches the pattern (pattern is regular expression) +// In case of error return false +func Matches(str, pattern string) bool { + match, _ := regexp.MatchString(pattern, str) + return match +} + +// LeftTrim trim characters from the left-side of the input. +// If second argument is empty, it's will be remove leading spaces. +func LeftTrim(str, chars string) string { + pattern := "" + if chars == "" { + pattern = "^\\s+" + } else { + pattern = "^[" + chars + "]+" + } + r, _ := regexp.Compile(pattern) + return string(r.ReplaceAll([]byte(str), []byte(""))) +} + +// RightTrim trim characters from the right-side of the input. +// If second argument is empty, it's will be remove spaces. +func RightTrim(str, chars string) string { + pattern := "" + if chars == "" { + pattern = "\\s+$" + } else { + pattern = "[" + chars + "]+$" + } + r, _ := regexp.Compile(pattern) + return string(r.ReplaceAll([]byte(str), []byte(""))) +} + +// Trim trim characters from both sides of the input. +// If second argument is empty, it's will be remove spaces. +func Trim(str, chars string) string { + return LeftTrim(RightTrim(str, chars), chars) +} + +// WhiteList remove characters that do not appear in the whitelist. +func WhiteList(str, chars string) string { + pattern := "[^" + chars + "]+" + r, _ := regexp.Compile(pattern) + return string(r.ReplaceAll([]byte(str), []byte(""))) +} + +// BlackList remove characters that appear in the blacklist. +func BlackList(str, chars string) string { + pattern := "[" + chars + "]+" + r, _ := regexp.Compile(pattern) + return string(r.ReplaceAll([]byte(str), []byte(""))) +} + +// StripLow remove characters with a numerical value < 32 and 127, mostly control characters. +// If keep_new_lines is true, newline characters are preserved (\n and \r, hex 0xA and 0xD). +func StripLow(str string, keepNewLines bool) string { + chars := "" + if keepNewLines { + chars = "\x00-\x09\x0B\x0C\x0E-\x1F\x7F" + } else { + chars = "\x00-\x1F\x7F" + } + return BlackList(str, chars) +} + +// ReplacePattern replace regular expression pattern in string +func ReplacePattern(str, pattern, replace string) string { + r, _ := regexp.Compile(pattern) + return string(r.ReplaceAll([]byte(str), []byte(replace))) +} + +// Escape replace <, >, & and " with HTML entities. +var Escape = html.EscapeString + +func addSegment(inrune, segment []rune) []rune { + if len(segment) == 0 { + return inrune + } + if len(inrune) != 0 { + inrune = append(inrune, '_') + } + inrune = append(inrune, segment...) + return inrune +} + +// UnderscoreToCamelCase converts from underscore separated form to camel case form. +// Ex.: my_func => MyFunc +func UnderscoreToCamelCase(s string) string { + return strings.Replace(strings.Title(strings.Replace(strings.ToLower(s), "_", " ", -1)), " ", "", -1) +} + +// CamelCaseToUnderscore converts from camel case form to underscore separated form. +// Ex.: MyFunc => my_func +func CamelCaseToUnderscore(str string) string { + var output []rune + var segment []rune + for _, r := range str { + if !unicode.IsLower(r) { + output = addSegment(output, segment) + segment = nil + } + segment = append(segment, unicode.ToLower(r)) + } + output = addSegment(output, segment) + return string(output) +} + +// Reverse return reversed string +func Reverse(s string) string { + r := []rune(s) + for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 { + r[i], r[j] = r[j], r[i] + } + return string(r) +} + +// GetLines split string by "\n" and return array of lines +func GetLines(s string) []string { + return strings.Split(s, "\n") +} + +// GetLine return specified line of multiline string +func GetLine(s string, index int) (string, error) { + lines := GetLines(s) + if index < 0 || index >= len(lines) { + return "", errors.New("line index out of bounds") + } + return lines[index], nil +} + +// RemoveTags remove all tags from HTML string +func RemoveTags(s string) string { + return ReplacePattern(s, "<[^>]*>", "") +} + +// SafeFileName return safe string that can be used in file names +func SafeFileName(str string) string { + name := strings.ToLower(str) + name = path.Clean(path.Base(name)) + name = strings.Trim(name, " ") + separators, err := regexp.Compile(`[ &_=+:]`) + if err == nil { + name = separators.ReplaceAllString(name, "-") + } + legal, err := regexp.Compile(`[^[:alnum:]-.]`) + if err == nil { + name = legal.ReplaceAllString(name, "") + } + for strings.Contains(name, "--") { + name = strings.Replace(name, "--", "-", -1) + } + return name +} + +// NormalizeEmail canonicalize an email address. +// The local part of the email address is lowercased for all domains; the hostname is always lowercased and +// the local part of the email address is always lowercased for hosts that are known to be case-insensitive (currently only GMail). +// Normalization follows special rules for known providers: currently, GMail addresses have dots removed in the local part and +// are stripped of tags (e.g. some.one+tag@gmail.com becomes someone@gmail.com) and all @googlemail.com addresses are +// normalized to @gmail.com. +func NormalizeEmail(str string) (string, error) { + if !IsEmail(str) { + return "", fmt.Errorf("%s is not an email", str) + } + parts := strings.Split(str, "@") + parts[0] = strings.ToLower(parts[0]) + parts[1] = strings.ToLower(parts[1]) + if parts[1] == "gmail.com" || parts[1] == "googlemail.com" { + parts[1] = "gmail.com" + parts[0] = strings.Split(ReplacePattern(parts[0], `\.`, ""), "+")[0] + } + return strings.Join(parts, "@"), nil +} + +// Truncate a string to the closest length without breaking words. +func Truncate(str string, length int, ending string) string { + var aftstr, befstr string + if len(str) > length { + words := strings.Fields(str) + before, present := 0, 0 + for i := range words { + befstr = aftstr + before = present + aftstr = aftstr + words[i] + " " + present = len(aftstr) + if present > length && i != 0 { + if (length - before) < (present - length) { + return Trim(befstr, " /\\.,\"'#!?&@+-") + ending + } + return Trim(aftstr, " /\\.,\"'#!?&@+-") + ending + } + } + } + + return str +} diff --git a/vendor/github.com/asaskevich/govalidator/validator.go b/vendor/github.com/asaskevich/govalidator/validator.go new file mode 100644 index 0000000..9cd5148 --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/validator.go @@ -0,0 +1,930 @@ +// Package govalidator is package of validators and sanitizers for strings, structs and collections. +package govalidator + +import ( + "encoding/json" + "fmt" + "net" + "net/url" + "reflect" + "regexp" + "sort" + "strconv" + "strings" + + "unicode" + "unicode/utf8" +) + +var fieldsRequiredByDefault bool + +// SetFieldsRequiredByDefault causes validation to fail when struct fields +// do not include validations or are not explicitly marked as exempt (using `valid:"-"` or `valid:"email,optional"`). +// This struct definition will fail govalidator.ValidateStruct() (and the field values do not matter): +// type exampleStruct struct { +// Name string `` +// Email string `valid:"email"` +// This, however, will only fail when Email is empty or an invalid email address: +// type exampleStruct2 struct { +// Name string `valid:"-"` +// Email string `valid:"email"` +// Lastly, this will only fail when Email is an invalid email address but not when it's empty: +// type exampleStruct2 struct { +// Name string `valid:"-"` +// Email string `valid:"email,optional"` +func SetFieldsRequiredByDefault(value bool) { + fieldsRequiredByDefault = value +} + +// IsEmail check if the string is an email. +func IsEmail(str string) bool { + // TODO uppercase letters are not supported + return rxEmail.MatchString(str) +} + +// IsURL check if the string is an URL. +func IsURL(str string) bool { + if str == "" || len(str) >= 2083 || len(str) <= 3 || strings.HasPrefix(str, ".") { + return false + } + u, err := url.Parse(str) + if err != nil { + return false + } + if strings.HasPrefix(u.Host, ".") { + return false + } + if u.Host == "" && (u.Path != "" && !strings.Contains(u.Path, ".")) { + return false + } + return rxURL.MatchString(str) + +} + +// IsRequestURL check if the string rawurl, assuming +// it was recieved in an HTTP request, is a valid +// URL confirm to RFC 3986 +func IsRequestURL(rawurl string) bool { + url, err := url.ParseRequestURI(rawurl) + if err != nil { + return false //Couldn't even parse the rawurl + } + if len(url.Scheme) == 0 { + return false //No Scheme found + } + return true +} + +// IsRequestURI check if the string rawurl, assuming +// it was recieved in an HTTP request, is an +// absolute URI or an absolute path. +func IsRequestURI(rawurl string) bool { + _, err := url.ParseRequestURI(rawurl) + return err == nil +} + +// IsAlpha check if the string contains only letters (a-zA-Z). Empty string is valid. +func IsAlpha(str string) bool { + if IsNull(str) { + return true + } + return rxAlpha.MatchString(str) +} + +//IsUTFLetter check if the string contains only unicode letter characters. +//Similar to IsAlpha but for all languages. Empty string is valid. +func IsUTFLetter(str string) bool { + if IsNull(str) { + return true + } + + for _, c := range str { + if !unicode.IsLetter(c) { + return false + } + } + return true + +} + +// IsAlphanumeric check if the string contains only letters and numbers. Empty string is valid. +func IsAlphanumeric(str string) bool { + if IsNull(str) { + return true + } + return rxAlphanumeric.MatchString(str) +} + +// IsUTFLetterNumeric check if the string contains only unicode letters and numbers. Empty string is valid. +func IsUTFLetterNumeric(str string) bool { + if IsNull(str) { + return true + } + for _, c := range str { + if !unicode.IsLetter(c) && !unicode.IsNumber(c) { //letters && numbers are ok + return false + } + } + return true + +} + +// IsNumeric check if the string contains only numbers. Empty string is valid. +func IsNumeric(str string) bool { + if IsNull(str) { + return true + } + return rxNumeric.MatchString(str) +} + +// IsUTFNumeric check if the string contains only unicode numbers of any kind. +// Numbers can be 0-9 but also Fractions ¾,Roman Ⅸ and Hangzhou 〩. Empty string is valid. +func IsUTFNumeric(str string) bool { + if IsNull(str) { + return true + } + if strings.IndexAny(str, "+-") > 0 { + return false + } + if len(str) > 1 { + str = strings.TrimPrefix(str, "-") + str = strings.TrimPrefix(str, "+") + } + for _, c := range str { + if unicode.IsNumber(c) == false { //numbers && minus sign are ok + return false + } + } + return true + +} + +// IsUTFDigit check if the string contains only unicode radix-10 decimal digits. Empty string is valid. +func IsUTFDigit(str string) bool { + if IsNull(str) { + return true + } + if strings.IndexAny(str, "+-") > 0 { + return false + } + if len(str) > 1 { + str = strings.TrimPrefix(str, "-") + str = strings.TrimPrefix(str, "+") + } + for _, c := range str { + if !unicode.IsDigit(c) { //digits && minus sign are ok + return false + } + } + return true + +} + +// IsHexadecimal check if the string is a hexadecimal number. +func IsHexadecimal(str string) bool { + return rxHexadecimal.MatchString(str) +} + +// IsHexcolor check if the string is a hexadecimal color. +func IsHexcolor(str string) bool { + return rxHexcolor.MatchString(str) +} + +// IsRGBcolor check if the string is a valid RGB color in form rgb(RRR, GGG, BBB). +func IsRGBcolor(str string) bool { + return rxRGBcolor.MatchString(str) +} + +// IsLowerCase check if the string is lowercase. Empty string is valid. +func IsLowerCase(str string) bool { + if IsNull(str) { + return true + } + return str == strings.ToLower(str) +} + +// IsUpperCase check if the string is uppercase. Empty string is valid. +func IsUpperCase(str string) bool { + if IsNull(str) { + return true + } + return str == strings.ToUpper(str) +} + +// IsInt check if the string is an integer. Empty string is valid. +func IsInt(str string) bool { + if IsNull(str) { + return true + } + return rxInt.MatchString(str) +} + +// IsFloat check if the string is a float. +func IsFloat(str string) bool { + return str != "" && rxFloat.MatchString(str) +} + +// IsDivisibleBy check if the string is a number that's divisible by another. +// If second argument is not valid integer or zero, it's return false. +// Otherwise, if first argument is not valid integer or zero, it's return true (Invalid string converts to zero). +func IsDivisibleBy(str, num string) bool { + f, _ := ToFloat(str) + p := int64(f) + q, _ := ToInt(num) + if q == 0 { + return false + } + return (p == 0) || (p%q == 0) +} + +// IsNull check if the string is null. +func IsNull(str string) bool { + return len(str) == 0 +} + +// IsByteLength check if the string's length (in bytes) falls in a range. +func IsByteLength(str string, min, max int) bool { + return len(str) >= min && len(str) <= max +} + +// IsUUIDv3 check if the string is a UUID version 3. +func IsUUIDv3(str string) bool { + return rxUUID3.MatchString(str) +} + +// IsUUIDv4 check if the string is a UUID version 4. +func IsUUIDv4(str string) bool { + return rxUUID4.MatchString(str) +} + +// IsUUIDv5 check if the string is a UUID version 5. +func IsUUIDv5(str string) bool { + return rxUUID5.MatchString(str) +} + +// IsUUID check if the string is a UUID (version 3, 4 or 5). +func IsUUID(str string) bool { + return rxUUID.MatchString(str) +} + +// IsCreditCard check if the string is a credit card. +func IsCreditCard(str string) bool { + r, _ := regexp.Compile("[^0-9]+") + sanitized := r.ReplaceAll([]byte(str), []byte("")) + if !rxCreditCard.MatchString(string(sanitized)) { + return false + } + var sum int64 + var digit string + var tmpNum int64 + var shouldDouble bool + for i := len(sanitized) - 1; i >= 0; i-- { + digit = string(sanitized[i:(i + 1)]) + tmpNum, _ = ToInt(digit) + if shouldDouble { + tmpNum *= 2 + if tmpNum >= 10 { + sum += ((tmpNum % 10) + 1) + } else { + sum += tmpNum + } + } else { + sum += tmpNum + } + shouldDouble = !shouldDouble + } + + if sum%10 == 0 { + return true + } + return false +} + +// IsISBN10 check if the string is an ISBN version 10. +func IsISBN10(str string) bool { + return IsISBN(str, 10) +} + +// IsISBN13 check if the string is an ISBN version 13. +func IsISBN13(str string) bool { + return IsISBN(str, 13) +} + +// IsISBN check if the string is an ISBN (version 10 or 13). +// If version value is not equal to 10 or 13, it will be check both variants. +func IsISBN(str string, version int) bool { + r, _ := regexp.Compile("[\\s-]+") + sanitized := r.ReplaceAll([]byte(str), []byte("")) + var checksum int32 + var i int32 + if version == 10 { + if !rxISBN10.MatchString(string(sanitized)) { + return false + } + for i = 0; i < 9; i++ { + checksum += (i + 1) * int32(sanitized[i]-'0') + } + if sanitized[9] == 'X' { + checksum += 10 * 10 + } else { + checksum += 10 * int32(sanitized[9]-'0') + } + if checksum%11 == 0 { + return true + } + return false + } else if version == 13 { + if !rxISBN13.MatchString(string(sanitized)) { + return false + } + factor := []int32{1, 3} + for i = 0; i < 12; i++ { + checksum += factor[i%2] * int32(sanitized[i]-'0') + } + if (int32(sanitized[12]-'0'))-((10-(checksum%10))%10) == 0 { + return true + } + return false + } + return IsISBN(str, 10) || IsISBN(str, 13) +} + +// IsJSON check if the string is valid JSON (note: uses json.Unmarshal). +func IsJSON(str string) bool { + var js json.RawMessage + return json.Unmarshal([]byte(str), &js) == nil +} + +// IsMultibyte check if the string contains one or more multibyte chars. Empty string is valid. +func IsMultibyte(str string) bool { + if IsNull(str) { + return true + } + return rxMultibyte.MatchString(str) +} + +// IsASCII check if the string contains ASCII chars only. Empty string is valid. +func IsASCII(str string) bool { + if IsNull(str) { + return true + } + return rxASCII.MatchString(str) +} + +// IsPrintableASCII check if the string contains printable ASCII chars only. Empty string is valid. +func IsPrintableASCII(str string) bool { + if IsNull(str) { + return true + } + return rxPrintableASCII.MatchString(str) +} + +// IsFullWidth check if the string contains any full-width chars. Empty string is valid. +func IsFullWidth(str string) bool { + if IsNull(str) { + return true + } + return rxFullWidth.MatchString(str) +} + +// IsHalfWidth check if the string contains any half-width chars. Empty string is valid. +func IsHalfWidth(str string) bool { + if IsNull(str) { + return true + } + return rxHalfWidth.MatchString(str) +} + +// IsVariableWidth check if the string contains a mixture of full and half-width chars. Empty string is valid. +func IsVariableWidth(str string) bool { + if IsNull(str) { + return true + } + return rxHalfWidth.MatchString(str) && rxFullWidth.MatchString(str) +} + +// IsBase64 check if a string is base64 encoded. +func IsBase64(str string) bool { + return rxBase64.MatchString(str) +} + +// IsFilePath check is a string is Win or Unix file path and returns it's type. +func IsFilePath(str string) (bool, int) { + if rxWinPath.MatchString(str) { + //check windows path limit see: + // http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx#maxpath + if len(str[3:]) > 32767 { + return false, Win + } + return true, Win + } else if rxUnixPath.MatchString(str) { + return true, Unix + } + return false, Unknown +} + +// IsDataURI checks if a string is base64 encoded data URI such as an image +func IsDataURI(str string) bool { + dataURI := strings.Split(str, ",") + if !rxDataURI.MatchString(dataURI[0]) { + return false + } + return IsBase64(dataURI[1]) +} + +// IsISO3166Alpha2 checks if a string is valid two-letter country code +func IsISO3166Alpha2(str string) bool { + for _, entry := range ISO3166List { + if str == entry.Alpha2Code { + return true + } + } + return false +} + +// IsISO3166Alpha3 checks if a string is valid three-letter country code +func IsISO3166Alpha3(str string) bool { + for _, entry := range ISO3166List { + if str == entry.Alpha3Code { + return true + } + } + return false +} + +// IsDNSName will validate the given string as a DNS name +func IsDNSName(str string) bool { + if str == "" || len(strings.Replace(str, ".", "", -1)) > 255 { + // constraints already violated + return false + } + return rxDNSName.MatchString(str) +} + +// IsDialString validates the given string for usage with the various Dial() functions +func IsDialString(str string) bool { + + if h, p, err := net.SplitHostPort(str); err == nil && h != "" && p != "" && (IsDNSName(h) || IsIP(h)) && IsPort(p) { + return true + } + + return false +} + +// IsIP checks if a string is either IP version 4 or 6. +func IsIP(str string) bool { + return net.ParseIP(str) != nil +} + +// IsPort checks if a string represents a valid port +func IsPort(str string) bool { + if i, err := strconv.Atoi(str); err == nil && i > 0 && i < 65536 { + return true + } + return false +} + +// IsIPv4 check if the string is an IP version 4. +func IsIPv4(str string) bool { + ip := net.ParseIP(str) + return ip != nil && strings.Contains(str, ".") +} + +// IsIPv6 check if the string is an IP version 6. +func IsIPv6(str string) bool { + ip := net.ParseIP(str) + return ip != nil && strings.Contains(str, ":") +} + +// IsCIDR check if the string is an valid CIDR notiation (IPV4 & IPV6) +func IsCIDR(str string) bool { + _, _, err := net.ParseCIDR(str) + return err == nil +} + +// IsMAC check if a string is valid MAC address. +// Possible MAC formats: +// 01:23:45:67:89:ab +// 01:23:45:67:89:ab:cd:ef +// 01-23-45-67-89-ab +// 01-23-45-67-89-ab-cd-ef +// 0123.4567.89ab +// 0123.4567.89ab.cdef +func IsMAC(str string) bool { + _, err := net.ParseMAC(str) + return err == nil +} + +// IsHost checks if the string is a valid IP (both v4 and v6) or a valid DNS name +func IsHost(str string) bool { + return IsIP(str) || IsDNSName(str) +} + +// IsMongoID check if the string is a valid hex-encoded representation of a MongoDB ObjectId. +func IsMongoID(str string) bool { + return rxHexadecimal.MatchString(str) && (len(str) == 24) +} + +// IsLatitude check if a string is valid latitude. +func IsLatitude(str string) bool { + return rxLatitude.MatchString(str) +} + +// IsLongitude check if a string is valid longitude. +func IsLongitude(str string) bool { + return rxLongitude.MatchString(str) +} + +// ValidateStruct use tags for fields. +// result will be equal to `false` if there are any errors. +func ValidateStruct(s interface{}) (bool, error) { + if s == nil { + return true, nil + } + result := true + var err error + val := reflect.ValueOf(s) + if val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr { + val = val.Elem() + } + // we only accept structs + if val.Kind() != reflect.Struct { + return false, fmt.Errorf("function only accepts structs; got %s", val.Kind()) + } + var errs Errors + for i := 0; i < val.NumField(); i++ { + valueField := val.Field(i) + typeField := val.Type().Field(i) + if typeField.PkgPath != "" { + continue // Private field + } + resultField, err2 := typeCheck(valueField, typeField, val) + if err2 != nil { + errs = append(errs, err2) + } + result = result && resultField + } + if len(errs) > 0 { + err = errs + } + return result, err +} + +// parseTagIntoMap parses a struct tag `valid:required~Some error message,length(2|3)` into map[string]string{"required": "Some error message", "length(2|3)": ""} +func parseTagIntoMap(tag string) tagOptionsMap { + optionsMap := make(tagOptionsMap) + options := strings.SplitN(tag, ",", -1) + for _, option := range options { + validationOptions := strings.Split(option, "~") + if !isValidTag(validationOptions[0]) { + continue + } + if len(validationOptions) == 2 { + optionsMap[validationOptions[0]] = validationOptions[1] + } else { + optionsMap[validationOptions[0]] = "" + } + } + return optionsMap +} + +func isValidTag(s string) bool { + if s == "" { + return false + } + for _, c := range s { + switch { + case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c): + // Backslash and quote chars are reserved, but + // otherwise any punctuation chars are allowed + // in a tag name. + default: + if !unicode.IsLetter(c) && !unicode.IsDigit(c) { + return false + } + } + } + return true +} + +// IsSSN will validate the given string as a U.S. Social Security Number +func IsSSN(str string) bool { + if str == "" || len(str) != 11 { + return false + } + return rxSSN.MatchString(str) +} + +// IsSemver check if string is valid semantic version +func IsSemver(str string) bool { + return rxSemver.MatchString(str) +} + +// ByteLength check string's length +func ByteLength(str string, params ...string) bool { + if len(params) == 2 { + min, _ := ToInt(params[0]) + max, _ := ToInt(params[1]) + return len(str) >= int(min) && len(str) <= int(max) + } + + return false +} + +// StringMatches checks if a string matches a given pattern. +func StringMatches(s string, params ...string) bool { + if len(params) == 1 { + pattern := params[0] + return Matches(s, pattern) + } + return false +} + +// StringLength check string's length (including multi byte strings) +func StringLength(str string, params ...string) bool { + + if len(params) == 2 { + strLength := utf8.RuneCountInString(str) + min, _ := ToInt(params[0]) + max, _ := ToInt(params[1]) + return strLength >= int(min) && strLength <= int(max) + } + + return false +} + +func checkRequired(v reflect.Value, t reflect.StructField, options tagOptionsMap) (bool, error) { + if requiredOption, isRequired := options["required"]; isRequired { + if len(requiredOption) > 0 { + return false, Error{t.Name, fmt.Errorf(requiredOption), true} + } + return false, Error{t.Name, fmt.Errorf("non zero value required"), false} + } else if _, isOptional := options["optional"]; fieldsRequiredByDefault && !isOptional { + return false, Error{t.Name, fmt.Errorf("All fields are required to at least have one validation defined"), false} + } + // not required and empty is valid + return true, nil +} + +func typeCheck(v reflect.Value, t reflect.StructField, o reflect.Value) (bool, error) { + if !v.IsValid() { + return false, nil + } + + tag := t.Tag.Get(tagName) + + // Check if the field should be ignored + switch tag { + case "": + if !fieldsRequiredByDefault { + return true, nil + } + return false, Error{t.Name, fmt.Errorf("All fields are required to at least have one validation defined"), false} + case "-": + return true, nil + } + + options := parseTagIntoMap(tag) + var customTypeErrors Errors + var customTypeValidatorsExist bool + for validatorName, customErrorMessage := range options { + if validatefunc, ok := CustomTypeTagMap.Get(validatorName); ok { + customTypeValidatorsExist = true + if result := validatefunc(v.Interface(), o.Interface()); !result { + if len(customErrorMessage) > 0 { + customTypeErrors = append(customTypeErrors, Error{Name: t.Name, Err: fmt.Errorf(customErrorMessage), CustomErrorMessageExists: true}) + continue + } + customTypeErrors = append(customTypeErrors, Error{Name: t.Name, Err: fmt.Errorf("%s does not validate as %s", fmt.Sprint(v), validatorName), CustomErrorMessageExists: false}) + } + } + } + if customTypeValidatorsExist { + if len(customTypeErrors.Errors()) > 0 { + return false, customTypeErrors + } + return true, nil + } + + if isEmptyValue(v) { + // an empty value is not validated, check only required + return checkRequired(v, t, options) + } + + switch v.Kind() { + case reflect.Bool, + reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, + reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, + reflect.Float32, reflect.Float64, + reflect.String: + // for each tag option check the map of validator functions + for validator, customErrorMessage := range options { + var negate bool + customMsgExists := (len(customErrorMessage) > 0) + // Check wether the tag looks like '!something' or 'something' + if validator[0] == '!' { + validator = string(validator[1:]) + negate = true + } + + // Check for param validators + for key, value := range ParamTagRegexMap { + ps := value.FindStringSubmatch(validator) + if len(ps) > 0 { + if validatefunc, ok := ParamTagMap[key]; ok { + switch v.Kind() { + case reflect.String: + field := fmt.Sprint(v) // make value into string, then validate with regex + if result := validatefunc(field, ps[1:]...); (!result && !negate) || (result && negate) { + var err error + if !negate { + if customMsgExists { + err = fmt.Errorf(customErrorMessage) + } else { + err = fmt.Errorf("%s does not validate as %s", field, validator) + } + + } else { + if customMsgExists { + err = fmt.Errorf(customErrorMessage) + } else { + err = fmt.Errorf("%s does validate as %s", field, validator) + } + } + return false, Error{t.Name, err, customMsgExists} + } + default: + // type not yet supported, fail + return false, Error{t.Name, fmt.Errorf("Validator %s doesn't support kind %s", validator, v.Kind()), false} + } + } + } + } + + if validatefunc, ok := TagMap[validator]; ok { + switch v.Kind() { + case reflect.String: + field := fmt.Sprint(v) // make value into string, then validate with regex + if result := validatefunc(field); !result && !negate || result && negate { + var err error + + if !negate { + if customMsgExists { + err = fmt.Errorf(customErrorMessage) + } else { + err = fmt.Errorf("%s does not validate as %s", field, validator) + } + } else { + if customMsgExists { + err = fmt.Errorf(customErrorMessage) + } else { + err = fmt.Errorf("%s does validate as %s", field, validator) + } + } + return false, Error{t.Name, err, customMsgExists} + } + default: + //Not Yet Supported Types (Fail here!) + err := fmt.Errorf("Validator %s doesn't support kind %s for value %v", validator, v.Kind(), v) + return false, Error{t.Name, err, false} + } + } + } + return true, nil + case reflect.Map: + if v.Type().Key().Kind() != reflect.String { + return false, &UnsupportedTypeError{v.Type()} + } + var sv stringValues + sv = v.MapKeys() + sort.Sort(sv) + result := true + for _, k := range sv { + resultItem, err := ValidateStruct(v.MapIndex(k).Interface()) + if err != nil { + return false, err + } + result = result && resultItem + } + return result, nil + case reflect.Slice: + result := true + for i := 0; i < v.Len(); i++ { + var resultItem bool + var err error + if v.Index(i).Kind() != reflect.Struct { + resultItem, err = typeCheck(v.Index(i), t, o) + if err != nil { + return false, err + } + } else { + resultItem, err = ValidateStruct(v.Index(i).Interface()) + if err != nil { + return false, err + } + } + result = result && resultItem + } + return result, nil + case reflect.Array: + result := true + for i := 0; i < v.Len(); i++ { + var resultItem bool + var err error + if v.Index(i).Kind() != reflect.Struct { + resultItem, err = typeCheck(v.Index(i), t, o) + if err != nil { + return false, err + } + } else { + resultItem, err = ValidateStruct(v.Index(i).Interface()) + if err != nil { + return false, err + } + } + result = result && resultItem + } + return result, nil + case reflect.Interface: + // If the value is an interface then encode its element + if v.IsNil() { + return true, nil + } + return ValidateStruct(v.Interface()) + case reflect.Ptr: + // If the value is a pointer then check its element + if v.IsNil() { + return true, nil + } + return typeCheck(v.Elem(), t, o) + case reflect.Struct: + return ValidateStruct(v.Interface()) + default: + return false, &UnsupportedTypeError{v.Type()} + } +} + +func isEmptyValue(v reflect.Value) bool { + switch v.Kind() { + case reflect.String, reflect.Array: + return v.Len() == 0 + case reflect.Map, reflect.Slice: + return v.Len() == 0 || v.IsNil() + case reflect.Bool: + return !v.Bool() + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.Interface, reflect.Ptr: + return v.IsNil() + } + + return reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface()) +} + +// ErrorByField returns error for specified field of the struct +// validated by ValidateStruct or empty string if there are no errors +// or this field doesn't exists or doesn't have any errors. +func ErrorByField(e error, field string) string { + if e == nil { + return "" + } + return ErrorsByField(e)[field] +} + +// ErrorsByField returns map of errors of the struct validated +// by ValidateStruct or empty map if there are no errors. +func ErrorsByField(e error) map[string]string { + m := make(map[string]string) + if e == nil { + return m + } + // prototype for ValidateStruct + + switch e.(type) { + case Error: + m[e.(Error).Name] = e.(Error).Err.Error() + case Errors: + for _, item := range e.(Errors).Errors() { + n := ErrorsByField(item) + for k, v := range n { + m[k] = v + } + } + } + + return m +} + +// Error returns string equivalent for reflect.Type +func (e *UnsupportedTypeError) Error() string { + return "validator: unsupported type: " + e.Type.String() +} + +func (sv stringValues) Len() int { return len(sv) } +func (sv stringValues) Swap(i, j int) { sv[i], sv[j] = sv[j], sv[i] } +func (sv stringValues) Less(i, j int) bool { return sv.get(i) < sv.get(j) } +func (sv stringValues) get(i int) string { return sv[i].String() } diff --git a/vendor/github.com/asaskevich/govalidator/wercker.yml b/vendor/github.com/asaskevich/govalidator/wercker.yml new file mode 100644 index 0000000..4840449 --- /dev/null +++ b/vendor/github.com/asaskevich/govalidator/wercker.yml @@ -0,0 +1,15 @@ +box: wercker/golang +build: + steps: + - setup-go-workspace + + - script: + name: go get + code: | + go version + go get -t ./... + + - script: + name: go test + code: | + go test -race ./... diff --git a/vendor/github.com/blang/semver/LICENSE b/vendor/github.com/blang/semver/LICENSE new file mode 100644 index 0000000..5ba5c86 --- /dev/null +++ b/vendor/github.com/blang/semver/LICENSE @@ -0,0 +1,22 @@ +The MIT License + +Copyright (c) 2014 Benedikt Lang + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + diff --git a/vendor/github.com/blang/semver/README.md b/vendor/github.com/blang/semver/README.md new file mode 100644 index 0000000..4399639 --- /dev/null +++ b/vendor/github.com/blang/semver/README.md @@ -0,0 +1,191 @@ +semver for golang [![Build Status](https://drone.io/github.com/blang/semver/status.png)](https://drone.io/github.com/blang/semver/latest) [![GoDoc](https://godoc.org/github.com/blang/semver?status.png)](https://godoc.org/github.com/blang/semver) [![Coverage Status](https://img.shields.io/coveralls/blang/semver.svg)](https://coveralls.io/r/blang/semver?branch=master) +====== + +semver is a [Semantic Versioning](http://semver.org/) library written in golang. It fully covers spec version `2.0.0`. + +Usage +----- +```bash +$ go get github.com/blang/semver +``` +Note: Always vendor your dependencies or fix on a specific version tag. + +```go +import github.com/blang/semver +v1, err := semver.Make("1.0.0-beta") +v2, err := semver.Make("2.0.0-beta") +v1.Compare(v2) +``` + +Also check the [GoDocs](http://godoc.org/github.com/blang/semver). + +Why should I use this lib? +----- + +- Fully spec compatible +- No reflection +- No regex +- Fully tested (Coverage >99%) +- Readable parsing/validation errors +- Fast (See [Benchmarks](#benchmarks)) +- Only Stdlib +- Uses values instead of pointers +- Many features, see below + + +Features +----- + +- Parsing and validation at all levels +- Comparator-like comparisons +- Compare Helper Methods +- InPlace manipulation +- Ranges `>=1.0.0 <2.0.0 || >=3.0.0 !3.0.1-beta.1` +- Sortable (implements sort.Interface) +- database/sql compatible (sql.Scanner/Valuer) +- encoding/json compatible (json.Marshaler/Unmarshaler) + +Ranges +------ + +A `Range` is a set of conditions which specify which versions satisfy the range. + +A condition is composed of an operator and a version. The supported operators are: + +- `<1.0.0` Less than `1.0.0` +- `<=1.0.0` Less than or equal to `1.0.0` +- `>1.0.0` Greater than `1.0.0` +- `>=1.0.0` Greater than or equal to `1.0.0` +- `1.0.0`, `=1.0.0`, `==1.0.0` Equal to `1.0.0` +- `!1.0.0`, `!=1.0.0` Not equal to `1.0.0`. Excludes version `1.0.0`. + +A `Range` can link multiple `Ranges` separated by space: + +Ranges can be linked by logical AND: + + - `>1.0.0 <2.0.0` would match between both ranges, so `1.1.1` and `1.8.7` but not `1.0.0` or `2.0.0` + - `>1.0.0 <3.0.0 !2.0.3-beta.2` would match every version between `1.0.0` and `3.0.0` except `2.0.3-beta.2` + +Ranges can also be linked by logical OR: + + - `<2.0.0 || >=3.0.0` would match `1.x.x` and `3.x.x` but not `2.x.x` + +AND has a higher precedence than OR. It's not possible to use brackets. + +Ranges can be combined by both AND and OR + + - `>1.0.0 <2.0.0 || >3.0.0 !4.2.1` would match `1.2.3`, `1.9.9`, `3.1.1`, but not `4.2.1`, `2.1.1` + +Range usage: + +``` +v, err := semver.Parse("1.2.3") +range, err := semver.ParseRange(">1.0.0 <2.0.0 || >=3.0.0") +if range(v) { + //valid +} + +``` + +Example +----- + +Have a look at full examples in [examples/main.go](examples/main.go) + +```go +import github.com/blang/semver + +v, err := semver.Make("0.0.1-alpha.preview+123.github") +fmt.Printf("Major: %d\n", v.Major) +fmt.Printf("Minor: %d\n", v.Minor) +fmt.Printf("Patch: %d\n", v.Patch) +fmt.Printf("Pre: %s\n", v.Pre) +fmt.Printf("Build: %s\n", v.Build) + +// Prerelease versions array +if len(v.Pre) > 0 { + fmt.Println("Prerelease versions:") + for i, pre := range v.Pre { + fmt.Printf("%d: %q\n", i, pre) + } +} + +// Build meta data array +if len(v.Build) > 0 { + fmt.Println("Build meta data:") + for i, build := range v.Build { + fmt.Printf("%d: %q\n", i, build) + } +} + +v001, err := semver.Make("0.0.1") +// Compare using helpers: v.GT(v2), v.LT, v.GTE, v.LTE +v001.GT(v) == true +v.LT(v001) == true +v.GTE(v) == true +v.LTE(v) == true + +// Or use v.Compare(v2) for comparisons (-1, 0, 1): +v001.Compare(v) == 1 +v.Compare(v001) == -1 +v.Compare(v) == 0 + +// Manipulate Version in place: +v.Pre[0], err = semver.NewPRVersion("beta") +if err != nil { + fmt.Printf("Error parsing pre release version: %q", err) +} + +fmt.Println("\nValidate versions:") +v.Build[0] = "?" + +err = v.Validate() +if err != nil { + fmt.Printf("Validation failed: %s\n", err) +} +``` + + +Benchmarks +----- + + BenchmarkParseSimple-4 5000000 390 ns/op 48 B/op 1 allocs/op + BenchmarkParseComplex-4 1000000 1813 ns/op 256 B/op 7 allocs/op + BenchmarkParseAverage-4 1000000 1171 ns/op 163 B/op 4 allocs/op + BenchmarkStringSimple-4 20000000 119 ns/op 16 B/op 1 allocs/op + BenchmarkStringLarger-4 10000000 206 ns/op 32 B/op 2 allocs/op + BenchmarkStringComplex-4 5000000 324 ns/op 80 B/op 3 allocs/op + BenchmarkStringAverage-4 5000000 273 ns/op 53 B/op 2 allocs/op + BenchmarkValidateSimple-4 200000000 9.33 ns/op 0 B/op 0 allocs/op + BenchmarkValidateComplex-4 3000000 469 ns/op 0 B/op 0 allocs/op + BenchmarkValidateAverage-4 5000000 256 ns/op 0 B/op 0 allocs/op + BenchmarkCompareSimple-4 100000000 11.8 ns/op 0 B/op 0 allocs/op + BenchmarkCompareComplex-4 50000000 30.8 ns/op 0 B/op 0 allocs/op + BenchmarkCompareAverage-4 30000000 41.5 ns/op 0 B/op 0 allocs/op + BenchmarkSort-4 3000000 419 ns/op 256 B/op 2 allocs/op + BenchmarkRangeParseSimple-4 2000000 850 ns/op 192 B/op 5 allocs/op + BenchmarkRangeParseAverage-4 1000000 1677 ns/op 400 B/op 10 allocs/op + BenchmarkRangeParseComplex-4 300000 5214 ns/op 1440 B/op 30 allocs/op + BenchmarkRangeMatchSimple-4 50000000 25.6 ns/op 0 B/op 0 allocs/op + BenchmarkRangeMatchAverage-4 30000000 56.4 ns/op 0 B/op 0 allocs/op + BenchmarkRangeMatchComplex-4 10000000 153 ns/op 0 B/op 0 allocs/op + +See benchmark cases at [semver_test.go](semver_test.go) + + +Motivation +----- + +I simply couldn't find any lib supporting the full spec. Others were just wrong or used reflection and regex which i don't like. + + +Contribution +----- + +Feel free to make a pull request. For bigger changes create a issue first to discuss about it. + + +License +----- + +See [LICENSE](LICENSE) file. diff --git a/vendor/github.com/blang/semver/json.go b/vendor/github.com/blang/semver/json.go new file mode 100644 index 0000000..a74bf7c --- /dev/null +++ b/vendor/github.com/blang/semver/json.go @@ -0,0 +1,23 @@ +package semver + +import ( + "encoding/json" +) + +// MarshalJSON implements the encoding/json.Marshaler interface. +func (v Version) MarshalJSON() ([]byte, error) { + return json.Marshal(v.String()) +} + +// UnmarshalJSON implements the encoding/json.Unmarshaler interface. +func (v *Version) UnmarshalJSON(data []byte) (err error) { + var versionString string + + if err = json.Unmarshal(data, &versionString); err != nil { + return + } + + *v, err = Parse(versionString) + + return +} diff --git a/vendor/github.com/blang/semver/range.go b/vendor/github.com/blang/semver/range.go new file mode 100644 index 0000000..238e131 --- /dev/null +++ b/vendor/github.com/blang/semver/range.go @@ -0,0 +1,233 @@ +package semver + +import ( + "fmt" + "strings" + "unicode" +) + +type comparator func(Version, Version) bool + +var ( + compEQ comparator = func(v1 Version, v2 Version) bool { + return v1.Compare(v2) == 0 + } + compNE = func(v1 Version, v2 Version) bool { + return v1.Compare(v2) != 0 + } + compGT = func(v1 Version, v2 Version) bool { + return v1.Compare(v2) == 1 + } + compGE = func(v1 Version, v2 Version) bool { + return v1.Compare(v2) >= 0 + } + compLT = func(v1 Version, v2 Version) bool { + return v1.Compare(v2) == -1 + } + compLE = func(v1 Version, v2 Version) bool { + return v1.Compare(v2) <= 0 + } +) + +type versionRange struct { + v Version + c comparator +} + +// rangeFunc creates a Range from the given versionRange. +func (vr *versionRange) rangeFunc() Range { + return Range(func(v Version) bool { + return vr.c(v, vr.v) + }) +} + +// Range represents a range of versions. +// A Range can be used to check if a Version satisfies it: +// +// range, err := semver.ParseRange(">1.0.0 <2.0.0") +// range(semver.MustParse("1.1.1") // returns true +type Range func(Version) bool + +// OR combines the existing Range with another Range using logical OR. +func (rf Range) OR(f Range) Range { + return Range(func(v Version) bool { + return rf(v) || f(v) + }) +} + +// AND combines the existing Range with another Range using logical AND. +func (rf Range) AND(f Range) Range { + return Range(func(v Version) bool { + return rf(v) && f(v) + }) +} + +// ParseRange parses a range and returns a Range. +// If the range could not be parsed an error is returned. +// +// Valid ranges are: +// - "<1.0.0" +// - "<=1.0.0" +// - ">1.0.0" +// - ">=1.0.0" +// - "1.0.0", "=1.0.0", "==1.0.0" +// - "!1.0.0", "!=1.0.0" +// +// A Range can consist of multiple ranges separated by space: +// Ranges can be linked by logical AND: +// - ">1.0.0 <2.0.0" would match between both ranges, so "1.1.1" and "1.8.7" but not "1.0.0" or "2.0.0" +// - ">1.0.0 <3.0.0 !2.0.3-beta.2" would match every version between 1.0.0 and 3.0.0 except 2.0.3-beta.2 +// +// Ranges can also be linked by logical OR: +// - "<2.0.0 || >=3.0.0" would match "1.x.x" and "3.x.x" but not "2.x.x" +// +// AND has a higher precedence than OR. It's not possible to use brackets. +// +// Ranges can be combined by both AND and OR +// +// - `>1.0.0 <2.0.0 || >3.0.0 !4.2.1` would match `1.2.3`, `1.9.9`, `3.1.1`, but not `4.2.1`, `2.1.1` +func ParseRange(s string) (Range, error) { + parts := splitAndTrim(s) + orParts, err := splitORParts(parts) + if err != nil { + return nil, err + } + var orFn Range + for _, p := range orParts { + var andFn Range + for _, ap := range p { + opStr, vStr, err := splitComparatorVersion(ap) + if err != nil { + return nil, err + } + vr, err := buildVersionRange(opStr, vStr) + if err != nil { + return nil, fmt.Errorf("Could not parse Range %q: %s", ap, err) + } + rf := vr.rangeFunc() + + // Set function + if andFn == nil { + andFn = rf + } else { // Combine with existing function + andFn = andFn.AND(rf) + } + } + if orFn == nil { + orFn = andFn + } else { + orFn = orFn.OR(andFn) + } + + } + return orFn, nil +} + +// splitORParts splits the already cleaned parts by '||'. +// Checks for invalid positions of the operator and returns an +// error if found. +func splitORParts(parts []string) ([][]string, error) { + var ORparts [][]string + last := 0 + for i, p := range parts { + if p == "||" { + if i == 0 { + return nil, fmt.Errorf("First element in range is '||'") + } + ORparts = append(ORparts, parts[last:i]) + last = i + 1 + } + } + if last == len(parts) { + return nil, fmt.Errorf("Last element in range is '||'") + } + ORparts = append(ORparts, parts[last:]) + return ORparts, nil +} + +// buildVersionRange takes a slice of 2: operator and version +// and builds a versionRange, otherwise an error. +func buildVersionRange(opStr, vStr string) (*versionRange, error) { + c := parseComparator(opStr) + if c == nil { + return nil, fmt.Errorf("Could not parse comparator %q in %q", opStr, strings.Join([]string{opStr, vStr}, "")) + } + v, err := Parse(vStr) + if err != nil { + return nil, fmt.Errorf("Could not parse version %q in %q: %s", vStr, strings.Join([]string{opStr, vStr}, ""), err) + } + + return &versionRange{ + v: v, + c: c, + }, nil + +} + +// splitAndTrim splits a range string by spaces and cleans leading and trailing spaces +func splitAndTrim(s string) (result []string) { + last := 0 + for i := 0; i < len(s); i++ { + if s[i] == ' ' { + if last < i-1 { + result = append(result, s[last:i]) + } + last = i + 1 + } + } + if last < len(s)-1 { + result = append(result, s[last:]) + } + // parts := strings.Split(s, " ") + // for _, x := range parts { + // if s := strings.TrimSpace(x); len(s) != 0 { + // result = append(result, s) + // } + // } + return +} + +// splitComparatorVersion splits the comparator from the version. +// Spaces between the comparator and the version are not allowed. +// Input must be free of leading or trailing spaces. +func splitComparatorVersion(s string) (string, string, error) { + i := strings.IndexFunc(s, unicode.IsDigit) + if i == -1 { + return "", "", fmt.Errorf("Could not get version from string: %q", s) + } + return strings.TrimSpace(s[0:i]), s[i:], nil +} + +func parseComparator(s string) comparator { + switch s { + case "==": + fallthrough + case "": + fallthrough + case "=": + return compEQ + case ">": + return compGT + case ">=": + return compGE + case "<": + return compLT + case "<=": + return compLE + case "!": + fallthrough + case "!=": + return compNE + } + + return nil +} + +// MustParseRange is like ParseRange but panics if the range cannot be parsed. +func MustParseRange(s string) Range { + r, err := ParseRange(s) + if err != nil { + panic(`semver: ParseRange(` + s + `): ` + err.Error()) + } + return r +} diff --git a/vendor/github.com/blang/semver/semver.go b/vendor/github.com/blang/semver/semver.go new file mode 100644 index 0000000..8ee0842 --- /dev/null +++ b/vendor/github.com/blang/semver/semver.go @@ -0,0 +1,418 @@ +package semver + +import ( + "errors" + "fmt" + "strconv" + "strings" +) + +const ( + numbers string = "0123456789" + alphas = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-" + alphanum = alphas + numbers +) + +// SpecVersion is the latest fully supported spec version of semver +var SpecVersion = Version{ + Major: 2, + Minor: 0, + Patch: 0, +} + +// Version represents a semver compatible version +type Version struct { + Major uint64 + Minor uint64 + Patch uint64 + Pre []PRVersion + Build []string //No Precendence +} + +// Version to string +func (v Version) String() string { + b := make([]byte, 0, 5) + b = strconv.AppendUint(b, v.Major, 10) + b = append(b, '.') + b = strconv.AppendUint(b, v.Minor, 10) + b = append(b, '.') + b = strconv.AppendUint(b, v.Patch, 10) + + if len(v.Pre) > 0 { + b = append(b, '-') + b = append(b, v.Pre[0].String()...) + + for _, pre := range v.Pre[1:] { + b = append(b, '.') + b = append(b, pre.String()...) + } + } + + if len(v.Build) > 0 { + b = append(b, '+') + b = append(b, v.Build[0]...) + + for _, build := range v.Build[1:] { + b = append(b, '.') + b = append(b, build...) + } + } + + return string(b) +} + +// Equals checks if v is equal to o. +func (v Version) Equals(o Version) bool { + return (v.Compare(o) == 0) +} + +// EQ checks if v is equal to o. +func (v Version) EQ(o Version) bool { + return (v.Compare(o) == 0) +} + +// NE checks if v is not equal to o. +func (v Version) NE(o Version) bool { + return (v.Compare(o) != 0) +} + +// GT checks if v is greater than o. +func (v Version) GT(o Version) bool { + return (v.Compare(o) == 1) +} + +// GTE checks if v is greater than or equal to o. +func (v Version) GTE(o Version) bool { + return (v.Compare(o) >= 0) +} + +// GE checks if v is greater than or equal to o. +func (v Version) GE(o Version) bool { + return (v.Compare(o) >= 0) +} + +// LT checks if v is less than o. +func (v Version) LT(o Version) bool { + return (v.Compare(o) == -1) +} + +// LTE checks if v is less than or equal to o. +func (v Version) LTE(o Version) bool { + return (v.Compare(o) <= 0) +} + +// LE checks if v is less than or equal to o. +func (v Version) LE(o Version) bool { + return (v.Compare(o) <= 0) +} + +// Compare compares Versions v to o: +// -1 == v is less than o +// 0 == v is equal to o +// 1 == v is greater than o +func (v Version) Compare(o Version) int { + if v.Major != o.Major { + if v.Major > o.Major { + return 1 + } + return -1 + } + if v.Minor != o.Minor { + if v.Minor > o.Minor { + return 1 + } + return -1 + } + if v.Patch != o.Patch { + if v.Patch > o.Patch { + return 1 + } + return -1 + } + + // Quick comparison if a version has no prerelease versions + if len(v.Pre) == 0 && len(o.Pre) == 0 { + return 0 + } else if len(v.Pre) == 0 && len(o.Pre) > 0 { + return 1 + } else if len(v.Pre) > 0 && len(o.Pre) == 0 { + return -1 + } + + i := 0 + for ; i < len(v.Pre) && i < len(o.Pre); i++ { + if comp := v.Pre[i].Compare(o.Pre[i]); comp == 0 { + continue + } else if comp == 1 { + return 1 + } else { + return -1 + } + } + + // If all pr versions are the equal but one has further prversion, this one greater + if i == len(v.Pre) && i == len(o.Pre) { + return 0 + } else if i == len(v.Pre) && i < len(o.Pre) { + return -1 + } else { + return 1 + } + +} + +// Validate validates v and returns error in case +func (v Version) Validate() error { + // Major, Minor, Patch already validated using uint64 + + for _, pre := range v.Pre { + if !pre.IsNum { //Numeric prerelease versions already uint64 + if len(pre.VersionStr) == 0 { + return fmt.Errorf("Prerelease can not be empty %q", pre.VersionStr) + } + if !containsOnly(pre.VersionStr, alphanum) { + return fmt.Errorf("Invalid character(s) found in prerelease %q", pre.VersionStr) + } + } + } + + for _, build := range v.Build { + if len(build) == 0 { + return fmt.Errorf("Build meta data can not be empty %q", build) + } + if !containsOnly(build, alphanum) { + return fmt.Errorf("Invalid character(s) found in build meta data %q", build) + } + } + + return nil +} + +// New is an alias for Parse and returns a pointer, parses version string and returns a validated Version or error +func New(s string) (vp *Version, err error) { + v, err := Parse(s) + vp = &v + return +} + +// Make is an alias for Parse, parses version string and returns a validated Version or error +func Make(s string) (Version, error) { + return Parse(s) +} + +// ParseTolerant allows for certain version specifications that do not strictly adhere to semver +// specs to be parsed by this library. It does so by normalizing versions before passing them to +// Parse(). It currently trims spaces, removes a "v" prefix, and adds a 0 patch number to versions +// with only major and minor components specified +func ParseTolerant(s string) (Version, error) { + s = strings.TrimSpace(s) + s = strings.TrimPrefix(s, "v") + + // Split into major.minor.(patch+pr+meta) + parts := strings.SplitN(s, ".", 3) + if len(parts) < 3 { + if strings.ContainsAny(parts[len(parts)-1], "+-") { + return Version{}, errors.New("Short version cannot contain PreRelease/Build meta data") + } + for len(parts) < 3 { + parts = append(parts, "0") + } + s = strings.Join(parts, ".") + } + + return Parse(s) +} + +// Parse parses version string and returns a validated Version or error +func Parse(s string) (Version, error) { + if len(s) == 0 { + return Version{}, errors.New("Version string empty") + } + + // Split into major.minor.(patch+pr+meta) + parts := strings.SplitN(s, ".", 3) + if len(parts) != 3 { + return Version{}, errors.New("No Major.Minor.Patch elements found") + } + + // Major + if !containsOnly(parts[0], numbers) { + return Version{}, fmt.Errorf("Invalid character(s) found in major number %q", parts[0]) + } + if hasLeadingZeroes(parts[0]) { + return Version{}, fmt.Errorf("Major number must not contain leading zeroes %q", parts[0]) + } + major, err := strconv.ParseUint(parts[0], 10, 64) + if err != nil { + return Version{}, err + } + + // Minor + if !containsOnly(parts[1], numbers) { + return Version{}, fmt.Errorf("Invalid character(s) found in minor number %q", parts[1]) + } + if hasLeadingZeroes(parts[1]) { + return Version{}, fmt.Errorf("Minor number must not contain leading zeroes %q", parts[1]) + } + minor, err := strconv.ParseUint(parts[1], 10, 64) + if err != nil { + return Version{}, err + } + + v := Version{} + v.Major = major + v.Minor = minor + + var build, prerelease []string + patchStr := parts[2] + + if buildIndex := strings.IndexRune(patchStr, '+'); buildIndex != -1 { + build = strings.Split(patchStr[buildIndex+1:], ".") + patchStr = patchStr[:buildIndex] + } + + if preIndex := strings.IndexRune(patchStr, '-'); preIndex != -1 { + prerelease = strings.Split(patchStr[preIndex+1:], ".") + patchStr = patchStr[:preIndex] + } + + if !containsOnly(patchStr, numbers) { + return Version{}, fmt.Errorf("Invalid character(s) found in patch number %q", patchStr) + } + if hasLeadingZeroes(patchStr) { + return Version{}, fmt.Errorf("Patch number must not contain leading zeroes %q", patchStr) + } + patch, err := strconv.ParseUint(patchStr, 10, 64) + if err != nil { + return Version{}, err + } + + v.Patch = patch + + // Prerelease + for _, prstr := range prerelease { + parsedPR, err := NewPRVersion(prstr) + if err != nil { + return Version{}, err + } + v.Pre = append(v.Pre, parsedPR) + } + + // Build meta data + for _, str := range build { + if len(str) == 0 { + return Version{}, errors.New("Build meta data is empty") + } + if !containsOnly(str, alphanum) { + return Version{}, fmt.Errorf("Invalid character(s) found in build meta data %q", str) + } + v.Build = append(v.Build, str) + } + + return v, nil +} + +// MustParse is like Parse but panics if the version cannot be parsed. +func MustParse(s string) Version { + v, err := Parse(s) + if err != nil { + panic(`semver: Parse(` + s + `): ` + err.Error()) + } + return v +} + +// PRVersion represents a PreRelease Version +type PRVersion struct { + VersionStr string + VersionNum uint64 + IsNum bool +} + +// NewPRVersion creates a new valid prerelease version +func NewPRVersion(s string) (PRVersion, error) { + if len(s) == 0 { + return PRVersion{}, errors.New("Prerelease is empty") + } + v := PRVersion{} + if containsOnly(s, numbers) { + if hasLeadingZeroes(s) { + return PRVersion{}, fmt.Errorf("Numeric PreRelease version must not contain leading zeroes %q", s) + } + num, err := strconv.ParseUint(s, 10, 64) + + // Might never be hit, but just in case + if err != nil { + return PRVersion{}, err + } + v.VersionNum = num + v.IsNum = true + } else if containsOnly(s, alphanum) { + v.VersionStr = s + v.IsNum = false + } else { + return PRVersion{}, fmt.Errorf("Invalid character(s) found in prerelease %q", s) + } + return v, nil +} + +// IsNumeric checks if prerelease-version is numeric +func (v PRVersion) IsNumeric() bool { + return v.IsNum +} + +// Compare compares two PreRelease Versions v and o: +// -1 == v is less than o +// 0 == v is equal to o +// 1 == v is greater than o +func (v PRVersion) Compare(o PRVersion) int { + if v.IsNum && !o.IsNum { + return -1 + } else if !v.IsNum && o.IsNum { + return 1 + } else if v.IsNum && o.IsNum { + if v.VersionNum == o.VersionNum { + return 0 + } else if v.VersionNum > o.VersionNum { + return 1 + } else { + return -1 + } + } else { // both are Alphas + if v.VersionStr == o.VersionStr { + return 0 + } else if v.VersionStr > o.VersionStr { + return 1 + } else { + return -1 + } + } +} + +// PreRelease version to string +func (v PRVersion) String() string { + if v.IsNum { + return strconv.FormatUint(v.VersionNum, 10) + } + return v.VersionStr +} + +func containsOnly(s string, set string) bool { + return strings.IndexFunc(s, func(r rune) bool { + return !strings.ContainsRune(set, r) + }) == -1 +} + +func hasLeadingZeroes(s string) bool { + return len(s) > 1 && s[0] == '0' +} + +// NewBuildVersion creates a new valid build version +func NewBuildVersion(s string) (string, error) { + if len(s) == 0 { + return "", errors.New("Buildversion is empty") + } + if !containsOnly(s, alphanum) { + return "", fmt.Errorf("Invalid character(s) found in build meta data %q", s) + } + return s, nil +} diff --git a/vendor/github.com/blang/semver/sort.go b/vendor/github.com/blang/semver/sort.go new file mode 100644 index 0000000..e18f880 --- /dev/null +++ b/vendor/github.com/blang/semver/sort.go @@ -0,0 +1,28 @@ +package semver + +import ( + "sort" +) + +// Versions represents multiple versions. +type Versions []Version + +// Len returns length of version collection +func (s Versions) Len() int { + return len(s) +} + +// Swap swaps two versions inside the collection by its indices +func (s Versions) Swap(i, j int) { + s[i], s[j] = s[j], s[i] +} + +// Less checks if version at index i is less than version at index j +func (s Versions) Less(i, j int) bool { + return s[i].LT(s[j]) +} + +// Sort sorts a slice of versions +func Sort(versions []Version) { + sort.Sort(Versions(versions)) +} diff --git a/vendor/github.com/blang/semver/sql.go b/vendor/github.com/blang/semver/sql.go new file mode 100644 index 0000000..eb4d802 --- /dev/null +++ b/vendor/github.com/blang/semver/sql.go @@ -0,0 +1,30 @@ +package semver + +import ( + "database/sql/driver" + "fmt" +) + +// Scan implements the database/sql.Scanner interface. +func (v *Version) Scan(src interface{}) (err error) { + var str string + switch src := src.(type) { + case string: + str = src + case []byte: + str = string(src) + default: + return fmt.Errorf("Version.Scan: cannot convert %T to string.", src) + } + + if t, err := Parse(str); err == nil { + *v = t + } + + return +} + +// Value implements the database/sql/driver.Valuer interface. +func (v Version) Value() (driver.Value, error) { + return v.String(), nil +} diff --git a/vendor/github.com/cloudfoundry/cli/LICENSE b/vendor/github.com/cloudfoundry/cli/LICENSE new file mode 100644 index 0000000..915b208 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright 2014 Pivotal + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/vendor/github.com/cloudfoundry/cli/cf/app_constants.go b/vendor/github.com/cloudfoundry/cli/cf/app_constants.go new file mode 100644 index 0000000..b1420a8 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/app_constants.go @@ -0,0 +1,15 @@ +package cf + +import ( + "os" + "path/filepath" +) + +var ( + Version = "BUILT_FROM_SOURCE" + BuiltOnDate = "BUILT_AT_UNKNOWN_TIME" +) + +func Name() string { + return filepath.Base(os.Args[0]) +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/configuration/config_disk_persistor.go b/vendor/github.com/cloudfoundry/cli/cf/configuration/config_disk_persistor.go new file mode 100644 index 0000000..47cbe85 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/configuration/config_disk_persistor.go @@ -0,0 +1,84 @@ +package configuration + +import ( + "io/ioutil" + "os" +) + +const ( + filePermissions = 0600 + dirPermissions = 0700 +) + +//go:generate counterfeiter -o fakes/fake_persistor.go . Persistor +type Persistor interface { + Delete() + Exists() bool + Load(DataInterface) error + Save(DataInterface) error +} + +type DataInterface interface { + JsonMarshalV3() ([]byte, error) + JsonUnmarshalV3([]byte) error +} + +type DiskPersistor struct { + filePath string +} + +func NewDiskPersistor(path string) (dp DiskPersistor) { + return DiskPersistor{ + filePath: path, + } +} + +func (dp DiskPersistor) Exists() bool { + _, err := os.Stat(dp.filePath) + if err != nil && !os.IsExist(err) { + return false + } + return true +} + +func (dp DiskPersistor) Delete() { + os.Remove(dp.filePath) +} + +func (dp DiskPersistor) Load(data DataInterface) error { + err := dp.read(data) + if os.IsPermission(err) { + return err + } + + if err != nil { + err = dp.write(data) + } + return err +} + +func (dp DiskPersistor) Save(data DataInterface) (err error) { + return dp.write(data) +} + +func (dp DiskPersistor) read(data DataInterface) error { + dp.makeDirectory() + + jsonBytes, err := ioutil.ReadFile(dp.filePath) + if err != nil { + return err + } + + err = data.JsonUnmarshalV3(jsonBytes) + return err +} + +func (dp DiskPersistor) write(data DataInterface) error { + bytes, err := data.JsonMarshalV3() + if err != nil { + return err + } + + err = ioutil.WriteFile(dp.filePath, bytes, filePermissions) + return err +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/configuration/config_disk_persistor_unix.go b/vendor/github.com/cloudfoundry/cli/cf/configuration/config_disk_persistor_unix.go new file mode 100644 index 0000000..b1d4520 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/configuration/config_disk_persistor_unix.go @@ -0,0 +1,12 @@ +// +build !windows + +package configuration + +import ( + "os" + "path/filepath" +) + +func (dp DiskPersistor) makeDirectory() error { + return os.MkdirAll(filepath.Dir(dp.filePath), dirPermissions) +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/configuration/config_disk_persistor_win.go b/vendor/github.com/cloudfoundry/cli/cf/configuration/config_disk_persistor_win.go new file mode 100644 index 0000000..859d252 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/configuration/config_disk_persistor_win.go @@ -0,0 +1,30 @@ +// +build windows + +package configuration + +import ( + "os" + "path/filepath" + "syscall" +) + +func (dp DiskPersistor) makeDirectory() error { + dir := filepath.Dir(dp.filePath) + + err := os.MkdirAll(dir, dirPermissions) + if err != nil { + return err + } + + p, err := syscall.UTF16PtrFromString(dir) + if err != nil { + return err + } + + attrs, err := syscall.GetFileAttributes(p) + if err != nil { + return err + } + + return syscall.SetFileAttributes(p, attrs|syscall.FILE_ATTRIBUTE_HIDDEN) +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/configuration/core_config/access_token.go b/vendor/github.com/cloudfoundry/cli/cf/configuration/core_config/access_token.go new file mode 100644 index 0000000..5c9479b --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/configuration/core_config/access_token.go @@ -0,0 +1,60 @@ +package core_config + +import ( + "encoding/base64" + "encoding/json" + "strings" +) + +type TokenInfo struct { + Username string `json:"user_name"` + Email string `json:"email"` + UserGuid string `json:"user_id"` +} + +func NewTokenInfo(accessToken string) (info TokenInfo) { + tokenJson, err := DecodeAccessToken(accessToken) + if err != nil { + return TokenInfo{} + } + + info = TokenInfo{} + err = json.Unmarshal(tokenJson, &info) + if err != nil { + return TokenInfo{} + } + + return info +} + +func DecodeAccessToken(accessToken string) (tokenJson []byte, err error) { + tokenParts := strings.Split(accessToken, " ") + + if len(tokenParts) < 2 { + return + } + + token := tokenParts[1] + encodedParts := strings.Split(token, ".") + + if len(encodedParts) < 3 { + return + } + + encodedTokenJson := encodedParts[1] + return base64Decode(encodedTokenJson) +} + +func base64Decode(encodedData string) ([]byte, error) { + return base64.StdEncoding.DecodeString(restorePadding(encodedData)) +} + +func restorePadding(seg string) string { + switch len(seg) % 4 { + case 2: + seg = seg + "==" + case 3: + seg = seg + "=" + } + return seg +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/configuration/core_config/config_data.go b/vendor/github.com/cloudfoundry/cli/cf/configuration/core_config/config_data.go new file mode 100644 index 0000000..c7500ea --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/configuration/core_config/config_data.go @@ -0,0 +1,67 @@ +package core_config + +import ( + "encoding/json" + + "github.com/cloudfoundry/cli/cf/models" +) + +type AuthPromptType string + +const ( + AuthPromptTypeText AuthPromptType = "TEXT" + AuthPromptTypePassword AuthPromptType = "PASSWORD" +) + +type AuthPrompt struct { + Type AuthPromptType + DisplayName string +} + +type Data struct { + ConfigVersion int + Target string + ApiVersion string + AuthorizationEndpoint string + LoggregatorEndPoint string + DopplerEndPoint string + UaaEndpoint string + RoutingApiEndpoint string + AccessToken string + SSHOAuthClient string + RefreshToken string + OrganizationFields models.OrganizationFields + SpaceFields models.SpaceFields + SSLDisabled bool + AsyncTimeout uint + Trace string + ColorEnabled string + Locale string + PluginRepos []models.PluginRepo + MinCliVersion string + MinRecommendedCliVersion string +} + +func NewData() (data *Data) { + data = new(Data) + return +} + +func (d *Data) JsonMarshalV3() (output []byte, err error) { + d.ConfigVersion = 3 + return json.MarshalIndent(d, "", " ") +} + +func (d *Data) JsonUnmarshalV3(input []byte) (err error) { + err = json.Unmarshal(input, d) + if err != nil { + return + } + + if d.ConfigVersion != 3 { + *d = Data{} + return + } + + return +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/configuration/core_config/config_repository.go b/vendor/github.com/cloudfoundry/cli/cf/configuration/core_config/config_repository.go new file mode 100644 index 0000000..57bcd43 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/configuration/core_config/config_repository.go @@ -0,0 +1,531 @@ +package core_config + +import ( + "strings" + "sync" + + "github.com/blang/semver" + "github.com/cloudfoundry/cli/cf/configuration" + "github.com/cloudfoundry/cli/cf/models" +) + +type ConfigRepository struct { + data *Data + mutex *sync.RWMutex + initOnce *sync.Once + persistor configuration.Persistor + onError func(error) +} + +func NewRepositoryFromFilepath(filepath string, errorHandler func(error)) Repository { + if errorHandler == nil { + return nil + } + return NewRepositoryFromPersistor(configuration.NewDiskPersistor(filepath), errorHandler) +} + +func NewRepositoryFromPersistor(persistor configuration.Persistor, errorHandler func(error)) Repository { + data := NewData() + if !persistor.Exists() { + //set default plugin repo + data.PluginRepos = append(data.PluginRepos, models.PluginRepo{ + Name: "CF-Community", + Url: "http://plugins.cloudfoundry.org", + }) + } + + return &ConfigRepository{ + data: data, + mutex: new(sync.RWMutex), + initOnce: new(sync.Once), + persistor: persistor, + onError: errorHandler, + } +} + +type Reader interface { + ApiEndpoint() string + ApiVersion() string + HasAPIEndpoint() bool + + AuthenticationEndpoint() string + LoggregatorEndpoint() string + DopplerEndpoint() string + UaaEndpoint() string + RoutingApiEndpoint() string + AccessToken() string + SSHOAuthClient() string + RefreshToken() string + + OrganizationFields() models.OrganizationFields + HasOrganization() bool + + SpaceFields() models.SpaceFields + HasSpace() bool + + Username() string + UserGuid() string + UserEmail() string + IsLoggedIn() bool + IsSSLDisabled() bool + IsMinApiVersion(string) bool + IsMinCliVersion(string) bool + MinCliVersion() string + MinRecommendedCliVersion() string + + AsyncTimeout() uint + Trace() string + + ColorEnabled() string + + Locale() string + + PluginRepos() []models.PluginRepo +} + +//go:generate counterfeiter -o ../fakes/fake_repository.go . ReadWriter +type ReadWriter interface { + Reader + ClearSession() + SetApiEndpoint(string) + SetApiVersion(string) + SetMinCliVersion(string) + SetMinRecommendedCliVersion(string) + SetAuthenticationEndpoint(string) + SetLoggregatorEndpoint(string) + SetDopplerEndpoint(string) + SetUaaEndpoint(string) + SetRoutingApiEndpoint(string) + SetAccessToken(string) + SetSSHOAuthClient(string) + SetRefreshToken(string) + SetOrganizationFields(models.OrganizationFields) + SetSpaceFields(models.SpaceFields) + SetSSLDisabled(bool) + SetAsyncTimeout(uint) + SetTrace(string) + SetColorEnabled(string) + SetLocale(string) + SetPluginRepo(models.PluginRepo) + UnSetPluginRepo(int) +} + +type Repository interface { + ReadWriter + Close() +} + +// ACCESS CONTROL + +func (c *ConfigRepository) init() { + c.initOnce.Do(func() { + err := c.persistor.Load(c.data) + if err != nil { + c.onError(err) + } + }) +} + +func (c *ConfigRepository) read(cb func()) { + c.mutex.RLock() + defer c.mutex.RUnlock() + c.init() + + cb() +} + +func (c *ConfigRepository) write(cb func()) { + c.mutex.Lock() + defer c.mutex.Unlock() + c.init() + + cb() + + err := c.persistor.Save(c.data) + if err != nil { + c.onError(err) + } +} + +// CLOSERS + +func (c *ConfigRepository) Close() { + c.read(func() { + // perform a read to ensure write lock has been cleared + }) +} + +// GETTERS + +func (c *ConfigRepository) ApiVersion() (apiVersion string) { + c.read(func() { + apiVersion = c.data.ApiVersion + }) + return +} + +func (c *ConfigRepository) AuthenticationEndpoint() (authEndpoint string) { + c.read(func() { + authEndpoint = c.data.AuthorizationEndpoint + }) + return +} + +func (c *ConfigRepository) LoggregatorEndpoint() (logEndpoint string) { + c.read(func() { + logEndpoint = c.data.LoggregatorEndPoint + }) + return +} + +func (c *ConfigRepository) DopplerEndpoint() (logEndpoint string) { + //revert this in v7.0, once CC advertise doppler endpoint, and + //everyone has migrated from loggregator to doppler + + // c.read(func() { + // logEndpoint = c.data.DopplerEndPoint + // }) + c.read(func() { + logEndpoint = c.data.LoggregatorEndPoint + }) + + return strings.Replace(logEndpoint, "loggregator", "doppler", 1) +} + +func (c *ConfigRepository) UaaEndpoint() (uaaEndpoint string) { + c.read(func() { + uaaEndpoint = c.data.UaaEndpoint + }) + return +} + +func (c *ConfigRepository) RoutingApiEndpoint() (routingApiEndpoint string) { + c.read(func() { + routingApiEndpoint = c.data.RoutingApiEndpoint + }) + return +} + +func (c *ConfigRepository) ApiEndpoint() (apiEndpoint string) { + c.read(func() { + apiEndpoint = c.data.Target + }) + return +} + +func (c *ConfigRepository) HasAPIEndpoint() (hasEndpoint bool) { + c.read(func() { + hasEndpoint = c.data.ApiVersion != "" && c.data.Target != "" + }) + return +} + +func (c *ConfigRepository) AccessToken() (accessToken string) { + c.read(func() { + accessToken = c.data.AccessToken + }) + return +} + +func (c *ConfigRepository) SSHOAuthClient() (clientID string) { + c.read(func() { + clientID = c.data.SSHOAuthClient + }) + return +} + +func (c *ConfigRepository) RefreshToken() (refreshToken string) { + c.read(func() { + refreshToken = c.data.RefreshToken + }) + return +} + +func (c *ConfigRepository) OrganizationFields() (org models.OrganizationFields) { + c.read(func() { + org = c.data.OrganizationFields + }) + return +} + +func (c *ConfigRepository) SpaceFields() (space models.SpaceFields) { + c.read(func() { + space = c.data.SpaceFields + }) + return +} + +func (c *ConfigRepository) UserEmail() (email string) { + c.read(func() { + email = NewTokenInfo(c.data.AccessToken).Email + }) + return +} + +func (c *ConfigRepository) UserGuid() (guid string) { + c.read(func() { + guid = NewTokenInfo(c.data.AccessToken).UserGuid + }) + return +} + +func (c *ConfigRepository) Username() (name string) { + c.read(func() { + name = NewTokenInfo(c.data.AccessToken).Username + }) + return +} + +func (c *ConfigRepository) IsLoggedIn() (loggedIn bool) { + c.read(func() { + loggedIn = c.data.AccessToken != "" + }) + return +} + +func (c *ConfigRepository) HasOrganization() (hasOrg bool) { + c.read(func() { + hasOrg = c.data.OrganizationFields.Guid != "" && c.data.OrganizationFields.Name != "" + }) + return +} + +func (c *ConfigRepository) HasSpace() (hasSpace bool) { + c.read(func() { + hasSpace = c.data.SpaceFields.Guid != "" && c.data.SpaceFields.Name != "" + }) + return +} + +func (c *ConfigRepository) IsSSLDisabled() (isSSLDisabled bool) { + c.read(func() { + isSSLDisabled = c.data.SSLDisabled + }) + return +} + +func (c *ConfigRepository) IsMinApiVersion(version string) bool { + var apiVersion string + c.read(func() { + apiVersion = c.data.ApiVersion + }) + + requiredVersion, err := semver.Make(version) + if err != nil { + return false + } + actualVersion, err := semver.Make(apiVersion) + if err != nil { + return false + } + return actualVersion.GTE(requiredVersion) +} + +func (c *ConfigRepository) IsMinCliVersion(version string) bool { + if version == "BUILT_FROM_SOURCE" { + return true + } + var minCliVersion string + c.read(func() { + minCliVersion = c.data.MinCliVersion + }) + if minCliVersion == "" { + return true + } + + actualVersion, err := semver.Make(version) + if err != nil { + return false + } + requiredVersion, err := semver.Make(minCliVersion) + if err != nil { + return false + } + return actualVersion.GTE(requiredVersion) +} + +func (c *ConfigRepository) MinCliVersion() (minCliVersion string) { + c.read(func() { + minCliVersion = c.data.MinCliVersion + }) + return +} + +func (c *ConfigRepository) MinRecommendedCliVersion() (minRecommendedCliVersion string) { + c.read(func() { + minRecommendedCliVersion = c.data.MinRecommendedCliVersion + }) + return +} + +func (c *ConfigRepository) AsyncTimeout() (timeout uint) { + c.read(func() { + timeout = c.data.AsyncTimeout + }) + return +} + +func (c *ConfigRepository) Trace() (trace string) { + c.read(func() { + trace = c.data.Trace + }) + return +} + +func (c *ConfigRepository) ColorEnabled() (enabled string) { + c.read(func() { + enabled = c.data.ColorEnabled + }) + return +} + +func (c *ConfigRepository) Locale() (locale string) { + c.read(func() { + locale = c.data.Locale + }) + return +} + +func (c *ConfigRepository) PluginRepos() (repos []models.PluginRepo) { + c.read(func() { + repos = c.data.PluginRepos + }) + return +} + +// SETTERS + +func (c *ConfigRepository) ClearSession() { + c.write(func() { + c.data.AccessToken = "" + c.data.RefreshToken = "" + c.data.OrganizationFields = models.OrganizationFields{} + c.data.SpaceFields = models.SpaceFields{} + }) +} + +func (c *ConfigRepository) SetApiEndpoint(endpoint string) { + c.write(func() { + c.data.Target = endpoint + }) +} + +func (c *ConfigRepository) SetApiVersion(version string) { + c.write(func() { + c.data.ApiVersion = version + }) +} + +func (c *ConfigRepository) SetMinCliVersion(version string) { + c.write(func() { + c.data.MinCliVersion = version + }) +} + +func (c *ConfigRepository) SetMinRecommendedCliVersion(version string) { + c.write(func() { + c.data.MinRecommendedCliVersion = version + }) +} + +func (c *ConfigRepository) SetAuthenticationEndpoint(endpoint string) { + c.write(func() { + c.data.AuthorizationEndpoint = endpoint + }) +} + +func (c *ConfigRepository) SetLoggregatorEndpoint(endpoint string) { + c.write(func() { + c.data.LoggregatorEndPoint = endpoint + }) +} + +func (c *ConfigRepository) SetDopplerEndpoint(endpoint string) { + c.write(func() { + c.data.DopplerEndPoint = endpoint + }) +} + +func (c *ConfigRepository) SetUaaEndpoint(uaaEndpoint string) { + c.write(func() { + c.data.UaaEndpoint = uaaEndpoint + }) +} + +func (c *ConfigRepository) SetRoutingApiEndpoint(routingApiEndpoint string) { + c.write(func() { + c.data.RoutingApiEndpoint = routingApiEndpoint + }) +} + +func (c *ConfigRepository) SetAccessToken(token string) { + c.write(func() { + c.data.AccessToken = token + }) +} + +func (c *ConfigRepository) SetSSHOAuthClient(clientID string) { + c.write(func() { + c.data.SSHOAuthClient = clientID + }) +} + +func (c *ConfigRepository) SetRefreshToken(token string) { + c.write(func() { + c.data.RefreshToken = token + }) +} + +func (c *ConfigRepository) SetOrganizationFields(org models.OrganizationFields) { + c.write(func() { + c.data.OrganizationFields = org + }) +} + +func (c *ConfigRepository) SetSpaceFields(space models.SpaceFields) { + c.write(func() { + c.data.SpaceFields = space + }) +} + +func (c *ConfigRepository) SetSSLDisabled(disabled bool) { + c.write(func() { + c.data.SSLDisabled = disabled + }) +} + +func (c *ConfigRepository) SetAsyncTimeout(timeout uint) { + c.write(func() { + c.data.AsyncTimeout = timeout + }) +} + +func (c *ConfigRepository) SetTrace(value string) { + c.write(func() { + c.data.Trace = value + }) +} + +func (c *ConfigRepository) SetColorEnabled(enabled string) { + c.write(func() { + c.data.ColorEnabled = enabled + }) +} + +func (c *ConfigRepository) SetLocale(locale string) { + c.write(func() { + c.data.Locale = locale + }) +} + +func (c *ConfigRepository) SetPluginRepo(repo models.PluginRepo) { + c.write(func() { + c.data.PluginRepos = append(c.data.PluginRepos, repo) + }) +} + +func (c *ConfigRepository) UnSetPluginRepo(index int) { + c.write(func() { + c.data.PluginRepos = append(c.data.PluginRepos[:index], c.data.PluginRepos[index+1:]...) + }) +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/endpoints.go b/vendor/github.com/cloudfoundry/cli/cf/endpoints.go new file mode 100644 index 0000000..19e56d8 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/endpoints.go @@ -0,0 +1,9 @@ +package cf + +type EndpointType string + +const ( + UaaEndpointKey EndpointType = "uaa" + LoggregatorEndpointKey = "loggregator" + CloudControllerEndpointKey = "cloud_controller" +) diff --git a/vendor/github.com/cloudfoundry/cli/cf/formatters/bools.go b/vendor/github.com/cloudfoundry/cli/cf/formatters/bools.go new file mode 100644 index 0000000..ff73072 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/formatters/bools.go @@ -0,0 +1,12 @@ +package formatters + +import ( + . "github.com/cloudfoundry/cli/cf/i18n" +) + +func Allowed(allowed bool) string { + if allowed { + return T("allowed") + } + return T("disallowed") +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/formatters/bytes.go b/vendor/github.com/cloudfoundry/cli/cf/formatters/bytes.go new file mode 100644 index 0000000..9d1b832 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/formatters/bytes.go @@ -0,0 +1,82 @@ +package formatters + +import ( + "errors" + "fmt" + "regexp" + "strconv" + "strings" + + . "github.com/cloudfoundry/cli/cf/i18n" +) + +const ( + BYTE = 1.0 + KILOBYTE = 1024 * BYTE + MEGABYTE = 1024 * KILOBYTE + GIGABYTE = 1024 * MEGABYTE + TERABYTE = 1024 * GIGABYTE +) + +func ByteSize(bytes int64) string { + unit := "" + value := float32(bytes) + + switch { + case bytes >= TERABYTE: + unit = "T" + value = value / TERABYTE + case bytes >= GIGABYTE: + unit = "G" + value = value / GIGABYTE + case bytes >= MEGABYTE: + unit = "M" + value = value / MEGABYTE + case bytes >= KILOBYTE: + unit = "K" + value = value / KILOBYTE + case bytes == 0: + return "0" + case bytes < KILOBYTE: + unit = "B" + } + + stringValue := fmt.Sprintf("%.1f", value) + stringValue = strings.TrimSuffix(stringValue, ".0") + return fmt.Sprintf("%s%s", stringValue, unit) +} + +func ToMegabytes(s string) (int64, error) { + parts := bytesPattern.FindStringSubmatch(strings.TrimSpace(s)) + if len(parts) < 3 { + return 0, invalidByteQuantityError() + } + + value, err := strconv.ParseInt(parts[1], 10, 0) + if err != nil { + return 0, invalidByteQuantityError() + } + + var bytes int64 + unit := strings.ToUpper(parts[2]) + switch unit { + case "T": + bytes = value * TERABYTE + case "G": + bytes = value * GIGABYTE + case "M": + bytes = value * MEGABYTE + case "K": + bytes = value * KILOBYTE + } + + return bytes / MEGABYTE, nil +} + +var ( + bytesPattern *regexp.Regexp = regexp.MustCompile(`(?i)^(-?\d+)([KMGT])B?$`) +) + +func invalidByteQuantityError() error { + return errors.New(T("Byte quantity must be an integer with a unit of measurement like M, MB, G, or GB")) +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/formatters/memoryLimit.go b/vendor/github.com/cloudfoundry/cli/cf/formatters/memoryLimit.go new file mode 100644 index 0000000..3fa15d4 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/formatters/memoryLimit.go @@ -0,0 +1,11 @@ +package formatters + +import "strconv" + +func InstanceMemoryLimit(limit int64) string { + if limit == -1 { + return "Unlimited" + } + + return strconv.FormatInt(limit, 10) + "M" +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/formatters/string.go b/vendor/github.com/cloudfoundry/cli/cf/formatters/string.go new file mode 100644 index 0000000..fc09732 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/formatters/string.go @@ -0,0 +1,16 @@ +package formatters + +import ( + "fmt" + "reflect" +) + +func MapStr(args interface{}) []string { + r := reflect.ValueOf(args) + rval := make([]string, r.Len()) + for i := 0; i < r.Len(); i++ { + rval[i] = r.Index(i).Interface().(fmt.Stringer).String() + } + return rval + +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/i18n/README-i18n.md b/vendor/github.com/cloudfoundry/cli/cf/i18n/README-i18n.md new file mode 100644 index 0000000..ce4d105 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/i18n/README-i18n.md @@ -0,0 +1,48 @@ +# CLI i18n Support + +The CLI currently supports a variety of languages. These translations can be accessed by setting either LC_ALL or LANG in your environment, or by setting your locale within the cli via `cf config -locale your_LOCALE # (e.g. fr_FR)`. + +Translations only affect messages generated by the CLI. Responses from server side components (Cloud Controller, etc.) will be internationalized separately and are likely to be English. + +If you are interested in submitting translations for a currently unsupported language/locale, please communicate with us via the [cf-dev](https://lists.cloudfoundry.org/archives/list/cf-dev@lists.cloudfoundry.org/) mailing list. + +## How can you contribute? + +If you see typos, errors in grammar, ambiguous strings or English after setting your locale, please find the appropriate entry in the corresponding `cf/i18n/resources/_.all.json` file and submit a [pull request](https://help.github.com/articles/creating-a-pull-request/) with the fix(es). It is much better to submit small pull requests as you complete translations, rather than submitting a large one. This makes it much easier to rapidly merge your changes in. You can also report translations needing fixes as an issue in Github. + +Pull requests should only contain changes to "translation" values; the "id" value should not change as it is the key which is used to find the translations, and will always be English. For example: + +Given a missing translation for "Create an org": +``` +[ + { + "id":"Create an org", + "translation":"" + }, + ... +] +``` + +Adding the translation would look like: +``` +[ + { + "id":"Create an org", + "translation":"Créez un org" + }, + ... +] +``` + +Finally, it is also important not to translate the argument names in templated strings. Templated strings are the ones which contain arguments, e.g., `{{.Name}}` or `{{.Username}}` and so on. The arguments can move to a different location on the translated string, however, the arguments cannot change, should not be translated, and should not be removed or new ones added. So for instance, the following string is translated in French as follows: + +``` +[ + ..., + { + "id": "Creating quota {{.QuotaName}} as {{.Username}}...", + "translation": "Créez quota {{.QuotaName}} étant {{.Username}}..." + }, + ... +] +``` diff --git a/vendor/github.com/cloudfoundry/cli/cf/i18n/excluded.json b/vendor/github.com/cloudfoundry/cli/cf/i18n/excluded.json new file mode 100644 index 0000000..ede5b16 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/i18n/excluded.json @@ -0,0 +1,41 @@ +{ + "excludedStrings" : [ + "", + " ", + "\n", + "\t", + "\n\t", + "extract_strings", + "excluded.json", + "i18n4go", + ".en.json", + ".extracted.json", + "recursive:", + ".json", + ".po", + ", column: ", + ", line: ", + ", offset: ", + "msgid ", + "msgstr ", + "# filename: ", + ".", + "\\", + "help", + ".go", + "", + "/", + "false", + "true", + + "allow-paid-service-plans" + ], + "excludedRegexps" : [ + "^\\d+$", + "^[-%]?\\w$", + "^\\w$", + "^json:", + "^\\w*[-]?quota[-]?\\w*$", + "^\\w+-paid-service-plans$" + ] +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/i18n/i18n.go b/vendor/github.com/cloudfoundry/cli/cf/i18n/i18n.go new file mode 100644 index 0000000..bae4683 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/i18n/i18n.go @@ -0,0 +1,83 @@ +package i18n + +import ( + "fmt" + "os" + "path" + "strings" + + "github.com/cloudfoundry/cli/cf/configuration/core_config" + "github.com/cloudfoundry/cli/cf/resources" + go_i18n "github.com/nicksnyder/go-i18n/i18n" + "github.com/nicksnyder/go-i18n/i18n/language" +) + +const ( + defaultLocale = "en-us" + lang = "LANG" + lcAll = "LC_ALL" + resourceSuffix = ".all.json" + zhTW = "zh-tw" + zhHK = "zh-hk" + zhHant = "zh-hant" + hyphen = "-" + underscore = "_" +) + +var T go_i18n.TranslateFunc + +func Init(config core_config.Reader) go_i18n.TranslateFunc { + loadAsset("cf/i18n/resources/" + defaultLocale + resourceSuffix) + defaultTfunc := go_i18n.MustTfunc(defaultLocale) + + assetNames := resources.AssetNames() + + sources := []string{ + config.Locale(), + os.Getenv(lcAll), + os.Getenv(lang), + } + + for _, source := range sources { + if source == "" { + continue + } + + for _, l := range language.Parse(source) { + if l.Tag == zhTW || l.Tag == zhHK { + l.Tag = zhHant + } + + for _, assetName := range assetNames { + assetLocale := strings.ToLower(strings.Replace(path.Base(assetName), underscore, hyphen, -1)) + if strings.HasPrefix(assetLocale, l.Tag) { + loadAsset(assetName) + + t := go_i18n.MustTfunc(source) + + return func(translationID string, args ...interface{}) string { + if translated := t(translationID, args...); translated != translationID { + return translated + } + + return defaultTfunc(translationID, args...) + } + } + } + } + } + + return defaultTfunc +} + +func loadAsset(assetName string) { + assetBytes, err := resources.Asset(assetName) + if err != nil { + panic(fmt.Sprintf("Could not load asset '%s': %s", assetName, err.Error())) + } + + err = go_i18n.ParseTranslationFileBytes(assetName, assetBytes) + if err != nil { + panic(fmt.Sprintf("Could not load translations '%s': %s", assetName, err.Error())) + } +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/i18n/locale.go b/vendor/github.com/cloudfoundry/cli/cf/i18n/locale.go new file mode 100644 index 0000000..d6d4036 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/i18n/locale.go @@ -0,0 +1,55 @@ +package i18n + +import ( + "path" + "strings" + + "github.com/cloudfoundry/cli/cf/resources" + "github.com/nicksnyder/go-i18n/i18n/language" +) + +func SupportedLocales() []string { + languages := supportedLanguages() + localeNames := make([]string, len(languages)) + + for i, l := range languages { + localeParts := strings.Split(l.String(), "-") + lang := localeParts[0] + regionOrScript := localeParts[1] + + switch len(regionOrScript) { + case 2: // Region + localeNames[i] = lang + "-" + strings.ToUpper(regionOrScript) + case 4: // Script + localeNames[i] = lang + "-" + strings.Title(regionOrScript) + default: + localeNames[i] = l.String() + } + } + + return localeNames +} + +func IsSupportedLocale(locale string) bool { + for _, supportedLanguage := range supportedLanguages() { + for _, l := range language.Parse(locale) { + if supportedLanguage.String() == l.String() { + return true + } + } + } + + return false +} + +func supportedLanguages() []*language.Language { + assetNames := resources.AssetNames() + languages := []*language.Language{} + + for _, assetName := range assetNames { + assetLocale := strings.TrimSuffix(path.Base(assetName), resourceSuffix) + languages = append(languages, language.Parse(assetLocale)...) + } + + return languages +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/app_event.go b/vendor/github.com/cloudfoundry/cli/cf/models/app_event.go new file mode 100644 index 0000000..9bfa707 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/app_event.go @@ -0,0 +1,11 @@ +package models + +import "time" + +type EventFields struct { + Guid string + Name string + Timestamp time.Time + Description string + ActorName string +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/app_file.go b/vendor/github.com/cloudfoundry/cli/cf/models/app_file.go new file mode 100644 index 0000000..33f23d3 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/app_file.go @@ -0,0 +1,8 @@ +package models + +type AppFileFields struct { + Path string + Sha1 string + Size int64 + Mode string +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/app_instance.go b/vendor/github.com/cloudfoundry/cli/cf/models/app_instance.go new file mode 100644 index 0000000..514c52d --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/app_instance.go @@ -0,0 +1,24 @@ +package models + +import "time" + +type InstanceState string + +const ( + InstanceStarting InstanceState = "starting" + InstanceRunning InstanceState = "running" + InstanceFlapping InstanceState = "flapping" + InstanceDown InstanceState = "down" + InstanceCrashed InstanceState = "crashed" +) + +type AppInstanceFields struct { + State InstanceState + Details string + Since time.Time + CpuUsage float64 // percentage + DiskQuota int64 // in bytes + DiskUsage int64 + MemQuota int64 + MemUsage int64 +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/application.go b/vendor/github.com/cloudfoundry/cli/cf/models/application.go new file mode 100644 index 0000000..be1b800 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/application.go @@ -0,0 +1,183 @@ +package models + +import ( + "reflect" + "strings" + "time" +) + +type Application struct { + ApplicationFields + Stack *Stack + Routes []RouteSummary + Services []ServicePlanSummary +} + +func (model Application) HasRoute(route Route) bool { + for _, boundRoute := range model.Routes { + if boundRoute.Guid == route.Guid { + return true + } + } + return false +} + +func (model Application) ToParams() (params AppParams) { + state := strings.ToUpper(model.State) + params = AppParams{ + Guid: &model.Guid, + Name: &model.Name, + BuildpackUrl: &model.BuildpackUrl, + Command: &model.Command, + DiskQuota: &model.DiskQuota, + InstanceCount: &model.InstanceCount, + HealthCheckType: &model.HealthCheckType, + Memory: &model.Memory, + State: &state, + SpaceGuid: &model.SpaceGuid, + EnvironmentVars: &model.EnvironmentVars, + DockerImage: &model.DockerImage, + } + + if model.Stack != nil { + params.StackGuid = &model.Stack.Guid + } + + return +} + +type ApplicationFields struct { + Guid string + Name string + BuildpackUrl string + Command string + Diego bool + DetectedStartCommand string + DiskQuota int64 // in Megabytes + EnvironmentVars map[string]interface{} + InstanceCount int + Memory int64 // in Megabytes + RunningInstances int + HealthCheckType string + HealthCheckTimeout int + State string + SpaceGuid string + StackGuid string + PackageUpdatedAt *time.Time + PackageState string + StagingFailedReason string + Buildpack string + DetectedBuildpack string + DockerImage string + EnableSsh bool +} + +type AppParams struct { + BuildpackUrl *string + Command *string + DiskQuota *int64 + Domains *[]string + EnvironmentVars *map[string]interface{} + Guid *string + HealthCheckType *string + HealthCheckTimeout *int + DockerImage *string + Diego *bool + EnableSsh *bool + Hosts *[]string + RoutePath *string + InstanceCount *int + Memory *int64 + Name *string + NoHostname bool + NoRoute bool + UseRandomHostname bool + Path *string + ServicesToBind *[]string + SpaceGuid *string + StackGuid *string + StackName *string + State *string + PackageUpdatedAt *time.Time +} + +func (app *AppParams) Merge(other *AppParams) { + if other.BuildpackUrl != nil { + app.BuildpackUrl = other.BuildpackUrl + } + if other.Command != nil { + app.Command = other.Command + } + if other.DiskQuota != nil { + app.DiskQuota = other.DiskQuota + } + if other.Domains != nil { + app.Domains = other.Domains + } + if other.EnvironmentVars != nil { + app.EnvironmentVars = other.EnvironmentVars + } + if other.Guid != nil { + app.Guid = other.Guid + } + if other.HealthCheckType != nil { + app.HealthCheckType = other.HealthCheckType + } + if other.HealthCheckTimeout != nil { + app.HealthCheckTimeout = other.HealthCheckTimeout + } + if other.Hosts != nil { + app.Hosts = other.Hosts + } + if other.RoutePath != nil { + app.RoutePath = other.RoutePath + } + if other.InstanceCount != nil { + app.InstanceCount = other.InstanceCount + } + if other.DiskQuota != nil { + app.DiskQuota = other.DiskQuota + } + if other.Memory != nil { + app.Memory = other.Memory + } + if other.DockerImage != nil { + app.DockerImage = other.DockerImage + } + if other.Name != nil { + app.Name = other.Name + } + if other.Path != nil { + app.Path = other.Path + } + if other.ServicesToBind != nil { + app.ServicesToBind = other.ServicesToBind + } + if other.SpaceGuid != nil { + app.SpaceGuid = other.SpaceGuid + } + if other.StackGuid != nil { + app.StackGuid = other.StackGuid + } + if other.StackName != nil { + app.StackName = other.StackName + } + if other.State != nil { + app.State = other.State + } + if other.EnableSsh != nil { + app.EnableSsh = other.EnableSsh + } + + app.NoRoute = app.NoRoute || other.NoRoute + app.NoHostname = app.NoHostname || other.NoHostname + app.UseRandomHostname = app.UseRandomHostname || other.UseRandomHostname +} + +func (app *AppParams) IsEmpty() bool { + return reflect.DeepEqual(*app, AppParams{}) +} + +func (app *AppParams) IsHostEmpty() bool { + return app.Hosts == nil || len(*app.Hosts) == 0 +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/buildpack.go b/vendor/github.com/cloudfoundry/cli/cf/models/buildpack.go new file mode 100644 index 0000000..f53416b --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/buildpack.go @@ -0,0 +1,11 @@ +package models + +type Buildpack struct { + Guid string + Name string + Position *int + Enabled *bool + Key string + Filename string + Locked *bool +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/domain.go b/vendor/github.com/cloudfoundry/cli/cf/models/domain.go new file mode 100644 index 0000000..1f5fbc7 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/domain.go @@ -0,0 +1,13 @@ +package models + +type DomainFields struct { + Guid string + Name string + OwningOrganizationGuid string + RouterGroupGuid string + Shared bool +} + +func (model DomainFields) UrlForHostAndPath(host, path string) string { + return urlStringFromParts(host, model.Name, path) +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/environment.go b/vendor/github.com/cloudfoundry/cli/cf/models/environment.go new file mode 100644 index 0000000..48a6fe7 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/environment.go @@ -0,0 +1,19 @@ +package models + +func NewEnvironment() *Environment { + return &Environment{ + System: make(map[string]interface{}), + Application: make(map[string]interface{}), + Environment: make(map[string]interface{}), + Running: make(map[string]interface{}), + Staging: make(map[string]interface{}), + } +} + +type Environment struct { + System map[string]interface{} `json:"system_env_json,omitempty"` + Environment map[string]interface{} `json:"environment_json,omitempty"` + Running map[string]interface{} `json:"running_env_json,omitempty"` + Staging map[string]interface{} `json:"staging_env_json,omitempty"` + Application map[string]interface{} `json:"application_env_json,omitempty"` +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/environment_variable.go b/vendor/github.com/cloudfoundry/cli/cf/models/environment_variable.go new file mode 100644 index 0000000..db14923 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/environment_variable.go @@ -0,0 +1,6 @@ +package models + +type EnvironmentVariable struct { + Name string + Value string +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/feature_flag.go b/vendor/github.com/cloudfoundry/cli/cf/models/feature_flag.go new file mode 100644 index 0000000..f50389c --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/feature_flag.go @@ -0,0 +1,7 @@ +package models + +type FeatureFlag struct { + Name string `json:"name"` + Enabled bool `json:"enabled"` + ErrorMessage string `json:"error_message"` +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/organization.go b/vendor/github.com/cloudfoundry/cli/cf/models/organization.go new file mode 100644 index 0000000..ac7d1e5 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/organization.go @@ -0,0 +1,14 @@ +package models + +type OrganizationFields struct { + Guid string + Name string + QuotaDefinition QuotaFields +} + +type Organization struct { + OrganizationFields + Spaces []SpaceFields + Domains []DomainFields + SpaceQuotas []SpaceQuota +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/plugin_repo.go b/vendor/github.com/cloudfoundry/cli/cf/models/plugin_repo.go new file mode 100644 index 0000000..25337df --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/plugin_repo.go @@ -0,0 +1,6 @@ +package models + +type PluginRepo struct { + Name string + Url string +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/quota.go b/vendor/github.com/cloudfoundry/cli/cf/models/quota.go new file mode 100644 index 0000000..751a03d --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/quota.go @@ -0,0 +1,21 @@ +package models + +func NewQuotaFields(name string, memory int64, InstanceMemoryLimit int64, routes int, services int, nonbasicservices bool) (q QuotaFields) { + q.Name = name + q.MemoryLimit = memory + q.InstanceMemoryLimit = InstanceMemoryLimit + q.RoutesLimit = routes + q.ServicesLimit = services + q.NonBasicServicesAllowed = nonbasicservices + return +} + +type QuotaFields struct { + Guid string `json:"guid,omitempty"` + Name string `json:"name"` + MemoryLimit int64 `json:"memory_limit"` // in Megabytes + InstanceMemoryLimit int64 `json:"instance_memory_limit"` // in Megabytes + RoutesLimit int `json:"total_routes"` + ServicesLimit int `json:"total_services"` + NonBasicServicesAllowed bool `json:"non_basic_services_allowed"` +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/route.go b/vendor/github.com/cloudfoundry/cli/cf/models/route.go new file mode 100644 index 0000000..651aaea --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/route.go @@ -0,0 +1,38 @@ +package models + +import ( + "fmt" + "net/url" + "strings" +) + +type Route struct { + Guid string + Host string + Domain DomainFields + Path string + + Space SpaceFields + Apps []ApplicationFields + ServiceInstance ServiceInstanceFields +} + +func (r Route) URL() string { + return urlStringFromParts(r.Host, r.Domain.Name, r.Path) +} + +func urlStringFromParts(hostName, domainName, path string) string { + var host string + if hostName != "" { + host = fmt.Sprintf("%s.%s", hostName, domainName) + } else { + host = domainName + } + + u := url.URL{ + Host: host, + Path: path, + } + + return strings.TrimPrefix(u.String(), "//") // remove the empty scheme +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/route_summary.go b/vendor/github.com/cloudfoundry/cli/cf/models/route_summary.go new file mode 100644 index 0000000..b682ed2 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/route_summary.go @@ -0,0 +1,12 @@ +package models + +type RouteSummary struct { + Guid string + Host string + Domain DomainFields + Path string +} + +func (r RouteSummary) URL() string { + return urlStringFromParts(r.Host, r.Domain.Name, r.Path) +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/router_group.go b/vendor/github.com/cloudfoundry/cli/cf/models/router_group.go new file mode 100644 index 0000000..e873ba2 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/router_group.go @@ -0,0 +1,9 @@ +package models + +type RouterGroups []RouterGroup + +type RouterGroup struct { + Guid string `json:"guid"` + Name string `json:"name"` + Type string `json:"type"` +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/security_group.go b/vendor/github.com/cloudfoundry/cli/cf/models/security_group.go new file mode 100644 index 0000000..7376f11 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/security_group.go @@ -0,0 +1,22 @@ +package models + +// represents just the attributes for an security group +type SecurityGroupFields struct { + Name string + Guid string + SpaceUrl string `json:"spaces_url,omitempty"` + Rules []map[string]interface{} +} + +// represents the JSON that we send up to CC when the user creates / updates a record +type SecurityGroupParams struct { + Name string `json:"name,omitempty"` + Guid string `json:"guid,omitempty"` + Rules []map[string]interface{} `json:"rules"` +} + +// represents a fully instantiated model returned by the CC (e.g.: with its attributes and the fields for its child objects) +type SecurityGroup struct { + SecurityGroupFields + Spaces []Space +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/service_auth_token.go b/vendor/github.com/cloudfoundry/cli/cf/models/service_auth_token.go new file mode 100644 index 0000000..2df5c3b --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/service_auth_token.go @@ -0,0 +1,8 @@ +package models + +type ServiceAuthTokenFields struct { + Guid string + Label string + Provider string + Token string +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/service_binding.go b/vendor/github.com/cloudfoundry/cli/cf/models/service_binding.go new file mode 100644 index 0000000..1acff82 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/service_binding.go @@ -0,0 +1,13 @@ +package models + +type ServiceBindingRequest struct { + AppGuid string `json:"app_guid"` + ServiceInstanceGuid string `json:"service_instance_guid"` + Params map[string]interface{} `json:"parameters,omitempty"` +} + +type ServiceBindingFields struct { + Guid string + Url string + AppGuid string +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/service_broker.go b/vendor/github.com/cloudfoundry/cli/cf/models/service_broker.go new file mode 100644 index 0000000..dc7aa79 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/service_broker.go @@ -0,0 +1,10 @@ +package models + +type ServiceBroker struct { + Guid string + Name string + Username string + Password string + Url string + Services []ServiceOffering +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/service_instance.go b/vendor/github.com/cloudfoundry/cli/cf/models/service_instance.go new file mode 100644 index 0000000..f9351bb --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/service_instance.go @@ -0,0 +1,47 @@ +package models + +type LastOperationFields struct { + Type string + State string + Description string + CreatedAt string + UpdatedAt string +} + +type ServiceInstanceCreateRequest struct { + Name string `json:"name"` + SpaceGuid string `json:"space_guid"` + PlanGuid string `json:"service_plan_guid,omitempty"` + Params map[string]interface{} `json:"parameters,omitempty"` + Tags []string `json:"tags,omitempty"` +} + +type ServiceInstanceUpdateRequest struct { + PlanGuid string `json:"service_plan_guid,omitempty"` + Params map[string]interface{} `json:"parameters,omitempty"` + Tags []string `json:"tags"` +} + +type ServiceInstanceFields struct { + Guid string + Name string + LastOperation LastOperationFields + SysLogDrainUrl string + RouteServiceUrl string + ApplicationNames []string + Params map[string]interface{} + DashboardUrl string + Tags []string +} + +type ServiceInstance struct { + ServiceInstanceFields + ServiceBindings []ServiceBindingFields + ServiceKeys []ServiceKeyFields + ServicePlan ServicePlanFields + ServiceOffering ServiceOfferingFields +} + +func (inst ServiceInstance) IsUserProvided() bool { + return inst.ServicePlan.Guid == "" +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/service_key.go b/vendor/github.com/cloudfoundry/cli/cf/models/service_key.go new file mode 100644 index 0000000..f304cee --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/service_key.go @@ -0,0 +1,20 @@ +package models + +type ServiceKeyFields struct { + Name string + Guid string + Url string + ServiceInstanceGuid string + ServiceInstanceUrl string +} + +type ServiceKeyRequest struct { + Name string `json:"name"` + ServiceInstanceGuid string `json:"service_instance_guid"` + Params map[string]interface{} `json:"parameters,omitempty"` +} + +type ServiceKey struct { + Fields ServiceKeyFields + Credentials map[string]interface{} +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/service_offering.go b/vendor/github.com/cloudfoundry/cli/cf/models/service_offering.go new file mode 100644 index 0000000..0bf02ff --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/service_offering.go @@ -0,0 +1,31 @@ +package models + +type ServiceOfferingFields struct { + Guid string + BrokerGuid string + Label string + Provider string + Version string + Description string + DocumentationUrl string + Requires []string +} + +type ServiceOffering struct { + ServiceOfferingFields + Plans []ServicePlanFields +} + +type ServiceOfferings []ServiceOffering + +func (s ServiceOfferings) Len() int { + return len(s) +} + +func (s ServiceOfferings) Swap(i, j int) { + s[i], s[j] = s[j], s[i] +} + +func (s ServiceOfferings) Less(i, j int) bool { + return s[i].Label < s[j].Label +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/service_plan.go b/vendor/github.com/cloudfoundry/cli/cf/models/service_plan.go new file mode 100644 index 0000000..8d16d2f --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/service_plan.go @@ -0,0 +1,34 @@ +package models + +type ServicePlanFields struct { + Guid string + Name string + Free bool + Public bool + Description string + Active bool + ServiceOfferingGuid string + OrgNames []string +} + +type ServicePlan struct { + ServicePlanFields + ServiceOffering ServiceOfferingFields +} + +type ServicePlanSummary struct { + Guid string + Name string +} + +func (servicePlanFields ServicePlanFields) OrgHasVisibility(orgName string) bool { + if servicePlanFields.Public { + return true + } + for _, org := range servicePlanFields.OrgNames { + if org == orgName { + return true + } + } + return false +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/service_plan_visibility.go b/vendor/github.com/cloudfoundry/cli/cf/models/service_plan_visibility.go new file mode 100644 index 0000000..61417e3 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/service_plan_visibility.go @@ -0,0 +1,7 @@ +package models + +type ServicePlanVisibilityFields struct { + Guid string `json:"guid"` + ServicePlanGuid string `json:"service_plan_guid"` + OrganizationGuid string `json:"organization_guid"` +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/space.go b/vendor/github.com/cloudfoundry/cli/cf/models/space.go new file mode 100644 index 0000000..ae012f4 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/space.go @@ -0,0 +1,17 @@ +package models + +type SpaceFields struct { + Guid string + Name string + AllowSSH bool +} + +type Space struct { + SpaceFields + Organization OrganizationFields + Applications []ApplicationFields + ServiceInstances []ServiceInstanceFields + Domains []DomainFields + SecurityGroups []SecurityGroupFields + SpaceQuotaGuid string +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/space_quota.go b/vendor/github.com/cloudfoundry/cli/cf/models/space_quota.go new file mode 100644 index 0000000..13ebea4 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/space_quota.go @@ -0,0 +1,12 @@ +package models + +type SpaceQuota struct { + Guid string `json:"guid,omitempty"` + Name string `json:"name"` + MemoryLimit int64 `json:"memory_limit"` // in Megabytes + InstanceMemoryLimit int64 `json:"instance_memory_limit"` // in Megabytes + RoutesLimit int `json:"total_routes"` + ServicesLimit int `json:"total_services"` + NonBasicServicesAllowed bool `json:"non_basic_services_allowed"` + OrgGuid string `json:"organization_guid"` +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/stack.go b/vendor/github.com/cloudfoundry/cli/cf/models/stack.go new file mode 100644 index 0000000..c3b08a0 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/stack.go @@ -0,0 +1,7 @@ +package models + +type Stack struct { + Guid string + Name string + Description string +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/user.go b/vendor/github.com/cloudfoundry/cli/cf/models/user.go new file mode 100644 index 0000000..10ddaa0 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/user.go @@ -0,0 +1,8 @@ +package models + +type UserFields struct { + Guid string + Username string + Password string + IsAdmin bool +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/user_provided_service.go b/vendor/github.com/cloudfoundry/cli/cf/models/user_provided_service.go new file mode 100644 index 0000000..1a07385 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/user_provided_service.go @@ -0,0 +1,18 @@ +package models + +type UserProvidedServiceSummary struct { + Total int `json:"total_results"` + Resources []UserProvidedServiceEntity `json:"resources"` +} + +type UserProvidedService struct { + Name string `json:"name,omitempty"` + Credentials map[string]interface{} `json:"credentials"` + SpaceGuid string `json:"space_guid,omitempty"` + SysLogDrainUrl string `json:"syslog_drain_url"` + RouteServiceUrl string `json:"route_service_url"` +} + +type UserProvidedServiceEntity struct { + UserProvidedService `json:"entity"` +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/models/user_roles.go b/vendor/github.com/cloudfoundry/cli/cf/models/user_roles.go new file mode 100644 index 0000000..5413d28 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/models/user_roles.go @@ -0,0 +1,29 @@ +package models + +const ( + ORG_USER = "OrgUser" + ORG_MANAGER = "OrgManager" + BILLING_MANAGER = "BillingManager" + ORG_AUDITOR = "OrgAuditor" + SPACE_MANAGER = "SpaceManager" + SPACE_DEVELOPER = "SpaceDeveloper" + SPACE_AUDITOR = "SpaceAuditor" +) + +var UserInputToOrgRole = map[string]string{ + "OrgManager": ORG_MANAGER, + "BillingManager": BILLING_MANAGER, + "OrgAuditor": ORG_AUDITOR, +} + +var UserInputToSpaceRole = map[string]string{ + "SpaceManager": SPACE_MANAGER, + "SpaceDeveloper": SPACE_DEVELOPER, + "SpaceAuditor": SPACE_AUDITOR, +} + +var SpaceRoleToUserInput = map[string]string{ + SPACE_MANAGER: "SpaceManager", + SPACE_DEVELOPER: "SpaceDeveloper", + SPACE_AUDITOR: "SpaceAuditor", +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/resources/i18n_resources.go b/vendor/github.com/cloudfoundry/cli/cf/resources/i18n_resources.go new file mode 100644 index 0000000..be6a8fd --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/resources/i18n_resources.go @@ -0,0 +1,448 @@ +// Code generated by go-bindata. +// sources: +// cf/i18n/resources/de-de.all.json +// cf/i18n/resources/en-us.all.json +// cf/i18n/resources/es-es.all.json +// cf/i18n/resources/fr-fr.all.json +// cf/i18n/resources/it-it.all.json +// cf/i18n/resources/ja-jp.all.json +// cf/i18n/resources/ko-kr.all.json +// cf/i18n/resources/pt-br.all.json +// cf/i18n/resources/zh-hans.all.json +// cf/i18n/resources/zh-hant.all.json +// DO NOT EDIT! + +package resources + +import ( + "bytes" + "compress/gzip" + "fmt" + "io" + "io/ioutil" + "os" + "path/filepath" + "strings" + "time" +) + +func bindataRead(data []byte, name string) ([]byte, error) { + gz, err := gzip.NewReader(bytes.NewBuffer(data)) + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + + var buf bytes.Buffer + _, err = io.Copy(&buf, gz) + clErr := gz.Close() + + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + if clErr != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +type asset struct { + bytes []byte + info os.FileInfo +} + +type bindataFileInfo struct { + name string + size int64 + mode os.FileMode + modTime time.Time +} + +func (fi bindataFileInfo) Name() string { + return fi.name +} +func (fi bindataFileInfo) Size() int64 { + return fi.size +} +func (fi bindataFileInfo) Mode() os.FileMode { + return fi.mode +} +func (fi bindataFileInfo) ModTime() time.Time { + return fi.modTime +} +func (fi bindataFileInfo) IsDir() bool { + return false +} +func (fi bindataFileInfo) Sys() interface{} { + return nil +} + +var _cfI18nResourcesDeDeAllJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xfd\x5d\x73\xe3\x48\x72\x28\x0c\xdf\xbf\xbf\xa2\x4e\x9f\xf7\x44\xf7\x6c\x88\xea\x99\xd9\xb5\xe3\x84\x4e\x9c\xb0\xd9\x12\x5b\x2d\xb7\x3e\xb8\xa4\xd4\xe3\xe9\xd1\x86\x16\x24\x8b\x24\x56\x20\xc0\xc5\x87\x34\xd2\x78\x7c\xe5\xdf\xf0\x5c\x39\xc2\x37\xf3\x1b\xf6\x6a\xee\xf4\xc7\x9e\xfc\xa8\x2a\x14\x40\x14\x08\x90\x94\x7a\xec\xc7\x76\xec\x34\x45\x02\x99\x59\x59\x55\x59\x59\xf9\xf9\xc3\xff\x4f\x88\x9f\xe0\x7f\x42\xbc\xf2\x27\xaf\x0e\xc4\xab\xeb\xf0\x3a\xbc\x3c\xe9\x1f\x5c\x87\xaf\xf6\xf8\xfb\x34\xf6\xc2\x24\xf0\x52\x3f\x0a\xad\x07\xe8\x09\x78\xe0\xe7\xbd\x2a\x08\xdf\x47\x59\x2c\xfe\x69\x78\x71\x2e\x92\x34\xf6\xc3\x99\x48\x1e\xc2\xd4\xfb\x51\xf8\x89\xf0\xc3\x3b\x2f\xf0\x27\xfb\x42\xf4\xe3\x68\x29\x63\xeb\xa7\x74\xee\x27\x07\x42\x8c\xa7\x22\x91\x69\x27\xce\xc2\x10\x5e\xed\xc8\xf0\xce\x8f\xa3\x70\x21\xc3\xb4\x73\xe7\xc5\xbe\x37\x0a\x64\x67\x16\x47\xd9\x52\xbc\xfe\xe9\xfa\x55\xe8\x2d\xe4\xf5\xab\x83\xeb\x57\x00\x36\x83\x4f\x7b\xab\x5f\xfd\xfc\xba\x66\x2c\x27\xf3\x58\x12\xa9\x9d\xcf\xd2\x1f\xcf\x65\x38\x8d\x82\x99\x34\x44\xa5\x22\x0b\x67\x4f\xbf\x06\xa9\x3f\xdb\x17\x47\xbe\x14\xb7\x51\x1c\xcb\xdb\x54\x8a\x21\x3f\x12\x78\x59\x2a\xd3\x83\x67\xa1\xfa\x59\xf9\x9b\xa4\xde\xec\x3f\x1f\x7f\x77\x4a\xb5\x83\xbf\xbf\x13\x97\x73\x99\x48\xc0\x17\xdf\xf9\x63\x29\x96\x01\x8c\x4a\xcc\xbd\x3b\x29\xbc\x50\x78\x49\x12\x8d\x7d\x2f\x95\x13\x31\x8e\x92\x74\x5f\x1c\xc6\x12\x46\x0c\x93\xe0\x99\x37\xfc\x10\xe8\x0c\xe1\xc3\xbd\x1f\x04\xf0\xd7\x18\xa6\x0b\xb9\xcf\x6f\x38\xb9\xf5\x3b\xe4\x40\x22\x43\x31\x64\x38\xcb\xe0\xe9\x97\x10\xfe\x4c\xfc\x70\x22\x3e\xc2\xab\xf0\xf9\x31\x9b\xc9\x28\x9e\x84\x12\x30\xbf\x93\xfe\x42\xf4\x62\xf8\x3e\x08\xe0\x27\xe9\x87\x30\xdf\xea\x5d\x26\xe1\x51\x4c\x3d\xfa\x6d\x82\x80\x35\x0c\x2f\xdc\x17\xae\xc1\x77\x97\x4b\x58\x54\x5e\x0c\xe3\xab\x91\x01\xf8\x14\xcc\x22\x3d\x97\xba\x25\x01\x3e\xf6\xd3\x4f\xfb\xf0\xcf\x39\x70\xff\xe7\x9f\xc5\xbd\x97\x68\xe8\x22\x4b\x90\x69\x8a\x2d\x8b\x85\x07\x63\xfc\x33\x3c\x7c\xc8\x9f\x7f\xfe\xf9\xcf\x6b\xf0\x17\x01\x67\xf1\x44\x8a\x85\x9f\xf2\x48\x17\xc0\x9b\xa9\x9c\x07\x39\x91\x07\xab\xc0\x1d\x44\x9f\x47\xc2\x5b\xfa\x42\x86\x93\x65\xe4\x87\x29\x2e\x3b\xf7\x94\xf5\x12\x85\xfa\x16\x38\x2e\xba\xfd\x93\x4e\x0f\xde\xcb\xc2\xdb\x54\x4c\x01\xf5\x4c\x06\x72\x06\xaf\x3b\x50\x0d\x22\x58\xdc\x22\x8d\xc4\x48\xc2\x3e\x58\x78\xcb\x25\xf0\x05\xf8\x11\x46\xa9\x80\x35\x13\xc3\xea\x0e\x1e\x84\xfa\x1e\x1e\x4b\xe7\xb0\x04\x97\xcb\xc0\x1f\x13\x09\x6e\xb2\x70\x27\x11\xf0\x3d\x31\x91\x00\x46\x7c\xce\x70\xd1\x64\xb8\x4a\xb3\xe9\x4c\xce\xa3\x11\x7c\x79\x2f\x81\x72\x58\x5e\x51\x10\xec\xd1\x5e\x5c\x44\xb8\xa1\x60\x91\xdf\xf2\x5a\xea\x86\xf7\xc0\x06\x7c\xcb\x5a\x76\xae\xc1\xe0\xb1\x21\xc4\x15\x2c\xb3\xd7\xb0\x59\x17\x5e\x7c\x2b\x53\xd8\x3a\xb0\x0b\x3a\x89\x18\xf6\x06\x9f\x4e\x0e\x7b\xaf\x71\x14\x77\xbe\xbc\x07\xb2\x92\x71\xec\x2f\x91\xe4\x44\x44\x53\xd8\x24\x13\xff\xce\x9f\x64\x5e\xa0\xf6\x1b\x7c\xe7\x89\x99\x7f\x87\x04\xf2\x92\x76\x0f\x97\x0e\x24\x21\x3e\xc9\x18\xe9\xc5\x0d\xe4\xd7\x52\xb1\x27\x32\x5c\x21\xc9\x18\x84\x93\x3f\x82\xf1\xf1\xee\x79\x94\x01\x8e\xba\x4f\xdb\x8e\xb6\x53\x02\x7b\x65\x26\x67\x12\xb8\x95\x6f\x4b\xf8\xee\x31\x7b\x94\x3e\xbc\x55\xcf\x8c\x6e\x92\xf8\xb3\x50\xc4\x51\x00\x80\xee\xfd\x74\x0e\xb2\x09\xd6\x20\x4f\x2c\x30\x2a\x86\x85\x8b\x42\x2d\x8a\x67\x1d\x7c\xe8\xb5\xc0\x4d\x50\xfd\x4c\xb2\x84\x31\xf0\x53\x6b\xd8\x30\x88\x68\xc7\xe3\x5e\x58\x87\x2e\x6b\x82\x0e\xe6\x9e\x66\xde\xb9\x61\x68\xac\x34\xef\x08\xea\xfd\xa5\x17\xcf\x64\x6a\x76\x1a\x4d\x79\x4a\xdf\x89\x10\x26\x9e\x20\xaf\x19\x42\x69\x22\x2b\xc1\xd2\x1c\xe2\x1c\x85\x00\x36\x83\xff\xbe\x83\x85\x0e\x27\x0c\x90\x2b\xc2\x2c\x7d\x5c\x37\x39\x86\x60\x17\xa1\xc0\xa6\xf6\x64\xae\x92\x47\xd4\x89\x8b\x78\xe6\x85\x7e\x42\x20\x84\x17\x24\xe2\xb3\x2f\x03\xd8\x8b\xc9\x63\x76\xff\xf4\xcb\x3c\x58\xc3\xdd\x4c\xed\xaa\x20\x82\xd3\x4f\x74\x3c\x94\x34\xa2\xd3\x49\x6e\xfd\x65\x27\x49\x82\x0e\x9d\xf9\x04\xfc\x35\xd0\x4d\x8f\xa2\x0c\xab\x79\x0a\xc6\x9a\x64\xcb\x65\x2c\x13\x56\x0c\x84\x8c\xe3\x28\x6e\x37\xe0\xa6\x04\x81\x08\x6a\x40\x12\x71\x6c\xc2\x07\xe0\x7b\x90\xdd\xf0\x12\x4c\x65\x16\xa6\x20\xa5\xe2\xa7\x5f\xc7\xb7\xce\x19\x85\x4f\x87\xef\x6f\xce\xbb\x67\x3d\xe0\x28\xec\x32\x3c\xea\xff\x51\xfe\xe8\x2d\x96\x81\xdc\x87\xb3\x45\x5c\xbf\xba\xbe\xbe\x7e\xb5\x84\xa3\xfb\x1e\x96\x32\x7e\xbe\x7e\x25\xde\xc0\xfe\xf7\x96\x52\xfc\x35\x8b\x52\xd8\x9f\xfe\x14\xb9\x0c\xe2\x37\x14\xfa\xc1\xaf\x1c\xec\xd8\x10\x5f\x37\x9c\x3e\xfd\x3a\x07\x0d\x71\x96\x3c\xb2\x2e\x24\xe0\xfc\xfe\x28\xc3\x10\x9e\x4a\x69\xc3\xf6\x88\x24\xfd\xeb\x9d\x8c\x13\x09\x1f\xbe\xda\x78\xd8\x8b\x07\x33\x18\xa4\x00\x97\x91\x1a\xee\x14\x96\x89\xfe\x49\x09\x27\x8f\xf7\xe6\x57\xce\x73\xb7\x3d\xc2\x8a\x21\xc3\x17\x31\x0f\xfa\xe9\x6f\x70\x30\xc7\x34\xee\x53\x29\x63\x6b\xd4\xbc\xc8\xbe\x72\x9d\xd1\x16\x1d\xe3\x68\xf9\xd0\x49\x40\x1d\x06\xb1\x3c\xbc\xb8\x1a\x1c\xf6\x3a\xdd\x7e\x5f\x5c\x76\x07\xc7\xbd\x4b\xfa\xf8\x43\x27\xd2\x7f\x5e\x0c\x8e\xff\x04\x7f\x27\xfa\xef\x61\xbf\x7b\xd8\xc3\x6f\x3a\x61\xd4\x89\x59\x53\xf8\x93\x73\xf4\x6b\x69\xe1\xbd\xf0\x26\xc2\x01\x01\xa7\x63\x64\x0f\x49\x74\xcd\x11\xdc\x74\xfc\x90\x8f\xab\xda\x1b\xa7\x70\xbc\xc1\x01\xdf\xe9\x18\x18\xa4\x30\x2e\xe3\x68\xb1\x4c\x69\x8a\x46\x51\x3a\x6f\x34\x21\x0a\xf9\x3b\x49\xb2\x8f\x70\x87\x24\xdf\xcd\xfa\x22\xc6\x33\xe2\x5b\x44\x0c\xa7\xfb\x42\x06\x74\xba\xdf\xcb\x59\x00\x34\xc2\x1b\x16\x29\x80\x1e\x36\x6e\x0a\x9b\x30\x16\x3d\x50\xd5\x3c\x50\x52\x46\xd2\x9f\x90\x5e\x80\x7f\x85\xa8\x4b\x34\x99\x24\x25\x24\x60\xc3\x47\xe2\x4d\x79\xa4\x70\xe8\x03\x97\x44\x16\x07\xc8\x9e\x68\x94\x7a\xf0\xac\x27\xa2\x50\x76\x52\x1f\x18\xb8\xc2\xbc\x06\xbb\xb2\x12\x21\xa9\xc9\x29\xcb\xe4\xab\xc1\x29\x8d\x0b\x04\x1a\xb0\x65\x06\x3c\xd0\xf2\x1a\x87\xba\xf0\x82\xdb\x02\xd7\x40\x2a\x59\xdc\xf2\x46\xf0\x6a\x36\x6d\xb2\x2f\x15\x21\xd9\xea\x56\xe9\x2c\x37\x96\x4a\xcd\x97\x43\x2b\xc4\x9b\x8b\xa7\xe6\x4b\xc0\x45\xcf\xb3\xc9\xa9\x76\x78\x9f\x5d\x5c\xd5\x92\xb3\xf4\xfe\xee\xef\xee\xa3\xc1\x91\x78\x93\x2c\xe5\xd8\x9f\x3e\x38\xa4\x08\xdc\xa1\x40\x4b\xc9\x50\x55\x4f\xb6\x67\x42\x8e\xd5\x96\x1d\x45\xd1\x81\x0a\x4b\x57\xa1\x94\xa4\x12\x8f\x9a\x8d\x77\x99\x25\x73\x38\xf2\xfb\xfc\xd7\x0f\x9d\x91\x78\x77\x75\x72\x7a\x04\x72\xf7\x23\x7d\x85\xc2\x77\x2c\x0e\x2f\xce\xce\xba\xe7\x47\xf8\xc7\x44\x1c\x5d\x9c\x75\x4f\xce\xf1\xf3\x54\xc0\xb7\x27\xef\x7b\xc3\xcb\x9b\x7e\xf7\xf2\x03\x09\xea\x49\x04\x7a\x40\xdc\xf1\x17\xde\x4c\xc2\xa3\x87\x1f\x7b\x83\x9b\x93\xb3\xee\x71\x6f\x0b\xb9\x4d\x44\xae\xa2\x6b\x0f\xf0\x82\xae\x33\x70\xe1\x7e\xb0\x04\x5b\x80\x17\x2b\xb8\xcc\xd0\x1d\xb7\x33\x91\x81\x0f\x2b\x08\xaf\x73\xde\x0c\x35\x2f\x2f\x65\x49\x08\xc2\xf5\x3e\xf6\x53\xbc\x9e\xab\x8b\xde\xa7\xc3\x6e\xff\x46\xdd\x58\x86\xc2\x32\x78\x08\x6d\xf0\xa0\xcd\xe1\x85\x0f\x70\x4a\xe0\x74\x59\x37\xc3\xc4\x75\x57\xb2\xa8\x14\xda\x6e\x80\xba\x1c\x49\xc5\x53\x20\x55\x5d\xa2\xe1\x40\x9d\x8b\x8f\x48\x72\x02\xa4\xcd\xe0\x76\xf0\x88\xa4\x5d\x22\xd1\x65\xc1\x89\xd2\x91\xb6\x09\x9a\x1a\xe0\xc6\x0d\x17\xaa\x09\xdd\x97\xcc\xf5\x11\x45\x09\xd9\x20\xc4\xd5\x82\x7e\x9f\x25\x66\x0c\xc5\x61\xce\xe8\x52\xe6\xcb\xfc\x7a\xea\x32\x55\x54\xf3\x5b\x5d\x15\x3b\xbc\x83\xfc\x31\xb0\x3d\x9c\xfa\xb3\x2c\x66\xcd\x7b\xe9\xc5\xb0\xb8\x61\x1b\xa3\xa1\x0c\x26\x87\xd4\x4f\xb6\xa4\x45\xa3\xbf\xc8\x71\x0a\x5f\x77\x02\xe0\xc5\xfe\x75\x68\xad\x90\x6c\x09\x3a\x2a\x00\x55\xf7\x3f\x58\xb2\x8d\x8d\x4c\x68\x03\x73\x2d\x8d\xa9\x0f\xe3\x07\x02\xf1\xc8\x23\x2b\xde\x96\xc4\xef\x0b\xc2\x75\x39\xc7\x53\x13\x04\xa5\x5a\x48\xd6\x7b\x8c\x11\x2e\xf8\x23\xb6\x65\x8d\xe0\xee\x8f\x26\x08\x58\x47\xb1\xc4\x55\x72\x97\xbf\xca\xf4\xad\x63\x04\x6e\x95\x9b\xcb\x8b\x9b\xf7\x27\xa7\x3d\x35\xd6\x1e\x0b\x18\x5c\xf4\x2b\x24\x1e\xd0\x13\x3f\xd1\x7f\xe1\xff\xae\x5f\x8d\x83\x0c\x16\x5d\x7c\x13\xc2\x2d\x21\x01\xd6\xe5\xbf\xf1\xcf\xb0\xb2\x53\xfc\xfa\xef\xf6\x0a\xdf\x2f\xe4\x22\x8a\x1f\x6e\x16\x23\xfc\xed\x9b\xaf\xbf\xfd\x83\xfe\xf5\x67\xfa\xf0\x73\xcb\xe5\xaf\x06\x04\x8c\x7f\x04\xc6\xc3\x12\x44\x5b\x99\xc5\xfb\xc4\xf0\x10\x59\x8f\x9b\x65\x21\x94\xd9\x12\x20\x90\x79\xf3\x02\xc6\x77\x9b\x92\x82\x35\x83\x05\xac\x14\xa7\x7c\x9f\xa8\xc9\xd9\xfd\x92\x5a\xdd\xc7\x47\x00\xd9\xa7\x7d\xbc\x3a\xae\xd0\x35\xb0\x70\xdd\xc8\x2a\x87\x73\x84\xf6\x92\xa9\x37\xa1\x5f\xfb\x1a\xd6\x84\x08\xb8\xf5\x42\x82\x68\x96\x59\xcc\x57\x41\xbd\xd2\xcc\x9b\xca\x72\xc9\x64\x27\xf0\xc7\x5a\x5e\x55\xac\xba\x77\xd2\x4f\x96\x78\xa9\x26\x51\x84\x68\xf5\x30\x12\x7b\x18\xa5\x05\xf8\x8c\x2b\xf0\x0b\x48\xad\x03\xc5\x0b\xcd\xb8\x91\x1f\x4e\x0c\xdb\xcc\x31\xac\x84\xed\xcd\xc9\xf9\xf0\xb2\x7b\x7e\xd8\xfb\xff\xb0\x3c\x6b\xce\xa0\x6d\xe5\xdc\x52\xc6\x0b\x3f\x49\x70\xcb\xe1\x82\xb9\x7e\x15\x4b\x6f\xd2\x89\xc2\xe0\x01\xb4\xef\xdf\xa8\xc8\x7a\xf9\xe5\xf4\x85\x64\xd9\xcb\x89\xb2\xad\x16\xdc\x66\x22\xae\xd1\xda\xfb\x0d\x08\xab\x31\xfa\xd1\x72\x29\xaf\x78\x22\xfa\xa7\xdd\xf3\xff\x44\x22\x6b\xf7\x12\x6b\x5b\x3e\xfd\xb7\x86\xb6\xa1\xb8\x7b\xa9\x05\xf9\x5f\x50\x81\x7b\x86\x35\xbb\xa9\xf0\x7b\x69\xf5\xae\x8f\x9b\x37\x99\x47\x59\x30\xa1\x3d\x2e\x1e\xfd\x25\xed\xe3\xbd\xdc\xca\x69\x7f\x89\x57\x78\x11\x44\x63\x58\x07\x13\x3f\x86\x0d\x08\x68\xf7\x45\x3f\x4a\x7c\x92\x38\x7e\x02\x3f\x2f\xe9\xaf\x3b\xc9\x6b\x57\xc6\x7b\xe8\xa3\x4b\x40\x8c\xf9\x51\xec\xa7\x0f\x7b\x64\x1f\x82\x27\x93\x88\x3c\xeb\xd3\x38\x5a\x00\xc8\x7b\x99\xa4\x88\x6d\xee\xcf\xe6\xd2\x1d\x77\x60\x2f\x02\x74\x05\xa7\x6a\x11\xde\x46\x0b\x40\xb0\xc0\x8d\xa2\x56\xe4\x9e\x6d\x3c\x55\x73\x6e\x3f\x15\xaa\x15\x40\x8b\x04\x67\x28\x88\x6e\x3d\xf4\x7d\x7e\x52\xe6\xb2\x10\x69\xa4\x43\x11\x1d\xd4\xd6\x18\x95\x59\xd6\x8c\x73\xe6\x85\x8f\x52\x7c\xf6\xe6\xc1\x9e\x40\x0f\x3a\xd9\x0e\xfa\x3c\xdc\xa7\x5f\xd8\xb7\x4e\x26\xaa\x7b\x3f\x9e\x88\x3b\x80\x81\x28\x43\x5f\x4e\x62\x7f\xa6\xe2\x24\x62\x31\x7f\xfa\xdb\x78\x4e\x7f\x21\x24\xe2\x0e\xd2\x59\x63\x51\xe8\xa3\x29\x68\x91\xc1\xb2\x42\xf1\xe8\x2d\x97\xc6\xe4\xb8\xf0\x42\x1f\xb1\xba\x23\xa3\xe0\xab\x33\x39\x8f\x65\x0c\x07\x3b\xbe\x88\xdb\x97\xb7\xe3\x99\x7a\x17\xbf\x9a\xfb\xc1\x54\x2a\xde\x21\xb6\xce\x05\x9c\xce\x7c\xb8\x3c\xfd\x3a\x02\xea\x62\x0f\xf6\xad\x33\xba\x4a\x1f\x2e\x7c\x80\x4d\xf8\xa8\xd8\x40\x01\x3e\x49\xf5\x1a\xe5\xb8\x16\x8c\x31\x99\xe1\x90\xe3\xd8\x7b\xe0\x31\x5b\x67\x02\x9e\x76\x09\x1e\x98\xec\xb5\x1f\x71\xe0\x86\x14\x71\x06\xb3\xbb\x66\x5d\x8d\xd0\x2d\x9b\x62\x1c\x86\xa4\xb5\x45\xeb\x6c\x0b\x7d\x8a\xa5\x16\x85\xb3\xa8\xd5\x4a\x7c\x53\xae\x60\xed\xc5\x0f\x45\x97\x46\x82\x93\x60\x49\x07\xb6\xd7\xa2\x04\x94\x21\x1b\xae\xf0\x7f\x03\xd8\x53\x01\xb2\x50\x05\x04\xd4\x39\x1a\xb7\xe5\x3e\x43\x20\x2d\xc0\x9a\x00\x1a\xd4\x56\x93\xc0\x70\xe9\xf1\x77\x1e\xf0\xe6\x42\xe9\x5a\x09\x8b\x79\x74\x4a\xa1\x68\x40\x41\x81\x8a\x1f\xbd\x99\xfc\x35\xf3\x60\xb5\x8e\x62\x6f\x7c\x8b\xf2\x04\x7f\xb4\xc3\x9b\x60\xad\x4e\xb4\xd2\x86\x0f\xc6\xf2\xaf\x19\x88\x28\xf2\x46\xa4\x6a\x14\x80\x58\x09\xe8\x4f\xa4\x49\xfc\x25\x81\x95\x4c\xc3\x53\x76\x66\x16\xc8\x3f\x28\xf1\x69\x5f\xbc\x81\x8d\x69\x34\x8e\x02\xd6\x49\xd3\xf1\x12\x8f\xcb\xfc\x67\x18\x66\xea\x87\xb4\x9c\xf8\x89\x6f\xbe\xde\xff\xf6\x0f\x7f\xd8\xff\x66\xff\x9b\xff\x5d\x7c\x72\x09\x1b\x5b\x69\xb6\xbf\xff\xfd\xd7\x7f\xaf\x94\x5a\x2d\xaa\xff\xf4\xb2\xeb\x93\x44\x9b\xfa\xdb\x5a\x9f\xd7\xe1\x8e\x57\x28\xe0\x48\x4a\xf3\x7d\x9b\xb2\x3c\xe4\xd5\x94\x25\xf0\x0e\x7b\xf5\x50\x52\xfa\x2c\x23\x15\x65\x18\x51\x16\x66\xec\xd9\x92\xe3\x5b\xd2\x15\x3e\x06\xde\x62\x81\x7a\x04\x3e\x8e\x3f\x60\xd0\x0f\xc8\xd0\x98\x7e\x25\x47\xbc\x0e\x02\x82\xbf\x15\xb9\x02\x88\x25\x47\x61\x00\xf2\x7d\x5f\xb8\x0e\x6b\x69\x4e\x6b\x1e\x2c\x91\xf1\x1b\x58\x1a\xae\x6d\xfe\x09\x63\x94\xe0\xae\x10\xdd\x93\x91\x1a\x9d\x51\x9e\x8e\xe1\xd1\x4a\x0d\x7f\xe9\x0a\xc7\x81\xaf\x3e\x67\xc1\xd3\x2f\x18\x03\x24\xc5\x71\xfc\xf4\xb7\xa7\xff\x90\x21\xcf\xe0\xd3\x2f\xe1\x2d\x9b\xc5\x29\x4a\xa7\x04\x10\xe3\x8b\x28\xba\xc8\x49\xdd\x0f\x1d\x5f\x9c\x5f\x9d\x19\x95\x69\x88\xbe\x91\x5b\x71\x74\x32\xfc\x88\x9f\xe0\xc4\xe9\x9d\x5d\x0c\xbe\x27\x8f\xc9\x3c\x4a\x52\xf2\xe8\x7c\xb8\x18\x5e\xe2\x37\x4b\xa1\xbd\x29\x89\x80\xd7\x0f\xe9\x95\x54\x5c\x9e\x9c\xf5\x2e\xae\xe8\x89\x4c\x7c\xe8\x75\x4f\x41\x03\x3b\xfc\xd0\x3b\xfc\x78\x73\xf9\x7d\x9f\xbd\xe4\x31\x46\x94\x75\x48\xa0\x0d\xe0\xd1\xde\x1a\x3f\xc9\x17\x22\xd4\x79\x74\x7a\x13\x94\xd9\x30\x8d\xce\x29\x9b\xc3\xde\x84\x35\x8f\xbb\x8f\x9d\x5e\x8e\x18\x51\x31\x89\x24\x47\xe9\xc9\x1f\x51\x79\x41\x8f\x1c\xc8\x86\x65\xe4\x02\x4c\x0f\x01\xbc\x81\x24\x15\x07\x54\x3c\x50\x56\xc6\xf3\x14\x54\x97\x78\xee\xa1\xbb\xc4\x81\x08\x3d\x3c\x2e\xa0\xb4\xb7\x1c\xef\xa1\xda\x18\xe0\x35\xff\x41\xc7\x5b\xba\xa0\x70\xf8\x22\x4b\xc1\x24\x8f\x97\x6c\x02\x37\xc2\xb8\xc4\xe6\x70\xe1\xf1\x1a\xb0\x72\xb1\x4c\x1f\xea\xf8\x17\x48\x19\xbb\x5f\xc7\xc9\xd0\xf7\x71\xd0\xb2\xf7\x04\x1c\x3d\x28\x17\x0b\x11\x06\xa0\xc0\xee\xc3\xc5\x67\x9e\xa6\xcb\x83\xb7\x6f\x1f\xa2\x2c\xbe\xc1\x59\x43\x57\x68\x1d\xe6\xdb\xa2\x00\x03\xfd\x77\x5f\xbc\xc3\xf3\x74\xf5\xe6\xb6\x1a\x58\xb0\x6f\x84\xe1\x41\x35\xe2\xfa\x21\xdd\x79\x7e\x40\x22\x08\xe4\x37\xbe\xe2\x5e\xbc\x48\xa9\xbf\xa8\x58\x62\x4c\xca\xc8\x8b\x9d\xcb\x59\x21\x8b\xe1\x9e\x19\x85\x13\x1f\x89\xee\x33\xfb\x16\xde\x2d\x8c\x32\x83\xc3\xdf\x4f\xf9\x2e\xc2\x2c\x5e\x06\xd9\x4c\x51\xe4\xd4\xff\xbc\x30\x45\xef\x31\x86\xd3\x21\x21\x55\x3c\x4b\xd0\x87\x0e\xd7\x99\x09\x9c\x53\x02\xb6\x14\xfe\xad\x03\x31\xf2\xeb\x5d\x1f\x90\x75\xfc\xb0\x63\x0d\x8d\x36\x4d\xe0\x0a\x46\xa5\xd1\x4c\xd1\x29\x5a\xbf\x3a\x99\x41\xb0\xe1\xb3\x9a\x2d\x18\xc3\x4d\xf0\xce\xdc\xaa\x94\x37\x37\xd6\xa4\x80\x22\x5a\x8f\x43\x5f\x4e\xd8\xb9\x8a\x9f\xf2\x61\xc0\x98\xc3\x74\x0a\x47\xae\x63\x5f\x5c\xbf\xea\x13\x9f\xe1\x04\xd3\x7a\x98\x19\x99\x56\xc2\xd4\xa4\x01\x81\x70\x69\xf7\x9c\x31\xb2\x16\x24\x63\x07\x11\x18\xc9\x37\x92\x66\x9e\xd4\x05\x2e\x2c\xf1\xc5\xc1\xe4\xd7\xf9\xb6\x8b\xe5\x0c\x47\x17\x53\x4c\x3c\x45\x40\xee\x8b\xa1\xe4\x08\xc1\xb9\x0c\x96\xae\x35\xfb\xda\x6c\x2f\x05\x82\xcc\x32\xc0\x22\x8e\xde\xde\xc7\x35\x32\xb7\xc1\x54\x12\xf2\x95\x11\x49\x24\x8d\x9d\x17\x92\xaf\x08\x9b\x96\x48\x46\xf2\x3a\x86\xf7\xbb\xdf\x75\xd1\x1b\x8f\x2f\x1f\x08\xc5\x3c\xd2\x82\x41\xf1\xf6\x70\xda\x8d\xbf\x7e\xf4\x00\x17\x57\x7a\x94\x8c\x8b\xa0\x28\xc5\x68\x72\x98\x50\x90\x5c\x14\x83\x6e\x7e\x82\xc1\xf8\x41\x40\x0a\x36\xc6\xb6\x2c\x35\xb8\x54\xa0\x2c\x10\xd1\x3d\x30\xc0\x4f\x6e\xf7\x7f\xf7\x3b\x54\xa0\x8e\x22\xfc\x5a\xdc\xc3\xc4\xe0\xcd\xc1\x57\x6f\x93\x25\x91\xf7\xdd\x4f\x3f\xed\x33\x49\x3f\xff\xfc\x0f\xe2\xcd\x03\x5e\x38\x9c\x71\x51\x30\x10\x98\x4d\xb4\x6f\xe9\x8d\x94\xe8\xc8\x6f\x3c\x92\xde\xf9\xe1\xd3\x2f\x6c\xf0\x41\xdd\x13\x56\xeb\xe2\xe9\x6f\xb3\x80\x36\xe6\x3d\x48\x2e\x99\x8b\x11\x00\x9c\xc9\x30\xb9\x87\x73\x67\x42\x3a\x61\x37\x83\x55\x0c\xff\x5a\x5e\x7b\x9a\x33\x4d\xb2\x4f\xb1\xe7\xb8\x58\x4d\x94\x4c\x4e\x83\x97\x4d\x05\xa9\x39\xc0\xca\x81\x9f\xf8\xb7\x91\x1a\xfe\x19\x5e\xdb\x53\x25\x21\x40\x32\xe8\x57\xec\x51\x17\x30\x00\x0b\xfe\x89\xf5\xf3\x73\x47\x48\x56\xd7\xa4\x18\xa0\xe5\x19\x98\x1a\x05\xcc\x59\x0e\xc3\x63\xc5\xee\x30\x88\xb2\x89\x78\x8f\x9b\x2b\x76\x9d\x44\x3d\x3f\x54\x8b\x13\x23\x84\x40\x8c\x11\x28\x94\xf8\x27\x3a\xb2\x2e\x62\xad\xae\x08\xad\x9a\xaa\xa3\xa3\xb7\x03\x50\x80\x3e\xa1\x25\xec\xea\xf8\xe4\xdc\x81\x14\x7f\xec\x9c\x9c\x8b\x0f\x27\xe7\x9f\xaf\xde\x3f\xfd\xfb\x71\xef\xfc\x6d\xef\xfc\xf2\x7d\x6f\x70\xde\x3b\x6f\x08\x5a\x0c\x7a\xfd\x8b\xe1\xc9\x25\x68\x5b\xf5\x58\x3a\xf9\x83\xed\x10\x7e\x42\x05\xef\xc8\xc5\xb7\xc1\x77\xbd\x93\xcb\xde\xe0\xd2\xf1\xf6\xe9\x49\x77\xd8\x2a\xdc\x06\xe3\x88\x75\x8a\x86\xe3\x45\x3b\x1b\x63\x3d\x10\xf1\xc6\xe8\x06\x09\x9c\xd1\xde\xd2\xdf\xb7\x22\xa5\x5c\x9b\xab\x90\xf1\xf1\xe6\x71\xff\x5d\x0d\x84\xb5\x24\x1c\x34\x40\x72\xe0\xd0\xf8\x0a\x70\x38\x37\xc6\xef\xa9\xbf\x7f\x76\x19\xdb\x8b\x80\x57\x5e\xda\x00\x91\x78\x83\xbf\x63\x64\x20\xc9\x4d\xfe\xf9\x13\xff\xf9\xf3\xcf\x4d\xb8\xe8\x80\xd9\xf9\xe4\x84\xd9\x8c\xcc\xf6\xcc\x58\xcf\x89\x7e\xcb\x35\x3b\x1e\x63\xb8\x3d\x85\x34\xe6\x39\x2e\x4b\xd0\xb7\xfd\x71\x16\x80\x7e\x36\x8a\xa3\x5b\xe9\x0a\xc2\xff\x9c\xcd\x62\x7f\x3a\x25\xb9\xa9\x52\x54\xcc\xed\x9a\x4c\x03\xa9\xbf\x58\xa0\xd8\x7c\xc7\x50\xd6\x91\xa0\x8d\xf1\x74\xe7\x2a\x53\xa2\x7f\x8c\xa6\xa0\x9e\x80\x42\xd8\x80\x26\x95\x1d\x43\xe0\x38\x77\xc6\xa2\x49\xfd\x48\xa1\x83\x51\x9a\xb8\x88\x43\xfb\x12\xda\xb5\x54\x1a\x25\x90\x31\xce\xd0\xc2\x2d\x28\xb5\x2f\xa1\xcb\x1b\xcc\x8c\x8e\x8b\xfc\xd9\x99\x7a\xd8\xe5\x10\xe7\x21\x1d\x63\x73\x3c\xf0\x67\x71\x06\xd7\x15\x3e\xf3\x4a\x30\xe0\x5c\x66\x1b\x86\x43\x05\xcc\xe9\x52\xe9\x87\x25\xba\x90\xac\x02\x44\x17\xb7\xee\xd9\x83\x33\x43\x7f\x0e\x51\x96\x3a\x49\x2c\xc0\x5b\x4b\xe0\x04\x94\x0d\x4a\x5a\xb1\xf4\x72\x56\x31\x1d\xa4\x9c\xcb\xcc\xa1\x58\xe3\x15\x98\xcd\x4f\x75\xb8\xd0\x91\x11\xeb\xec\x35\x34\x7d\x2e\x97\x0e\x4c\x70\x23\xea\x70\x9e\x9b\xb1\x96\x61\xf6\x5e\x13\x3c\xb4\x12\xe8\x55\xe0\x06\xc0\x01\x46\x20\xb6\x72\xee\x1f\x8c\x37\x8a\x67\xf8\xdd\x45\x3c\x53\xdf\xbd\xe5\x18\x61\xfc\x72\x88\x1f\xd4\xd7\x3c\x51\x57\x86\xb1\xfb\xfb\x2e\x65\xf1\x43\x4e\x1f\x29\x45\x83\x22\x1d\x30\x96\x95\x1c\x44\xa0\xa3\x90\xe6\x53\x22\x48\xe7\x27\x95\x49\x0a\x2a\x68\xaa\xe6\x48\xe0\x03\xfd\xc5\x34\x46\x7d\x0b\x50\xf3\x3e\x92\xc8\x33\xa5\x1b\x71\x2e\x21\xac\x0b\x36\x44\x1f\xbe\xd7\x4a\xd0\x5b\x0f\x21\xed\x0b\xb8\x89\xd0\x6e\x45\x00\x25\xb0\x5a\x5d\x5a\x03\x1e\x39\x8f\x7a\x17\x4c\x0b\x80\xa2\x6b\x2a\xdb\xa9\xf1\x01\x95\xec\xc4\x3a\xaf\x8b\xcf\xd5\x83\xe2\xab\x6c\xae\xe3\xa5\xb9\xe2\x48\x77\xc3\x50\x59\x61\x0f\xdf\x77\x58\x1b\x7b\xdb\xe9\xaa\x31\xbd\xc3\xd0\xd3\x50\x6b\x8f\x52\xab\x6b\x2b\x28\x16\x38\x87\xb6\x16\x69\x29\xa7\x70\x05\xe5\x6c\x24\x49\xe6\xd3\x13\x7b\x3c\xa8\xcd\xaa\x3c\x28\x4e\x8c\x14\x32\x36\x1a\xb3\x33\x5a\xd5\x31\x4c\x98\x9d\xc2\x9c\x50\x9c\x3f\xf3\xfa\xb5\xd1\x76\x79\xa1\xbc\x86\xb1\x7d\x0f\xb7\x82\x31\x39\x0d\xd2\x18\x2f\x1a\x9a\x7c\xa0\xc3\xf5\x16\xf1\x3f\xa5\x60\x7e\x73\x8d\x00\xbc\xea\x71\x7b\x02\xfd\xf0\x0e\xce\x8d\x9a\xc5\x00\x04\x7c\x88\xee\xe5\x1d\x5e\xd8\xf1\x7e\xa2\xfc\x17\x53\x3f\x86\xe9\x9a\x66\x7c\xf7\x01\x60\x98\x78\x4c\x38\x81\xc9\x4b\xd4\xae\xe1\x70\x29\xd0\x8a\x3f\xd1\x55\x0d\xff\x58\xa5\x98\x69\x6b\xbd\x60\xa4\x51\xcd\xdf\x76\x35\x2f\xf5\x7c\x56\x31\x13\xd7\xc7\xed\xd3\xdf\x68\xad\xe0\x2d\xe3\x48\x16\x6e\x2d\x93\x5c\x3e\x26\x15\x44\xa2\x8a\x93\x91\x3b\x5e\x59\xcb\x93\xfc\x79\xe0\x39\xc8\x79\x80\x83\x16\xdf\x49\x61\x91\xa9\x65\xe5\x5a\x95\x70\x8e\xaa\xdc\x12\xbe\x47\xb1\x07\x21\x14\x7f\x91\x93\x88\x52\x1b\x91\xbb\x9c\x8e\x92\x25\xf7\x7e\x8c\x56\x64\x36\xeb\xcb\xc2\xa6\x43\xe2\xcd\x05\xd7\xbe\x74\x55\x0f\x24\x95\xb5\x4b\xd7\x4a\xc9\x25\xb7\x91\x4e\x83\x85\xcb\xb0\xbe\x79\x7b\xa4\x57\xf8\x26\x28\x1d\xde\x01\x99\xec\x32\x8d\x74\x31\x50\x5c\xe9\x30\x48\xaa\x4e\xac\x25\xb7\x84\xbe\xa0\xe7\x21\xe5\xb6\x54\xe5\x14\x78\x78\x73\xc6\x0e\x87\xdd\xd1\x4c\xfb\xc2\x9d\xf4\xd9\x9c\x66\xce\xb5\x2f\x1c\x05\x16\xc9\x5b\x10\xec\x87\x2f\xc9\xe6\x2c\xdc\x15\xa3\x57\xe8\x7e\x4e\x56\x17\xc8\x76\x12\x1d\xdd\x8b\xe1\xf0\x83\x5a\x02\x8a\x26\x59\x9b\x9b\x0c\x8f\x77\xb4\xba\xcb\xb8\xad\x9c\x63\xfb\x08\x70\xe1\x4c\x22\x78\x25\x90\x94\x40\x63\x92\xfa\x49\xbd\x71\xcd\xdf\xe9\xd3\xdf\x38\xe2\x07\x45\x01\x9a\x09\xa5\x9a\xa9\x3c\x1b\x5f\x2a\xcd\xc4\x85\x95\x55\xa3\x45\x46\x86\x2f\x95\xdd\x2c\x91\x89\x30\x64\xfd\xb7\xaa\x5d\x51\x33\xf6\x1e\x1a\x4d\x0a\x5c\x06\x88\x49\x21\x8f\x79\x26\x29\x8f\x39\x25\x27\xe8\x1e\x20\x00\xf1\xa3\x44\x32\xb3\xc8\x3c\xac\x4d\x41\xa9\xb6\x42\xa1\xb3\xd5\xa5\xf2\x80\x8e\xd5\xee\x8a\x05\x2f\x90\x4e\xe3\xb3\x4b\x46\x39\xac\xa7\x80\xd8\x65\x0b\x3e\x62\x8d\xb4\x73\xce\xaf\xf1\x41\x62\x7b\x35\x61\x05\xbe\xc7\xd7\x9d\x08\x0b\x5a\x60\xd1\x35\xe4\x3c\xc5\x56\x94\xc7\x24\x2d\xbb\x84\x6a\x78\x52\x7a\x15\x86\x7a\x1f\xc5\xb7\x14\x18\x74\xeb\x2f\x97\xb9\xe2\x4c\x81\x57\x88\xb3\x05\x19\x38\xfe\xef\x14\x38\x3c\x5b\x26\xba\x98\x84\xe4\x52\x23\x78\xe6\x90\x4f\x3b\x59\xe2\xa5\xc8\x65\x84\xaf\xa4\x53\x49\x04\x4e\x58\x02\xa5\x03\x95\x61\xde\xdd\xfc\x50\x2b\x7e\x69\x51\xe0\x85\x2b\x70\x4c\x1a\x92\x9b\x38\x3c\x9a\xd1\x4a\x80\x8b\x44\xd2\xa9\xea\xcd\xc2\x08\x94\x92\x71\xc2\xf1\x1a\x41\x34\xa3\x48\x06\x17\x49\xe1\x1c\xc5\x8c\x52\x15\x8e\xf8\x6d\xb9\x8c\xa3\x59\xec\x2d\x16\x4a\x40\xa1\x51\xa1\xab\x2e\x6f\xec\xf1\xf5\x38\x10\x00\xcb\xf3\xa4\xd1\x2d\x9c\xef\x64\x7a\x75\x52\xa9\x33\xba\xc4\x5c\x7a\x01\x46\x9b\xcc\xe5\xf8\x56\xa4\x0f\x4b\xa9\x0c\x56\xaf\xd1\xc5\xcd\x59\xff\x21\xc8\xed\xd7\x2e\x1b\xcb\xd3\xbf\x03\xbb\x96\xf1\xd3\xaf\x53\x4c\xbf\x02\x00\x8a\x40\x9d\xa3\x95\xa8\xf1\x4b\x65\xc6\x52\x70\xdf\xf4\xe1\x9f\xaf\x54\x0e\x3f\x21\x10\x6f\xb8\x3a\xc8\x57\x2e\xcb\x8b\x45\xb4\x29\x84\x03\x92\x5b\xfe\xe8\x64\xa4\x26\x41\x15\xad\xe1\x87\x5d\xc0\x13\x97\x99\xcc\xf1\x06\x17\xe1\xf0\xd8\xbb\xae\xae\xab\xee\xb3\xe7\x82\xc4\x2a\x4f\x51\xa5\xd3\x5e\xdd\x61\x4b\xc7\xfb\x1a\xdc\x7c\x19\x65\x0a\x26\x72\xea\x87\x1c\xf8\x46\xcb\xac\x4e\xf0\xda\xd4\x28\x41\x3a\xab\x22\x2a\xb1\x80\x72\xcc\x59\x5e\x0d\xa3\x11\x69\x58\xe9\x83\xc9\x41\xab\x43\x73\x6a\x92\x18\xab\x8d\x18\x9c\x9c\x40\xba\x16\x29\x9f\x4a\xad\x71\xda\x3c\xdf\x04\x31\x1c\x04\x9f\x30\x06\xd7\x6d\xcc\xd2\xa7\x6a\x2c\xbe\x83\x4b\x67\x1d\x2c\x16\xb1\x01\x99\x04\x06\xf0\x2f\xdb\x26\x70\x20\x62\xa5\xa0\x4a\x6e\xa0\xe0\x22\x26\x30\x0e\xf8\xd6\x6d\x7b\xf8\xac\x0a\xae\xb0\xb7\x90\xc6\x99\x63\x81\x0b\xa7\x19\x6e\x15\xa6\xb2\x09\xa2\x8c\x72\xe3\x31\x31\xa0\xda\x21\x59\x56\x17\xfe\x9a\x0c\x1d\xc6\xee\x52\xa0\x75\x37\xc3\x2f\x13\x55\x37\x7a\x63\x82\x59\x25\x2f\xa8\xa6\xef\x39\x79\xf5\x9b\x60\xc9\x86\x03\x2f\x99\x3f\x01\x82\xfe\xe6\x86\xbe\x61\x66\x98\xb5\x90\x28\x36\xe7\x8c\x88\x88\xa6\x47\xa2\xc9\xf0\x22\x6b\x60\x96\x2b\x30\x62\xc5\x74\x5a\x49\x09\xb1\xc7\x98\xde\x2c\x5a\xca\x8c\x29\x13\x55\xb6\xc2\x36\x61\x8c\x25\xe7\xe1\xdd\x3f\xe2\x07\xa5\x90\xd8\x0c\xd9\xcc\x24\x59\x18\xbb\x96\xbf\x95\xc7\x41\x19\x77\x91\x05\x1b\x5a\x1f\xd3\x14\x43\x74\xc8\x7e\x03\x37\x99\xe8\x3e\x0c\x22\x6f\xc2\xde\xf0\x07\x8e\xf8\xa4\x08\x09\xf2\xa9\xa2\xc8\xf6\x26\x13\xac\x2e\xe4\x1e\xcf\x27\x36\xa1\xa8\xa8\x72\xcb\x0f\x4d\x06\x57\xaa\x13\x88\xe6\x24\xf6\xac\x02\x44\x8f\xe0\x49\xd0\x84\x62\x0a\x46\x7c\xcc\x02\x0f\x34\xbc\x83\x1a\xb1\x56\xa0\x79\xe1\x83\x66\xc6\x46\x5c\xa5\x2b\x9e\x28\xf5\xe4\x28\x2f\x46\x56\x37\x01\x86\xe0\x35\x10\x90\xdf\x88\x8c\x2c\x3e\xb5\xc4\xa9\xf0\x02\x0a\x2a\x86\x5b\x34\x99\x83\xfa\xf0\x81\x67\xe7\xcf\x78\xa9\xd6\x17\xea\x3f\x97\x55\xdc\x3f\xeb\xf8\x8b\x69\x2c\x75\x5c\xb1\xd1\xb7\xfe\xbc\x4a\xa2\x7e\xcb\xaa\x49\xe8\xa9\x12\x86\xe2\x10\x33\xa0\xc6\x2a\x1a\xc1\x9b\x2c\x40\x97\x48\x60\xf0\x29\x68\x95\xfe\x94\x8c\x7d\x70\x65\x0f\x6f\xf9\xe2\x4e\x55\x26\xb9\x5e\x94\x53\x5d\xd7\x11\x07\x94\x59\x50\x35\x32\xfb\x5e\x5f\x39\x34\x7d\x1d\xba\xa5\x9a\x85\x41\x94\x70\x64\xed\x89\xaa\x6b\x58\x3b\xc0\xd8\x94\x4b\x84\xcb\x66\x16\x27\x1e\x9b\x66\x41\x4a\x7a\x18\xa7\x00\x60\x29\x7c\x01\xaf\xd5\x58\x9f\x32\x14\x5d\x7b\xc8\x7b\x70\x31\x0d\xf9\xd7\x05\x39\xd7\x54\x7c\x12\x1a\x1b\xe8\x72\xa4\xaa\x53\xd1\xf5\xae\x7a\x6a\x33\xb4\xb8\xa6\xa8\x05\x4b\x3e\x13\x40\x73\xee\x14\x8a\xfe\x38\x18\x67\x04\x39\x0f\x3e\x2f\xd7\x43\xc1\x24\x08\x73\xea\x3f\x2a\x83\xf8\x5a\xdc\x18\xc8\xe5\x5c\xcc\xdd\x02\xbc\xba\x75\x6a\x01\xc4\x7b\x08\x08\x2c\xf9\xe3\x12\xaf\xd5\x58\x64\x94\xc3\xc4\xf0\xaa\x34\xf2\xe0\x62\xe2\x93\x52\x1b\xcb\x8e\x67\xb1\x60\x5f\x57\x95\xa5\xa2\x6b\x7f\xb6\xcb\x86\x5d\x67\x5f\x7f\xfd\xfb\xb1\x76\xd4\xd2\x5f\x12\x2b\x95\xf0\xf7\xc8\x3a\xfd\x5d\xa4\xbe\x03\x29\xad\xbf\x4a\xd4\x57\x24\x57\xf9\xcb\x3f\xab\x32\x41\x86\x1a\x34\x45\x97\xc9\x69\xc4\x11\x14\xa3\x14\xb6\x39\xc2\x30\x6a\x36\xc9\x9e\xc9\x60\x62\x45\xae\x81\xf0\x4b\x29\x02\x3a\x94\x19\x3c\xc8\xc6\xdd\x84\xed\x41\xf4\x15\xc8\x01\xaf\xcc\x66\x61\x2a\xe8\x96\xca\xa9\x3d\x2f\x5f\x56\x68\xc3\x22\x86\x0b\x1e\x0f\xde\xc5\x6b\x28\x76\x2f\x8b\x28\x56\xc7\x25\x49\x29\x32\x15\x4c\x54\x24\x21\xe7\x32\x71\x60\x4d\x84\x21\x37\x58\xcb\x69\x0c\xd7\xc8\x3a\x2b\x0c\x86\x13\xf9\x09\x33\x3f\x51\x20\xb1\x42\x0a\x9a\xe7\xaf\x16\x01\x1c\xf4\x26\x38\x2d\xcf\xae\xf9\x0c\x5f\x23\x60\x34\x9c\xc0\xae\x8e\x16\x0b\x97\x35\xec\xdd\xc9\xe9\xe9\xc9\xf9\x31\xd6\x79\xe9\x1e\xf7\x06\x0e\x4a\xde\x77\x3f\x5e\x5e\x0d\x4e\x7a\x83\xab\xf3\xe3\xa1\x7e\xb4\x1a\x9e\xae\x65\xe3\x0a\x03\x50\x0f\x7c\xec\x5d\xf6\x1c\x10\xd0\xa2\xe9\x95\xf5\xa9\xb5\xd7\x42\xb2\xc7\xad\x6a\x3f\x9e\xce\x31\xd0\x87\x3d\x66\x1b\x3b\x99\xe1\x42\x8d\x86\x50\x1d\xe6\x58\xf6\xbf\xab\x52\xa5\x58\x91\x0a\x6d\xa6\xda\x4d\x6f\x57\x9e\x69\x4d\x32\x9a\x97\xf2\xe0\xc8\x0a\x77\x38\x8f\x42\x2d\x60\x49\xc1\x56\xdd\x2c\xd1\x95\x9a\x48\x59\xb0\x2b\xcd\xc0\x12\x36\xd1\x66\xcf\x37\x74\x1d\x09\xf0\xa2\x43\x27\x8b\xcd\x90\x31\x7b\x9b\x0d\xb9\x54\xa0\x98\x96\x1a\x99\x0a\x5b\x19\x55\xea\xc0\xd5\x05\x03\x30\x2b\x8a\x15\x8a\xb5\x41\x0c\x4d\x7c\x6b\x17\xec\x18\xd1\xa0\xef\xb9\x35\xb9\x38\x59\x23\x99\xde\x4b\x49\xca\x7e\x51\x69\xa0\x63\xa2\x68\xc6\x55\x92\x8c\xac\xb8\xae\xed\xed\x2b\x1f\xb0\x8a\xeb\xa8\x80\x9b\x95\xe1\xde\x7b\x71\xb3\xd0\x7f\x4d\xf3\xc2\x7b\x80\x51\x63\xd4\xa8\x32\x54\xb2\xbb\x62\x35\x2e\x02\x73\xd0\x02\x0e\xc2\x1d\x3d\xac\x4e\x8d\x4b\x5f\x02\xb5\xaa\x18\x6e\xba\x8c\xa3\xb1\x94\x93\x7f\xa8\x19\xf4\x17\xa5\x4b\xbc\x79\x78\xeb\x2a\xbd\xa7\x89\x5b\xa5\xa2\x31\xde\xf6\xe1\x24\x0d\xef\xf0\xf5\x14\x37\xbb\x52\x4f\xe4\xd4\xcb\x02\xcd\x6a\x2d\x7d\x9b\x45\x1f\xbd\xa3\xbd\x45\xe2\xb2\xd9\xc5\x59\x09\xa8\x21\xba\xf3\x3d\xac\xbe\x97\xd7\x42\xb4\xc4\xef\xca\x35\x79\x17\xe3\x34\xd2\xf5\xf9\x86\x36\xd4\x28\xda\xd2\xcf\xeb\xc8\xb9\x7c\x76\x12\xa1\xd4\x70\x49\xd9\xe3\x5e\x47\x17\x0c\x79\xb7\x11\x4b\xcd\x8c\x46\x6e\xbe\xed\x92\x5f\x4d\xcc\x27\xb5\xcc\x7a\x2e\x26\x35\x30\xac\x68\x0e\xd9\xd2\xca\x26\xa0\xd1\x88\xcc\xcb\xec\x0b\x2b\xbc\x5c\x8d\x35\xf3\x83\xc9\x12\x2f\x49\xf0\xb8\xf9\xc3\x10\x6f\xe7\x53\xb8\xb0\xd7\x41\x68\x93\x69\x51\x0b\xa8\x99\x3b\x75\x2d\x2d\xcd\x5c\xab\xef\x1e\x52\xb4\xde\xc1\x81\x83\x12\x4a\x7b\xcd\xbd\x50\xd7\x5d\xd0\xc5\x00\xb2\xd0\x27\x1d\x71\x01\x97\xdf\x2c\x96\x54\x94\x31\xf0\x6f\xa5\x38\xdb\x13\x67\xef\xf6\xc4\x31\x95\x75\x38\x7e\xe7\xba\xeb\x80\x08\x45\x54\x0b\x0c\x05\x65\x57\x3a\x67\x98\x99\xaa\x07\xe6\x7a\x13\x8b\x33\xef\xe9\x3f\xe0\x13\x4a\x34\x40\x9f\xa3\x60\x97\xdc\xf1\x3b\xce\x3a\xae\x1e\x8f\xa9\xd6\x3c\x99\x74\x38\xaa\xaa\x43\x39\x64\x18\xe2\xcf\xbf\xc0\xa2\xc1\xfb\x68\xef\x9f\xbb\x67\xfd\xd3\x1e\x27\xe4\x62\xa5\xee\xd2\x0b\xfd\xd8\xbf\x83\x9b\x33\xc6\x89\xea\x24\xb6\xc5\xc3\x92\xbf\xd4\x89\x6c\x6f\xf1\xc3\xdb\x56\x87\x9f\xa1\x0f\x03\x32\x54\xcd\xf9\x24\x99\x0b\x2a\xcc\x4c\x3f\x6d\x06\x6e\xe9\x8b\x1f\x60\x64\xae\xcc\xef\x75\x6f\x2f\x4d\x65\xa6\xcd\x00\x60\x6d\xec\xab\x61\x6f\x40\x7f\xf5\xbb\xc3\xe1\x77\x17\x83\x23\x64\xf3\x46\xe0\xa8\x64\x14\xa7\xde\x6a\x21\xca\x35\x52\x57\x2b\xa7\xfc\xd0\x99\xae\xa6\xd2\xe6\x75\x56\xfb\xdd\x01\x7c\xbe\xec\x0d\x86\x37\xdd\xe1\x0d\xe6\x61\xff\xc9\x9a\xfc\xe1\xc1\x6a\xa5\xaa\x22\x5a\xbb\x72\xec\xe2\x01\x6d\xa9\x5c\xcc\x34\x16\x16\xca\xc5\x03\x30\x70\x0b\x48\x63\x2e\x2b\x80\x75\x04\xb6\x82\x82\xd5\x78\x28\x57\x91\x6a\xef\x10\xb8\xbc\xf4\xce\x49\x28\xbe\x03\x78\xd1\x7d\x22\xfa\xd1\xbd\x8c\x87\x73\xb8\x54\x50\x6a\xd6\x24\xca\xb0\x95\x0c\x55\x1f\x9e\xec\x09\xae\xc6\xcc\x05\x92\x30\x89\xfc\x27\xac\x96\xcc\x60\xaf\x11\xf0\xb5\x02\x0d\xff\xfe\xac\x92\xcb\x2d\xd8\x2a\xb2\x0f\xee\x78\x21\x5d\x1d\x55\x81\x07\x07\xf4\xd7\x75\xc0\x5d\x81\xee\x4d\xd6\x8e\xea\x49\xa4\xb5\x20\xd5\x27\x67\xd8\x3b\xbc\x1a\x9c\x5c\x7e\x7f\x73\x3c\xb8\xb8\xea\x6f\x0e\xbe\x16\xac\xb8\x18\x1c\xf3\x76\xde\x06\xc1\xba\x72\x69\x8e\xc5\xbd\x05\x4a\xd5\x66\xe8\x19\x58\xa6\x0f\x27\xd7\xb1\x5a\xff\x3a\x85\x7f\xf0\x36\xa0\xcd\xad\x45\x01\x6c\x7a\xca\xcb\x57\x19\xf9\xae\x4d\x6d\xbf\xbe\x78\xc0\x3d\x5b\xd8\x44\xd6\xff\xfd\x4f\xfb\x87\x36\x30\x14\x21\xd3\x28\x02\x18\xfc\xbb\x9d\x06\xf5\x16\x7e\x70\x8c\x7c\xcd\x18\xd7\x30\x86\x8a\x62\x21\x1f\xbc\xe4\x21\x1c\x53\xed\x78\x80\xa0\xab\x05\xc0\x5a\xb9\x39\x3b\x39\xbf\xba\xe4\x12\x04\x1d\x40\x0d\x2b\xea\x4d\x1a\x67\x52\xfc\x0b\x36\x49\x4a\xf0\x5f\xa4\xfc\x6d\x1a\xbd\x45\x09\xf4\x15\x3d\x37\x8e\x02\x38\xc9\x0b\xcf\xf1\x0f\x54\xb1\x09\x20\x9c\x5e\x1c\x76\x4f\x7b\xf0\xdb\xe1\x69\xaf\x3b\xf8\x6a\xb3\x35\xa7\xca\x63\x81\xe0\xec\xe8\x3a\x43\x76\xd5\xec\xa5\x78\xab\x29\x63\xc3\x2e\x3e\x48\x65\xc5\xc8\xb6\x6b\xde\xd9\x7f\x58\x04\xce\x72\x27\x8d\x28\x30\xab\x33\xaf\xd3\x4d\x4b\x4a\x50\x4a\xe0\xc9\x05\x2d\x34\x8e\xf4\xff\x97\x4e\x67\x02\x2a\x31\x7c\xda\x0a\xe3\x24\x5a\x60\xc1\x7f\x14\x13\x6a\x9a\xb7\x00\x86\x97\x06\x80\xb4\x0d\x08\xf6\xdd\xfe\xf1\xea\xe2\xb2\x4b\x05\x2a\x2e\xe1\xc3\xe9\x4d\x5e\xa6\xc2\x17\x5a\xea\x58\x5f\xc6\x5c\x0f\x63\xa8\x6a\x55\x94\xc4\x13\xaf\x38\xd6\x71\x96\x9e\x6f\x04\x5a\x87\x02\x67\xb7\xe2\x1e\x6f\x12\x92\xaf\x96\x24\xa8\x3c\xfe\x9b\xc9\x07\x1b\xec\xe2\x81\x55\x32\x97\x88\x58\xf9\xbf\x1a\x99\xb1\x16\x6e\x59\x83\x28\xc2\xa5\xaf\xf6\x77\x08\xbd\x24\xa5\x4a\xd0\x9b\x08\xa9\x9a\x09\x08\x73\xc6\x37\x9a\xc5\xfa\x13\x54\xd7\xc2\xc3\x23\xed\x66\x70\x05\x73\x46\x65\xf1\xb6\x59\x36\xcd\xea\xf0\x39\x4e\x55\x2e\xc2\xd2\x3d\x1e\x6e\xb5\x72\xf5\x1e\x40\x65\xb9\x93\x46\xb7\x70\x8f\x3d\xed\xbe\xeb\x9d\x8a\xfe\xe0\xe2\xd3\xc9\x51\x6f\x00\x3b\xef\x63\x6f\x2b\x69\xa0\x51\x70\x56\xa5\x19\xdf\xbb\x01\x00\x1e\xac\x2a\xe8\x54\xbb\x03\xf6\x89\xba\x86\x8c\x23\xd0\xcc\x76\x32\xc4\x5b\xf9\xb0\xca\x5c\xfd\xc5\xc7\xde\xf7\x75\xba\xb9\x78\xc1\x2a\xf7\x6d\xc9\xfe\xcd\xd6\x60\x7d\xce\x8a\xd1\x1b\x30\x69\xab\x02\xac\x4d\xaa\xf7\xae\xdc\xe0\x6b\x88\x5d\x3c\x4c\x46\xf0\x1f\xfc\xa8\xe6\xaf\x08\xbf\x00\x1e\xe7\xad\x0d\xb8\x7f\x7d\x8b\x61\xe8\xb4\x81\xde\xa6\x8b\xe5\x5b\x6d\x6c\xbf\xe1\x19\xa4\x4b\xdd\x56\x3b\x6a\xee\xc5\x72\xa2\x75\x86\xed\xf5\x05\x3e\x28\x58\x7a\x63\x9f\x28\xd5\x20\xea\xaf\xfc\x55\x87\xb4\x80\xed\x44\x00\xc9\x92\xa2\x4e\x51\xa9\x41\xd8\x95\xb0\xbe\x98\x36\x41\x91\x2a\x2b\x72\x71\x5b\x88\x1d\x5d\x2e\xb1\x7c\xec\xd8\x27\xcd\x52\x1c\x0e\x7a\x47\xbd\xf3\xcb\x93\xee\x29\x8d\x30\x10\xc3\xef\x87\xa7\x17\xc7\x37\x47\x03\x98\xe4\x1b\xb4\xe6\xe4\xac\xd1\xfd\x42\xe8\x6b\xb5\xa5\xfa\x18\xa2\x43\x99\x8a\x20\x40\x70\xc3\x53\x09\x43\x58\x2e\x5c\x98\x25\x97\x01\x94\x1f\x92\xd8\x29\xab\x79\x5c\x8e\x58\x44\x13\x59\xb9\x87\x1a\x8e\x84\xba\x0a\x11\x15\x7b\x39\x19\x7b\x39\xf2\x3d\xc6\x7e\xfd\xaa\x40\x75\x05\x95\x94\xeb\x4e\x52\x01\x08\x65\x1a\x2c\x87\xeb\x4a\x38\xd1\x96\x34\xa3\x1c\x80\x3d\xfc\x4d\x2e\xb4\xbf\x21\x41\x0e\xdf\x7d\x9b\x7f\xf7\xad\x25\xc9\x87\xaa\x45\x91\x57\x92\x96\xb6\x20\x27\xb3\xc6\x76\x84\x95\x65\x67\x9d\x98\xab\x86\x0a\xfa\xe0\x64\xd4\x59\xa0\x05\x86\x26\x47\x3b\x7a\xf6\xac\xce\x4f\x9b\x42\x33\xd7\xb2\x7c\x06\x93\x55\xcb\xd5\x5a\x80\x31\xf0\x2b\xef\x6e\x11\x88\xe4\x21\x09\xa2\xd9\xc1\xdb\xb7\x6b\x14\x5e\x27\xc4\xa2\x99\x0c\x76\x8d\xae\x49\x52\x00\x48\x20\x4f\xfd\x30\xfb\xf1\xed\x99\x37\xde\x98\xa5\xb8\x76\x34\x53\x69\xad\x50\xfc\x20\x2d\x9f\x9c\xc3\x07\xf8\x07\x37\x9a\xb2\x16\x51\x95\x9d\x6c\xf3\x99\x25\xf3\x99\xa1\x44\x5b\xd0\x98\x9a\x6b\xa4\xa7\xd4\xf4\xec\x80\xbf\x50\x54\x69\x0b\x5e\x81\xb0\xdc\x38\xb8\x05\x77\xb6\xa5\x6a\x33\xd3\xdf\x18\x4b\x34\xd0\xdd\x1d\x8e\x9c\x3b\x14\x9e\xff\x0c\x67\xcc\xe5\x87\x0b\xea\xb3\xf5\x01\x2b\x27\x82\x96\xad\x7a\x6e\x75\xe1\x9c\xc3\x63\x05\xd6\xcd\x32\x4b\x05\xee\x36\x2d\x57\xdf\x3d\x68\xaf\x73\x5e\xa8\x12\x61\xbf\x56\x1d\xfc\x28\x53\x6e\x01\xbb\xff\xb8\x77\xa9\xf5\x2d\xa5\xb9\x81\x00\x46\x02\xf6\xc5\xc9\x94\x8a\x93\x11\x3c\x4c\x3e\xd7\xf5\x73\xef\x7c\x4f\x74\x26\x58\x18\xbb\x8f\x76\x1e\xdd\x08\x4b\xc1\x94\x9c\x3a\x0d\xea\xc8\x9e\xce\x62\xa7\x40\x55\xec\xf9\x7d\xf9\xb0\xe4\x95\xa2\xdf\x49\x64\xaa\x5c\x89\x3a\x1c\xe7\x2d\x6e\xc4\x7d\xca\x99\xc7\x58\x85\xe8\x4e\xc6\x31\x2a\x9c\x73\x00\x88\xf2\x95\x7c\x39\xc0\x08\x05\x9a\xa0\xe9\x5c\x30\x10\xc1\xf3\x68\xa2\x1e\xf9\xe7\x7d\xc5\x8a\xf7\x11\x25\x74\x89\x49\x34\xa6\x56\x68\x84\xc6\x54\x1a\xbc\xf3\x13\x3f\xd5\xde\x11\x6f\xe9\xc3\x53\xc9\xfe\x18\xab\x40\x4d\xb9\x08\x14\x06\x98\xef\xaf\xde\xbd\xc7\x53\x9e\xab\xeb\x57\x6f\xef\xbe\x7d\x8b\x35\xa7\xaf\x5f\x01\x52\xe2\x27\xcc\x7f\x58\x7d\xd7\x06\xc2\xaf\x5f\xd9\xdc\x38\x28\x8c\xfd\xc7\xce\xfd\xfd\x7d\x07\xb9\xd8\x01\xd8\x32\xc4\x00\x39\x6c\x71\x57\x03\x70\x22\x5e\xff\xf5\xff\xe2\x22\x3d\xa0\xfb\xb0\xde\xa3\xd5\xe4\x4d\xc4\x3f\xbe\xb5\xad\x65\x1b\x2d\x51\x95\x0e\x6b\x59\xba\xa6\x20\xac\x36\x53\x61\x18\x56\xa5\x01\x0b\xbd\x22\xdb\xc0\x2c\xa8\x9b\x5b\x43\x53\x36\xaa\x1d\xc0\x59\xce\xbd\x50\x2a\x9f\x48\xb2\x35\xbc\xa2\x92\xba\x1d\x2c\xb6\x8a\x34\x37\x48\x11\x42\xb7\x55\xaa\x00\xb5\xa9\x31\xaa\xc6\x1a\xe5\x84\x57\x30\x13\x91\x65\xbb\x00\x6f\xd5\x9a\xbd\x29\xd8\xed\x8d\xe4\x6d\x38\x3d\x5d\x63\x86\x52\xb0\xea\xcd\x50\xdb\xae\x89\x1a\xe5\x7f\x27\x80\x6b\x2c\x49\xbb\xc2\x50\x6d\x48\xda\x15\xf4\x06\x66\xa2\xc2\x26\xa9\xdc\x23\xd5\x77\xf3\x66\x6b\xa9\x35\x21\xef\x7a\x27\xc3\xfe\x49\xef\xb4\x0d\x25\x8d\x38\x52\x71\xcd\xdf\x9e\xcd\x85\xbb\xfe\x0e\x60\x29\x89\x69\x99\x0a\x3a\xfa\x14\xdb\x0a\x78\xf1\x16\xbe\x39\x34\x76\xce\x74\xa6\xa0\xaa\x66\x31\xfc\x1b\x78\x33\xf1\xbe\xd7\xbd\xbc\x1a\x6c\x11\x5a\xa1\xa1\x26\x56\x5f\xd7\x8d\x01\xed\x36\xea\x83\x6f\xf3\x3b\x1e\xaf\x02\xba\xf5\x70\x65\x78\xb7\x25\x80\x3b\x6c\xf7\xbb\x1d\x8c\xdd\xb2\xc6\x86\xb6\x99\x33\x1b\x15\xc7\xc4\x52\xff\xb4\x2e\x90\x5b\xc8\x50\xcc\xa4\xf4\xff\x94\x3f\x84\x72\xe6\x32\xe2\x10\x7d\xae\x4e\x86\x37\x8d\x54\x01\xc2\x1a\x86\x14\x7c\x6e\x22\x63\x23\xae\x5e\x76\xe4\xcb\x59\x44\x19\x41\x32\x84\xbb\x04\x06\x62\x98\xab\x0c\xcc\xac\xeb\x7e\xf5\x5b\x20\x13\xb4\x6f\xa2\xb0\x96\x8f\x33\x99\x76\xb8\x3c\x44\x87\xcb\x43\x6c\xb5\x4a\xb0\xd2\xb2\xf8\x41\xf7\x64\xde\x08\x84\xaa\x45\xa5\x42\xc8\x94\x93\xbc\x83\x7c\x7b\x7b\x79\xf1\x56\x15\xa4\xfd\x17\x72\xb8\xfc\x0b\x9a\x27\xf2\x78\x34\xfe\x8d\x3e\x7f\x65\xce\x19\x40\xd0\xa7\x96\xf8\x1c\xf7\x4c\xc6\xe4\x78\xc1\xde\x80\x2c\x0c\xb0\x82\xcf\xeb\xce\xf4\xb5\x7d\xb5\xac\xbe\x67\x95\xe8\xfa\xd7\xb7\x47\x2a\x8d\x35\x79\xab\xa2\xdd\x40\xf1\x1a\x79\xb1\xe3\xf9\x0a\x2b\x4a\xf1\xbd\x9b\x00\xad\x29\x37\xde\x62\xf2\xf7\x7f\x70\xc0\x80\xd1\x9e\x3d\x50\xc1\x45\x55\xe7\xac\x23\xc7\x73\x97\xb2\x57\xcf\x65\x5c\x5f\x76\x94\xde\x66\x9b\x90\x53\xce\x7e\xe8\x78\x78\xb5\xd5\x76\xd6\xcc\x1c\x40\xba\x11\x03\xdb\x82\xff\x64\x9b\xc9\x13\x96\xd8\x7f\xda\x38\xb2\x0d\x50\x83\xfa\xba\xe9\xab\x5b\x0a\xc3\x85\xb7\x54\xda\xb3\xd9\xd9\xbb\xf0\xa0\xe7\x60\x17\x0f\x18\xd0\xb1\x8b\xfb\x4a\x2d\xcc\xed\xee\x2c\x2d\x41\x6f\x7e\x6f\x11\xad\x9a\x81\x84\x4d\x9b\x80\xb8\x9a\x7d\x98\xf1\x71\xce\xb7\xd1\x46\xb5\x47\x2a\x11\x77\xdf\x68\x2f\x02\x7e\x34\x77\x05\xfc\x8c\xde\xf0\xbb\x6f\xf3\x9f\xbf\xa5\xaf\x36\x5e\xe6\x51\x7e\x33\xd9\xec\xfd\x2d\xa2\x5a\xe0\x5d\x52\x28\x93\x8d\x21\x90\x6d\xb2\x5d\xba\x95\x79\x95\xcb\xdc\x6f\xf6\x6e\x16\xcf\x56\xa7\x6d\xe5\x5e\xb2\x03\xd8\xba\xc4\xb1\x89\x86\xa0\x45\xa7\xd6\xc3\x66\xe7\x9f\x65\x4b\xd9\xfc\xfd\xcd\xf8\xc6\xdd\x2a\xaa\xa3\xbd\xab\x22\xbd\x2b\x9e\xb7\x82\xbd\x37\x5c\xf1\x31\xd7\x95\x35\x82\xf5\xbc\xf7\xdd\xcd\x56\xc2\x9a\x01\x56\x59\xf7\x72\x04\xc5\xaf\xb6\x41\xa3\x4d\x74\x08\x75\xd3\x6d\xa3\x40\x39\xad\x1e\x08\x7b\x27\x8b\xb9\x88\xc8\x61\xa3\xb0\xb1\xf1\x57\x5b\xe1\xb2\xae\xd2\x04\x79\xe3\xf8\x5e\x5c\x6f\x1d\xdd\x0d\xe3\x07\x5b\x13\x5c\xb5\x74\x8c\xa7\xc5\xc7\xe1\x69\x6b\xa5\x6e\x88\x1e\x03\x7d\xe5\x76\x8a\x44\xcc\x2d\x93\x76\x02\x84\x42\x40\x8d\xb0\x33\xfb\xe7\xe4\xfc\xa8\xf7\xcf\x9b\xc1\x55\xb1\xdf\x70\xff\xf4\xe3\x28\x44\xaf\x45\xe7\xce\x8b\x7d\xba\xd5\x92\x9d\x6f\x23\xb0\x09\x05\xbf\x5a\x86\xfb\xfc\x2e\x54\x73\xaa\x6f\x68\xc9\xd8\x7d\x10\xb6\x6b\x57\x6e\x03\xcc\xb2\x3f\x6e\x26\xb9\x9b\x9a\xdf\x9c\x26\xc0\x8d\x6c\x7f\x6d\xb0\x56\xdb\xfb\x36\x31\xf4\x59\xef\xac\x46\xb8\x34\x19\x60\x42\xa8\x9a\x8f\xad\x1a\xcb\xda\x01\x29\x34\x6b\xc6\x92\x76\x6c\xf3\x8e\xe8\x9d\x7f\xba\xf9\xd4\x1d\x14\xff\xf8\xd4\x3d\xbd\xda\x74\x7d\x39\x6e\xf7\xaa\x44\xe3\xbf\x70\x59\xc6\x8d\x61\xa3\x8a\x48\x95\xcc\x8c\xcd\x11\xcf\xbe\xc1\x05\x07\x5c\x6c\x0c\x96\x75\x20\x04\x45\x7a\xd0\x56\xb0\xd6\x4b\xb1\xe6\x91\x88\x1b\x13\xb1\x6a\xf4\xa5\x9f\xca\xf6\xdf\x2d\xe1\xaf\xce\x04\x9f\xb3\x5b\xcf\x87\x4e\x69\xf9\x72\x3c\x44\xab\x7e\x47\x25\x0d\xee\x28\xee\xdf\xd2\x44\x36\x7f\xdf\x9e\xd3\x1b\x9a\xc8\xcd\xcf\x71\x0b\xe0\x86\xa7\x80\x36\x87\x73\x88\x9f\x9c\x6c\x6b\x16\x67\x80\xe6\x0e\xb8\x2d\xb3\x36\x1c\x95\x65\x3f\x27\x6d\xc1\xd6\x73\x3a\x54\xef\x95\x53\x14\x55\xab\x01\xfc\xe3\x54\xfc\x80\xb9\x58\x37\xaa\x8e\xdc\xc1\x9f\x50\xda\x1d\xa0\xc9\x81\xfe\x83\x7f\x91\x55\x06\x2b\x1e\x93\xa1\xa2\x43\xa1\xb4\x44\x51\xfe\x03\xde\x6f\x60\xb9\xc9\x1f\x41\x89\x30\xbf\xa8\x30\x8f\xce\x32\x91\xd9\x24\xea\xa4\xe9\x03\x7d\x3d\x8d\x62\x8c\xa3\x2c\x7e\xa9\x3d\x1e\xd6\xd7\x9b\xb2\xa0\x53\x53\xff\x68\xfd\xcb\xec\x8a\x98\x6c\xa7\x67\x02\xc7\xe1\x04\x21\x43\xca\x96\x40\x36\x5c\x08\x6b\xa5\xd0\xa6\x60\xb7\xd5\xc0\xb1\x3f\xe9\x76\x10\xb8\x9a\x7a\x95\x85\x74\x23\x70\x59\xd8\x2a\xf3\xd7\xe5\xfa\x77\x6a\x53\x95\xf0\x9b\xa7\xf8\x6e\x35\xa6\x67\xcb\x48\x55\x08\x9e\x33\x27\xd5\xa0\x58\x93\x95\xba\x15\xf0\x67\xcb\x3f\x35\x8d\x58\xb4\x43\x82\x3d\x2e\x9b\xab\x2e\x59\xf8\x4c\x96\x74\x1b\xf0\xee\x6c\xe9\x6b\xa0\x6e\x67\x4d\x6f\x0d\x7c\xfb\x38\xa0\xd6\xec\x5f\x37\x9b\xb5\xd7\x99\x0d\x57\xc8\x33\x5d\x33\x18\xf0\x8a\x0e\xb7\xe5\x85\xc3\x86\xfa\x2c\xda\x38\x20\x78\x06\x55\x38\x5b\x4e\x5c\x19\xbc\xb6\x17\xc5\x37\xa9\xbc\x7f\xaa\xcc\xe5\x55\xb9\xcd\xb7\xf0\x55\x16\xe2\x87\x0d\x0f\x2f\xa6\xa6\x7d\x36\x2d\xfa\x7e\xd0\xa6\xa8\x45\xc5\x36\xc9\x30\xe8\x5c\xee\x98\x40\x93\x5d\x25\xcb\xa8\xa1\xbd\x5c\xd2\xa6\x41\x58\x93\x3d\x83\x2c\x43\x27\x95\xb3\xd0\xc7\x96\x59\x9b\x45\x1a\x9e\x25\x6b\xb3\x84\xa2\x45\xd6\xe6\x56\xe8\xea\x43\xb9\x7c\x71\xd6\xfd\xe7\x8e\x66\x75\xa7\x3a\x61\xab\xc1\x8a\xfd\x82\x0b\xf5\xbf\x40\x0e\x56\xbb\x91\xfc\x36\x72\xb0\x5a\xd3\xfc\x52\x39\x58\xad\x09\x6b\x94\x83\x55\x0b\x75\x17\x09\x43\x9b\xe1\x6a\x96\xa1\xb5\x16\x60\xeb\x0c\xad\x75\x10\x9b\x64\x68\xb5\xdd\xf4\x97\x03\x54\x4d\x7a\x83\xc1\xc5\x00\x77\x72\xf7\x12\x6b\x1d\xc3\xf6\xa5\x74\x1e\x2c\x8c\xd6\x07\x5e\xfc\xfc\x33\xcc\x1b\x7c\xee\xc5\xb1\xb3\x9c\xa2\x03\x83\x17\x52\x21\x36\x1a\x0e\xa6\x0b\x8b\x3c\x98\x22\x9a\x0a\x94\x5a\x66\x6f\x90\xd4\x72\x40\x57\x15\xdc\xa9\x67\xf1\xa3\x37\xc7\xd2\xa0\xba\x20\xdf\x92\x7b\xbe\xe9\xae\x8c\x5c\xb4\x8d\xcb\xc8\xcd\x24\xf5\x9e\xd2\x4d\xc3\xdc\x24\xbe\x1c\x79\xcf\x45\x98\x78\x73\xc4\x09\x57\x07\x26\x4a\x56\x4e\x5c\x6d\x9d\xb6\x24\x77\x5f\xbc\xd1\xf5\x3d\x0f\x14\xbf\x1f\x33\x78\x0f\x3b\x5a\x38\x6a\xac\xc2\x58\x70\x19\xa8\xe4\x9d\x72\x5d\xd5\x3d\xf3\x0d\xb9\x4f\x30\xfc\x71\xc4\x05\x0e\x13\x2e\xa8\xc7\xed\x42\x47\x52\x01\x70\x45\x96\x98\xde\x77\xaa\xdc\xb7\x6a\xaf\x87\xb5\xf9\xfd\x40\x37\xc2\x1c\x16\x2a\x09\x63\xa1\x64\xf5\x0d\xb6\xdf\x7c\xfa\x35\x49\x64\x40\x15\x78\x55\xa1\x5e\x80\x36\x93\x01\x01\x36\xcd\xe7\x16\xf4\x98\xb3\xf9\xa5\x1a\x2c\x85\x72\x2e\xbc\xf8\x56\xa6\x30\x45\x63\x33\x6c\xce\x22\xc3\x3a\x43\x5e\xde\x5c\xaf\xae\x72\xf7\x19\xc0\x40\x10\xe9\xa3\x81\xa0\xe7\x27\x9a\x87\xb2\xb2\xa5\x9e\x55\xd0\x9b\x99\xe1\x65\x53\x18\x07\xd6\x8d\x36\xd3\xb8\x9e\x7a\xea\x2f\xe1\x63\x2b\x32\x15\x39\x89\xa1\x94\x2b\x05\x30\x5b\x0e\x07\x3b\x3a\x58\x30\x81\x52\xaa\x11\xbb\x02\x76\x27\x63\xac\x9f\xa2\xdf\xb6\x58\x42\x0a\x13\x75\x5c\x8f\x22\x38\xac\xf1\x6a\xc5\xbd\x91\xe9\x96\x25\x22\xaa\x8c\x91\xb8\x0a\x5c\x62\xc9\xc8\x59\x80\xfc\x79\x04\xac\x3e\xc6\x2c\x84\x33\x6f\x24\xb9\x9c\xe9\x52\xc6\x71\x87\x56\xfa\x7b\x20\x0a\xbf\x67\x70\xd8\xf5\xd7\x14\xbf\xd4\x5b\x68\x0d\x1f\x0b\x54\xe2\x41\xc1\x66\xe7\xbc\x46\xf6\x11\xdf\x14\x27\xee\x66\x7d\xb5\xc4\x16\x40\x66\x65\x90\x55\xf4\x36\x23\xd7\xdc\x7b\x47\xdc\x12\x70\x42\x2c\x7e\xcb\xec\xad\xa3\xd4\xa2\xcd\x54\x0e\xed\xbc\x43\x20\x48\x1d\xf1\x56\x86\x6f\x7b\x61\x9a\xf0\xc7\x36\x2c\x9d\x63\xc3\x7b\xac\x2d\x72\xe7\xcb\x7b\x6e\x89\xac\x83\x3b\xc6\x51\x16\xa6\x7b\x28\xe1\x6f\x95\x1b\x8b\x2c\xad\x9c\xea\xba\x90\x0b\x6c\xc6\x4e\xdf\x70\xa7\xd7\xba\xaa\xea\x47\xba\x47\x75\xf8\xf8\x88\xbb\x89\x1b\x37\x86\xe2\x18\xa8\x7d\x84\x85\x99\xe6\x0d\x4b\x61\xc3\x62\xdb\x19\xdd\x7f\x5e\x37\x2f\xc6\x61\xd2\x17\x23\x39\xc3\x97\xb0\xb0\x33\xbd\x63\x2a\xb3\xc3\x0e\xc0\xfe\xf3\x5c\x75\x14\xf7\x89\xef\xec\xdc\xae\x46\x6d\x6f\x3a\x1e\xc3\xca\x61\xe1\x18\x8f\xd9\x76\x5e\x68\x51\x51\x14\xf6\x9a\xa0\x5a\x12\x28\x95\x46\xeb\x94\x0e\x64\xba\xe3\x0a\xdc\x65\x43\x78\x2c\x6d\x00\x98\xfa\x6d\x2b\xa8\xee\xea\xbc\x4f\xff\xc6\x1c\xc3\x4e\x37\x1f\x15\xf0\xc4\x59\x8f\xf7\x10\x5d\xfb\x08\xd8\x14\x51\x77\x43\x1e\x72\xe3\x69\x6c\x66\xc3\x8d\x39\xdd\x50\x31\xfd\x58\xbc\xe7\xfc\x63\xca\x5d\xc6\x76\xcf\x7e\xa4\x8a\x04\xfb\x9f\xa8\x49\x98\x6a\x93\x9a\x88\xc3\xd3\xc2\x03\x87\x81\x7f\xe6\x63\x47\x24\xee\x3c\x8e\x2d\x7d\xc7\x5c\xf4\x39\x78\xc0\xa4\x85\xe2\xa3\x04\x6b\x1f\x13\x1f\xb2\xe5\x2c\xf6\x26\x92\xbb\x09\x01\xcc\x62\x8a\xf4\x81\xd1\x75\x67\x70\xd8\x64\x23\x32\x74\xda\x79\xd2\xf0\x87\xff\x3f\x75\x83\x29\x97\xb8\x2e\x8c\xac\x83\x6d\x36\x3f\x55\x8c\x4c\xb7\x71\x4d\x91\x0c\xfb\x09\x6b\x68\xd8\x7b\xc5\x74\x4f\x10\xde\x6d\x9a\x61\x2d\x50\xdc\x14\x9f\xaa\xc6\x77\xb5\x50\x9b\x02\x1e\xf4\x02\xdd\xad\x84\xfa\x08\xd1\x60\xf1\x54\x7b\xcc\xa8\x3c\x3a\x2a\x24\x33\xa9\x1b\xf8\xc2\x89\x66\x9a\x5a\xc1\x62\xf6\x53\xd9\x96\x13\xd5\x53\xac\x6a\x27\x7c\x90\x81\x4b\x3e\x7c\xf0\x83\xa9\x6a\x1e\xc1\x6d\xc7\xeb\x21\xe1\x99\xed\xdc\x2c\xf8\x7a\x82\x37\xb7\x7a\x18\xe5\xfe\xec\x9c\xe1\xa2\x5c\x0e\x23\x89\x0b\x5d\xf9\x21\x30\xcb\x1f\x1b\xd8\x72\x4b\x7f\xb8\x40\x15\x3b\xe2\xc3\x04\x0d\x38\x9a\xd4\xdd\x98\x7e\x1d\x78\xab\xc9\xbd\x36\x37\xa4\x89\x28\x34\x4c\xa7\x93\x38\x71\xb6\x06\xaa\xee\xd6\xee\x2f\xac\xde\xee\x69\xde\x66\xdd\x74\xd1\xe5\x31\xc1\xb2\x78\xdf\x51\x9d\xe9\x3b\x5d\x1e\xd4\x3b\x6c\xcb\x1e\xaa\x95\xe1\xee\x07\x0f\x18\x1e\xb3\x42\x03\xf9\x89\x85\x26\x5b\xa8\x76\xf2\xa8\xc1\xf2\x09\xa0\xc7\x83\x72\x5d\xb5\x17\xa2\x0e\x15\x59\xa1\x45\xb5\xf3\xbc\x72\xcc\x5e\x42\x9d\xc2\xac\x59\x41\x9e\x2a\x6e\x57\xb5\xd6\x47\x69\x01\xe7\x5b\x30\x11\x29\x88\x9d\x42\xef\x7f\xd7\x5b\xba\x0c\x43\xa8\x47\xcb\xbd\xc6\xd4\xe3\xf6\x14\xfa\xe1\x5d\x74\x5b\xb7\x1c\x80\x80\x0f\x70\x65\xba\xc3\x63\x10\x1b\x48\x24\x73\x22\x85\x2f\x1e\xd3\x0c\x8b\x8f\x61\x6b\xe0\x18\xcf\x11\xae\x2a\xe1\x2f\x96\xd8\xfd\x0c\xd4\xc5\x02\xad\xf8\x13\x95\x1d\xc7\x3f\x56\x29\x66\xda\x5a\x2e\x19\xb5\x32\xd4\x72\xe8\x32\x33\x17\x66\x4a\x2b\xb8\x89\x2b\x44\xab\x9e\xd8\x08\xc9\xb4\xfa\xa7\xf5\x40\xc7\xcb\x9a\xf6\xfe\x7c\x5c\xa8\xa3\x3e\xc9\x9f\x07\x9e\xe3\x45\xc9\x97\xd8\x40\x70\x52\x58\x66\x6a\x61\xb9\xd6\x25\xc8\xb2\xc7\x2c\xe6\xa6\x58\xd4\x0d\x2b\x0a\x48\x87\xff\x8b\x9c\x44\xd4\x74\x96\xae\x67\xaa\x55\xc4\xbd\x1f\x53\x53\x42\x9c\x3f\x43\x3c\x2f\x53\x24\xde\x14\x65\xcf\x57\xb6\x6b\x20\xa9\x6c\xb0\x78\xb1\xff\x58\x16\x62\x11\x38\x58\x3f\x94\xea\xa8\xca\xbd\x51\x8f\x5c\x90\x07\x0b\x6a\x7d\x3e\xc7\x2e\xb4\xa0\x83\xb8\xbb\x81\xe5\x62\x9c\x1b\x2e\x22\x23\xa8\x09\x1d\xb2\xf0\x3d\x02\xc6\xce\xe5\xa0\xab\xcd\xe3\x29\x1e\xc5\xdc\x83\x17\x0f\x9b\x35\x17\x96\x68\xb1\xcc\xa8\x0d\xfc\x04\xd7\x26\xeb\x85\xc9\xdc\xfb\x46\x90\x85\x4f\x77\xd2\xd7\xd2\x2c\x6f\xb0\xe8\x5c\x69\xb1\x1c\xcf\x6d\x61\x82\xc0\x3a\xd8\xc1\x96\x5b\x45\x5a\x9d\x15\x0b\xab\x05\x57\x04\x2b\x72\xf4\xa6\x3f\xc7\x15\x51\x47\x33\x55\xe7\x43\x42\x51\x49\xc9\x05\xac\x8a\xc8\xde\xe3\x2d\x8b\xc5\x56\x52\xef\x16\x4d\xa5\xf7\x73\xb4\x46\xd6\x34\x30\x60\xca\x75\x17\x27\x06\x8d\xc7\x94\x2d\x56\x0d\xbd\x8a\xf7\xb1\xf8\x44\x9d\x3a\x15\xfb\xe9\x30\xfe\x4e\x22\xa2\x89\x07\xeb\xce\xdd\xc8\xee\x30\x82\x3d\x34\x26\x5b\xf0\x24\x5b\x70\x93\x74\x39\xa6\xda\xfd\x98\x4d\x46\x2a\xea\x6e\x3b\x51\x38\x1d\x84\x20\x9a\xb9\x3d\xb9\xdc\x83\xbd\xfd\x6b\xfc\x18\x70\x67\x36\xbe\x4c\xe6\xea\x38\xe9\x12\xb3\x64\xa9\x7b\x85\xab\x53\xfc\x19\x7b\x54\x38\x13\xaa\x72\xe6\xa5\x9e\x4f\xe2\xf1\x8b\x72\xed\x92\x89\xe8\xf4\x73\xd6\xbc\x39\x85\xc3\x56\x5d\x4d\x68\xe1\x2b\x5d\x0e\x96\x77\x20\xd3\x47\x3a\xa0\xf5\xd3\x8f\xb8\x60\xc2\xaf\xbe\x20\x3b\x97\x0f\xb4\x9b\x40\x45\x1e\xab\xce\xa9\x8a\x8d\x43\xfa\x0a\x88\xe1\x56\x20\x2a\xaa\x48\xfd\xc8\xcd\x7b\xf9\xc7\x67\xe9\x92\xf2\x31\x5a\xea\x73\x25\x16\x7f\x24\xf6\x71\x87\xb5\x55\xe2\xb0\x11\x1b\xda\x71\x3a\xdd\x4a\xda\x9e\xb5\x69\xca\x21\x1d\xe9\x68\x00\x40\xeb\xa2\xdd\xe0\xa9\x6c\x7b\xba\x0e\x7b\xd8\xa9\xf4\x40\xac\x31\x7a\x7f\x84\x05\x9e\xa2\xd5\x12\x4f\x67\xd5\xd8\xcb\xab\x69\x15\x33\x57\xbb\x95\x5b\x3a\x72\x4b\x50\x0b\xc9\x1a\xaa\xc7\x30\xff\x45\x09\x7f\x20\xb4\x5d\x3e\x5a\x4b\x24\x1e\xac\x4e\xa9\xae\xdb\xa6\xf2\x3c\x96\xc0\xae\x21\x6b\x82\x6e\x2f\xf2\x9d\xe0\x09\xa4\x2e\x7b\x02\x8b\x7a\xe2\x62\xe5\x9e\x8e\x51\xfc\xf0\x3f\xd6\x90\x07\xcb\x4d\xef\x3d\xd1\x8d\x47\xd8\x05\x06\x8e\xef\x47\x9c\xf2\xd0\xd7\x14\x22\xa2\x14\x38\x18\xfe\x8f\x75\x54\x4d\xb9\xdb\x9c\x2e\x43\xc6\xf1\x12\xeb\xa7\x31\x6f\x5d\x05\x6f\x90\x05\x6f\xca\x0d\x73\x9a\xe1\x83\x45\x8d\x8b\x70\x42\xba\x88\x91\x0d\xaf\x71\x69\xeb\x82\xeb\xf5\x34\x80\x5a\x77\xa6\xab\xb9\xdf\x1a\x43\x0a\x5a\x74\x26\x72\x41\xb7\xac\xb0\x0c\xbb\x0d\x81\xaa\x02\x3d\x42\xb8\x0a\x93\x6c\x89\x01\xb1\x72\x72\x4a\xdf\x92\xe2\x88\x55\x70\x6f\x43\xb8\x3d\xaa\x47\x13\xbc\xc1\x1f\xb4\x0d\x5a\x29\x22\x25\x9b\x0c\x95\x45\xa3\x3b\x59\xbe\x2b\xf2\xde\xbe\x0d\x26\x26\xe4\x9e\xc0\x45\x56\x54\xc1\x52\x0c\x69\x44\x9a\x4b\x00\x50\x0f\x3a\x25\x24\x6c\x6e\x37\xa2\xd3\xb9\xfd\x1f\x41\x3f\x56\xfd\x97\x4a\x2d\x97\x5a\x4d\x62\x51\x5a\x1b\xa1\x6e\xfa\x90\x2b\xc1\xd9\x90\xda\xb2\x58\x75\x0a\xe2\xc6\x9c\x05\xa6\xfa\x70\xe3\x7b\x94\xb6\xeb\x60\xbd\x70\x3a\x29\xf8\x04\x78\xbf\x2b\x50\x09\x89\xa5\xe6\x78\xd9\x93\xea\x34\x8c\x5b\x48\x8b\x16\x99\xcd\xf0\xaa\xd3\x96\x2b\xf5\xb1\x25\xa9\xc1\xa1\x81\xd8\x0b\x5c\x56\x3e\x0c\xcb\xd1\x41\x6e\x0e\xa0\xa9\x08\xd5\x4d\x4d\xf8\x3a\xd5\x21\x07\xd8\xc3\x5c\x35\x58\x07\x65\x2b\x5b\xa2\x31\xa8\x89\xf4\xc3\xf7\xa2\x18\x0e\x09\x29\x8e\xe8\x98\x60\x2b\x30\x08\xe7\x0f\x70\x49\xa3\xde\xe9\xc2\x1c\x62\x6b\x48\x89\xa8\x1b\xa9\xb1\xb1\xd7\xdc\x46\xec\x23\x4a\x3f\xcf\xa7\x14\x33\xe5\xe9\x6f\xd3\x69\xb8\x16\xdf\x7d\xec\x03\x90\x47\x7f\xd9\x00\x15\x8f\xf6\xf3\x49\xbf\xc3\xc3\xc4\x46\xf8\xd2\x1f\x39\x71\xe8\x40\x0e\x33\x1c\xd7\xed\xc4\x0c\x77\x1d\x97\x34\x44\x15\xc9\x47\x37\x6b\xd2\xcd\x70\xc2\x02\xec\x91\x85\xc6\x25\x97\xf5\x5e\x1d\x4e\x7e\xa8\x3a\x7e\x15\x56\x12\x2a\x59\xc9\xf2\xe9\x97\x94\x94\x32\xcb\xa4\xd3\x92\xa6\x14\xfb\x28\xab\x8b\x30\x35\xb1\x1d\x3d\x60\xdb\x2d\xa4\x32\x11\x6f\x28\x02\x83\x8a\x7e\xbb\xfc\xcc\x9a\x4a\x83\x76\x8f\xa6\x18\x55\x43\x8f\x54\x6c\x9b\x6a\x6e\xbc\x4e\x16\x55\xe3\x68\xa5\xcb\xda\x9b\x10\x9b\xf7\x22\x32\x97\x73\x59\x93\x1d\xca\x7b\x32\xdf\x3b\xc8\x39\x97\x19\xc9\x3b\xd5\x2d\xbd\x29\x33\x00\x08\xf0\x43\xb5\x07\xc5\xc9\xa1\x1b\xab\xdb\xb3\xf2\x39\x9b\x3e\xfd\x02\xf7\x50\xb8\x50\x0c\xf8\x1d\xd5\x02\x33\xe1\xc3\xbc\x29\xde\x62\xd7\x4b\x97\x59\x7f\xa5\x75\x65\x73\xf0\x7c\x4a\x51\xe7\xb1\xba\x42\x13\xea\x0c\xf3\xca\x9d\xce\x13\x8e\xe5\x6b\x8b\x8f\x63\xf4\xea\x71\x75\xde\x71\x20\x5f\x5b\xd8\xcd\x7c\x44\xda\x1b\xd4\x18\x7a\x8d\x33\x5b\x9f\x9e\x4d\x61\x61\x55\x54\x5e\x49\xd4\x87\x80\x8f\xf2\x26\x3b\xfe\x6a\x70\xda\x19\xe8\x17\xb9\x89\xb9\xc6\xbd\xed\x76\xe7\xc2\x52\xa6\x89\x50\xee\x3a\x64\x01\x80\xcd\xfb\x47\xd8\x01\x79\x99\x25\x73\xf4\xed\x67\xe3\xb1\x4c\x12\x32\x8a\xba\xec\x60\xcb\x65\xc7\xa8\xb1\x45\x9f\x60\x49\x16\xa0\xb3\x25\x98\xf1\x38\xf2\xfe\x85\x7d\xc0\xd4\xb9\x58\x4a\xd5\xbd\xe1\xe9\xd7\x91\x8c\x01\x05\x9e\xcf\xf7\x19\x48\x86\x75\xe3\x01\x01\xe5\xa0\xac\x20\x27\x9b\xf2\x67\x82\xcc\xc1\x9c\x7f\xac\x64\xcb\x26\x38\x15\x88\xb1\xa7\xfe\x92\x6c\xd8\xc0\x3f\xb0\xde\x40\x9c\x26\x4e\x95\xb9\x8b\x30\xc8\x4b\xac\x83\x39\x0c\x19\xf4\x35\x0a\x41\x8f\x0c\xa3\xf8\x97\x65\xaa\xa0\xa0\x14\xd0\x4b\xe0\x40\x94\xc6\x9b\xea\xb4\x15\xac\xd0\x8e\x97\xb3\x91\xcf\x46\x6a\x6f\x4c\x9e\x64\xfa\x79\xe9\x3d\x50\x2f\x4a\xd4\xd5\xdc\x44\x8f\xb4\xd1\x2d\xb9\x8d\x42\x50\x8a\x91\x18\x6c\x3a\x89\xdf\x14\x83\x39\x1c\xa3\x59\x43\x28\x26\x82\xb7\xf3\xf7\xe6\xd1\x3a\x4e\x77\x6f\x93\xf9\xf5\xf9\xca\x5e\xdc\x01\x68\x59\xd1\x17\xd9\x44\xa6\x29\x45\x22\x61\x0d\x36\x78\xaa\xc9\x92\xa7\x13\xce\x18\x92\x7a\x54\x91\x3a\x08\x58\xc1\x44\x1b\x49\xd3\x63\x40\x35\x8b\x7f\x81\x46\xb7\x3d\x33\x6b\x96\xe1\xe6\xe5\xfa\xd9\x9a\xd1\x8e\x6a\x9a\xb2\x36\xa5\xbe\xae\xb1\xeb\x7a\x0a\x94\xee\x83\x11\x26\xf4\x49\x5f\xd0\x60\x71\xae\xb0\x7d\x53\xfe\x6a\xc5\x68\x05\x09\xae\x64\x37\xa3\x37\xe0\xe7\xce\x48\xde\x29\x55\x1c\x3a\x0f\x2f\xfd\x11\x3f\x6c\x49\xd9\x71\xfc\xf4\x37\x74\x46\x8d\x30\x82\x0f\xae\x2e\x21\x39\x8e\xca\xc0\xdb\x13\x69\xfa\xc1\x7f\x50\xf9\x50\xcd\x49\x1a\x54\xbf\xda\x10\x1f\x37\x65\xae\x5c\x70\x3b\xde\xe7\x83\x12\xca\xfa\xe5\xb7\xcb\x7d\xde\xa0\xa5\x7b\xc3\x3e\xee\xc5\x11\x35\x6c\xe5\xde\xac\x7f\xbb\x45\x6d\x59\x57\x6e\xd7\x73\xbd\x44\x63\xae\x50\x47\xb1\x36\x3d\x28\x6d\xba\x55\x9f\xf4\x15\xfa\x54\xfe\x0b\x00\xd8\x72\x61\x94\xf4\x70\x0b\xe0\x26\x53\xed\x20\xae\x70\x90\x55\x2c\xee\x56\xf4\x37\x24\xc2\x84\xd2\xad\x18\xe7\x9e\xab\xdf\x7e\x25\x63\xb5\x86\x52\x45\xc5\x73\x77\xd7\x5f\xe1\x09\xea\x5e\x39\x21\x1f\xe5\x83\x75\xe4\xd5\xf0\xed\x44\x7d\xb5\x33\xa6\x58\x01\xd8\x95\xe4\xa0\x74\x72\xf2\xaf\x4c\xcd\x66\x1c\xa1\x22\xe2\x2e\x15\x60\xd3\xcd\x34\x93\x0b\x24\xd8\x5b\xc0\x27\xb4\x3d\xe0\x45\xcf\xa5\x01\x6c\xb2\xbf\x68\x89\x56\x1e\xa9\x3b\x55\x5a\xd4\xda\x03\xb9\xda\xe0\xbc\xdd\xbd\x26\x53\xb9\x13\xab\x36\xed\x16\x0b\xd1\xb1\xbd\x6a\x37\xe5\x66\x2b\x8d\xa3\x4c\x75\x4f\x1b\xa7\x1b\xe2\x65\x84\xd2\x5d\xb4\xc8\xcd\x62\x68\x4d\xf8\x04\xd7\xf2\xa7\x5f\x67\x38\xaf\x3a\x58\x5d\x2e\xdc\x7e\x8d\x97\x14\x5a\xc4\x38\xe3\x38\x6e\x3b\xbd\x6a\x8c\x15\xef\xbb\xb0\xea\x04\x30\x34\x49\x4a\xb8\xdc\xff\x45\x05\x34\xa8\xe8\x54\x8c\x55\xf3\x66\x5e\x5d\x48\x17\xde\x9c\x53\x1f\x99\x99\x60\xf4\xed\xbd\xf4\xe1\x3d\x32\x63\x60\x2b\xc9\x99\x0c\xe4\x3c\x4c\xf7\xc5\x3b\x74\x6c\x5a\xa1\x57\x18\x5d\x43\xc6\x81\x50\x66\xa9\x33\x2c\x28\x27\x70\x2f\x5f\x4e\x7e\x88\x8d\x3a\x05\xc5\xdb\xa8\xf4\xbe\x3d\xf2\x68\x61\x68\xda\x32\x4a\xa4\x89\x7e\xfc\x74\xd8\xed\xeb\xa4\xcc\xa1\xb0\x0a\xac\x08\x5d\x60\x85\x64\xc8\x08\x43\x4b\xed\x5e\x41\x2d\x0b\xb9\xa8\xab\x74\xbf\x3e\xaa\xba\xab\x6e\xcc\x79\xe8\x73\x3d\x38\x1d\x4e\x2d\x26\x3e\x3b\x62\x16\x5e\x3a\x9e\x37\x06\x2e\x92\xd4\x5f\x2c\x74\x58\x3e\xd9\x98\xa4\xef\xcc\x8a\xc9\x40\x41\x5b\xd8\x19\x03\x0f\xec\xcd\x7c\x23\xf7\x67\xfb\x98\x9d\x67\x7e\xfa\x0a\x19\x7f\xec\xa7\x54\xaa\x9c\x7f\x7e\xbd\x2e\x66\xf7\x2f\xde\x9d\x97\x43\xd8\x87\xc7\x5e\x17\xc0\x90\xf7\xd4\x03\x15\x0a\x8e\xb8\x39\xfe\x90\x7a\xb3\xcd\x61\xff\xcf\xbb\xdf\xef\xff\x7e\xff\xeb\xd7\x34\xb7\xaf\xf5\x1f\x00\xf2\x2b\x0e\xc5\x86\xf5\x89\xcf\xa7\x18\xee\x97\xf7\x9e\x17\x68\xea\xdf\x33\xc9\x13\xaf\x95\x6b\xfd\x35\x92\xf3\x3a\xcc\x82\xc0\x59\x13\xbf\x2d\xef\x4e\x2e\x2d\xde\x55\x0c\x0f\x34\xfc\xe8\x36\x53\xff\xe4\x2f\x63\xde\xf3\x03\x8e\xcf\xe5\x27\x60\x3a\x74\x2f\x2f\x0a\x0b\x1d\x07\xd9\x44\xea\xdd\xa0\x4a\x3c\xed\x15\x22\x00\xf3\xbe\x64\x0b\x18\xad\x8f\x1d\x58\xb1\x4f\xbc\x6b\x07\x74\xc3\x99\xc4\x85\x89\x7d\xe8\x09\x11\xdb\x39\x01\x03\xb9\x1b\x43\x8e\x2d\x27\xeb\xac\x0f\x47\xe8\x63\x44\x46\x4d\x76\x77\x60\x44\x24\x86\x86\x1c\x79\x95\xb1\x82\x98\x9e\x30\x93\x23\xf3\xbc\x4b\x28\x70\x41\x88\xa1\xcb\x29\x73\x71\xf6\xf4\x6f\xe7\x3d\x47\x6b\x7c\x40\x3d\x1f\x45\x94\xd9\xa7\xaf\x85\xad\xb6\xfa\x11\xc5\x4b\x2a\x5f\x4c\x2c\x55\xa8\x12\x29\x27\x35\x5e\x19\x31\x90\x09\x3f\x1a\x56\x6b\x17\x3a\x4c\xd2\x65\x2d\x2b\xa0\xe5\xe3\xb1\x39\x72\xad\xd8\xc4\x5b\x13\x41\xd9\x8d\x6d\x9c\x84\x81\xca\x58\x5c\x03\xb0\x36\x7a\x45\xab\x92\x0d\x61\xd5\xb1\xa3\xda\x94\xd2\x10\x30\xd9\x2f\x1c\x80\xd9\xd0\xd0\x10\xd0\xae\x3c\x53\x2d\xd1\xb5\x71\x4c\x69\xd0\xae\x1d\x58\x86\xdd\xce\x31\xd5\x16\xba\xbb\x62\xeb\xea\xcd\xaa\x29\x53\xec\x9b\x90\x6b\xb5\xac\xdc\x6b\x44\xcb\xb5\xd8\xc4\xb3\xd6\x06\x94\xba\x05\xf1\x46\xcd\x73\x34\x42\x0f\x53\x93\x43\xd5\x66\x32\x7f\x8e\x23\x28\x83\xa0\xbe\x4a\x61\x0f\x25\x4b\xed\xe5\x27\xb1\x10\x9a\xb9\xd3\x59\x72\x9f\x33\x90\xf8\xa1\x8e\x65\xaf\xbf\x44\xe5\x9e\x71\xf5\x1c\xaa\x88\xd9\x74\x2e\x9d\x81\x09\x66\xfc\x35\x7e\x6f\xa3\xf6\x36\x63\x25\x39\xf8\xb9\x4f\xa0\x50\x7d\x02\xdf\xf8\xfb\x72\x1f\xd8\x17\x25\x92\x7d\x82\x98\xd6\xc5\x1a\xd7\x72\x29\x29\x4a\x8a\x7d\x28\xae\x48\x80\x2e\x85\x84\xa2\x2f\x08\xb3\x73\x95\xe1\x31\x14\x6f\x1e\xf7\xdf\xed\x1f\x08\xe2\xd3\x2d\xbb\xfe\xce\xbc\x25\x5c\x41\x66\x12\x99\x26\x41\x47\xf3\xc3\xc9\x57\x0d\x09\xaf\x4b\x77\xec\x69\xff\x63\x53\x50\x6e\x17\x22\x81\x2a\xdc\x77\x1a\xc1\x1c\xe3\xfe\xc7\xd0\xf7\x75\xc9\xeb\x74\x35\xa0\x9b\x01\x48\xa4\x75\x60\x93\xcd\x03\x05\x1a\x50\xfd\x72\xfe\x27\x33\xfa\x2f\xe2\x7e\x32\x83\xdd\xcc\xfd\x54\x20\x7e\x23\xef\x93\x21\x60\x6b\xd3\x53\x81\x96\xed\xad\x4c\x86\xb0\x2f\x60\x24\x2c\x0c\x65\xf8\xa5\x8c\x83\x86\x03\x5b\x18\xd2\x0a\x23\xd9\x85\x55\xcc\x10\xb5\xa5\x27\xad\x40\xd8\x8e\x1d\x69\x86\x46\xe3\xd8\x22\xa9\xdf\x98\x9c\x41\xc5\x6b\x0d\x11\xd1\xbd\xa5\x2d\x1a\xf3\x52\x3d\x92\xdd\x79\xae\x8a\xeb\x7b\x97\x8e\x2b\x8b\xd8\x26\x8e\xab\x46\xf4\xd5\xeb\xda\x55\x5b\xaa\x21\x6d\x5b\x38\xad\xaa\x28\xdc\xc6\x67\xb5\x42\xdb\x8b\x19\x64\xab\x46\xf2\x45\x0c\xad\x39\x0b\xdc\x6e\x85\x0d\x27\xa8\x95\x03\x61\x93\x49\xd3\xb3\xc0\xb6\xdd\x62\x74\x7c\xfe\x3d\x3b\x1b\x37\x9f\x1d\x8b\xcb\x2b\x88\xca\xb3\x53\xc0\xb8\xd1\x34\x54\xd9\xbb\xb7\x22\xbe\xda\x04\xde\x96\xba\x64\x1c\xfb\x54\x2e\xe6\xc0\x5a\xa5\xd6\xd7\x4e\xa1\xf2\x4e\xaa\x50\x6b\x98\x73\xf7\xbb\xd5\x58\xb9\xe2\x0b\x46\xaf\x61\xfb\x46\x15\x2e\x66\xcc\x73\x76\x0a\x84\x33\x34\x77\x16\xfb\xd3\xa9\x15\x31\x66\x6c\x6a\x25\x95\xde\x0f\xbd\xdb\xd4\xbf\xab\xb3\xf6\x14\xa9\xa1\x42\x7a\x5a\x6c\x58\x3a\x91\xa9\x64\x12\xb1\x45\x5e\xc7\x4f\xaf\xa1\x10\x0b\x3f\x14\xb3\x49\xa8\x88\x4a\xe1\xab\x52\xad\x13\xae\xb2\x82\x17\xad\x52\x58\xf5\x86\x63\x31\x8c\xb5\x87\xd2\x98\xec\x9c\xb1\x45\x7a\x9b\x13\x93\x17\xcf\xc7\x51\x45\xe3\xba\x89\xed\xf3\xb3\x97\x97\xdf\x77\xf2\xfb\x76\x73\x54\xd8\x6a\x80\x23\xbb\xa5\xed\xe5\x70\x5d\xa5\x86\x1f\x54\x0e\x68\xa8\x23\x6d\x9b\xa3\xa2\x30\xcc\x3c\x27\x02\x2d\x10\x5c\x7b\x82\x02\xec\x49\x9b\xe6\x3a\xde\xee\x7c\x56\x8d\x14\x33\xf8\xde\xe5\xe6\x79\x56\x81\xf9\xe5\x96\x04\xa1\xc5\x1f\xc3\x1b\x75\x7f\x5e\x91\x44\x7c\xcf\xe7\x16\x10\x73\xef\xae\xb0\x36\xc2\x09\x19\xc7\xb3\x84\xdf\x56\x2f\xad\x27\x18\x57\x46\x22\xde\xf3\xe3\x49\x81\xc6\x3d\x44\x39\xc1\xa2\x9a\x46\x42\xd9\x6b\x4a\xd5\x20\x50\xaf\x02\x41\x23\x65\x61\xc1\x5a\x00\xa6\x0e\x8b\xaa\x78\x50\x37\x5e\x15\xfd\x8a\x23\xc1\x42\x5f\x01\xe7\x61\xd9\xc9\x63\xd6\xde\x5d\x39\x7f\x9b\x1f\x7c\x27\xd6\xd8\x68\xa2\xd4\x68\x12\x92\xc2\xfd\x0a\xbc\xd6\x05\xa6\x02\x71\xf3\xd3\xb0\x3c\x4c\x9c\x30\x90\x39\x5c\x25\x10\xc6\xec\x1c\xdc\xd4\x92\x4e\xd6\x48\xd7\x5d\x7e\xdd\x23\xc5\x89\x23\x79\xd4\xe7\x5a\x68\xb5\xaa\x0d\x8d\xbf\x4a\x7a\x59\x43\x5f\x77\x89\xde\x6a\xe8\xb8\x92\xb7\xb8\xe2\xed\x92\x0d\x2b\xa9\x61\x9b\xde\x12\x2b\x18\x52\xb1\xe4\xd7\x71\xe6\xd9\xb8\x52\xb1\x0d\xd6\x33\x67\xb7\x8c\x41\xc9\xaf\xf2\x60\xd9\x1b\xfa\xbf\x92\xd7\x0d\x87\x43\xa4\x0e\x3f\x74\xae\xb0\x9e\x6f\x92\x3e\xfd\x9a\xe6\x25\xd0\x34\x98\x96\xd8\x59\x83\xdd\x11\x0d\x5a\x4f\x5d\x4b\x0b\x16\x0b\x45\x28\xb6\x62\x65\x4c\xe5\xee\x33\xb0\x53\xd0\xa6\x48\x42\x97\x0b\x32\x3e\x66\x81\x87\x75\x86\x9c\xb8\x6f\x55\xb9\x3a\x76\xf5\x7e\xfb\x77\x7f\x7f\xb6\x27\xbe\xf9\xfa\xdb\x3f\xe0\x3f\xc7\x2e\x63\x72\xa9\x44\x1d\x97\xa7\x63\x5b\xf2\x2a\x08\x17\x66\xf4\x15\x0b\x6e\x91\xc6\x39\x1c\x29\x1c\x2d\xa6\x34\x85\x53\xcd\xe1\xfa\x3f\x94\xbe\xa1\x5e\xd0\xc5\x20\xea\xeb\xdb\x1d\x45\x2a\x85\x3f\x88\x62\xcc\x50\x8d\xb2\x74\xe9\x6c\x63\xdd\xcd\x12\x2a\x2f\xc8\x4c\x9c\x7a\xf1\x88\x4a\x7d\x60\xb5\x39\xce\x87\x5f\x83\x85\x1b\x17\x91\x4f\x8e\x3a\x19\xe9\x22\x47\x0e\x74\xef\x61\xbf\x8c\xb8\x64\x8f\xae\xa3\x99\xa8\x22\x36\xb5\x68\x16\xde\x52\xbb\xfd\xa8\xe8\x84\x4a\x8b\x53\x59\x30\xd8\x22\x56\xfb\x0f\x48\xcd\x59\xc6\xf2\xce\x8f\x80\x65\x94\x47\x94\x70\xc9\x9a\xda\x4c\xba\x0b\xf4\x01\x70\x24\x0c\xe7\x6b\xb2\xad\xe6\x31\xe3\xd5\xc6\x7c\x87\xbf\x48\x11\x08\xd3\x29\xc6\xca\xf0\xe3\xca\xbf\xc0\xc1\x4d\xf1\x5c\xc6\x54\xb0\xa6\x98\x56\x24\x43\x0b\x4c\xed\x40\xb9\x53\x90\xca\x12\xf1\xa6\x18\xbf\x87\x63\x70\x2b\x69\x43\x7c\xa1\x40\x79\x97\x2a\x03\x60\xa2\x58\x45\x82\x93\x0b\xf9\xf8\x56\xc6\x1d\x7f\x41\xd9\x3b\x91\x49\xc2\xe4\xbd\x82\x9a\xd9\xdb\x89\xf5\x48\x07\x65\x9e\x6b\xcb\x7c\xce\x72\x35\x09\xc5\xb0\x82\x7d\x42\xb0\x61\xe7\x88\x77\x6e\x88\x2e\xe2\x32\x8c\x13\x62\x31\x9c\xc5\xc1\xda\x78\x81\xa3\xe8\x36\x7f\x23\xe9\xc0\xa3\xd6\x2b\x0e\x1c\x64\x0b\xe7\xf1\x5a\x35\xae\xd7\xa5\x9b\xaa\xf1\x14\xde\xa8\x41\x90\x1c\xd4\xc3\x0b\x0f\x5c\x6f\x73\x8d\x3d\x81\xe2\x67\xb1\xc4\x8d\xea\x07\x72\xa2\xeb\x79\x60\xe9\x0c\xac\x7c\x7e\xc5\xd5\xe3\x28\xda\x84\x0a\x14\xed\x99\x02\x65\x09\xad\x2e\xef\x0e\xde\xe3\x50\x2b\xdc\x26\x28\x79\x67\xfe\x9d\x24\xae\xba\x0e\x81\x4f\x1c\x26\x86\x7b\xeb\x03\x9a\xe1\x60\x49\x72\x6e\x36\xd6\x0a\xc3\x9d\x3c\x23\x9f\x2f\x66\xcc\x95\xe9\x39\xb1\x0b\x81\x15\x4b\x92\xfe\x9f\x42\x31\xba\xbb\x88\x93\x95\xec\x9b\x1c\x86\xe5\xf0\x3b\x77\x1c\x22\x38\xf2\x62\xd7\xc9\xa2\xd8\x63\x6a\x3d\xa9\x9a\x25\xaf\x13\x41\x2d\x29\x13\x2c\x16\x16\xc9\x24\x8f\xdc\xa2\xd4\x39\xb1\x90\xa9\x37\xf1\x9c\x21\x0a\x58\x7d\xf5\x63\x14\xa6\x71\x14\x04\x00\x62\xc1\x55\x7b\xe6\x8a\x09\x33\xc9\x6c\xb0\x0a\x9d\x94\xcb\x9d\x15\xa2\xbe\xb8\x9a\x44\x28\xb0\x1b\x70\xe2\x63\x99\x12\x85\x5e\x86\x79\x44\x98\xcb\x0d\x9f\x2d\x96\x85\x62\x50\x94\xe6\x05\xeb\x01\x05\x1b\x57\x1a\x72\x89\x87\x42\xa5\x26\x1a\xc0\x4a\xb1\x21\x34\x4d\x70\xec\x22\x4d\xc4\x4a\xe9\xa2\x4d\x2a\x17\x55\x8f\xa3\x77\xfe\xe9\x64\x70\x71\x7e\xd6\x3b\xbf\x14\x9f\xba\x83\x93\xee\xbb\xd3\x9e\xa0\x8e\x24\xae\x10\xa2\xab\xb3\xe3\xde\xbb\xab\xf3\xe3\xa1\x7e\xfc\xfc\x78\x70\xd5\xef\xbb\x62\x8a\xaa\x10\x0c\x5d\x9b\x6e\x15\xb6\x63\xfb\xe5\x1d\x05\x5c\x96\xa6\xbc\x51\xeb\x3a\x08\x62\xa5\x08\x7f\x62\xca\xee\x4f\x46\xd8\x13\x60\x16\x05\x93\xf5\xcf\x8d\xa9\x4f\x41\xec\x2d\x6e\x66\xa3\xeb\x57\x07\x7f\xa8\xee\x41\x50\x7e\xe7\x5f\xdf\x62\xb1\x1c\xd2\xb6\xde\xa6\x8b\xe5\x5b\xed\x46\xbb\x19\x47\xe1\xd4\x9f\x39\x5b\x0f\x14\xe1\xa4\xe2\xfa\x15\xd6\xbe\xde\x8b\xa6\x58\x6e\x6b\x96\x5c\xbf\x5a\xcf\x98\xff\xaa\x03\x5f\x3f\xdf\xa7\x7e\x98\xfd\xf8\xf6\xcc\x1b\xf3\x9f\x16\x92\x42\xa7\x36\x6a\x5b\x57\x18\xe4\x12\x6b\x10\x25\x58\xe3\x35\xa1\x8e\x13\x31\x6c\x79\xaa\x82\x60\x35\xd9\xf8\x0e\x40\x44\xf7\x89\xd0\xe5\x05\x01\x99\x6c\x83\xe7\xfa\xd5\x4f\xd7\xd7\x45\x54\xd7\x88\xec\xda\x46\x07\x7f\xfc\x6c\xfa\x91\x68\x8c\xfd\x08\x14\xe3\xe1\x1c\xe4\x40\xcb\x71\x35\x42\x87\xe3\x4b\x0b\x33\x52\x03\xb4\xc9\xec\x36\x5a\xa1\x2f\x31\x55\xaa\xd6\x6a\x42\x92\xf2\xbf\xa7\xaa\x6a\xaa\xb6\xd9\x53\x5c\x95\xc6\x60\x9f\x8c\xcc\xc7\xc4\x0f\xb0\xda\xad\x5b\x8c\x34\xdf\x50\x8d\x91\xa8\x39\x53\x78\xae\x09\x53\x9b\xe9\x69\x33\x9a\x32\x1e\x3d\xa2\xd6\xb0\x9a\x09\xcb\x4d\x60\x1b\x01\x2a\x5a\x1e\x1d\xcf\x3e\xdf\xf5\xbb\xf2\xbf\xe7\x7b\x87\xf3\x5d\xbd\xbb\xf9\xee\x62\xfa\x04\xb1\xd5\xc2\x58\x8a\x55\xbc\xbc\xae\x7b\x91\x2c\x41\x1c\x39\xc3\x28\x35\x90\x8e\xb6\x6e\xe4\x16\x5f\x2b\x2a\x5e\x99\xf5\xbb\x61\x8a\x29\x1a\x92\xca\x28\xd4\xba\x31\x14\x89\x1f\x2e\x2f\xfb\x98\x00\xf3\xe3\x83\xae\x87\x8f\x85\xeb\x35\x81\x0e\x92\xf0\x25\xd4\xa8\xd5\x4b\x64\xc9\xe9\x9f\x74\x0a\xe4\xd4\x62\x7d\x09\x4f\x64\x43\x06\xbc\xa8\x1b\xb2\xa5\x03\x72\x93\x21\x3c\x8f\xf7\xb1\x21\x25\x51\x2c\x54\x6f\x4b\xb6\xd8\xb9\x0c\x67\x5e\x0c\xeb\xd8\x32\xc7\x12\x07\xd6\xbb\xde\x14\x96\xad\xbd\x8e\x0d\xf1\x14\x5d\x8e\x96\x25\x69\x67\xde\xc6\x16\x84\x7c\x19\x57\xa3\xed\x68\x9c\x78\x78\xeb\x7f\x2e\x37\x23\x0d\xf5\xa5\xbc\x8c\xdd\x2f\xe3\x63\x2c\x8f\x71\x5b\x17\xe3\xa6\xc3\x2c\x7b\xd6\xf0\xc7\xad\x1c\x8c\xcf\x39\xee\x2d\xfd\x8b\x4d\x79\xf0\x72\xde\xc5\x0a\x6e\xbc\xac\x73\xb1\x8e\x25\x5f\xcc\xb5\x68\xb8\xd2\xce\xb3\xd8\xdd\x81\x5f\xd1\x89\xba\x89\x5b\xb1\x21\x01\x8d\x9c\x8a\xbd\xf0\x2e\xcf\x1f\x06\xb6\x7d\xf2\x94\xeb\x5e\xdc\x7b\x89\x2a\xd5\x9a\xba\x08\xb9\x5a\xc0\xc1\x8d\x81\xa5\x0e\x08\x94\x1d\xa1\x3c\x63\xa0\xdb\x61\xfe\xf4\xcc\x99\x1f\x4d\x76\x6f\xb5\x40\x2b\x63\xb8\x91\x3d\xc7\x57\x27\x47\xaf\x0f\x5c\x85\xbd\xb8\x4a\x37\x06\xe9\x2c\x0a\x67\x85\x7b\xb1\x10\xa3\x34\xd0\x1a\xb2\xe8\x4c\xe6\x8e\x02\xa4\xa6\x36\x20\x20\xcf\x67\xa7\x32\x62\xb9\xa2\x5a\x87\x67\xac\x73\xe7\xf3\x02\x67\x78\x9d\x6a\x32\xe0\x22\x3e\x5d\xdf\x8c\xec\xea\xf5\x63\x33\x38\xd5\xd8\xd6\x37\x10\x6d\x34\x4c\x1b\x4c\x13\xec\xa9\xaa\x82\xbb\xb6\x92\xbb\x1b\x7b\x5e\x11\x37\x54\x25\x71\xdf\x00\xd4\xaf\xd6\x95\x6d\x2f\x11\x52\x5b\x81\xd7\x85\xdc\x2a\xba\xeb\x68\xe4\x54\xc6\x52\x11\x2c\xba\xdf\xa0\x44\xbc\x9b\x00\xad\x26\x25\xf5\x60\x6b\x88\x9b\x54\xe6\xd6\xf0\x56\x69\x49\x9a\x89\x64\x2d\xe9\xa2\xd5\xf0\x9a\xd0\x54\x9d\x6e\xd3\xa4\x8a\xb3\x83\x2e\x67\x65\x97\x06\x35\x9c\x15\x6d\xce\xe8\x90\xb6\x94\xb8\x64\xf8\x66\xd8\xf9\x10\x69\x40\x43\x29\xe6\xc7\x4d\x87\x3a\x4b\x6a\xc9\x31\x3d\x57\x48\x8a\xe4\xbb\xdf\xe9\xf5\xc9\x29\x29\x24\xdb\x63\xe9\xf5\x7c\x65\xf3\xed\xa0\xd4\x30\xa5\x00\xbc\x11\x4d\x6c\xf0\x68\x47\x14\x0b\x34\xb2\x6e\x60\xd3\xd0\xa7\x5f\xc9\xf3\x4a\x5f\x2b\xfa\xf2\xeb\xcb\x86\x04\x4a\x97\x1e\xd0\x60\xf2\xba\xcd\xa6\x6e\x23\xf4\x8d\x57\x50\x43\x22\xb4\x2e\x52\x47\xcc\x94\xfb\x08\x5b\x4e\x76\xbc\x7b\xb4\xdd\xe0\xaa\x79\x62\xee\xf3\x2e\x55\xdc\xc6\xf2\xa6\x0d\xb7\xf7\x2a\x41\x9c\x7c\xdc\xea\x7c\xac\xa2\x47\x67\x0c\x37\x3b\x21\x35\x19\xbb\x11\x80\x9a\x9e\x3c\xe5\x70\x0d\xc8\x06\x94\xad\xe9\x97\x51\x81\x1e\x4f\x05\xad\xa2\xd4\x9e\x97\x1a\x45\x59\x1b\xcc\x8f\x8f\x26\x99\x0c\x0e\x06\x38\xf5\x42\x17\xf4\x2d\x08\x6d\x40\x5b\x2b\xd2\x9a\x51\x53\x95\xed\xb4\xd1\xf2\x75\x56\xdc\x6a\x48\x4f\x14\xdf\x7b\x31\x91\x84\x32\xa6\x91\x42\xfb\x1d\xf6\xd0\x8c\x03\xfc\x2f\x13\xd0\xe7\x37\x6b\xd0\xcc\xb8\x00\x30\x45\x48\x8e\xa3\x89\x5b\x71\x6e\x0a\x04\xeb\x25\xbb\xc2\x1f\x0a\x62\x70\x44\xdd\xf2\x8c\x0c\xc4\x06\x19\xcd\x48\xb5\xac\x89\x02\x83\x64\xa8\x55\x50\x4b\x8c\xc6\xcc\x08\x67\x4f\xe2\x2d\x16\x32\x9c\x7a\x49\x42\x59\x3b\x4d\x48\xd0\x6d\x36\xa9\x8f\x38\xc7\xff\x71\x14\x10\xcc\xec\x7b\xd0\xc8\xfb\x5e\x3a\x6f\xb4\x58\x6c\x9a\x94\x3b\x88\x5a\x7c\x2b\x23\x17\xc7\x2b\x15\x81\x36\x20\x8f\x5a\x63\xe0\x44\xb4\xa4\x80\x6e\x00\x34\x13\x4d\xb0\x20\x02\x1e\xfc\xdd\xb7\x6f\x7d\x9e\xbe\x76\xf8\x10\x13\x87\x31\x1a\x00\x0d\xf0\xa2\x91\x1f\x8b\x14\x71\xde\x67\xed\xa2\xad\x46\x9c\x60\xd1\xea\x85\x17\x58\xe9\x9e\x32\xf6\x71\x31\x20\xb0\xa4\x19\x15\x6a\xc2\x75\x40\x17\x33\x02\x63\xbc\x5a\x73\x41\x4d\x73\xe7\xcc\x04\x67\x81\x4a\x44\x6d\x80\xf2\xc0\xad\x66\x34\x71\x99\x27\x6e\x4a\x25\xb9\x1f\x92\xc9\x62\xab\xbf\x88\xd4\x41\xa7\xe2\x1f\xd8\x7a\x06\x51\x0c\xfa\x87\xda\xe4\xd5\x68\xa0\x27\xea\xe5\x24\x37\x65\x01\x88\xce\xd0\x80\xa8\x41\x0c\x3b\x3b\x99\x7b\xa4\x6d\xfd\xd3\xf0\xe2\xbc\x09\x5b\x4d\x6c\xaf\x3a\x2f\x09\x40\x60\x1c\x60\x04\xa6\x06\x23\x36\x75\xc9\xa5\x21\xf5\xf7\x23\xfe\x35\x40\xfd\xf4\xff\x50\x17\x17\x23\xcf\xb0\x35\x1f\x37\x4d\xab\x1f\xa4\x46\xd9\xa8\x95\x8c\x0b\x61\xb1\xaf\x4c\x1d\xba\x25\xb0\xa4\x05\x43\xfb\xea\x71\xdc\xa4\xeb\x98\xa7\x41\xab\x12\x64\x2d\xa0\xe3\x10\xb8\x9e\x58\x2d\x7c\xea\x5d\xbd\x68\x63\x53\x62\x59\xaf\x16\x85\xae\x52\xd3\xd0\xb0\xb4\x8c\x23\x6d\x58\xc3\x68\x12\x9c\x15\xea\xf2\x4b\x8d\x58\x49\x14\xbf\x6e\xb0\xb1\x6a\x60\x79\xa9\x30\xa0\x0a\x90\x5a\x12\xb5\xe5\xf6\xb6\x40\xe6\x82\x0c\xb7\x38\x76\xef\x6b\xc6\x61\x58\xeb\x1e\x35\xb5\x33\x4d\x6d\xbd\xd4\xca\xf6\x26\x40\x35\x14\x60\x6c\xcf\xaa\x05\xaf\x95\xd2\x75\x4a\xf9\x19\x15\x66\xbc\x66\xca\x96\xa6\x40\xdf\x7a\x5b\x61\x54\x17\xde\x36\xf0\x89\xc9\x9b\x20\x21\x9e\xb6\xc6\xd4\x7c\x3a\x5d\x28\x9b\x4d\xe3\x14\xb0\xce\xe9\x88\xce\x4b\x32\x34\x5d\x43\xa5\xee\xf1\x28\xbe\x2f\xba\x00\xa5\x73\x89\x50\xd6\x1c\xca\x31\x36\x44\xdf\x8d\x19\xee\x6a\x31\xd2\x9d\xc8\xb7\x35\xc4\x29\x29\x45\xa7\x4f\x93\xf9\x2e\x4b\xa7\x06\x93\x6d\x10\x18\xa5\x08\x55\x98\xe2\xa4\x6f\x25\x1d\xb0\xd0\x60\x70\x67\xea\x8f\xb4\xd9\x95\x4a\xf8\x4e\xb1\x14\x93\x16\x0c\x94\xba\xd2\x7c\x57\xa6\xb1\x2f\x09\x79\x92\xc2\x14\x6c\x74\x37\x29\x03\xd9\x56\x5c\x26\xde\x9d\x2d\xab\xb6\x84\x46\x31\xbf\xbb\x58\xb8\xae\x3d\xb4\xcd\xfa\x35\xc4\x71\x26\xd9\x0d\x65\x36\xdc\xa4\x0f\x4b\xd9\xcc\xe0\x56\x45\x13\x2e\xe9\x0a\x70\xeb\xcc\x6e\xec\x61\x28\xdd\xfe\x1a\x35\x24\xb4\xf7\x76\xde\xe5\xaf\x70\x07\x6c\xd2\x82\xb0\x4c\xc6\xf6\x82\xc6\x26\x66\xbb\x79\xc2\xd6\x80\xa4\xfe\x47\x9b\xb9\x84\x86\xba\x3d\x20\x95\x8a\x2d\xf7\x48\x6c\xe1\x10\x7a\xf4\x97\xcb\xd2\x1c\x35\x40\xff\x31\x5a\x2c\x63\x7f\x91\x9b\x44\xcd\xc4\xd4\xe1\xaa\x34\x37\x61\xd6\x11\x17\x1c\xc0\x2a\xb5\x5c\x09\xda\x4b\x38\x06\x29\x9e\x51\x86\x16\xbb\xab\xfb\x78\xaf\x82\x57\x5e\xc3\x44\xa6\xf6\x9f\x28\x52\x7d\x0a\xaa\x41\x6e\xa4\x72\x26\xe3\x7d\x21\xde\xe3\x6d\x04\x9b\xe4\x27\x0f\x61\xea\xfd\x08\x2b\x38\x58\xee\x51\x67\xac\x3f\x8f\xa7\x3a\x32\x31\x5f\x12\x9d\xf9\x9f\x5d\x0e\x60\x35\xf0\x6a\xea\x55\x71\xbc\x20\x11\x5d\x43\x2d\x39\xc6\x73\xfa\x28\x6f\x87\x82\xbf\xf6\x84\x07\x1f\xed\xdf\x48\x3f\x9e\x60\xea\x28\x45\xac\xcd\x30\x7f\x86\xfa\x58\xed\x2b\xcb\x90\x14\x43\xa2\x7f\xee\x07\x53\xd3\xfb\x17\xd3\xf8\x28\xbd\xa8\x66\x2c\xee\x79\x58\x73\xbc\xd7\x1e\xdb\x07\xe2\x3c\xe2\x5a\xc9\x54\xcd\x79\x4d\x7a\xaa\x06\xf8\x91\x06\x77\x4e\xaf\xe9\xf4\xd4\x99\x9c\x66\xee\xe6\xad\x0a\x19\x1e\x8f\x13\x8c\xf2\x14\xf7\x1e\x6f\x18\x42\x08\x53\x3a\x16\x7f\x89\x46\xa4\xd8\xc3\xa3\x94\xb3\xf7\x1a\x37\x13\x96\xbd\x4c\x5c\x25\xb7\x35\x39\x9f\xb3\xe0\xe9\x17\xac\xc0\x89\x41\x1a\xc0\x65\x4e\xf9\x65\x73\x1c\xe7\x49\x52\xec\x15\xac\xc2\x1e\x50\x48\x7b\x9d\x50\xce\x63\x8a\xcf\xf9\xa7\x68\x94\x94\x30\xd3\x14\x63\x1d\x19\xac\x99\x5e\x3f\xa4\x46\x9b\x7c\xed\xde\xe5\x84\xda\x84\x32\x6a\x49\xa1\xe0\x84\x57\xa9\x7a\xbf\x02\xd3\x30\xdc\x14\xb6\xe4\x32\x82\x2d\xd1\xee\x94\xfb\x71\xc9\xb6\x08\xdb\x68\xc7\x41\x7a\x1e\x5b\xcf\xa2\x29\x56\xdf\x7b\x7b\xe7\x05\x99\x84\x5d\xeb\xc7\x89\xea\x4f\x2e\xa2\x31\x75\x29\x9b\xd8\xfd\xa5\x45\x28\xbd\x18\x94\x10\xe4\xd8\xf7\x8b\x60\x18\x82\xc4\x91\x29\x70\xcd\x75\xfd\x4a\xc4\xbd\x1f\x4f\x04\x16\xe7\x84\xc9\x48\xf7\xb8\x0c\x07\x57\xab\xb6\xc3\xe9\xc4\x29\x99\xdd\x70\xee\xf2\x62\x7c\x6f\xbf\x83\xcd\xd4\xe9\x7b\x5e\xcc\xc9\x87\x79\x5f\xf3\x42\x2b\x6b\x9f\xc5\xd6\xf9\xd3\x2f\x73\x32\xdc\x55\xd2\xd7\x98\x3d\x49\x81\x3f\x5b\x8c\x0b\x68\x3e\xe5\x82\xa4\x58\x67\xd4\xb5\x89\x35\x05\xe6\xd4\x31\xe8\x13\xa9\x67\x47\xfc\xdf\xeb\xec\xeb\xaf\x7f\x0f\x83\xc3\x59\xda\x23\x99\xe9\xa7\x14\xef\x42\xe5\xb3\x2e\xe1\x0c\xff\xf9\x67\x67\x9b\x82\x6a\x5a\x73\x84\x9c\xfd\x2c\xfd\xb9\x2c\x17\x43\x54\x78\x3b\x38\x0f\x7a\x0a\x00\x1c\xae\x9b\xbf\xc8\x49\xc4\x19\xc7\x36\x05\x6b\xc7\xd8\x8f\xa3\x25\x00\x7b\x28\x8d\x75\x14\x45\x81\xf4\x9c\x7d\x0e\xdc\x43\x28\xc1\x23\x38\xb0\x77\x99\xd4\x8d\xc9\xd1\x3b\x23\x01\xdd\x35\x9c\x39\x5b\x3d\x37\x26\xab\xb4\xc2\x3f\x73\xf5\x5d\x6c\x4e\xa9\xb9\xba\x31\xa9\x61\x06\x17\xa6\x78\x75\x4d\xe8\xc7\x37\x5d\x1b\x55\x23\xc0\xb3\xac\x66\x11\x94\x51\x56\x0e\xe9\x7d\xf7\xe4\xb4\x77\xe4\x12\x98\xbd\x0f\xa7\xc7\xbd\xe1\xe1\x87\xd3\xee\xb1\x2b\xe1\xf3\x7d\xaf\x7b\x79\x35\xe8\x89\xf7\xf0\x8c\x2b\x87\x54\x3d\xd3\xe1\x67\xaa\xc1\x50\x3e\xb5\xe0\xe2\xcd\xda\x0d\x16\x47\x9c\x4c\x8d\xa1\x2e\xce\x93\x95\x6b\x40\x55\x78\xbd\x92\x98\x52\x6b\x1f\xb3\x3c\xfe\xb7\x2a\x63\xba\x96\x9e\xa9\x4c\xc7\xf3\x82\x82\x9b\x34\x89\xb1\xd1\xf6\xec\x42\x8d\xd8\xa4\x02\x7d\x83\xc8\x9a\x32\x25\xec\xc5\x6d\x4d\x86\xf1\xd5\x56\x10\x21\xda\x53\x21\xef\x40\x1d\x4b\x1a\x5d\x39\x6c\x2a\x7a\xa0\x59\xc3\xfc\x62\x9d\x10\x27\x37\xea\x6f\x1e\x65\x42\x60\x9d\x74\x38\x9c\x1c\xd5\x17\x5a\x31\xec\xed\x1c\xc0\xc7\xcb\x48\x55\xff\x50\xd5\x84\x5a\xf2\xac\xb0\x9a\x46\x6a\x11\xa9\x2c\x88\x01\x2d\x2e\x27\xaa\xdd\xcc\x35\xc6\x2f\xb4\xe6\x71\xb9\x22\xdc\x4e\xd8\x4c\xe6\x8e\x98\xeb\xa0\xe6\x6b\xaf\x11\x3d\x64\xe4\x88\xb9\xd0\x69\xfd\xf2\x6b\x45\xcc\x26\x54\xec\x06\x3d\xf9\xc4\x2b\x16\x1d\x39\xb5\x77\xb0\xec\x74\xed\x4c\xd7\x8a\x73\xe1\xd9\xcd\x9a\xe3\x10\x95\xfd\x76\xf1\x11\x15\xe4\xaf\x15\x35\x0d\x22\x23\x14\x6d\x70\x04\xf0\x45\x4c\x60\x22\x1c\xf3\x5c\x75\xfc\xb8\xd1\xd5\x24\xea\x3c\x20\xc5\xce\x50\xe8\xb8\xc9\xa3\xe3\x6d\x03\x63\x09\x68\x05\xf9\x0d\xc9\xd4\xfa\xf9\x1e\xf6\x23\x50\x15\x41\xd0\x1f\x24\x2b\xdb\x2e\x39\x8f\xb6\x22\xdd\xb9\x82\xbd\x42\xd7\xff\x11\xab\x91\xd4\xb7\x51\x08\xd7\x58\x15\x3d\x8d\x7d\x6a\x00\x98\x6a\x26\xb3\xe6\xd0\x03\x62\x95\xaf\xb1\xce\x2f\xd6\xc4\xb9\xb8\x09\x0b\xb9\x00\x0f\x9b\xcc\xeb\xa7\x55\x57\xde\x21\xa1\x47\xc6\x71\x7b\x32\xab\x16\x9f\x03\xb7\x4a\x01\xc2\xc0\x02\xfe\x88\x0d\x79\x60\x3f\xa9\xb2\x89\x13\xb7\xf5\xc2\xf1\x22\x5b\x2e\xf2\xe4\x30\xa7\x46\xe9\x84\xc0\x59\x54\x9b\x62\x6e\x8a\xb7\x5d\x6b\x2f\x8c\xba\xa0\x88\x7e\xb6\x4f\xa0\x3f\x3d\xc0\x2e\x51\x0b\xef\x56\x8a\x04\xc9\xa1\xb4\x2d\x7c\x4a\xfe\xe8\x53\xae\x68\xaa\xca\xdb\x2c\xbd\x94\xe2\x7e\xf0\xc7\x65\x5d\x34\x08\x96\x7c\x61\x43\x1b\x8f\x24\x88\x6e\xbd\xc0\x2c\x62\x36\x6b\xfc\x1f\xa1\xb7\x05\x1a\x6b\x12\x0a\x9b\xb4\x6e\x7c\xfc\xba\xb7\xb0\x7a\x28\xf5\xa7\xde\xa4\x88\x9e\x4a\x45\x79\xe1\xa4\x5e\xe1\x7f\x1f\x61\x53\xa1\x91\x8a\x85\xc2\xc6\x5c\x68\x2f\xa1\xa4\x5c\xd5\x04\xbd\x1d\x03\x09\xdc\x84\x7b\x44\xbc\x99\x70\xc1\xa9\x65\x1c\x51\x41\x21\x8c\xed\xb6\x00\xbb\x0a\x1f\x99\xa8\x5f\x19\x3f\xde\xfb\x74\xad\x7d\xc3\x65\xa7\x7a\xf0\x97\x37\x92\x5e\x36\xb5\x43\x61\x31\x90\x26\x49\x9f\x7e\xe1\xae\x74\x8e\xb2\x30\x16\x61\x68\x91\x68\x31\x50\x43\x4e\x34\xa7\xce\x29\x39\xaa\x9c\xc0\x3a\x9c\xaa\x4e\x12\xa7\xce\x51\x08\xc9\x8e\xb8\xbc\xf0\x67\x5c\x70\xab\x0d\xc0\x33\xf3\xd2\x86\xc3\xd9\xba\x8e\x6d\x23\x2c\xb0\x71\x59\x48\x72\x97\x7a\x3d\x40\x5e\x49\x0e\x6c\xe7\x32\xe3\x97\x74\x4f\x7a\x1a\x61\xd5\x9a\x69\x44\x42\x16\xee\x6c\x57\x1c\xf7\x2e\x2f\x4f\xce\x8f\xc5\xf0\xb2\x3b\xb8\x74\xde\x45\x7b\x83\xe1\x65\x4f\xc0\x5d\x74\x70\x72\x09\x1f\x1c\xa0\x4e\x2f\xde\x75\x4f\xc5\x45\xff\xf2\xe4\xe2\xdc\x59\x76\x88\x9f\xea\xa9\xc7\x9c\x45\x87\x8e\x65\x0a\x77\x77\xe3\x49\x34\x1d\x08\x29\xbc\x39\x99\x8b\x71\xe0\xe3\x1d\xc8\x45\x2f\xc5\x54\xdd\xea\xfe\x83\x9c\x8e\x39\xfc\xd0\x39\xe4\xb7\x84\xc7\x1a\x93\x1b\x35\xca\xd2\x55\xd7\x10\x1b\x06\x71\xe2\xeb\x3a\xe0\x7c\x67\x0a\x26\xae\x42\xe0\xa2\x74\x54\xc5\x70\x0d\x09\x1c\x5e\x88\x2d\x93\x54\x67\x29\x76\xa4\x82\x6e\x70\x2b\x53\x50\x3b\xc7\xb2\x26\xc5\x4c\x29\x84\x98\xae\x68\xf2\x50\x13\xea\x3e\x0a\x9a\xc2\x2d\xbe\x9e\x3e\x3a\x93\xca\x8e\xf3\xd8\xc6\xe4\x79\x7a\xd0\xd8\x0a\x6b\x57\x61\x79\xd6\xb6\x33\x7a\x48\x96\x21\x61\x7f\xdf\x99\x44\x50\x6d\x40\xe0\x37\x6a\xc1\x2b\xeb\x40\x4d\xb3\xdc\xb6\xdc\xc9\x0d\x07\xbb\x69\x67\xa2\x29\x95\x56\xe2\xa0\xa9\xc5\x29\x7e\x7a\xf6\xee\x43\xf6\xd8\x56\xb4\xe6\x30\x77\xa2\x94\x29\x79\x91\xd5\xc1\x66\x95\xe7\xe0\x46\xa3\xa5\x66\x9b\x67\x9e\x9b\x11\xeb\x56\x32\x47\x85\x7d\x99\x75\x71\xa4\x8a\x09\x7e\xd9\xc5\xe0\x92\xfe\x35\xd1\x06\x76\x54\x2f\x1e\x02\x89\xeb\x14\xa8\x09\x31\x38\x2e\x04\x34\x6f\x99\xb6\x5d\x0a\x6f\x4e\x76\x97\x7c\xbd\x42\xe6\xee\x9a\xf5\x38\xa8\xde\x69\xdb\x9e\x55\xf2\xd7\x75\x34\xd9\xb0\xeb\xb9\x63\x30\x6d\x3a\x9b\x6c\xd8\x00\x5d\x0f\xf1\x0b\xb4\x13\xb3\xf7\x41\xee\x40\x4b\xaa\xc9\x78\xb6\x76\x62\x16\x03\x92\x97\x19\x6d\x6c\xbb\x0b\x9f\x7f\x60\xae\xda\x1e\x8d\x0e\x9b\x06\xa5\x39\xd6\x9d\x11\x7c\x65\x4c\xf2\xe6\x9e\xb1\x4e\x11\xf0\x61\xe2\x01\xc0\x3a\x39\x69\xe5\x95\x24\x56\x47\xce\x3c\xd3\x20\x21\x20\xcd\x89\x30\x04\x3c\x08\x97\x13\xde\x89\x7b\x60\xbf\x5b\x8b\xb2\xb2\x53\x13\x49\x92\xcd\xce\x3b\x96\x0b\x68\x2c\xd8\x71\x5f\xb8\x02\xc1\xad\xca\xc0\x58\xd4\x55\xd2\xd4\xaa\x98\x8b\x26\xa3\xe0\xc5\x58\xa1\x46\x34\x5d\xb9\x45\x8f\xc6\x0a\x19\xa2\xc1\xca\x55\xc5\xd2\xb7\x23\x61\x3b\xdc\x95\x47\x7b\x43\x35\xaa\x96\xce\xcd\xb1\xb7\x42\xd3\x04\xa0\x0b\x62\x3d\x85\x99\xd6\x3c\xa9\x33\x42\x51\xad\x10\xaa\x91\x15\x7f\x79\x8c\xdf\x9d\xb7\x58\xcb\x03\x39\x93\x41\x98\xbb\x1f\x56\x74\x8a\x3a\xf0\xb5\x54\x17\xe9\x4c\xda\xea\x3a\x95\x7d\x09\xc3\xb6\xda\x8c\x3e\xe0\x54\x99\xa0\xcd\x14\x45\x75\x40\x79\x13\x6c\xd2\x2e\x37\xd8\xe6\x25\x2a\x70\x26\xf3\xc6\x83\xdc\x32\x10\x17\x5b\x58\xac\xde\xa7\x56\x8e\xf9\x7b\xe3\xdb\x83\xa2\xff\x91\x0b\xc8\xe8\x6b\xc4\xbb\x55\x0a\xd0\x8a\x5e\xa1\x6b\x15\x28\x78\xc6\xc1\xaf\xd6\x6a\x7a\x2e\xae\x58\xc5\xba\x1e\x75\xe5\xa6\x3a\xa6\xac\x96\x6e\xfa\xad\x72\xeb\xcb\xb0\xe2\xd9\xc6\xf9\xac\xc3\xd9\x09\xd5\x2f\xb7\x36\x5f\x62\xad\xfd\x06\xb6\xe0\x17\xdd\x6b\x3b\xda\x54\xab\x52\xb7\x66\x6c\x5b\x10\x6e\xd2\xb8\x92\xcd\x2e\x68\x1b\x36\xd7\x6d\x4c\x20\x6f\xe9\xcd\xaf\x64\x8a\x36\xd5\x56\x77\xb3\x3b\x59\x62\x57\xa1\xc5\x3b\x89\xf2\x09\x35\xa9\x83\xb9\x39\x3b\x11\x9b\x85\x4c\x1f\xba\xce\x1a\x80\x5b\xb1\xb9\xd5\xd0\x9e\x73\x18\x4d\x29\x5e\xf5\xdc\x3c\x5b\x73\xe3\x8a\x41\x95\xdd\x3e\x2f\xd1\xda\x78\x85\x01\x2f\x3a\xde\x97\x1c\x60\x45\xeb\xe6\xcd\x8d\x01\xb9\x91\x90\x23\x07\x9a\x34\x71\xde\x4c\xa4\xe6\x64\x6f\x7a\x4d\xa8\xa5\x6e\x23\xf3\x00\x87\xbe\x55\x35\x91\xae\x5d\x19\xcd\xbc\x78\x79\x54\x5c\x4d\xeb\xe8\xfa\x95\xb0\x56\xf4\x62\x46\x27\xa5\xcf\x0c\xf1\x13\x66\xcf\x14\x96\xbd\x39\xbe\x9f\xc3\x67\x32\xac\x44\x5e\xa7\x44\xec\xde\x63\xc2\x29\xad\x2f\x3d\x68\xd7\x7e\x7f\xc6\x81\x72\xf0\x69\x75\xb7\xf3\xb7\x2e\x57\x42\xc5\xea\x6d\xb4\x70\x75\x14\xea\x9a\x9e\xe7\x6f\xdd\x3e\x85\xaa\xf5\xbc\xf9\x00\x37\x96\xcf\x8d\x87\xd2\x4a\x12\x53\x3b\x02\xaa\x15\x41\x7d\xdf\xc6\x41\x46\xb1\x7f\xaa\xfc\x0c\x67\x90\x8d\xa2\xc9\xc3\x1e\x96\x9a\x7f\xfd\x8f\xaf\x41\x5b\xc0\x2e\x9c\x72\x22\x46\x0f\x58\x1b\x9d\xa2\xea\x60\xda\xf1\x75\xac\x57\x40\x2f\x9a\xda\x13\xad\x6c\x6c\x44\xca\x42\xa6\xf3\x68\x22\xde\x1c\xf7\x2e\xf7\xfa\x17\x43\xf8\xcf\xd5\xe5\xde\x51\xef\xb4\x77\xd9\xdb\x93\xe9\xd8\x15\x58\x46\x0d\x12\xce\xe8\x5d\xc9\x2f\x0b\x7a\x5b\xe0\xeb\x82\xdf\x17\xf0\xfe\xbe\x23\x86\xec\x43\x94\xa4\x34\x0c\xee\xe1\xb7\x78\xe8\x24\xd9\x88\xc3\x11\x9c\x28\xcd\x2b\xd4\xcf\xb3\xf8\x4a\x3d\x12\x6d\x9d\xe3\x8e\x94\x6f\x54\x9e\xaa\x0a\xce\x99\x7b\xf8\x51\x85\x42\xac\x45\x5e\x00\xb5\x06\x6d\xa6\xb2\x68\xc7\xd1\x02\x3b\xdc\x99\xf8\x32\x71\x74\x71\xd6\x3d\x39\xa7\xf8\x55\xea\x66\xf0\x60\x51\x87\xb9\x41\xbe\xb3\x23\xe7\x33\x61\xe4\x00\xad\x2d\x70\xe2\x62\x9e\xd0\x0d\xc5\x82\xbc\x03\x5e\x9e\x9c\x0f\x2f\xbb\xa7\xa7\xbd\x23\xd1\x3f\xbd\x3a\x86\x11\x1c\x5e\x9c\x9d\x75\xcf\x8f\x5c\xc9\x43\xea\xf9\x93\xde\x00\xd6\x1f\xbe\xd2\x39\x39\xef\xbc\xeb\x61\x6e\x52\xcf\x81\x61\x16\x62\x72\x72\xa1\x7e\x8a\x2b\xe0\xcf\x2e\x8f\x22\x7c\x7c\xb1\xa6\xb5\xc1\x89\xda\xdc\xa6\x9a\x88\xaa\xed\xa3\x77\x7b\x7d\xa3\x57\xae\x1f\xc2\xaf\xe0\x1b\xba\x37\x8a\xf4\x41\x75\x81\x4b\xe0\xbc\x06\x6d\x14\x63\x11\x2b\x71\x95\x78\x33\x89\x8d\x60\x5c\x61\xc1\x20\xb8\x40\xc7\x10\x79\x73\x04\x7a\xb8\x09\xd4\xfd\x56\x60\xf7\x9b\xc3\x15\xdd\x30\xcf\x36\xf7\x13\x41\xbd\xac\xc8\x77\xa8\xba\xe4\xd2\xc3\xc1\x83\x90\xc0\xdd\x08\x56\x5e\x4b\x4a\x30\xf9\x0d\xe3\xbc\x29\xcd\x3b\xcf\x14\xa7\xf6\x1c\xa0\xcc\xd9\x35\xc4\x6f\x11\xd7\x2d\x3d\xc8\x51\xe1\x11\x46\xba\xb4\x19\xcb\xa1\xa9\x74\x17\xc2\x62\x0f\xbc\x59\x02\xe2\xee\x47\xb8\xb7\xa5\xa2\x33\xfd\x0a\xdb\x57\xe0\x98\x46\xaa\xc7\x07\xec\xa2\x7b\xd4\xf8\x54\x03\x59\xb1\xc8\x82\xd4\x5f\x06\x92\xe3\xda\xd8\x69\x59\x5c\xa6\xce\x78\xef\x8a\x71\xdb\xfd\x92\x42\x45\x8b\x97\x81\x26\x1c\x13\x2d\xaa\x73\x85\x1a\x3a\xd6\x9f\x58\x69\x89\x8b\x01\xd2\xd4\xe7\x42\x27\x06\xec\xa9\x3a\x15\xf8\xe3\x42\xce\x63\xcc\x91\xa7\xe8\x38\x3c\x3d\x39\x70\xb0\xb8\x63\x30\x7d\xb2\xaa\xcb\x2d\x67\x6d\xc3\x20\x50\x11\x67\xd8\x2e\x37\xea\x0a\x8f\x3f\xf4\xba\xa7\x97\x1f\x6e\x0e\x3f\xf4\x0e\x3f\xde\x5c\x7e\xdf\xef\x01\xdf\x12\x62\xea\xf5\x2b\xac\xfd\x78\xfd\x0a\xd7\xce\xf5\xab\x10\xc6\x70\xfd\xea\x1a\x66\xaf\xd5\x72\xa9\x04\x9f\x58\xb0\x71\xe1\x68\xe8\x70\x7f\xf4\x61\x81\x30\x8e\x66\xe4\x9f\x47\xf9\x72\xd7\xc7\x52\xfb\x15\x8d\xd9\x0b\xb7\x85\x05\xad\xcb\x19\x60\x09\xe1\x36\x4b\xd6\x45\x0f\x29\x9c\xf0\x44\xcb\x42\x2d\x2b\xf0\x07\xba\x44\xc4\x6b\x58\xd5\xd4\x46\x18\x43\xfb\xf2\x0f\x14\xb3\xf4\x1a\x95\x36\x4d\x46\xd2\x96\x1d\xa6\x90\xc3\x1a\x14\x56\xa5\x08\xd9\x86\x45\x35\x43\x78\x36\xc2\x77\x42\xae\x76\xcb\x99\xe0\xe4\x5d\x91\x5b\x05\x78\x6b\x72\xbb\xfd\xbe\x18\xf6\x06\x9f\x4e\x0e\x7b\x37\x74\xaa\x9f\x1f\xf6\x76\x43\x6f\x35\xe4\x5d\x10\xcc\xcd\xd6\x50\xe4\x2b\x7d\x6b\x57\xf4\xaa\x26\xa7\x16\xe0\xdd\x92\xbb\x2a\xe6\x76\x4f\x79\x05\x8e\xdd\x0e\xe2\xd9\x56\x4b\x3e\x86\x67\x5d\x36\x39\xb5\xdb\x11\x6a\xd3\xb4\xdf\xd9\x05\x3d\xdb\x33\xaf\x40\xd3\x26\x6c\x7a\x77\x75\x72\x7a\xd4\xef\xc2\xd2\x41\x78\x7b\xe2\xbc\xf7\xdd\x4d\xf1\xbb\xdd\x4c\x77\x13\x3c\x5b\xcf\xb9\xde\xc4\x5b\x2c\xda\x4d\x51\x52\x71\xa6\x06\xf3\xda\x16\xfe\x69\xf7\x5d\xef\x14\xae\xff\x83\x8b\x4f\x27\x47\xbd\x01\x8d\xed\xf2\xe2\x63\x6f\x47\x32\xb0\x0c\x3e\xcb\xc1\x6f\x3d\x1b\x2b\xa4\x3f\x07\xc1\xdb\x93\x79\x31\x38\x2e\x1c\x2d\x5b\x93\x88\x00\x77\x7a\xa4\x94\x29\xdc\x05\x1f\x9f\x83\x48\xb5\xb5\xff\x78\x75\x71\xd9\xdd\x19\x95\x45\xa0\x5b\x93\x39\xe8\xf5\x2f\xf2\xa3\xed\x6a\x70\xfa\x5c\x82\x61\xd8\x3b\xbc\x1a\x9c\x5c\x7e\x7f\x43\x8d\xfd\x09\x5b\xbf\x0b\xe7\xf4\xe5\xc5\x0d\x26\x65\xdf\x0c\xae\x4e\x7b\xc3\x9b\xf7\x27\xa7\x3b\x12\xb0\x25\x7c\x59\x1d\xbe\xad\xb9\x58\x44\xb6\x67\x56\xe8\xb0\xdf\xdd\x95\x7e\x50\x85\x22\xcb\x51\xec\x60\x08\x7c\x40\xbc\x1b\x80\xb8\x1b\xf0\x81\x54\xfc\x6e\x57\xe3\x58\x8f\x67\xe7\x83\xb9\x82\x2f\x78\xdf\xf4\xbb\xc3\xe1\x77\x17\x83\xa3\xbd\x36\x6b\xbd\xdd\x88\x9c\xc8\x76\x36\x2c\x73\x88\xeb\x2f\x3e\xf6\xbe\xdf\xed\x58\xaa\x31\xec\x7e\x00\xb8\x49\xec\x15\xb0\x5b\x9d\x7a\x05\x6a\xe6\x44\xf7\x3c\x43\x7b\xfe\xf9\xc9\xca\x58\xb6\x1f\xc8\xc5\xd5\x00\x9b\x64\xc3\xed\xf5\xb2\x3b\x38\xee\x5d\xd2\xc7\xdd\x50\x5f\x0d\x7a\x7b\x92\x59\x06\xee\x58\x25\x60\xa8\x3b\x55\x0a\x72\x42\x77\xa8\x14\xe4\x74\xee\x4a\x29\x20\x88\x9d\xfc\xc2\x4b\x7f\x12\xf0\xce\xee\x6e\x40\x16\x92\xac\x12\xc9\x6e\x86\xc1\xca\x0d\x6d\xfa\xfc\xcf\xdd\x0d\xa0\x1a\xfc\x2e\x49\xdf\xc5\xfd\xd8\x41\xdb\x46\xa4\xe5\xc7\x1b\xa8\x20\x7b\x62\x70\xb1\x2b\x8d\xad\x12\xf0\xd6\x9c\x2c\x41\x25\x4e\x3c\x23\xd5\x05\xf8\x5b\x13\xdf\xec\x0e\x5d\x4f\xa0\x6d\xaf\xdf\x8c\x88\xe5\x92\x43\x01\x76\xb1\x12\xb1\xb6\x0d\x06\x98\x84\x76\xc9\x87\x6d\x97\x24\x50\x78\x83\x14\xee\x29\xf7\xfa\x4d\x99\xdc\xcd\xa7\xd7\x01\x7a\xfb\x99\xdd\xde\x60\xb8\x15\x7e\x53\xf1\x41\x8d\x8e\x6a\x21\xa1\xb0\x5f\xaa\x52\xd5\xbb\x61\x5f\x25\x9a\xac\x80\x66\x6b\x56\xce\xa3\x24\x25\xd2\x55\x2b\xc1\x9d\x10\x4e\x40\x33\x0b\xe8\xd6\x64\x46\xc1\xc4\xda\x4a\x00\x39\x94\xf7\x95\x7b\x6b\x73\xa2\x27\x14\x60\x88\x29\x78\x44\x39\xfa\x59\x65\x66\x36\xdc\xa4\x62\xbb\x6d\x3e\x14\x0c\x81\xe2\x39\xc5\x71\xe8\xbf\x5e\x6a\x1c\x85\x38\xa9\x1d\x0c\x28\x9e\x3d\x97\x00\x71\x80\xde\x9a\x64\x15\x43\xbc\x57\x88\xff\xde\x5b\x4d\xe6\xde\x8d\xaa\xa3\x91\x59\x11\xe1\x7b\xe5\x2c\xee\x1d\x8c\x89\xa2\x35\x9f\xe1\xac\xa1\x3c\x13\x8e\x8a\xdc\xfa\xb0\xb9\xfb\x46\x5f\x1f\xf1\xa3\x31\xbc\xe2\xe7\xd3\xee\xb9\xb8\xfb\x36\xff\xf9\x5b\xfe\x6a\x27\x53\xb0\x01\xda\xcd\xe6\xc3\xd9\x18\x72\x85\x3c\x47\x89\xaa\x1c\x9e\x2e\x8c\xb9\xf0\xd2\x83\xbc\xe5\x05\x9a\xdf\xb0\x6a\x1f\x36\xcf\xb8\x4e\xe1\xff\xc3\x4f\x5e\xe0\x4f\xd4\xd3\x5c\xa8\xcf\x5b\x2c\xa9\xbd\xd4\x0f\xd7\x21\x40\xc7\xff\x08\x0c\x86\x88\xa3\x34\x1a\x47\xc1\x35\xa0\xb9\x7e\x95\x8e\x97\xd7\xaf\xf6\xf4\x6f\x13\x6a\xb2\x43\xd4\xf2\xcf\xdf\x7c\xbd\xff\xed\x1f\xfe\xb0\xff\xcd\xfe\x37\xff\xdb\x7a\x0c\xe3\x29\x12\x7e\xe0\xf7\xbf\xff\xfa\xef\xaf\x5f\xe1\x0f\x40\xc8\x9f\xea\x47\x9d\x50\xe5\xc8\xce\x7b\x35\x96\x23\x6e\x5c\x55\x39\x98\x77\xd2\x4f\x96\xbe\xae\x74\x30\x7b\xfa\x35\x48\xfd\x99\xe4\xf7\xf9\xbd\x17\x1d\x96\x63\x8a\xb8\xc0\xdd\xe1\xe9\x89\xaa\x14\xd0\xd2\xca\x4b\xaf\x5b\x2d\x16\x81\x13\x7d\xfa\xc4\xad\xd2\xdc\x91\xaf\xfa\x55\x6a\x24\x52\x6a\xa0\x59\x86\xe0\xc6\x0d\x82\xad\x0e\x7e\xf8\x58\xff\xae\x38\x93\x8b\x28\x7e\xa8\x07\x91\xa8\xde\xd7\x6b\x40\xe9\x30\x20\x4f\x84\x51\xd8\x09\xe5\x0c\xe0\xdc\x49\xdd\x97\xa4\x1e\x05\x07\xf9\x50\x9d\x44\xd6\x87\xee\xec\x8e\x20\x14\xe6\xe3\xc2\x7e\x47\x5b\x86\xca\x99\x56\xb5\x11\x73\xe0\xbd\x0a\x8b\xeb\x31\x6f\x1f\xb6\x50\xed\xc3\xea\xf1\x0d\x54\x51\x61\xfc\xd7\x19\xa2\x63\x21\x31\xd5\x81\xd5\x0b\xb5\xc0\x87\xc3\x53\x71\x28\x55\xab\x6e\x0c\x04\xc2\x56\x1b\x14\x12\x74\xe9\x2f\xcf\x64\x52\x1b\x17\x94\x23\x4d\x10\x50\xe7\x33\x00\xf2\xa7\xfe\xad\xa7\x4a\xce\xb9\xe1\xd5\xd2\xc4\x9d\x47\x36\xe3\x70\xde\x42\x44\xac\xf2\xd9\x19\x77\xa6\xf0\xae\xef\xcd\x66\x8f\xb8\x5b\x9d\xb7\x77\xb0\x06\x0b\x55\x47\x9c\x65\x2a\x3a\x0e\xc4\xd0\x9d\x3f\x51\xe1\xca\x9d\x31\x45\x12\xee\xc3\xfe\x94\x1e\x8c\x5c\xfd\x08\xcb\xdc\x5a\x79\xd1\xe8\x2f\x28\xe6\xa9\xaf\x24\xd1\xab\x23\xc7\x01\x70\x0a\xba\x0e\x55\xcb\x5b\x7d\xc1\x25\x1b\x2c\xde\x7d\x2c\x50\xc6\x85\x09\xe0\x18\xc5\x7a\xb2\x48\x1a\xe6\x01\x7d\xe2\xde\xe3\x98\xf4\x03\x2c\xc0\xda\xab\xe9\xbe\x78\x87\xfd\x58\x0a\x95\x58\xf1\xfa\x9b\x33\x8a\x56\xfd\x05\x50\x71\xab\x83\x31\xfd\x50\x97\x62\x7d\xcc\xd4\x9d\xf4\xa8\x10\x45\xb8\x30\xaf\x87\x85\xd7\x8b\x34\xb8\x03\x09\x79\xf8\x79\xdb\x46\x4c\x46\xc1\x82\x2c\x9c\x66\xf1\x5a\x74\xb4\x0c\xa5\x47\x26\x11\x50\x89\xe1\x9a\x54\xac\x76\x3d\xa3\xf2\x2e\x8e\xab\x70\x75\xd3\x5a\x7e\x06\x1b\x8c\xa8\xb8\x4b\x53\x66\xd6\x29\x63\x15\xd1\x7e\x72\xcb\xe9\x50\x74\xd6\x1d\xc1\x9f\x2a\xb9\xaa\x5d\x21\x6e\x8b\xde\xea\x52\x2e\x34\xc1\x7d\x78\x21\x95\x4d\x31\x6d\x49\xf8\xb3\xd2\xba\x8e\x3c\xae\x7c\xd6\xa1\xca\x67\x1d\xaa\x7c\xb6\xf4\x62\x6f\x41\xe0\xf8\xb7\x43\xfc\x89\x7b\x64\xac\xa5\x33\xc6\x1e\xad\x30\xe9\x58\x44\xc6\x2a\xac\x66\x81\x77\x00\xae\xa5\xd1\x5c\x20\xc6\x51\x16\x72\x0b\x3d\x7d\xe6\x25\x87\xf8\x15\x0e\xf7\xa4\xf0\x90\x75\x16\x9a\xe3\xac\xfe\x1c\xb4\x07\xa1\xce\xc4\xc7\xa7\x5f\x4c\x43\xa4\x55\x84\x47\x2b\x0f\xae\x39\x43\x31\x9a\x78\xb4\x76\xa1\x9b\xc1\x2e\x48\x31\x10\xd4\x20\x8a\x48\x60\x4d\xe1\x14\xff\x6e\xb7\x78\xde\xc9\x19\xa8\x38\x8f\x66\xc5\x94\xb4\x8a\x5a\xe0\x8d\x68\x2d\x70\xa8\x30\x19\x5b\x4c\x83\x26\x73\x05\x38\x96\xc0\x6e\xae\xb5\x34\x64\xf7\xfa\x21\x04\x98\x93\x9f\x82\xb0\xb2\x9f\x54\xab\x61\x87\x83\xb9\x0d\x58\xf2\x23\xed\x3a\xcf\xaa\x8c\xad\x76\x44\x74\x77\x59\x97\x1e\x65\x9f\xd8\xe6\x3a\xa0\xf2\xaa\xeb\xc1\xeb\x70\x7c\xb8\x10\x9a\x6e\x54\xf0\xa5\xab\xd2\xae\x8d\xe8\x2c\x7f\x55\xe7\x1d\x70\xa7\x21\x38\x00\x6e\xb1\x54\xbd\xe9\xeb\xb3\x66\xd2\xaa\xb6\xc6\x06\xfb\x62\xa8\x36\xc0\xc8\xec\x0f\x37\xb0\xd6\xf4\x6c\xb6\x55\xdd\x24\xb5\xdf\x9d\x0e\xaa\xb6\x38\x31\x6b\xa9\xdb\xf0\x7c\xb4\x4b\x8e\x89\x59\xe6\x4f\x08\xe4\x31\x7c\x68\x1d\x78\xcf\x00\xb1\x18\x35\x55\xfb\x36\xe7\xd8\x25\x7f\xd3\x6a\x26\x56\x4e\x32\x05\xd6\x09\xb0\x96\xa6\xbc\x2e\x29\xb5\x03\x2f\xf4\xaa\xe2\xb6\xe0\x43\x6a\xdd\xf5\xc9\x0b\x1a\x35\x06\xb5\xe9\xcc\x6b\x59\xb7\x85\xed\x22\xd9\x4f\xd9\x2a\x0c\x5b\x1d\xee\x25\x9c\x6a\xba\x47\xdf\x48\xee\xd6\x31\x55\xdd\x11\xb8\xfa\xac\x6a\x61\x40\x49\xb5\x4e\x8b\x92\x69\x31\x05\x3b\x9e\xdb\x98\xa2\x3d\xf5\x0e\x37\xbc\xb1\xae\xbe\xcf\xc2\x5b\xbb\xaa\x03\x2b\xc4\xa6\x4b\x81\x34\x49\xe2\xa6\x7f\x83\xac\xb1\x24\x39\x86\x91\xc8\x00\x2f\x0a\xf8\xc3\x78\x8e\xb0\xc9\x5a\xa9\xc6\x87\x3d\xec\xe0\x58\xe4\xc2\xed\xb4\x71\x92\x4d\x47\xb4\x07\x8a\x19\xd6\x85\x86\xfb\x53\x72\x4f\xfa\x01\x3f\x00\xdf\x4d\x30\xc3\x16\x3f\xab\x0c\xb7\x90\x31\x09\x94\x8d\x01\x8c\xd5\x39\xa8\x53\x0f\x8e\x22\x93\x43\xe4\xa0\xeb\x54\xa6\x8f\x30\xf2\xfc\xb1\x6a\x50\x98\x40\x83\x76\x17\x5d\x42\x3c\x6f\xe0\xc8\x33\xe9\xca\xd2\xc3\x5b\x34\x17\x04\x5f\x88\xcf\xbe\x0c\x46\x7a\x4a\xb2\x69\x40\xed\x03\xd7\xe1\xbb\xf3\xfc\x80\x56\x91\xba\x6b\x8c\x39\x65\xcc\x55\x27\x9e\x10\xde\xf1\xe5\x66\x44\x9d\x15\xf5\x5d\x82\xf3\xbb\xe4\xc6\x98\x69\xd8\x9c\x1b\x8a\x99\x68\x56\x65\xca\x88\xf2\x0f\xe9\x9d\xc9\xc4\xfe\xc9\x6f\xd9\x11\xc4\xe0\xce\xab\x9a\xd7\x0d\xd3\x6a\x85\xd6\x74\x50\x58\x61\xb4\x0e\x64\xb9\x88\x68\x43\xb0\xaa\x66\xa0\x5a\x17\x63\xce\xf3\x56\x79\xf3\x2a\x85\x55\x7f\x69\x57\x62\xaa\xa3\x44\x37\x98\x5a\xe0\xee\xcd\xf8\x56\xac\xf7\x73\xa4\x52\x3e\xf1\x9f\xfc\xd7\xa2\x67\xa5\x21\xe5\xa5\x32\x7f\x75\x14\x55\x95\xf3\x6b\x8c\xa5\xe8\xdb\x68\xbd\x85\x8a\x0e\x0b\xe6\xcb\x26\xdb\x29\x2f\xc9\xe1\x51\x2d\x80\xda\xe5\xa5\x4a\x6c\xe0\xd3\xac\x64\x6e\xc6\x61\xf6\x5e\xbc\xf1\x94\x93\xc4\xc7\x16\x8e\xcb\x98\xbb\x00\x73\x9a\xa6\x48\x1e\x00\xd0\x62\x4f\xa5\xfb\x93\xf1\x05\xc8\x63\x91\x84\x75\x28\xd4\xcf\xa0\x4e\xa7\x98\x14\x2a\xe2\x8c\xda\x35\x38\x93\xd1\x99\x67\x69\x71\x6b\x88\x37\xa8\x23\x0f\x15\x11\x1c\x5e\x70\x87\x3e\x0a\xec\xc4\x8b\x2d\x40\x13\xb6\x9f\x30\x36\xfc\x19\x73\x5a\x7d\xf9\xf4\x1f\x98\x23\x08\xec\xc0\x56\xef\xa3\x44\x13\x83\x56\x1d\x92\x6c\x5e\xde\xb9\xe9\xd6\x0b\x5d\xa9\xf6\x86\x1f\xd4\x2e\x9a\xe4\x84\x92\x68\x0d\xc4\x05\x8d\x67\xee\x83\x0e\x35\x93\x28\xd9\x52\x4b\xae\x59\xc5\x75\x1b\xcf\x89\xc9\x29\x57\x67\x72\xbe\x32\xa2\xe9\xa6\x3b\x95\xce\x60\xaf\xb0\x70\x76\xb0\x3f\x4d\xe1\x0a\x4a\x08\x5f\xb7\x60\x75\x5f\xca\x2a\x57\x6b\x13\x84\x46\xe4\x47\xd3\xa9\xa4\xe6\xa8\x1a\xb5\x55\xeb\xc9\x41\xc2\xa7\xfc\xd0\x11\x5d\xbc\xbb\x47\xa9\xe4\xee\xcc\xb2\x50\xad\xa9\x1d\x21\x2c\x43\x75\x27\x35\x55\xe1\xa7\x01\x05\xae\x22\xbf\x76\xb1\xf2\x04\x0b\x82\x12\xdc\xb6\xec\xc9\xd0\x02\xbd\x23\x62\x72\xaf\x9c\xb5\x55\x6b\xa8\xb0\x5a\x72\x58\x12\xd4\xbd\x34\xec\x86\x1b\xb8\x2a\x50\x6c\x46\x6d\x57\x86\x29\x39\xee\xad\xc8\x72\x07\xda\x72\xe1\x70\xba\xba\x96\xfd\xce\x0d\x30\x17\x6a\x2c\x3b\x70\x95\x0a\x28\x37\xe1\x62\xb9\xbc\xad\xe2\xa6\xea\xca\x5c\xfe\x95\x5a\x04\x66\x61\x58\x6a\xbf\xef\xa2\xa7\xe2\xa4\x54\xcc\x3f\x93\xa8\x42\x53\x55\xda\xd5\x67\x58\x82\xdc\x92\x59\xc6\xee\x33\xdd\x84\x4d\xae\xf1\xa4\xde\x8c\xeb\x96\xa5\xba\xf7\xc5\xe6\xc4\x0f\x19\xd8\x82\xc6\xc0\xbd\x2c\x5a\x53\x59\x28\xd9\x98\x70\x75\x9e\x9a\x9e\x47\xe4\x0f\xb0\x36\x4b\xa9\x2a\x63\x2b\x9c\x79\xb5\x45\xd7\xc8\xd7\x94\x52\x6c\x81\x4c\x55\x4e\xac\x47\xa4\xea\x22\x36\x01\x8c\x73\xa8\x1c\xb0\x70\x70\xb2\xbb\x35\xa9\xa9\x52\x64\xb6\x80\x6f\xbc\xb6\xb8\x8b\x74\x7d\x78\xa7\x8f\xf6\x14\x9b\xf0\x89\x65\xc4\xbe\xbc\x7b\x2f\x9e\x68\x95\x9f\x17\xcd\xbe\xb8\x9c\x83\x02\x83\x0e\x26\x52\x44\x46\xb8\x98\x41\x7f\x00\xa2\x16\x11\x75\xec\x43\xc5\x05\xa4\x82\x8b\xb2\xef\x60\x5d\xc9\x38\x80\xff\x22\x63\x01\xf6\x23\xfb\xfa\x8c\xb3\x88\x3a\xf4\xe1\xf1\x1e\x61\xbb\xc1\x23\xd0\x09\xa4\xf2\x1e\xa1\x72\x41\x65\x24\xa6\x1e\xa8\x23\x46\x6d\xd1\xf5\x20\x9c\x03\xba\xa5\x9d\x60\xae\x14\xd4\x3c\x33\xa6\xce\x38\x22\x5b\x62\xdd\x09\xe7\x34\x81\x02\x16\x2b\x67\x14\x6a\x3b\xe6\xbe\xb1\x27\xb2\x85\xe8\xc2\xc1\xee\x01\x97\x79\x8d\xc0\x63\x8f\x19\x5e\xbc\x16\x12\xcb\xdc\xb8\x88\xe1\x4a\x54\xc2\xe9\xb5\x3f\x93\xc1\x44\x63\x94\x79\x85\x29\x50\x07\xd7\x40\x8c\x9c\x85\x62\x9c\x20\x47\x4e\x90\x33\x89\x3d\xc3\xe3\x28\x4e\x5c\x21\x25\x7d\x0c\x7c\xb8\x8d\xd4\xc2\x12\xdc\xb6\xdf\xe5\xb4\x44\x88\x54\xa2\x25\x4b\xeb\x0a\x6b\x2d\x88\xd0\x9a\xa5\x39\x9b\xc5\xe8\xa4\x07\x31\x06\x42\x67\x19\xf9\xe8\xb7\x50\xd5\x5f\xc8\x3f\xc7\x4e\xd1\xba\xfa\x3c\x16\x8c\x4e\x0f\x60\xa0\x05\x45\x55\x7b\x01\x19\x57\x70\x5d\x26\x54\x91\xc4\x49\x4b\x74\x4b\x65\xc5\x96\x64\x45\x42\x8c\x1c\xfc\xf0\x7a\xb5\x6d\x43\xd1\xb9\xe7\x0a\x2b\x58\x14\xda\x35\x94\x1c\x82\x21\x2e\xf8\x32\xa2\x24\x1b\x3b\x4b\xfc\x9c\x61\x0b\x4d\x0f\x18\xb2\x7c\xd0\x5d\xfd\x94\x02\x35\xc6\x72\x5c\x44\x23\x7a\xb7\xad\xe3\x80\x7c\xc0\x61\x04\x5b\x25\xde\x17\xe2\x2a\x24\xfb\x7d\x04\x0b\x3a\xf6\x27\x54\xca\x85\x2e\xb1\x00\xb0\x63\x20\x71\xed\x9a\x7b\x9f\x1a\x65\x70\x37\x40\x52\xee\x73\xa0\xae\xc9\xfe\x18\x2d\x69\x39\x26\xe2\x8f\xa8\x1c\x23\x51\x89\x89\x72\xcc\x8b\xc3\x98\xe3\xc5\x52\x21\xd0\xfb\x19\xa3\xe9\x5b\xb9\x8a\x41\x46\x50\xf1\x46\x9c\xc5\x02\x7d\x44\x10\x1c\x7b\xdc\x95\x57\x03\x92\x71\x28\xb3\x74\x0f\x84\x46\x88\x3d\x2f\x95\x5b\x95\xca\xcb\xa0\x6e\xe6\x53\x7f\x4f\x32\xb6\xbb\xfc\xc2\x8a\xb7\xb8\xeb\x3a\xc6\xf1\xbe\x1a\xbc\x67\x74\x45\xe0\xeb\xe1\x7b\xba\xad\xb9\xc4\x4c\xd1\xe7\x2d\x29\xd6\xc0\x6c\x53\x87\xc3\x7c\x45\x97\x22\x0e\x1d\xbe\xef\xd0\x95\xac\xf8\x52\xcd\x38\x48\x32\xd2\x29\xf4\x3a\x29\xc4\x23\xc2\xdc\x87\xc1\x83\xb8\x03\xf9\x86\x83\xc0\x12\x61\x05\x85\x13\xc7\x5c\x73\x69\x77\xa1\xb4\x6a\x13\xa9\xe6\xc6\x13\x5c\xc8\xa8\x0d\x4c\xb3\x00\x10\xc2\x05\xb7\x51\x6d\x2d\xe5\x0f\x89\xa7\x51\x30\x63\x13\x80\x5a\x11\x5c\x9b\xa8\x09\x7e\x3f\xb1\xba\xcf\x96\x4c\x37\x13\x1f\xc3\xe0\x60\x2f\xee\x01\x37\x0a\x61\x14\x70\x72\xcd\x49\x20\xe7\x11\xc0\x20\x90\xb4\x9b\xa7\x05\xed\x05\xcb\x0e\x4c\xd6\x23\x8e\x22\x44\xa2\x0a\xdd\x69\x2b\x23\x23\xc2\xf4\x5e\xe6\x31\x10\x30\xe5\x1d\x8e\x96\xd4\x81\x11\x79\x73\xe7\x52\xac\x83\x8b\x2f\x4b\x75\x25\x8e\xf4\xfd\x02\x97\x6d\x8a\x47\xbd\xbb\x2b\xe4\x00\x9e\x9e\xf0\xe5\x02\x37\x59\xa2\xb6\xef\x23\x35\x1f\x75\x4b\xa6\x1f\xc5\xbd\xe7\xa7\xdc\x04\x53\xb7\x63\x33\xdb\x86\x36\x6d\xb6\x44\x4b\x08\xc8\xf6\x30\x73\x1f\xce\x00\xc8\x5f\x80\xa6\x20\xbe\xc3\x6d\x0e\xcc\x4b\xd5\x65\x93\x4c\x1c\x79\x63\xd2\x8e\x76\x17\x22\x57\x08\x62\x63\xca\x72\x95\x41\xa9\xd1\x5b\x90\xe5\x25\x5a\x7d\x26\xb1\x67\x99\x2e\x1b\xd0\xe5\x2f\x40\xdf\xf0\x16\xe4\xa9\x07\x71\xae\x3c\x55\xbc\x04\x8d\xfc\xce\xdd\xfe\xf0\xc3\xdc\xbb\xd3\x95\x13\xbf\xf9\xfa\xdb\x3f\x9c\xed\x89\x6f\x8e\xe1\x7f\x5f\x1f\xbb\x2c\x46\x8a\xee\x7b\xe3\x1d\x41\x46\x2e\x9e\xfe\x36\x0b\xb8\xca\xac\xf6\x65\x95\x25\x73\xa2\xe5\x0f\xd7\x5c\x2c\x23\x7b\x89\x11\xed\x8b\xce\x37\x78\xe2\xc2\x19\xc4\xad\x50\xd1\x5b\x40\x3e\x02\x74\xb6\x12\x0e\xd7\x39\xf4\x3c\xa3\x26\x82\x60\xbf\xce\x53\xeb\xdc\xca\x42\xe5\x06\x4c\x25\xdf\x02\x9d\x7b\xf1\xc5\x99\x23\xde\x1c\xc9\xa9\x97\x05\xe9\x41\xfe\xdb\xcb\xae\x93\x86\x1c\x13\x6f\x60\x0f\x85\x13\xb8\x95\x1c\x58\xbf\xae\x59\x65\xb4\x9d\xdf\xa0\xef\x42\x82\x82\x38\x49\xbe\xa2\xbd\x8d\xf1\xb3\x20\xe2\x68\xc3\x97\x2e\xc6\x2c\x84\xf6\x04\xe9\x42\x2a\x66\x50\x24\x28\xfb\x95\x53\x33\x01\x71\xff\x40\x6f\xb8\x02\x51\x8d\x14\xf8\x0c\x02\x60\xe2\x65\x00\x00\x29\x18\xca\x5b\x92\xe9\x5f\xed\x91\x56\x82\xff\x43\x3a\x2a\xe4\x96\xd1\x57\x94\x83\x1f\x43\x00\x74\x05\x3e\xa5\x01\x21\x68\x9a\x2c\xa3\xbc\xf0\xa5\x0a\x43\x21\x52\x6c\x29\xa0\x5b\x34\x50\x05\xff\x6c\x9a\xc6\x70\x6a\x3b\xcb\xe6\x9d\x59\xde\x6f\xb5\x92\xbe\xfd\xbb\xbf\xc7\x29\xd2\x33\xe5\x5a\x11\xab\x5e\x6e\x35\xc7\x2b\xef\x3b\x10\x53\x38\xa7\xf2\x8c\xd7\x87\x8a\x9e\x7b\xa8\xa2\xc1\xe9\x58\x7a\xba\x1a\x30\x35\xdf\x96\x15\xbe\x07\xa3\xfe\x16\x0a\xf0\xe7\xfa\x6f\xfd\xad\x3d\xf7\x41\x68\x45\x75\x61\x27\x57\xe8\x60\xc4\x85\x9a\xa7\x90\x5a\x87\xd7\x54\x01\xc5\x14\xc4\x56\x5a\x14\xbe\xe0\xba\x97\x39\xde\x00\xe5\xa0\xf5\x0b\x74\x71\x00\xd1\x31\x43\x43\x42\x5c\xf0\xf8\xed\x12\x16\x96\xb4\x54\xad\xfe\x73\xe7\xa2\xf2\x0c\x80\xfa\x41\x4d\xcf\x65\xbb\xc2\xb3\xe7\xf2\x5e\xf4\x55\xa1\x39\xd7\x4a\x92\x19\x2c\x84\x8f\xaa\x9d\xb6\x1b\x4c\xe8\xe6\x1c\x82\x88\x29\x4b\xc5\xf1\x7a\x24\xfe\x57\xc2\xda\xa5\xeb\x16\x84\x9a\x1a\x3c\xa3\x55\x3d\x27\x9c\x6e\xff\x24\xbf\xf2\x26\x28\x0e\xae\x40\x23\xc5\x0b\x21\x5c\x68\xfd\xf0\xd2\x5f\xe2\x85\x50\x85\x4b\xc0\xc3\xea\x0b\x54\xe1\xd8\x3a\x0c\xcb\x52\xbf\xef\xbc\x92\x51\xb6\x69\xff\xc4\xbe\x17\x27\xe9\x4c\x06\x72\x06\xf8\x94\x91\x5a\xe9\x9f\x2b\x98\x51\x66\x15\x70\x93\x85\x84\xb5\x53\x03\x0f\xa3\xb3\xd0\xf8\x8c\x0e\xa3\xc7\x4c\x39\xf9\x1d\xa7\x20\x56\x99\x1c\xf3\xb5\x14\xae\x29\x20\xb5\xc4\xf7\x51\xc6\xb1\x65\x13\x3f\xa1\x7b\x95\xb2\x21\xe2\xb6\x85\x0b\xa8\xba\xb3\x4c\x57\x5b\x73\xe8\x4d\xae\x1d\x3d\xdc\x64\x32\xa4\xba\xd8\xa1\x00\x19\x01\x3c\xb5\x5a\xc8\x98\x47\x54\x1d\x56\x5c\x98\x85\x7e\x0b\xf0\x63\x1d\x0f\xe1\xac\xf2\x9e\xfe\x23\xf4\xe6\x58\x9c\x31\x56\x2d\xbb\xf6\x89\x6d\x0b\xb2\x87\x87\x24\xeb\x3f\xe7\x16\x4c\x76\x1a\xa9\xf0\x07\xab\xef\xc3\xea\x50\x72\x17\x53\xc9\x4f\xed\x87\x79\x88\x07\x85\x4a\x78\xc6\x77\x07\xb3\xe6\x7e\x0f\x85\x7d\x37\x4b\x98\xda\x15\x97\x51\x61\xd8\x9a\xe0\x99\xc4\x99\x8b\xdd\x27\x49\xab\xa9\x53\xdc\xed\xc3\xec\x29\x3c\x24\x43\xff\x73\xce\xe3\x84\xbc\x92\x5e\x58\x1a\x91\xd5\x2a\xe9\x3f\xf1\x94\x2e\x7d\x87\x08\xd2\x46\x2a\xac\x1c\x5e\x14\x35\x3b\x92\x34\x0a\x41\x95\x48\xc1\x17\x1f\x33\x0a\x02\xaa\x11\x24\x70\xc1\xd4\xdd\xbf\xd5\x55\x9f\x42\xbf\xd8\x8e\xd6\xee\x64\x89\x54\xad\xe5\x35\x52\x5d\xc5\xfc\xac\x15\xec\x79\x9c\x4b\x03\x90\xd6\x9d\x71\x2d\x60\x8e\xd5\x4a\xd0\x36\x8e\xbe\xdb\x89\xeb\x10\x63\xc8\x4f\xff\x86\xaa\x0a\x5b\xb1\xef\x60\x5f\xc8\x30\x5a\x2c\x6a\xa0\x6b\x17\xe4\x7a\x9a\x8d\xf3\x71\x2d\xc5\x35\xad\xea\x6b\x31\xe4\x3d\xe6\xab\xdb\xab\x3b\x11\x72\x89\x6b\xa3\x73\x50\x65\xe3\x15\xb6\xd5\x4b\x88\xf7\x04\xc2\x44\xdc\xe5\x81\xba\x21\x15\x5b\x76\x32\xb6\x66\x9f\x61\x3a\x36\x85\xd6\x91\xdf\x5b\xdb\xda\xf6\xd0\xdc\x48\xab\x56\x55\x0c\x5f\x39\xde\x0b\xef\xd5\x12\x5d\x90\x07\xb8\x1f\xa8\x2e\xb4\x09\x15\xb4\x0e\x69\x96\x0b\x01\x5c\x85\xee\x56\x36\x65\x4e\x87\xd9\x97\xab\x90\x79\xb7\x1a\xd0\x8d\x8e\x7d\x1c\x88\x69\x5f\x5e\x31\xfe\xf7\xdc\x58\x23\xc7\xdf\x7e\xb0\x72\x83\xe1\xae\xa2\xad\x1b\xc0\x6e\xe9\x7e\x39\x22\xdd\x8b\xab\x7e\x23\x6c\x46\xee\xba\x25\x54\xad\x30\xd6\xee\x9d\x26\x32\xa9\x74\x60\xae\x95\x4c\xc5\x2e\xcf\xeb\xe1\x17\xa3\x11\x9a\x81\x6f\x0c\xb7\x09\x40\x15\xa8\x20\xc3\x3b\x71\xe7\xc5\x3e\xaa\x5c\x09\x9b\x88\x46\x12\x23\x8f\xa5\xeb\x64\x2e\x8b\x2f\x8e\x45\x08\xc5\xd5\x02\xe4\x1b\x1a\x71\x34\xb8\xb0\x70\x64\xaf\xa5\xa4\x1c\x9c\xd0\x9c\x82\xaa\x28\x89\x1c\xb3\x13\x71\x82\x83\xa5\xcc\xc6\xb9\x97\xac\x1b\xb5\x1b\x4a\xa3\xd8\xc8\x8f\x0e\x42\x6b\xc0\x16\xbb\x2b\xae\x9f\xf9\x52\xbc\xc0\xda\x15\xa0\x31\xdc\xca\x87\x42\x2f\x41\x63\x33\xfc\xc9\xd1\xb6\xbf\x4e\x63\xd3\xdd\xe8\x4a\x71\x3d\x25\x37\x94\x13\x72\x13\x5a\xf3\x97\x3f\xca\x07\xad\x20\x93\xce\xf6\x8c\xa3\xa8\x44\xda\x62\x64\xcd\xa7\x23\x0f\xaa\x6b\x3c\xe5\x9e\x0e\xa4\x6b\x8a\xa4\x05\xec\x06\x6a\xe4\x4e\x4e\xe1\xe7\x3c\x6c\xdb\xa9\x49\x6b\xb5\xa3\x5d\xa8\x41\xd5\x40\x1a\x68\x3e\x2a\x02\xd5\x4b\x12\x50\x68\x9d\x26\x2f\x75\x17\xd0\x21\xa6\x18\x11\x4b\xfe\x36\x97\x11\xcb\xc0\x6d\x70\xc1\xd0\x40\xd7\xaf\x0b\xe5\xca\x6a\x7f\xc4\xa8\x15\xc8\xef\x67\x75\xe7\xca\x5a\xe4\xa5\x4e\xfa\x0d\x71\x76\x56\x0f\x33\x16\xd8\x8d\x50\x53\xec\x73\xee\xf6\xdf\x74\xfc\x54\x4d\x80\xc3\xac\x5d\xfe\xfd\xca\x53\x57\x9d\x8d\x0d\x28\xa5\xf0\x04\x1d\x9a\xb5\x29\x99\x23\x15\x84\x90\x87\x88\x6f\x47\x55\x2a\x02\x0e\x2e\xf2\xc3\xdc\x7e\x70\xf8\x9e\x4c\x89\xc5\x1d\x0b\xcf\xe1\x43\x2e\xd3\x2b\x79\xc8\x51\x36\x52\xcc\x50\xa5\xd5\x60\x15\x2c\xbb\xab\x28\x1a\x04\x5f\x73\xbb\xc3\x81\x50\x79\xc0\xde\x6f\x74\xf4\xa0\x19\x4b\x24\xd1\x82\xfd\x3f\x0e\x92\x3e\xf8\xe1\xbd\xf4\x93\x03\x8e\x58\x83\x29\xa5\x10\x5b\x15\xb4\x46\xcc\xfc\x0e\x1b\x2b\x09\x72\x06\x39\x85\x40\xb6\x18\x61\x2c\xd7\x34\x77\x56\xb8\xa2\xa5\xc2\x47\xcc\xd8\x9d\xe4\x49\xd5\xae\xdd\x7a\xf1\xb1\x95\xda\x73\xd1\xbf\x3c\xb9\x38\x77\x35\x4f\xe3\x5f\x7b\xe7\x8e\x77\x07\xc7\xa2\x7b\x74\x76\x72\xee\x7a\x7b\x70\xdc\x3d\x3f\x19\x76\x09\x03\x3d\x78\x32\xbc\x1c\x74\x2f\x2f\x06\x35\xf0\xae\x8e\x4e\xf0\x81\x26\x10\xd5\xa3\x4e\x58\x67\xdd\xf3\xee\x71\xaf\x11\x2c\xfd\xa8\x0b\x96\x93\x41\x16\x10\x27\x9b\x9c\xa1\xda\xf6\xcd\xc4\xf9\xae\xca\x02\xe1\x3a\x1d\x89\x1d\x03\x6e\xf9\x30\x1b\x20\x60\x1f\x24\x9e\x4f\x9e\x15\xc5\x2b\xc3\x74\xfe\xf4\x4b\xe0\xd8\xc2\x17\xe5\x96\xc7\x5e\x80\x2d\x26\x1f\xb8\xe6\x85\x6b\xb1\xba\x2d\x90\x3e\xe5\x8a\xa3\xe3\x32\xc9\x4b\x5b\x34\x44\x5d\xac\xb7\x41\x49\x68\xfc\x37\x1b\x81\x31\x6c\x69\x23\x7a\x4a\x85\x36\xd8\xb9\x41\x81\xf3\xca\x5c\x3a\xf1\x62\xb4\xf6\xe6\xcf\x6a\xf7\xf7\x46\x84\xbb\x64\x5c\x2b\x22\x1d\xf2\x04\xde\x71\x39\x0a\x6d\xf0\x8e\x6a\x60\x17\xeb\xf3\x5f\x1a\x2c\x58\x8e\x20\x94\xa6\xce\xcc\x84\x43\x0d\x74\xb0\xa6\x09\xb4\x72\x05\x9a\x72\x7d\x97\x85\xd0\x9e\xff\xdb\x42\x90\xe6\x9d\x15\x37\x65\xf9\xc1\x47\xce\x55\xe4\x22\xc7\x64\x57\xee\x9a\x2a\x55\x74\x84\x4b\x65\xb5\x22\x51\xc7\x54\xc2\x71\x50\x0a\xab\xa4\x68\x35\xde\xf3\x70\xb4\xfb\x71\x14\x52\x3b\x36\x6f\x8a\x76\x8a\x52\x8c\xe6\x32\x90\xee\x68\xa5\x73\x99\x25\x15\x41\x07\x56\xa6\x88\x56\xd1\x4a\xa4\xef\x51\x4c\x2a\x66\xf6\x60\x64\x13\x85\x73\xc6\xaa\xc0\x23\x45\x74\x02\xb9\x23\xab\x27\x22\xae\xd9\xea\xd1\xf6\x3d\x7f\x52\x0c\x3c\x74\xe6\x0f\xe3\x89\x97\xc7\x3d\x2e\xc9\x5f\xe6\x02\x9a\x24\x9c\xd0\x8e\x09\xe9\xd4\x10\x9c\x8a\x18\xc1\x7c\x73\xd0\x21\x3a\xa3\x73\x2b\x89\x61\xa0\x56\x69\x58\xa3\x74\xcd\xbd\x49\x74\x47\xfd\x9e\xe0\x12\x6f\xc8\x04\x9c\x5b\xb2\x54\x1e\x87\x53\xdb\xc4\x30\x01\x1d\xc3\xba\xf9\x28\x2c\x45\xfc\x59\x46\xb1\x56\x69\x6e\x36\x8c\x1a\x4f\x7c\xbd\x0f\x5e\xbf\x8c\x57\x2f\x93\x84\x90\x4b\xd0\x85\x97\x82\xd8\xad\x07\x4c\xc3\x5a\xc6\x4f\xbf\x4e\x29\x38\x86\x63\x44\x95\x79\xfe\xdf\xe9\xf0\x01\x05\xca\x5f\x2c\x28\xcc\x58\xba\xd7\x29\xc8\x8b\x62\x3b\xda\x6a\xb4\x87\x70\x30\xcb\x1f\x53\x16\x30\xe4\xf5\xd4\x3d\x9c\xe1\xd4\xc6\x50\xd2\x94\x42\x4f\xc6\x73\x98\x80\x31\x95\x4b\xa0\xf6\xcd\x5c\x70\x0b\x7e\xa7\xec\x4f\x93\x7b\x11\x78\xc9\x5c\xbc\x79\xfb\xd5\xbe\xb8\x8c\x3d\x9f\xea\xf6\xd1\x77\xe8\xa3\xc0\xb8\xeb\x11\x86\x4c\xc6\x3e\xcc\x04\x5c\x7e\x47\x59\xaa\x3b\x44\x27\xf0\x61\x2c\x61\x01\x4e\xb8\xbb\xaf\x27\xd2\xc2\xfb\xfc\x36\xb1\xcf\x71\x76\xf4\x75\x5d\xb0\xe5\x32\x17\x87\x94\xcc\x8c\xb5\xc2\x1e\x7d\xf6\xa9\x69\xe1\x84\xea\x08\xf9\x6f\x72\x61\xd5\x5c\x88\x62\x94\xa6\x1d\x00\x4b\x27\xae\xa9\xe9\xf5\xf9\xa4\xcf\xd5\x17\xc9\x91\x7a\x12\xce\xbd\x20\xe5\xe0\xa6\xd2\x7b\x09\x88\xb9\xda\xa1\x14\x86\xa1\x47\xb0\x8e\xb8\x0a\xc2\x2c\x9a\xea\x11\xae\x89\x0a\x36\x38\x74\xb4\x6e\x0d\xb4\xd6\x3d\x94\x1d\xb0\xa8\xed\x27\xf6\x89\x4d\x7c\x3c\x1a\x04\x95\x9a\xe2\x83\x10\x16\xe3\x02\x77\xc5\xfd\x5c\x72\x88\xb3\xea\xfe\xac\x62\xa2\x03\xad\xe5\xa9\x56\xbb\x0e\xbc\xef\x55\x2a\xb0\x89\x66\x87\xff\x60\xc2\x8e\xda\x6d\x66\x23\x7a\x59\x42\x62\x86\x5d\xb8\x4a\x82\xec\x89\x68\x24\x72\x63\xb7\x0e\x90\xb6\xb4\x31\xf7\x41\x82\x8e\xf7\x92\x4e\xa8\xf7\xab\x2b\x96\xc0\x35\x2f\x08\x8a\xde\xd7\x01\x8e\x4e\xf7\x7d\x49\x0f\xab\x21\x2d\x7f\xd5\x0a\x0d\xc8\x1b\xfc\xd6\x59\x67\xdc\xef\x83\xda\x01\xfb\xae\x14\x31\xae\x12\xa2\xda\xd2\x82\x96\xf2\x30\xaa\x08\x97\xc3\x85\xcc\xb1\x74\xad\xe9\xc3\x9b\x0a\x8b\x5a\xd8\xce\x26\x0e\x6e\xb2\x9a\xcf\xef\x26\xf6\xa0\x12\x72\xbb\x45\x4f\xb1\x41\xf9\xb5\x80\x1b\xe5\xc3\xc9\x9a\xfa\xe3\x2c\xf0\xe2\x26\x99\xde\x1c\x9e\xb3\xc7\x71\x1e\x7a\x69\x8f\x24\x9d\x1c\x69\xc9\x6f\x85\xd9\x89\x12\x36\x34\xe7\xc3\xbb\x68\xa2\xac\x82\xf1\x3c\x8a\x92\x3c\xa9\x00\x4f\x02\xdc\x5e\x18\x28\x83\x9f\xf7\xc5\xbb\x08\xcf\x1d\xf6\x33\xc7\x92\xd6\xf6\x12\xf7\x69\x9a\xb2\x3c\x18\x71\x4f\x55\x69\x32\x18\x12\x0c\xb7\x53\xb9\x39\xae\xbb\x05\x67\x14\xe8\x32\x2b\x85\x8c\x82\x47\x60\x08\x69\x6c\x24\xeb\x78\x61\x99\xef\x60\xcf\x62\x9f\x68\x54\x4e\xd9\xf5\x3d\x81\x0d\x82\xe3\xe4\xe7\xb8\x4e\x82\xaa\xfc\xbd\x48\xb0\x3a\x43\xa8\x33\x73\x72\xe5\x62\x4d\xff\x66\xc5\x18\x36\x00\x09\x6f\xe6\x39\x73\xe5\x78\x14\x8b\x3c\xbd\x2d\xe1\x34\x10\x4c\xf0\x11\x9e\xeb\x4e\x54\xaa\x8a\xc9\x71\x87\x68\x44\xb6\x52\x5c\xec\xf5\x60\x57\xc4\x6c\x75\xd7\xae\x2c\x68\x69\x59\x87\xfd\x10\x4e\x37\x38\xcc\x46\xab\x51\x3a\x45\x9b\xe0\x1e\x3d\xb0\x72\x59\x37\x57\x75\x37\x27\xe9\x4a\x53\x13\xfc\xa9\x4b\x28\xb8\x83\x18\x15\x0c\x95\x45\xaa\x18\x82\x62\x01\xf3\x50\xd7\x40\x3d\xb1\x5f\xc2\xeb\xc0\x28\x8e\xdc\x29\x6b\x0a\x13\x25\xd4\x98\x8a\xc2\x95\x37\xe6\x06\x83\x59\x81\x50\x71\x67\x6e\x4f\x06\x66\xc3\x28\x7b\x07\x85\xb6\x6d\x42\x08\xe7\xfe\x18\x9b\x87\x32\x5b\x3a\xcf\x34\x53\x20\x83\x28\x9a\x88\xeb\x57\x85\xd4\xc0\xeb\x57\x25\x0b\x8c\x49\x57\x42\x47\x88\x0a\x67\xa6\x57\x5d\xa2\x60\xb5\x8a\x06\x45\x90\xe1\xcd\x8e\x53\x8a\x56\x31\x56\x1a\x6d\x74\x9a\x52\xd1\x45\xa2\x4b\x52\x71\x20\x34\x01\x5c\xb3\x5a\x95\xfe\x0a\x43\x55\xe7\xd1\xc8\x0f\x3d\xcc\x7e\x30\xf9\x74\x78\xa8\x3f\xc0\xf5\x56\x5c\x0c\x0f\x5c\xb9\x62\x47\x1e\x87\xe5\xa8\x12\xec\xd2\x5c\xc0\x55\x65\x24\x95\xf1\xa7\xce\xa6\x77\x7e\xf8\xf4\x4b\xcc\xb9\x59\x5c\xf1\x71\x1e\x97\xca\x9d\x1c\xd4\x53\x5d\x9e\xe5\x42\x4a\x5b\x16\xfa\x3a\x73\x7b\xcd\x2c\x38\x56\x8b\x9d\xe5\x36\x91\x56\x46\xb7\x53\xc4\x55\x12\x75\x07\x5f\x80\x54\x49\x7c\xac\x32\x57\x24\x71\x63\x02\x3f\x15\x60\xae\x92\x6b\x13\xeb\x62\x61\x8c\x21\x85\x18\xe2\xac\xe6\x1e\x44\x9d\x37\x0b\x23\x38\x5a\xc7\xa4\x7c\x24\xe9\xc4\x9d\xdd\x8c\x71\x84\xdd\x90\xe7\x19\xef\xa7\xea\x5d\x2a\xda\xa3\x8d\x33\x1e\xd7\x0d\x13\x93\x38\x1b\xdf\x3a\x37\x3e\x91\x81\x95\xf0\xe0\x1a\x46\x06\xc5\xa9\x8a\x1a\xc4\x63\xa8\x74\x05\x2a\xdd\x78\x3c\x93\x24\x6f\x2e\x45\x2a\x3f\x50\x5b\x19\x22\x3e\x58\x8e\x7a\x5d\x31\xf2\x90\x08\x97\xf0\xec\x51\x85\x47\x0c\x93\xa7\x7d\x48\x97\x0c\xae\xc0\xc0\x49\x05\x2b\xd7\x11\xdc\x6a\x7c\x29\x52\xf7\x25\xa3\x94\x84\xaa\x1c\x72\x83\x61\x23\x6d\x77\x3c\x8d\xae\x1d\xe5\x53\xff\x80\x84\x64\x39\xfa\x44\x9d\xf6\xab\x15\x88\xc8\x8e\x63\x0e\xf5\xc5\x6c\x97\x7b\x8f\x7b\xd8\xa4\x7c\xb8\x3b\xe5\xb9\x8d\x11\xa3\xa2\x8f\x23\xa5\x7d\xa9\xc3\x10\x61\x99\x9c\x4f\x5a\x79\x2e\x7a\x22\x10\x1b\x98\x93\xbd\x80\x23\x1f\xf3\xef\xa2\xfb\x30\x88\x3c\xf4\xdf\x29\xe1\x82\xc7\xbe\x5c\x58\x37\x56\xa7\x60\xd1\xc0\x46\xd2\x5f\x88\x5e\x98\x4e\x51\xdd\x60\xbb\xd7\x1c\x17\x20\x06\xfe\x48\x2a\x6f\x87\x27\xbd\x25\x57\xfc\xe2\xd4\xbd\x46\x7c\xaf\x9d\x52\x05\x0e\x4a\x0a\x90\xa6\x1b\x19\x25\xc9\x82\xca\x8a\x6e\x61\x2f\x38\x10\xff\x2b\xc1\x62\xa2\x94\xc0\x85\x3a\x8b\x8b\x7d\x58\xee\x21\x8e\x1e\x25\x46\x46\xf2\xc6\x9c\x64\x31\x4a\x10\x0f\x7d\xc1\xc1\x8c\xf5\x70\x82\x49\xde\x40\x38\x85\x10\x36\x08\x3e\xfa\x4c\xcb\xcf\x49\x1e\x15\x4d\xac\xaa\xa0\x98\xc7\xd8\xe6\x95\x4f\xb9\x64\x04\x17\x41\x64\x23\x3d\xa8\x77\x21\x16\x63\x4c\xb2\x25\xd6\x9a\xc0\xe8\x4b\xa5\x97\xd1\x2c\xc1\x53\x5c\x72\x30\x45\xc9\x8f\xab\xc4\x25\x97\x7a\x58\xdc\x3b\x19\xcf\xbd\x69\x5a\x49\x8d\x49\xb5\x35\x09\xb1\x79\x5e\xad\xae\x2d\xa1\x08\xbb\xf7\x63\x5d\x65\x1b\x8b\x4c\x08\x9a\xcc\x24\x7d\xfa\x35\x7d\x34\xe5\xc9\xa5\x99\x71\x3a\xdd\x12\x5d\xc3\x90\x73\xf1\xf5\x97\xac\x82\xba\xe5\x1d\x69\x9e\xae\x2c\x23\xc7\x4b\x59\xac\x7c\xde\xe6\x22\x5a\x8c\x42\x71\x17\x56\x20\x7d\x33\xf4\x67\x2a\x61\x69\x58\x07\xa1\x29\xee\xc2\x25\x78\x13\xd4\x2b\x00\x1c\x98\x13\x34\x5d\xe9\x76\x4b\x18\x03\x84\x45\xfd\x75\x94\x2e\x65\x6c\xb1\xe2\xa3\x0a\xf3\xd4\xa4\xea\x50\x60\x30\x49\xcc\xa1\x2a\xee\xaf\xb4\xed\x84\x4b\x4c\xb2\xfb\x4b\x97\x8e\x87\xbd\x03\xb8\x3b\xa6\x2a\x24\x21\x62\xcf\xbd\x52\x78\x18\x20\xa9\x11\x80\x6d\xe6\x94\x86\x3c\x04\x2c\x52\x11\xb0\x59\xec\x0d\x19\xe4\x60\x2c\xf8\x2f\x9f\x37\x7a\xab\x7c\x75\xe0\x2c\x9f\xd9\x53\xa6\x94\x47\x19\x28\xd4\x4e\x52\x2d\x9a\xc4\x1b\x7c\x8a\x46\x1d\xcd\x29\xa5\xc1\x42\x54\x49\x2f\xd5\x43\x17\x47\xe4\xf0\xd7\xae\x27\xfa\xae\x8d\xc3\xaf\xb2\xde\x55\x32\x71\x02\x6d\xe1\x06\x64\xfa\x70\xe6\x29\x4c\x46\xe7\x90\xc0\x12\x01\x35\x46\x57\x14\xc0\xe8\xd6\x37\xf2\x47\x5d\x4b\x8f\x3c\xf9\x11\x95\xd7\x45\xa7\x4a\x86\xf6\x43\xea\x36\x86\x10\xc8\x64\x1e\x4d\x8d\x23\x88\x8a\x7a\xb9\x72\x1d\x2b\x07\xa6\x92\x39\x51\xd1\x96\xc6\x1a\x9e\x96\x0b\xbe\xe5\x81\x3a\xea\x02\x2c\x92\x28\x08\xc4\x1b\x2f\x03\x80\x31\xd7\xa3\xa0\x2c\x7a\x71\xb1\x54\x2f\x68\x03\x28\x25\xd4\x67\x94\x39\x1e\x1b\xa5\x66\xe6\x2a\x71\x3f\x8f\x5d\x19\xb1\x8d\x78\xc7\x97\xe1\x97\xe7\xde\xa2\xcc\x3d\x7d\x4f\xae\x67\xdc\xde\x0b\x72\xae\xb4\x6a\x1b\xdd\x4a\xab\x3b\x11\x54\xac\xff\x46\xb7\xd3\x41\xef\x8f\x57\xbd\xe1\xa5\xcb\xa9\xdb\x3d\x7f\x7f\x31\x38\xea\x0d\xae\xce\x8f\x1d\x3e\xdd\x41\x6f\xd8\xbf\x38\x1f\x3a\xf3\x47\xbb\xe7\x97\xdf\x5d\x0c\x2e\x5d\x6f\x5f\x9c\xf6\x86\x6e\x19\x05\x3f\x9f\xf6\xce\x9d\xa2\x65\x70\x71\x75\xd9\x73\x05\x4e\xd0\x8f\x8e\x80\x89\x01\x48\x9c\x0e\x95\x23\xc9\x13\xc7\x70\x8b\xfb\xa0\xf7\x93\x9a\x80\xd7\xd3\xb8\xa6\xf6\xf0\x29\x2c\x0e\xab\x64\x58\x61\x63\x26\xbe\xaa\xe3\xce\xd1\xe0\x78\xa0\xc3\xfa\x81\xc5\x87\xf3\xe1\xae\x2d\x0c\x34\xe1\xc5\x69\x22\xd1\xbd\x0a\xd4\x2c\x61\xda\xa4\x2a\xcf\x9d\xfc\x03\x6b\x22\x8b\xa5\xbb\xd6\xfd\x30\x22\xb3\x10\xd5\x3f\x26\x6d\x5f\x45\x77\x83\x16\x72\x4b\xe5\x36\x41\x8d\x7c\xfa\x5b\x82\x6b\x82\x57\x7d\x01\x66\x03\x92\x94\xdd\xfb\x0c\x84\x7f\xc0\x5d\x23\xcc\x9f\x5a\x94\x63\x86\x06\x10\xf0\x80\x76\xaf\x19\x6e\xe8\x68\xec\x7b\x5a\xad\x04\x15\xec\x1f\x6a\x68\x5f\x03\x9b\x12\xd6\xd0\x0d\x8c\xbb\x77\xfe\xf4\xb7\x98\x94\x80\x1e\xa8\xce\xd8\xd2\xac\x66\x94\x3b\x19\xda\x16\x84\x6f\x48\x99\x32\x90\x57\x04\x09\x17\x6a\xbb\x73\xea\xf9\x52\xd9\xcb\x2f\x82\xc9\xaa\xc9\x1c\xd6\x36\xe6\xbc\xc9\xfb\x95\x9f\xfe\xe1\x3a\xfb\xfa\xeb\xdf\x3b\xeb\x2d\xaa\xb1\xd5\xa2\x37\xa3\xe3\xfe\x5d\x35\x64\xe0\x36\x71\xd0\xa1\x0d\xf9\x86\x33\x8a\xae\x3a\xfe\x2c\x41\x87\x5c\x4d\xc5\x5f\x55\x42\x99\x41\x87\x41\x94\x4d\xc4\x7b\xbc\x49\xc4\x0f\xb5\x93\x89\x67\xc7\x6a\x9c\x76\x09\xa6\x19\x35\x1c\x5b\x05\xd0\x2d\x27\xb9\x38\x08\x1d\xcd\x5d\x91\xd3\xd9\x72\x0c\x5e\x52\x0a\xf7\x5e\x05\xb9\x83\x21\x28\x77\xb0\x6f\xf5\xec\x1a\x73\xab\x2d\xcc\xb0\x67\xa2\x1d\x64\xd6\xb4\xe8\x82\x6b\xec\xd4\x0b\xb5\x86\xef\xc4\x9d\xc1\x3d\xfe\x4e\x02\x0f\xd5\xfd\x2e\x2f\x23\xca\x95\xe5\x7d\xec\x4b\x4a\x2d\xa6\x92\x0a\xf6\x51\x7f\x8e\x11\x5e\x0f\xb5\xce\xbc\xf0\xa8\xfe\x9a\xf1\x76\x93\x53\xba\x98\x58\xe1\x52\xa4\x8b\x57\x38\x32\x50\xea\x8b\x09\x4a\x2d\x75\x87\x67\x8d\x03\x54\x0a\x6a\x19\x85\xf7\xd2\x5b\x1a\x03\x1a\x3f\x48\x9b\x28\x10\xc8\xfd\x40\x46\x5e\x78\xbb\xc7\x8a\xb6\x65\x92\x22\x03\xa8\xed\x45\xd4\x69\x1c\x70\xcc\xd4\x06\x4e\xd4\xb2\x2d\x2f\x34\xf6\xc5\xf9\x57\xde\x80\xbf\x35\x2e\x2a\xce\x95\xab\x4d\x3b\xc3\x12\x56\x2d\xe2\xe6\xda\xbf\x06\x85\x2a\x56\x8c\xad\xf6\x68\x12\xb8\x4a\x5c\xdd\xe5\x18\x8b\x10\x53\xa7\xbd\xbc\x96\x48\xde\x28\xa1\x21\xd6\x2c\x56\x05\xe8\x15\xd2\xb0\xe6\x26\x7c\x35\x38\xed\xb0\x6b\xdd\xaa\xb2\xd7\xef\x37\xc5\x45\x0d\x10\xac\x44\x70\x76\x86\xc1\x4a\x72\xa9\x93\xd4\xfe\xc0\x4a\xf5\x7e\x24\x0f\x16\x75\x71\x68\x8a\x33\x2c\x84\xaf\xd7\x5d\x8f\x57\x82\x94\x9a\xa3\x40\x75\xb2\xe1\xbc\xf5\xca\x39\x84\xdb\xcd\x60\x39\x8d\x02\x65\xff\x27\x2f\xb6\x8f\x92\x72\x3e\x34\x1e\x02\x51\x39\xaa\xf4\xad\x5a\x7d\x78\x74\xe0\x07\x7d\x8e\x53\x47\xa4\x43\x0e\xe1\xb8\x82\x51\xd5\xd9\x6b\x8a\x06\xcd\x8a\x48\xff\x02\x6d\x38\xe0\x72\xb6\x35\x92\xe6\x8e\x5c\x7d\x6b\x2e\x75\x65\x2a\x83\x6a\x32\xeb\xd9\x16\x17\x7a\x5a\x32\xaf\xa8\x18\x2a\xf6\x9c\xa1\x95\xc9\x90\x2c\x7e\xf1\xd7\x40\x51\x91\x63\xfc\x35\x51\xb4\x39\xcf\x90\x1f\xa5\xb6\x99\xf4\x9d\x59\x0e\x15\x64\x95\x79\x55\xa4\xcf\xe2\x56\x89\xc2\x2f\xc1\xaf\xdf\x08\x5b\x36\x1d\x7b\xc6\xea\x39\xf5\x12\xdd\xd5\xbe\x42\xec\xe1\x1a\x23\x68\x99\x13\x05\x3a\x76\xbf\x87\x8a\x24\xb5\x61\xca\x66\x43\xa8\xc1\xc2\xed\xc0\xf3\x22\x17\x6e\x81\x9a\xd7\xb6\x10\x98\x02\x03\x98\x6a\x84\xa6\x02\xdb\x4c\x5b\xb1\xf5\x3b\xad\x32\xb4\x46\xb1\xa6\xd4\x7d\xaf\x4a\x09\x6a\x8c\xa3\x26\x25\xb1\x57\x08\x18\x69\x0a\xb2\xee\xfc\xef\xa9\xda\x24\x2d\x80\xb9\x3b\x0b\xac\x9c\x84\xcd\xa0\x2a\x5b\x7d\x71\xcd\x9b\x6b\xef\x73\x6e\xc5\x2b\x43\x9e\x73\xe3\x95\x89\x78\xe6\x8d\xa8\xd8\x91\x57\x1a\xe5\xfb\xb8\xd9\x0e\x65\xee\x94\x7e\x68\x3c\xd4\x77\x6b\x10\x98\x91\x57\x20\xa8\x27\x7d\x65\x96\xca\x33\xb9\xf1\xf4\xd4\x64\xc0\x94\xe6\x69\x03\x8e\x17\xa5\x87\xe2\x4a\xc3\x11\x34\x23\xbf\x24\x74\x0a\x18\xd6\x0e\xa0\x21\xf5\x2b\x76\x82\xb2\xf5\xe8\x99\x15\xc6\xea\x21\xaf\x92\x65\xc6\xbb\xf2\xf5\xf3\x2b\x8b\x9a\x65\x7a\xb0\x68\xee\xb2\xa0\xe5\x1c\xb3\xbe\xac\xe2\xd7\x36\x8c\xb1\x46\x52\x42\x9f\x73\xa6\xf8\xa5\x9b\x2f\x2d\x87\xbf\x8c\xea\x22\x00\xf3\x4b\x6e\xe8\x8c\x01\x1c\xb0\x75\xdd\xc4\x85\x0f\x87\x1f\x38\x14\x2e\x88\xee\x39\xee\xb4\xfe\x14\xd3\xb6\xf4\x94\xa2\xbb\xe9\xed\xfc\xa6\xa4\x7d\x3c\xc1\xd3\x2f\xe8\x50\x72\xc7\x77\x3b\xa8\xe0\x16\x8b\x13\xc1\x2e\x5a\x3b\x47\x4a\xc5\x6d\x52\xb7\x85\xda\xe3\x7b\x95\xbe\xbc\x06\x6d\x5e\xbf\xd6\x80\x33\xcd\x6b\x54\x79\xb6\xb4\x9e\x66\xe6\xae\x33\xa0\xc4\xf5\x22\x47\x42\x2d\x13\x99\x4d\xa2\x4e\x9a\x3e\x10\xbb\x6b\xe3\x4d\xfb\xfc\xec\xe5\xe5\xf7\x9d\xdc\xef\xe5\x29\x0b\x8a\xf3\x3c\xc6\x04\xa2\xa6\x3a\x83\x0e\xad\x35\x75\xe9\xea\x80\x56\x9e\xf2\xcf\x76\x71\x25\xca\x30\x25\x24\xaf\x99\xf7\xe5\xae\xa7\x9c\x52\xd7\x8a\xa7\xdc\xac\xa0\x8e\xa1\x31\xc5\x38\x54\x59\xce\xb1\x96\xe1\xb4\xb0\xf4\x0b\x43\x6e\x78\x7a\x19\x16\x0e\x99\x14\xe2\xdf\xc9\xaa\x4d\x9d\x0a\x1a\xda\xc9\x82\x45\x64\x4d\x0f\x32\x0c\xae\x64\xd3\x8b\x1f\x4e\x60\xca\x26\x99\x17\x98\x18\x21\x6a\x2f\x43\x4e\x28\xc0\x99\x66\xae\x30\x83\x13\xf5\x26\x5a\xff\x4c\x1c\x4f\x87\x7a\xc5\x60\xd8\xc3\x90\xde\x15\xde\x28\xce\xa6\x6e\xd6\x1a\x42\xa8\xf7\xfc\x32\xf0\x38\xb5\xe6\xa2\x6b\xda\x05\x99\x34\x12\xd3\xd7\x11\xf3\x08\xdc\x39\xb1\xf8\x66\xe7\x92\xdf\xd4\x25\x07\x74\xa5\x7f\x31\xf4\x53\x2a\x91\xac\xa8\x52\x95\x1d\x1f\xa5\xef\x8c\x20\x71\x92\xc8\x7d\x64\x61\xde\x5f\x27\xd4\x09\x78\x5f\x88\x2e\x16\xbd\x24\xf1\xc8\x3d\xe3\xb9\x24\x1c\xf3\x01\x6e\x6d\xcb\x2c\xcf\x89\xa1\xb2\xfb\x09\x45\x60\x61\x1b\x34\x77\xe8\xe7\xf1\xd5\xc9\x91\xb2\x14\xe6\x9d\x65\x71\xe9\x56\x0d\x61\x5f\x90\xc9\x4f\x47\xfc\xea\x8e\xad\x68\xa5\xfd\x8c\xa9\xa6\x64\x1a\x9e\xe8\xa9\xc9\x2b\x32\x00\x38\xe5\xdc\x27\xcb\xf1\x24\x7e\xfa\x75\x7c\xeb\x8a\x6f\x5d\xc3\x11\x90\x30\x55\x1c\x29\x8d\x9f\x1c\xc8\x1b\x8f\xbf\x58\xa7\xac\x05\x23\xf4\x90\x93\xd2\xcd\xa9\x6a\xf4\x4e\x77\x4a\xed\xf0\x95\x6e\xd8\x80\x05\xe6\x7a\xdb\x8a\x0d\x89\xc5\x06\xad\xf0\x6d\xc6\x81\xfc\xfd\x9d\x8f\xbe\x73\x2b\x1f\x5e\x92\x03\x79\x3d\xa9\xe4\xb7\xc4\x0c\x3c\xc3\x9a\xb0\x81\x0e\xe0\xcd\x99\xa0\x5d\x19\x1b\x0f\x5d\x9f\xbb\x3b\x1c\x3a\xb6\x39\x35\x43\x77\x8f\x5c\xb7\x64\xdd\x74\xfa\x55\x8f\xd5\x4d\xa7\x9c\xd0\x6f\x32\x6a\x13\xa2\x6e\x1d\x99\x89\x7d\x66\xe2\x8f\x12\xfb\x46\xe1\x2f\x1d\xbb\x0f\xb9\x2b\x48\x86\xc2\x50\xf0\x6c\xb7\x4f\xd2\xc4\xa4\x83\xe8\xe3\x14\x06\x15\x13\xd0\xe9\xd3\x2f\x73\x0a\xeb\x78\xaf\xfb\x9b\x6b\x36\xac\xa1\xbd\x2a\x61\x78\xe3\x74\x7c\x15\xfb\x5e\x6c\xb5\xea\x4c\x57\x6f\xa6\x0c\x54\x11\xb8\x71\xa6\xbd\x45\xe0\xda\x6c\xfa\xe6\xe4\xc5\x59\x60\x35\xaf\x65\x59\x56\x2c\xb2\x58\x8e\xe7\x31\x1b\xdd\x79\x15\x9c\xc9\xc0\x6e\x63\x5b\xd5\xef\x99\xe9\xcb\x63\xf6\x2a\x82\xf4\x12\x50\xe8\x6a\x07\x40\xb7\x71\xb3\x46\x91\x7c\x5c\x4d\x58\x16\xca\x34\xca\x6f\x6e\x33\xea\xaa\x25\x37\x61\xcd\x35\x5f\xa1\xb8\x6c\xd5\x02\xf6\xe2\x5b\x55\xbc\x2a\x5f\xa9\x2d\x2c\x46\x15\x44\xc3\xab\x0a\x14\xa2\x68\x65\xe4\xaa\x20\xf8\x8e\x55\xf6\x12\xc4\x4d\x28\xdc\x6c\x67\x6d\x48\x7d\x9e\x8a\x1f\xd7\x54\x0a\xd5\x2b\x7b\x57\xc3\x59\xbf\x0f\x77\x30\x9c\xf5\x1b\xb5\xf9\x70\xb4\xb7\xe4\x43\x94\xa4\xca\xa8\x0a\x7f\x1d\x51\x09\x6d\x75\x6b\x82\xbf\x7b\x3f\x52\xbf\xce\x71\xdb\xdc\xe6\x06\xe0\xdf\xfe\xa4\x8b\x9d\xef\x04\x11\x7d\xc0\x90\x24\x8f\xa3\x5f\x47\x94\xf0\x91\xae\x66\x8e\x57\x44\xa3\x01\x71\x9b\x21\x65\x6f\x59\xa3\xe0\xf3\xd2\x3b\x2d\x62\xcb\x57\xde\x34\x08\xdb\x8c\x51\x4d\x42\xfb\x71\xaa\x12\xc3\x86\xc7\xf1\x31\xfe\x89\x45\x06\x74\x97\xba\xf6\x30\x6b\x99\x54\xc3\x06\xdc\x61\x98\x92\x77\x35\x38\xd1\x3d\x36\x4d\x8a\x8e\x9d\x9a\xad\xab\xfe\xe3\xce\xc4\x67\xbd\x2c\x8d\x30\x96\x76\x8c\x01\x73\x4e\xe3\x28\x3c\x88\xbb\xac\xd8\x0b\xb6\x83\xf8\xa8\x17\xa7\xce\xb6\x71\xa6\x76\x63\xf3\x79\x52\x4b\xfc\x22\xd6\x04\xd5\x1d\x53\x85\x90\x32\x7a\x9c\x8a\x14\x9e\x9f\xb5\x27\xa1\xeb\x3d\x96\xa6\x3d\x4b\xfc\x7c\xd2\xe2\x87\x26\xcc\xd9\x33\xd5\x25\x4c\x42\xab\x83\xfe\x81\x83\xdc\x61\xef\x10\x06\x7a\xf9\xbd\x38\x1e\x5c\x5c\xf5\x5d\xd1\x84\x27\x87\x1f\x7a\x83\x0f\xbd\x93\xcb\xe1\xf1\xe0\xaa\xdf\xef\xb9\x60\x0d\x3e\x9d\x1c\xf6\x6a\x4b\xf5\xa9\x67\x3a\xfc\x4c\x1d\x18\x57\x40\xb7\xe3\xa5\x7e\x77\x0d\xe6\x77\xbd\x41\x0f\xc6\x31\xac\xc3\xcc\x40\x6a\x2b\x03\x1a\x30\x75\x45\x01\x19\xd0\x51\xef\x53\xef\xf4\xa2\xef\x2c\x0c\xa8\x41\xf5\xce\x2f\xbf\x3b\x39\xfc\x78\xea\x2a\x0b\xc8\xd0\xea\x8b\x0c\x6a\x58\xb5\xf5\x05\x09\x90\x8b\xaf\x0a\x82\x6b\x6e\x87\x1f\x54\x5a\xd4\x46\xa6\x70\x7c\xdd\x64\x4f\xb8\x6d\xdf\x0e\xdc\xb0\xe9\x5f\xd4\xea\x3b\xbc\xf5\x82\x2f\x6b\xeb\x1d\x6a\x9d\xbb\x7e\xe7\xaf\x6a\xd2\xce\x7d\x5e\xac\x69\x0b\x84\x68\xb5\xfe\x66\xa6\x4e\x83\x46\x69\x27\x2b\x18\x2b\x41\x35\xce\x3b\x69\x40\x16\x7c\x47\x2d\xa3\x6f\x16\x6b\x9a\xb8\x35\x23\xad\x02\x9c\x83\xb2\x40\x8e\x4d\x69\x67\xf1\x06\x2e\x44\x74\x8f\xc7\xd8\x3b\x49\xc5\xaa\x92\x5b\x7f\xf9\x95\x6b\x66\xac\xde\x14\xba\x1c\xca\x1b\x55\xe5\x69\xc1\x05\x8b\x92\x25\x06\x79\x4b\x4a\x31\x12\x3d\x9f\x62\x17\x53\x8f\xae\xca\x74\x55\x97\xe1\x57\x8e\x6c\x19\x4d\x1a\xaf\xfe\xb6\x94\x15\x2d\x8c\xcf\x42\x1e\x35\x36\x24\x2e\xef\xf1\x3f\xd4\x1d\xfa\x40\x7c\xf3\xf5\xd7\xdf\xee\x89\x85\x6e\xcc\xa7\x8a\x14\xe1\x31\x6f\x05\xb8\x8e\xe4\xd8\xcb\xb8\xd0\x84\xa9\xbc\xb9\xb4\xca\x15\xba\xc3\x46\x9a\x90\xa3\xae\x5a\x4c\xcf\x1f\xbe\xfe\xfd\x0a\x81\xf8\x95\xa1\x10\x1b\x4c\xe9\xea\x38\xd8\xbd\x3f\x8a\xfd\x47\x2e\x8f\xb3\x54\xf5\xae\xe8\x22\x64\x4a\x4b\x70\x7f\x2a\xd7\xfa\x24\x42\xa6\xd4\xd1\x7c\x4f\x5d\xd1\x2c\x3a\xb8\xd5\x79\x81\x0e\xab\x2d\x21\xeb\x2a\xa1\x4e\x24\x46\xc5\x13\xfe\xf5\x67\x29\x5f\x99\x0b\x35\x29\xd0\x57\xc5\x73\xfb\x98\xa9\xe3\xdf\x29\x66\xea\x78\x73\x20\xba\x9c\x16\xe5\xe3\xe5\x25\xa4\x5e\x36\xc4\x92\x49\x44\x1c\xa1\x7a\xcf\xb0\x4c\xee\x7c\x6c\x94\x44\xb1\xde\xf2\x47\xd8\x6f\x94\x49\xe3\x27\xeb\x8a\x05\xd5\xf2\xe3\xc0\x54\x45\xa5\xc2\x1f\xfe\x8c\x0a\x3d\x20\x17\xe6\x64\xec\x62\x36\xe0\xd0\xdf\x69\x56\xa0\xf7\x83\xaa\xbe\x19\xa5\x87\xad\x61\x89\x2a\x15\x94\xb8\x54\xb6\x1a\x2e\xe0\xbd\x26\x8e\x99\xb6\x43\xf8\xe6\xe7\x9f\x8b\x0b\x86\x7f\xef\x2e\xfd\x1e\x7e\xa9\x9f\x58\x58\xad\x27\xe1\x87\x42\xaa\x4c\x6b\x66\x54\x91\x60\xaf\x95\x6a\x12\x8a\x1d\x2d\x57\x88\x70\xf2\x01\xef\x20\xe4\xa1\x62\x3f\x13\xbc\x7b\x0a\xfc\x0e\x58\x70\xea\x0c\xf3\x95\xc3\xa2\x6e\x8a\x31\xfb\x24\xc3\x56\x6a\x98\xd9\xf1\xe8\x73\x35\x8d\xb4\x1e\x7a\x55\x25\xda\x9a\xc9\x43\xa2\xf3\x68\x98\xca\x2c\xca\x35\x14\x76\x56\x5e\xdf\x80\x04\x7d\x51\xd3\x52\x8b\x24\x98\x2e\xe9\x5e\x8f\x5f\xfb\xfe\xb9\xac\x80\xc6\xbb\xbe\x5b\x7b\x3d\x41\x35\xe9\x50\xeb\xae\x7e\x6b\x73\x9f\x8a\xa5\xe1\x9a\xd3\x51\xdd\xea\xa2\xd5\x64\xad\x6d\x9c\xd1\xbc\x90\x71\x99\xc2\x83\x95\x10\xa3\x46\xa4\x54\xbc\x56\x8b\xce\xd5\x93\xa4\xa2\xcc\xe0\xd6\x86\x81\x15\x47\x52\x25\xe6\xbc\x2a\x61\x65\xe2\x5b\x35\x9f\xdb\xf1\xd8\xe4\xb5\x15\x47\x79\x1d\x5e\x9e\xf4\x0f\xc4\xc9\x14\x8b\x2f\xd1\x69\x9b\xc6\x0f\x64\xa4\x8b\x54\x62\x9c\x27\xee\xbe\x59\xc9\x8e\xdb\xa3\xc7\xa9\x0e\xaa\xb6\x13\x74\x96\x64\xf0\x5d\x27\x8c\x54\x2a\x5c\xc5\x22\x21\x52\x80\x96\xef\x30\xf3\x1b\xcf\x1a\x53\x81\x63\x8f\x0a\xd0\xdd\x7d\xd3\x29\x01\x99\x82\x96\x87\x26\x6a\xaa\x6d\xab\xdb\x37\xe2\x9b\x98\x7b\x47\x01\x03\x1d\x6a\x20\xf1\xd8\x9c\x3b\x0d\x77\xa6\xa6\xa0\xcd\x3e\x5c\x09\x9f\x6b\xb5\xed\x2a\xa2\xef\xda\xee\x33\x7b\x9f\x34\x39\x15\x6b\x81\xb9\xac\x2c\xf5\x2f\xb5\x6b\x70\x3c\xd4\x8d\x27\xad\x3c\x1a\xf2\x8d\xac\x8d\xc1\x59\xcd\x19\xb2\x82\xbf\xb0\x71\x24\x48\x70\xea\x2f\xe9\x46\xac\x6b\x1f\x60\x7c\x56\x20\xf7\x71\x8b\x9c\x5e\x1c\x76\x4f\x7b\x78\xc0\xbc\x3e\x3c\xed\x75\x07\xaf\xf7\x50\xf7\xbf\xf3\xa3\x2c\x51\x8f\xb1\xb2\x86\xe9\xcc\x6e\xc5\x4b\xd5\x2b\x60\x8a\x4e\xb9\x4c\x09\xed\x76\x38\x52\x74\xb5\x62\xee\x7d\xc9\x5b\x81\x9f\x63\xd4\x6c\x5f\x03\x75\x5c\x11\x90\x77\x29\xc4\xe5\xb0\xc7\xd5\x6e\x50\x88\xe0\x92\x90\x98\x9e\x5d\x85\xc1\x24\x97\xba\xcf\xd4\x54\x85\x9a\xdc\x50\x25\xd9\x9b\xf4\x61\xa9\xe2\x77\x50\xcd\xe4\xb2\x96\xaf\x31\x72\x8f\xfb\x13\x87\x51\x28\x5d\xbd\x82\xde\x23\xf9\xb4\x19\x57\x21\x9a\xfa\x94\x1a\x16\x7d\x26\x68\x4d\xa6\x08\x50\xdf\xf9\xf2\x3e\x2f\xde\xe8\x63\xd6\x9c\x83\x0e\xac\xb2\x88\xc6\xc8\xce\xd5\xe0\x34\x07\xce\x28\xeb\x43\x75\x0a\xa8\xe6\x79\x5f\xa2\x42\x53\xc3\x1a\xac\x91\x7d\xe7\x8b\x74\x09\xf6\x91\xba\xa3\xb6\x25\x45\x15\xc5\xb1\xd3\xf5\x28\xd6\xb5\xa7\xfe\xac\x33\xad\xbc\x37\xb8\xc8\xb4\x62\x37\x6b\x55\x99\xe1\x45\x28\xb5\x34\x14\xb6\x25\x56\x69\x32\x39\x64\xd4\xeb\x45\x7d\xf3\xc9\x0b\x32\xc9\x15\xa4\x56\x5b\x80\x3e\x9b\x0d\xa9\x38\xd0\x55\x69\x50\x22\x17\x07\xbf\x42\x6f\x55\xdb\xd1\x97\xb1\x3e\x31\x7f\xff\x5a\x55\x9d\x44\xd5\xc8\xa8\x08\x61\x6e\xe2\x18\xcb\xd9\x82\x4b\xad\x51\x11\x13\x62\xc3\xda\xb0\xe5\x06\x1e\x33\x3d\xac\x9d\xb8\x5b\xed\x81\xec\xca\xe1\xaa\x09\x7c\x76\x6f\x6b\x91\xf8\x67\xf2\xb7\xd6\x8d\x66\xa7\xce\x56\xf7\x68\x76\xe8\x6e\x1d\xce\x51\x35\xf5\xc8\xde\x81\x65\x0d\xb8\x55\xb1\x2a\x82\x5f\x97\xcc\xd4\x57\x2f\xa8\x8e\xc5\x56\x79\xad\xc2\x9a\xc6\x96\x53\x70\x40\x7a\x0b\x41\x37\x3e\x97\xf4\x05\x2a\x58\x85\x26\xec\x65\x7f\xaf\xaa\x00\xb6\xf1\xee\x3c\xd6\x44\x48\x71\x9e\x71\x3c\x29\xb2\x51\x93\x5e\x46\x87\x43\xd9\xc9\xc6\x9c\x47\xf7\x79\x2d\xb3\x62\xbc\x89\x5b\xc7\xe2\x8a\x65\xab\x56\xdf\x35\xe7\x17\xe1\x0a\x82\x52\xef\xb2\xb5\x4a\x1d\xc5\x5c\x55\xf5\x2b\x2d\x68\x75\x0d\x70\xcf\x65\xe0\xc2\xf1\xc1\x0f\xa6\x98\x1a\xb0\x16\x86\x55\x5a\x88\x29\x57\xf1\x66\x6f\xbc\x3c\xf0\x0c\x97\xaa\xec\x70\x41\x4c\x2a\x1e\xca\x05\x67\xf7\x54\xdb\x08\x3a\xc3\x61\xdd\x72\x75\x37\x94\x8a\xea\x67\xee\x02\x05\x3f\x81\xc4\xa1\xa6\xe4\xae\xaa\x5b\x27\x85\xfa\x46\x86\x0f\x3a\xf8\x4c\xb3\x42\xbc\x91\xbe\xfe\x0e\x2f\x0c\x74\x91\x8a\xac\xd6\x6f\x09\x97\x13\x65\xfc\xf8\xb3\x6e\x47\x4f\x75\x49\x8a\xe5\x72\xf7\xe8\x62\x45\x3d\xd0\x73\xdf\x26\x55\x43\x77\x14\xd8\x22\x76\xe9\x9a\x4e\x0d\x2c\xe2\x89\xaa\xfd\xb4\x76\x0a\x10\x26\x1a\x78\x12\xac\xa0\x89\x86\xeb\x26\xc0\x75\xdf\x3b\x6a\x72\xa3\x92\x97\x1b\xe0\xa2\xba\x3e\x13\x99\x7a\x7e\xa0\x56\xaa\x5d\x64\xbe\x7c\x33\x76\x96\x9f\xc0\x0b\x9a\x82\xa1\x26\x2b\xaf\xe9\xba\x52\x29\xa6\x01\x59\xac\x1e\xd4\x30\xb6\xba\x5c\x5f\x53\x0e\x63\xa3\x91\x90\x0a\xa2\xab\x1e\xee\xce\x22\x5c\xe9\x63\x4a\xdb\xaf\x63\xf5\x6c\x6f\x80\x60\xc5\xb4\x52\x33\x94\xa2\x49\x04\x1f\x4c\xda\xa0\x40\x83\xcf\x7a\xe8\xb9\x8d\xa6\x29\x8f\x54\x80\xad\x1b\xb2\x8e\xa0\x6d\x07\x70\xed\xcc\x6a\xb0\x95\x25\xef\x5a\x22\x6b\xb2\x8b\x34\xbe\xcd\x36\x10\x8a\x37\x93\x63\x41\x97\x64\xce\x6b\x79\x99\x9b\x80\x96\xe7\xa5\x50\x52\xe5\x64\xc6\x33\xf6\x8b\x79\x99\x15\x6f\x56\x73\x3a\x76\x73\x55\x6a\x14\x29\xa7\xb9\x83\x4c\x70\xa5\x72\xbc\x78\x25\x83\xe1\xad\xbf\x54\x95\x28\x75\x2e\x32\x39\x27\xd3\xa8\xae\x82\x0b\xa7\xc7\xc9\xb0\x42\xbf\x53\xb5\x5c\xa8\x02\xa0\x5a\xc2\xdc\xf8\x4c\xb9\x59\x6b\xc8\x98\x47\x49\x4a\x02\x84\xea\x6b\xd5\x65\xea\x61\xa8\x5e\x2e\x43\x8a\xfd\xa9\x9a\x62\x2b\xf4\xc3\x52\xda\x3a\x06\x50\xe9\xbb\xfe\xbe\xc0\x76\xab\x20\x9b\xa3\xc5\x02\xeb\x39\x4f\xfe\x47\x3b\x83\x5a\x7d\x3e\xa7\x74\x76\x3b\xa4\x17\xc5\x4e\xaa\xc8\xd6\x0b\xaf\x9d\x54\x93\xb5\xa8\x5d\x13\x21\x50\x4d\x85\x33\x8c\x83\xdb\x52\x6f\xde\xa8\x53\x61\x5d\xd7\xfa\xa3\x0e\xfb\xca\xa6\x6a\xce\xf2\xf2\xbb\x6d\x39\xba\x86\x97\xae\x80\x04\xaa\xa1\xcf\xad\x79\x54\xb3\x35\x52\x88\xa9\x32\x2d\x40\x20\xcb\x2a\xfd\x44\xe1\x08\x5c\x71\x1f\xfb\x9e\xe9\xf2\xc9\xfc\x38\x7a\xb4\x55\x2d\x5b\x6c\xe8\xa8\xce\x93\xfb\x28\xa6\x8a\x67\xa6\xc4\xbb\xfb\x6e\x35\x2a\xd4\x86\xa3\x26\x5d\xc6\xe5\xc2\xf5\xf8\x63\x63\x20\xf5\x80\xaa\xf7\x70\x4d\xe1\x7b\x2c\x3d\x1b\x9a\xe6\xc4\x65\x73\x2b\x5d\x3f\x74\x09\x66\x53\x16\x3e\x3f\x6a\xba\xf1\x08\x59\x6c\x77\x8f\xd4\xf5\x70\x5d\xf2\x8f\xd4\x75\x96\x76\x2f\x7b\xab\xf8\x9c\xe5\xad\x3e\xd4\x15\x1e\x2f\x36\x5f\xf4\x0e\xa1\x8c\x15\x1b\x84\x66\xae\x33\x40\xb8\xe3\xb5\xd6\xa7\xfa\xe2\xa1\x58\x9b\xde\xab\x60\xc0\x63\xd8\x5f\x3a\xca\xd2\xeb\x50\x39\xdb\xba\x56\x0c\x1f\xb9\xd0\x46\x9c\xf8\x23\xed\x9e\x12\xb1\x3f\x83\xf5\x86\x66\xf1\x7d\x72\x6d\xc3\x2e\xc7\x03\x61\x8e\x9e\x83\x71\x34\xd1\xa6\x1d\x7c\x80\xfb\xe3\xe3\x5f\xff\xff\xfe\xc5\xe0\xb2\xd2\xac\xe3\xda\x17\x9f\x61\x69\x06\x3e\x9a\x12\xa8\xf7\x81\xce\x12\x56\xa1\x82\xcb\xa5\x21\xfa\xc8\xb7\xd2\xe6\x91\xec\x44\xb5\x6d\x58\x08\x8a\x74\x20\x2d\xa2\x0f\xd4\xe8\xda\x91\x09\x8b\x16\x50\xc2\xb1\x2d\x78\xb1\x93\x37\x45\xf8\xae\x18\x65\x99\x7a\x0f\x95\xfc\x34\xa5\xa2\x80\x04\x8f\x64\x00\x1c\xdd\x38\x6a\x59\x13\x4d\x43\xfc\xce\xc2\xbc\x03\x8a\xa1\x3d\x4b\xca\x6d\xfd\x49\x0c\x2d\xa2\x58\xda\x97\x79\xf7\x2a\x8a\xb5\xa7\xcd\x6a\x82\x72\x6d\x1c\x96\x15\x5d\xca\x0d\x22\x6a\x86\x77\x4f\x11\xd1\x18\xa2\x60\xdf\xd9\xa9\xc7\x26\x5a\xcb\xea\x87\x24\x27\xec\xb7\xe3\xcf\x4e\x67\xdd\x31\x67\x93\xcb\xb4\xf4\xb4\x1b\xf0\xcb\x06\x75\xaa\x85\x35\x91\x5f\xc8\xa8\x8e\xf8\xb3\xa5\x8e\x8a\xda\x63\xb7\x75\x24\xc2\x0c\xf3\xac\x22\x2c\x81\xce\x5f\x68\xb7\x1f\x67\xfb\xab\xc7\xeb\x06\x35\xa2\xf0\x26\x6e\x62\x72\x8e\xd0\x8c\x43\x87\xe6\x5e\x05\xf0\xe5\x47\x0b\x6d\x9a\xbc\x8b\x4d\xf2\xff\x32\xf7\x6d\xcb\x6d\x1c\x49\xda\xf7\xff\x53\x74\xfc\x11\x13\xf2\xc6\x12\x1c\xcb\x31\x57\xf2\xc5\x04\xc4\x93\x38\xa6\x28\x2e\x49\xd0\xb1\xb2\x1c\x9a\x06\xd1\x04\x7b\x08\x74\x63\xfa\x40\x9a\x9c\xd0\xdd\x3e\x8a\x9f\xc1\x57\x7b\xa7\x17\xdb\x3c\xd5\xa1\x0f\x59\x68\x40\xa2\x3d\xb1\xb1\x13\x16\xd1\x95\x95\x55\x5d\x9d\x95\x95\xf5\xe5\x97\x4e\x06\xc2\x4c\x10\xdc\xf7\x54\xf3\x9d\xb5\x3a\x12\xb5\x64\x1f\x7b\xed\x7a\xbb\xba\x34\xab\xa3\xda\x34\x51\xe4\xa2\xca\x57\x03\xc9\x0f\x4a\x78\x74\xa5\xab\x0f\x3f\xfe\xce\x4b\x8f\xd4\xf9\xe3\x96\x1e\xed\x7b\x23\x01\x58\xcd\xb4\xcd\xea\x2a\x07\xf3\xcb\x3b\xa8\x02\x37\x52\x1c\x2c\x34\x71\x2a\x47\x3a\x59\x28\x8d\xed\x9c\x5b\xc2\xbf\x27\x68\x20\xf7\x0e\x3f\x9e\x8e\xdf\x1e\x88\x9b\x35\xc2\x93\xd6\xc8\xe0\xa7\x46\x26\xfd\x9c\xeb\x9f\xde\x71\xdc\xc0\xfe\x6c\x22\x2d\xa5\x57\xd0\x0b\x1e\xdc\x3b\x24\x67\x23\xac\x1a\xfc\xd2\x32\xa0\x83\x14\xa1\x8f\x6b\x08\x48\xcb\x02\x6a\xe4\x34\xbb\x77\x38\x22\xef\x43\x6a\x86\x4d\x63\x22\x9b\x5d\x62\x2d\x53\x15\x63\x46\xbb\xc8\x9e\xd4\x27\xa1\x1a\xbb\x84\x49\x85\x7d\xfc\x91\x71\x97\x52\xab\xc4\x5c\x13\x79\x27\x01\x2c\x26\x53\xa5\x94\xcb\xf9\x48\xf8\x1a\xa9\xff\xad\x03\x04\x78\x53\xf9\xfc\x3f\xae\x7c\xc9\x3c\xa1\xd2\x09\xe8\x35\x82\xf7\x64\x20\x01\x5e\xcd\x12\xa9\x4a\x3d\x76\x15\xff\x1b\x05\x14\x24\xc3\x66\x6e\xb6\x08\x06\xba\x85\x47\xeb\x21\x82\xa6\xc9\x2d\x62\x5f\x63\x70\x39\x8b\xe4\x81\xd8\x62\x89\x9d\xff\x9f\x75\x5a\x10\xd7\xc7\x9b\xcb\xcb\x33\x84\xda\xfd\xf2\xb8\xc3\x27\x58\x4e\xd9\xbe\xad\xaa\x55\xf9\x91\xfe\xde\x7f\xd5\x44\x28\xd5\x02\x3d\x77\x98\x47\xb0\x79\xbb\xd1\xc1\xa2\x4c\x76\xa4\x7a\x2d\x55\x83\xcb\x92\x0a\x7d\x7c\x3c\x6f\x65\x09\xe1\x7b\x37\x4b\xc1\xa2\xb1\x9c\xe6\x62\x46\xcc\xcd\xfd\x8e\x73\x09\x6e\x98\x84\xd2\x73\x0d\xb0\x7e\x86\x1c\xe8\x82\x57\xfb\xfc\x9e\x7e\x40\x6f\xd8\xe2\xcd\xc1\x2e\xe0\x91\x8e\x6b\x69\x11\xb6\xbb\xda\x69\x15\xcf\xeb\xef\xd5\xd6\xe6\xee\x17\xf6\x54\x0b\x50\x5c\xb1\x31\x34\xcc\x89\x8c\x69\xbc\x4a\x9b\xc3\xc1\xc3\x6a\x9a\xd5\x89\xbd\x2f\x83\xfd\x08\xaf\x79\x9a\xb1\x85\xe0\x30\xbb\x3e\x4e\xa3\x17\x52\xdf\xdc\xad\x2d\xd1\x0b\xa3\x8b\xa1\xa4\x05\x32\x00\xf7\xa7\x7a\xaa\x6f\xe2\x00\x28\xba\x31\x92\xbd\x43\xdb\x45\xc3\x6c\xd3\xa8\x12\x70\xf5\x60\x08\xb4\x4c\x1a\x58\x04\x5b\x48\x08\xed\x54\x72\x73\x03\xeb\x66\xc3\xb1\xa9\xfd\xd2\x38\x79\x6c\x5e\x75\xe3\x19\x96\x74\xc7\x8d\xde\xff\x68\x63\x95\x6e\x17\x59\xdf\xf1\xaa\x11\x11\xe5\xc3\x66\x41\x08\x9d\x5a\xfe\x6b\x9c\x99\x14\x46\xb4\xb2\xcf\x3e\x25\x3d\x4a\xd8\xa4\x72\x1a\xe3\xcc\x70\xc8\x94\x9b\x4d\xd3\x31\x1d\x01\xd7\x4d\x54\xc8\x58\x4d\xba\x0e\xfe\x33\xcf\x46\x73\xe5\xff\x5e\x2b\xc2\x59\xad\xc9\x0a\x23\x0d\x96\xd6\xb1\x39\xf0\x9a\x7e\xe4\x34\x80\x75\x34\xad\xea\x08\xf5\x2e\x8c\x5f\x4b\xe0\x7e\xcb\x40\x09\x9b\x28\xc6\x3c\x62\x38\xc9\x86\x8e\x69\x97\xf1\x9c\x9d\x50\xfc\x8f\x0d\x7d\xd0\x4b\xf0\x2d\x08\x70\xe5\x5d\x50\x2d\xf2\xf9\x80\xfb\xe3\x4b\xae\x92\x8f\x4e\x58\x95\xdf\x51\xa1\xa1\x13\xd8\x31\xe5\xf2\xa2\x75\x37\xb0\xa0\x2b\xad\x2c\xb2\x0f\xc3\x43\xf0\xf7\xff\x90\xca\x8c\x30\x41\x9d\x27\xda\xf8\xc2\xf0\xad\xc8\xa5\x0f\x20\xf3\x3d\x4e\xd5\x8d\x1b\xcf\x30\xc7\x88\x82\x2d\xba\xbf\xaa\xba\x79\xa6\xbb\x3e\x5f\x7a\x48\x97\x85\xe2\x07\xab\x1d\x9a\x02\x87\x0d\xec\x8c\x9f\xba\x68\xc1\xfa\x71\xe5\xb1\xbb\xc0\xea\x4f\x7e\x21\xe7\x82\x6f\xfa\x2a\xe4\xb9\x90\x4a\x71\xf6\x9a\x50\xa2\xe2\xbe\x34\x47\x84\x81\xd8\x09\x92\xa2\x0c\x6a\x3f\xed\x3a\x4b\xa5\x41\x5a\x53\x04\xc4\x91\xc0\x1c\x93\x36\x5c\x43\x91\x39\x60\xe8\xf5\x66\x58\x75\xce\x30\xa8\x35\x39\xd3\x84\x53\x45\x4a\x64\x73\x7b\x73\x67\x19\x60\xd6\xbb\x04\xcd\x29\x9a\xf7\x2f\x53\x86\xf5\x80\x12\x79\xd0\x36\xf4\x86\x79\x51\x99\x84\x99\x6e\xa4\xfc\x81\x8b\x7f\xaa\xef\x73\xdf\xc4\x39\x03\xdd\xf8\x11\x61\x98\x0b\x53\x33\xc1\x2f\x71\xe9\xb0\xc6\xea\xdb\xa7\x34\xb1\x19\xa5\xa5\x46\x0f\xb7\xb8\x6c\x50\x53\x6b\x88\xb8\xe4\x39\xf9\x78\xb0\x26\x67\x75\xd1\xa4\xca\xc5\xac\xef\xd1\x0c\xd6\x6b\x28\x9b\x0b\x07\x73\x9e\xa4\xe0\xb2\x53\xcd\x4b\x0c\x80\xda\x98\xfa\x6b\xd7\x11\x3a\x4d\x58\x99\x9e\x3f\x70\x97\x4e\xee\x3d\x94\x14\x77\xe0\x28\xf3\x81\x81\xae\x6b\xaa\x60\xa1\xfd\x4b\x9a\x73\x74\xa1\x1c\x8d\x80\x57\x82\xde\x30\xb7\xc0\x87\xad\x1d\x7b\xa8\x82\x27\x4b\x70\x93\xed\x76\x52\xff\xeb\xa6\x20\xd1\xfc\xf3\xaf\xd9\x1c\x03\xa9\x9a\x41\x5d\xaf\x11\xd7\x7a\x53\x31\x52\xba\x46\x3d\x8c\x66\xdb\x29\x04\xd6\xe0\x19\x27\xa9\xce\xbe\x92\x56\x5f\x73\xa2\x86\x2a\x55\xa8\xf4\x14\x58\x74\xbf\x4c\x76\x25\x88\xc9\xc7\x4f\x3e\x58\xe5\x65\x85\x57\xa8\x6c\xf8\x46\x70\x00\x7b\x77\x71\x49\x47\x66\x18\x03\xfa\x08\xa3\x11\x28\x3e\xcb\x97\x23\x16\x0e\x2e\x01\xec\x45\x49\xe1\xac\x29\xff\x9d\x6a\xb1\x62\x85\xd3\x15\x95\xb3\x0c\x55\x64\xa5\x0f\x4e\xa7\xe0\x00\x63\x71\x94\x4c\x8b\xb8\x86\xa1\x46\x26\x2e\xca\xbe\x8f\x44\x7c\xa1\x97\x37\xa2\x36\xd7\xe3\x6c\xa8\x8d\xdf\x67\xf3\x98\xd4\x1c\x82\x3d\x1e\xb1\xf9\x65\x4d\xc0\xe3\xa0\x61\x91\x69\xdd\x21\x0b\x6d\xee\x13\x38\x09\x24\xcb\xcc\xd1\x97\x9a\x52\x66\x2d\x8c\x6b\xee\x6c\x75\xa7\xca\x26\x15\xd3\x55\x7d\x4d\x1f\xfc\xed\x1f\x9d\xe0\x84\x55\x2f\x66\xcc\x9b\x82\x27\x7c\x0c\x26\xa8\xe7\x7b\x55\x36\x1e\xa6\x29\xdd\xd5\x6e\x99\x66\xd3\x13\xe4\x26\xae\x8d\xd5\x4a\x65\x4b\x2d\x61\x1b\x9d\x56\x52\xfd\xdc\x40\x49\x65\xa7\x32\xe9\x98\x14\x02\x0b\x8c\x4f\x74\xa8\x72\x0c\xf3\xc0\xf9\x82\x2b\x44\xd2\xe1\x42\xd8\xd8\x6c\x2d\x7a\x42\xf0\xa7\x7c\x5b\x81\xaf\x75\x9d\x5e\xf0\xba\xee\xe1\x38\x4b\x90\x91\x9a\xdd\xa3\x99\x29\xee\xe8\x2a\xcd\xcf\xed\x45\x1d\xae\x84\x53\x5a\x2e\x74\x83\x10\x52\x19\x27\x26\x93\xd4\x50\xc9\x0d\xf6\xea\x20\xe1\x95\x0a\xba\xb4\xc8\xdb\x3b\x29\x16\xe0\xc1\xbe\xd2\x78\x7b\x5f\x63\x61\x6d\x9c\x24\xb9\x9a\x32\x18\x4c\xaf\x64\x11\x7f\xf0\x28\xaf\xb0\xf2\x22\x10\xc3\xf7\x62\x9c\x1b\x8a\x51\x5e\xed\x6e\x69\x5b\x8d\x39\x91\x34\x2f\xd0\xed\x42\xf7\x39\x5d\xa9\xde\xf3\x26\x5d\x14\xbd\x5d\xfc\x49\x09\x22\x53\xcd\x67\x81\xbf\x22\xbd\x1e\xc2\x72\x31\xf1\xba\xc8\xcb\xd2\xda\x74\xb0\x58\xfb\x98\x03\x43\x2b\xb8\xe2\x78\x59\xe1\x95\x1a\x72\x0c\x66\x5c\x57\x71\x87\x0c\x11\x3d\x46\xa1\x45\x5c\x77\x18\x1d\x16\xb7\xce\xf5\x58\x67\xf4\x69\xd1\x7d\xd6\x87\x6c\xcc\x67\xbb\xc8\x1c\xf2\xa2\x87\x38\x93\x10\xbe\xad\x27\xd8\x8f\xd4\xfd\xab\xf6\xfa\xc9\x47\x12\xb8\x2d\xdd\xed\x22\x2c\x26\xa6\x43\x41\x6b\xcb\x71\x80\xe1\x39\xc5\x1f\x2b\x1c\xb4\x2d\xc4\x7d\x42\xe9\x35\x12\x73\xb6\x02\x99\x0f\xb0\x5b\x3f\x51\x6a\x44\x4a\x59\xa1\xca\x55\x59\xa4\x38\xa5\x7c\xb6\x2d\x29\x35\xd8\x3d\x72\xc9\xa7\x71\x81\x16\xf7\x02\x23\x74\x86\x52\x07\x93\x98\xe9\x04\x6a\xee\xda\x34\x08\xf1\xc2\xe8\xb9\xfc\xfc\x1b\xd5\xc5\xfc\xab\xba\x68\xf1\x6d\x0b\x9c\x0e\xf3\xd6\xb2\x17\x95\x29\xf3\x6d\x6f\xf2\xd1\x48\xdd\x25\x8f\xa5\xba\x87\xe0\x85\xb2\xad\xc9\xe6\xca\x70\xf3\x1d\x89\xbb\x7d\x27\xce\x79\x0b\xa4\x91\x6c\x73\x75\x07\x45\xc5\xe8\x5c\x63\xb6\xcd\xdb\x98\x16\x3e\xe3\x87\xec\xa9\x87\x40\x75\x81\xdd\xad\xf4\x4e\x39\x12\x1a\x76\xdb\x1b\xc1\x77\x78\x13\x71\x94\x78\x49\x14\x04\x91\x84\x14\xa6\xb5\xce\x44\x0b\x86\xb4\x97\xef\xa0\x30\x3e\xbb\x1b\xa9\x2b\x9b\xe1\x73\x7e\x44\x4a\x2b\x41\x88\x23\x92\xe2\xb7\x86\xfa\x65\x19\x9d\x26\x35\x5f\x6b\xcd\xcc\x3e\xa0\x2f\x9b\xc6\x2d\x49\x69\x29\x59\xec\x42\x51\x46\xc7\x57\xdd\xec\xe2\x51\x55\x6f\x8a\x0d\x9b\x82\x74\x6b\x2f\xa1\xd9\xc5\x2b\xa5\x94\x77\x42\xad\x47\x8d\x7a\x71\x5a\xbf\x2b\x89\x8e\xc4\xb3\xd9\x88\x0f\x45\x23\x34\x6d\x2f\x78\x62\xe7\x78\xbd\x5e\x08\x5f\xc4\x4a\xc3\x55\x82\x94\x55\x27\x16\xd2\x16\xc8\xd1\x0f\x58\x63\x5e\x25\x39\x98\x61\xee\xa3\x08\x86\x3e\x60\x05\x2e\xa2\xb7\x60\x09\xd5\x2a\x75\x47\x09\x98\x94\xaa\x5c\x25\xf4\x3a\x42\x62\xe2\x65\x5e\x73\x91\xe6\x25\x09\x8c\xbe\x49\x76\xe7\xbb\xd1\xcb\x6f\xbf\xfb\xcb\xdb\x9d\xe8\xe5\x11\xfc\xff\xb7\x47\x1a\xcc\x63\x9f\x58\x8f\xb1\xab\x24\xba\x90\xce\x60\x6f\xaf\x9e\xa2\x6f\x9e\x76\x5f\x77\xa5\x6c\xa2\x87\xe1\x6c\x41\xb8\x09\x71\x54\x7c\x1d\xc5\x98\xa2\xd5\x52\xd2\x22\x60\x24\x7a\x02\xa7\xc1\x93\xcc\x6e\x24\x48\x87\xef\xb6\x0a\x14\x6f\x67\xc5\x33\xac\x6a\x53\xa0\xe2\x45\x88\x52\x8d\xdf\xc8\x53\x7c\xbb\xa0\xaf\x26\xc4\xb0\xd6\x96\xdb\x46\x38\x0f\xec\xa2\x09\x76\x56\x3b\x2b\x70\x92\x87\x7c\x5d\xf4\x0d\xd1\xe3\xf1\xfa\x0f\x69\x32\x1e\x3b\xaf\x56\x28\xe2\xb8\xac\xd6\x75\x9e\xdd\xa4\x73\x0a\x54\x68\x4c\x68\xe3\xb1\x17\xea\x47\xca\x37\x74\x0f\x7f\xa0\x76\x35\xfb\xd7\x25\xe1\xa3\x94\xae\xcf\x4f\xf0\x63\xe5\x88\x81\x0d\xeb\xd9\x00\xb7\xbb\x50\x23\xeb\x39\xc5\x34\x26\x30\xf8\x4b\x95\xdc\x61\x40\x2f\xb6\x50\xa6\xeb\x89\x17\x83\xed\x03\x7e\x78\x88\x61\xce\x66\xbb\xb8\x25\xc1\xa6\xef\xce\x89\x28\xc9\xc0\x77\xe8\xaa\x6b\x33\x3d\x2e\xc6\x47\x07\xda\x55\xf0\xc1\xf9\x8f\x07\xa7\xfb\x93\xd3\xa3\x40\x5b\xf5\x1e\xd9\x36\x56\xee\x8b\x27\x17\x07\xe7\x6b\xb8\xda\x4e\x27\x97\xef\xed\x43\xaa\x10\x9d\xcb\x8c\xdb\x2b\x2d\x33\x73\x3d\x2c\x65\xbf\xfb\xa2\x92\xbb\xe4\xe3\x32\xad\x8a\xea\xe6\x8e\xeb\x1b\xed\x82\xfe\x2e\xcf\xb0\x20\x35\x83\x76\x70\xcb\x26\x36\x9b\xc4\x10\xb2\xb7\xc4\xaf\xd5\x93\x6f\x3a\x71\x43\x42\x2c\x17\xb1\xcf\x48\xad\x39\xa1\x25\x62\xff\x07\x36\xf0\x15\x2c\x50\xb5\xee\x57\x69\xf4\xc2\x23\x5a\x84\xbb\x1e\x49\x32\x55\x53\xc7\x35\x6c\x26\x14\x3d\xc7\xa8\x24\x6c\xf9\x0f\xe8\x5d\x4d\x93\xa7\x7c\xee\x34\x5f\xab\xac\xb0\xbd\x60\xf5\x5f\x15\xf5\xdd\x66\x84\x69\xce\x17\x5d\x5e\x8a\xef\x30\xb0\x57\x76\xb9\x77\x24\xae\xf0\xc2\xc4\x08\x5e\x0c\xe4\x38\xb0\xfe\xf2\x3a\x3d\xe4\xe4\xef\x75\x30\x9c\x05\xc1\xd7\xb6\xa2\x08\x75\x12\xed\xed\xd1\x39\x1e\xb6\xfc\x92\xa0\xa8\x3d\x5c\x98\x9b\x1d\xe3\x5d\x27\xf9\x14\x01\xc2\x26\x40\x4b\xe1\x1a\x34\x1d\x89\x8d\xb9\xd2\x71\xcb\xfe\x4b\x5d\xe5\x26\x08\x7b\x4a\x12\xc8\x3f\x92\xc3\xe9\x14\x4f\xea\x36\xa4\xeb\x8b\x6a\xcd\xe3\x74\x9e\x30\x21\x6e\x28\xb2\xe9\x34\x5f\xc5\x45\xd9\x9e\x1a\xbe\xf2\x3d\x3b\x96\x7f\xc2\xcc\x6f\x3a\x2d\xe4\x8e\x83\x77\xc0\xd9\x2d\x52\x90\x35\x98\x3a\x6f\xcb\xdd\xe8\xc9\xca\x5e\xde\x9b\xe3\xac\x26\x10\x55\x96\xdc\x2e\x03\x43\xb5\xc9\x05\x7e\xca\x4d\x3b\xf5\x19\x75\xfc\xc2\x04\x8b\xf7\xbe\x36\x34\x90\xe6\xb0\x82\x47\x88\xb6\x42\xad\x9a\x53\xdb\x25\x57\x4c\xb2\x29\xa3\x39\x9a\x99\x9e\x43\xde\xc8\xeb\x54\x70\xea\x84\x0e\xed\xcb\xfd\x6c\x43\x18\xea\x9b\x5b\x8c\xe7\x6c\xa1\x09\x73\x9f\x57\xec\x47\x35\x29\xd0\xf1\x33\xea\x43\xda\x6c\xa9\x35\xce\x2a\xbe\x8a\xb7\x49\x26\x57\x81\x3d\x14\xe9\xfc\xe1\x75\x60\x36\xcf\x38\x42\xaf\xda\xd2\xef\x37\x42\x83\x98\xde\x6a\x88\xad\x7c\x3e\x59\x50\xb4\x25\x6c\x68\x2c\xc2\x22\x43\x17\xbd\xad\xa9\x68\x52\x29\xc9\xfa\xe4\x1b\xda\x21\xa3\xba\xc6\x5e\x17\x8b\x4d\x5d\x4c\x6a\xdc\x8b\x71\x64\x93\x12\xa8\xa7\xf7\x3c\x39\x70\x32\x56\xb6\x38\x32\x43\xbd\x69\x6f\x71\xb8\xda\xdf\x73\x43\x25\xdd\xcc\x2d\xe3\xc7\x08\xf6\xe2\xfb\x84\xb1\x2d\x4b\xf8\x5f\xa6\x7e\x6c\x5d\x97\xdc\xd7\x0b\xbc\xd8\x80\x9d\xeb\xfb\x88\xce\x99\x69\xf7\xdc\xa5\x53\x68\x09\xaa\xb0\xf4\xbd\x26\xf2\x03\xf6\xf3\x46\xdc\x05\x9e\xbb\x4e\x92\x99\x16\x6c\xf9\x77\x57\x3b\xfa\xe6\xf1\xcf\x5a\x7a\x85\xd3\xbd\xaf\x96\xf2\x70\x9d\x9e\x6b\xed\xae\xd3\xba\x5c\xcf\x61\x4b\x23\x11\x5c\x77\x6b\xf7\x20\x4d\xea\x72\x4d\x11\x35\xf5\xfb\x19\x46\x7a\x1b\x33\x8d\xab\x45\x7c\x7b\x05\xb2\xbc\x6b\x06\xf9\x50\x3c\x65\x9e\x63\xe4\x76\x57\xf9\x03\x47\x6e\x32\x7a\x9e\x6d\xc4\xf0\x03\x73\x2e\xf1\xb9\x8c\x6b\x25\x94\x8d\x32\xf0\xdb\x8d\xbc\x77\xeb\xd4\x46\x1e\xd6\x62\xe8\xd8\x93\x5f\x56\xc9\x35\xde\x95\xf0\x45\x0e\x06\xb7\xf3\x6b\x4a\x7f\x9b\xbd\xa2\x53\xac\xdc\xd8\xe8\xa0\x7c\xba\x2b\x78\x20\xe0\x2f\x55\x01\xa2\x0b\x2a\xba\xb0\xc2\x5b\xaa\x86\x0c\x45\x07\xfa\xfa\xa5\x1e\x8d\x01\x9c\x60\xf2\x97\xe4\xe2\x31\x30\x2c\x8a\x8b\x79\x8d\xf8\x5e\x8d\xb0\x62\x69\x98\x60\xcd\x83\x91\x9f\x41\x26\xc7\x1c\xf8\x9b\xf4\x16\x00\xcc\x58\x8d\x70\x51\x88\x42\x16\xd4\x72\xba\xc6\x23\xdf\x6f\x74\x40\x8b\xd9\xf4\xdd\x23\x43\xe9\x7f\x91\x63\x82\x9e\x8f\x6a\x61\xc0\x21\x1d\xa1\x18\x7e\xa7\x3a\x6b\xb6\x05\xb2\x2a\xac\xf0\x1a\x87\x33\x45\xc6\x0e\x3d\xc7\x8e\x17\x25\x08\x2d\x3f\xff\x46\x08\x02\x7d\x2e\xca\x1e\x4e\xb0\x81\xbe\x80\x70\xf7\xd8\x93\x94\x0f\xd6\x0d\x8c\xbe\xdc\x96\x8d\xa7\x87\xe1\x86\x1d\x35\x91\x94\xad\xe3\xe9\x11\x34\x56\x48\xb1\x00\x41\x0f\x19\x87\x2f\x20\xe8\x79\x2d\x58\xb0\x19\x45\xa9\xcd\x50\x32\x3b\x16\x5c\x4b\xcf\xcd\xd6\xc3\xa8\xcc\x01\xf5\xf7\xdd\x3a\x6b\xc0\x32\xd7\x48\x1d\x44\xff\xd3\x73\xf2\xdb\xa8\x0b\xa9\x2e\x68\x4b\x71\x86\x79\x39\x34\xfe\xe2\x6d\xfa\xe4\xba\xe0\xe1\xfe\x0c\x1b\xf1\x36\xf2\xd7\x15\x62\x68\x9d\x47\x86\xf7\x90\x79\x49\x26\x49\x99\xd7\x85\x09\x5a\xa8\xd9\x44\x36\x39\xe4\x3c\x29\xb9\x41\xd6\x1f\x64\xd8\x4e\x0b\x2f\x6e\xb2\x5e\x85\x70\x94\x63\xb8\x02\xbd\x49\x47\xeb\x26\x3d\x24\x91\x73\x2b\xe5\xbf\x75\x5f\xc0\x29\x58\xb5\x1a\xe8\xb2\x71\x92\xfe\x54\xf6\x90\x5e\x22\x37\xe2\x9f\x4a\x2d\x7e\xd6\xdc\x05\xc8\xa4\xf4\x4a\x21\xca\x42\x14\x13\xd6\x20\x66\xd0\x9b\x24\xeb\x94\x14\xd2\xbb\x27\x64\x09\xfd\x61\xb6\xb7\xe7\x07\xf5\x10\x3f\x96\x25\x0f\x49\xb1\x8b\x4c\xf3\x85\x4d\xb3\x97\x7c\x18\x84\x7f\x3a\xcf\xbd\xd9\x54\xdd\x6f\x9a\xe3\xe1\x6b\x3c\x04\xd1\x95\x94\x4c\x4b\xa4\xf9\x1c\x68\x0c\x68\x85\x06\xf7\xf6\xf3\x6f\xb7\xa8\xd8\xf1\xad\xc3\x6a\x4b\x82\x0c\xc6\x80\xaf\x74\xc5\xd6\xcc\xd0\xef\x43\xb4\xe2\xaf\xf1\x67\xa0\x9c\x19\xba\x73\x34\xb1\xb6\xd0\xd0\x6e\x13\xeb\xfc\xa6\xee\x08\x5e\xaf\x91\x13\xd6\xa2\x37\xe4\xfa\x25\x13\x3a\x88\xce\x72\x8b\xe9\x1a\x70\xea\x18\x7a\xa6\xe8\xe8\x3c\xf0\x30\x31\xf0\xb0\xe0\x34\x6e\xef\xb0\x1b\xc6\x8b\xba\x7a\xfa\x5b\x71\x77\x27\xde\x28\xc6\xd3\xd6\x72\xda\x26\xff\xff\x92\x45\x20\x8a\x76\x65\x6e\xf3\xde\xd5\xd8\x47\x47\xd1\xcd\x3f\x1e\x95\xe5\xbd\xab\xf0\xd0\x2f\xaa\xef\x2a\xe3\x0b\xa7\x73\xd8\xf5\xc4\x76\xf3\xdb\x28\xd0\xf0\x07\x04\x45\x3b\x83\x1d\x94\x4d\xbc\xfc\x63\x03\xa4\xab\x45\x1e\xdb\xd0\x32\x62\x31\x4a\x3a\xd5\x90\x57\xc2\xd5\x20\x55\x76\xaa\xeb\xdb\x45\x3c\x73\x9b\xcf\x88\x49\x6f\xe8\xdf\x7e\xf3\x35\xfd\x6e\xb7\x79\x34\x7b\xdf\x72\xe3\x30\x2a\xf8\xbb\xe6\xd0\x2e\xdb\x6d\xd6\x77\xf1\x3e\x5d\x1d\xc2\xfc\xbe\x7e\x84\xa3\x3c\xd6\x74\x81\x3f\xe1\xbf\xf7\x10\xee\x84\x67\xc9\x54\xaf\x34\xd8\xe9\x7a\x8d\x2c\x79\x13\x8a\x52\x2a\xa3\xf9\xe4\xfc\x44\x69\xf2\x45\x7c\x27\xcf\x46\x67\x62\xd4\xf2\x72\x78\x89\x53\x9d\xea\x6c\x54\x9c\xa7\x29\x9e\x26\x7e\xf1\x44\x88\x17\xb8\x8d\xec\xea\xe9\x27\xe9\x62\x52\x69\xd4\x61\x5f\x47\x84\x0f\xa7\x9b\xfa\x14\xec\x0e\x90\xce\xae\x26\x32\x78\x3c\xd5\xcc\xc1\xaf\x0f\x25\x46\x40\xc8\x88\x00\x21\xab\xb8\x2c\x1f\xc0\x97\xc5\x21\x2d\xf2\x79\x3a\x6c\x6a\x11\x04\x72\x90\x66\xcb\x78\x81\x29\x48\x04\xf6\x70\x91\xe1\x0c\xcb\x64\x82\xe5\x51\xfb\xf7\x6c\x67\x15\xab\x89\x34\x57\x83\x18\x12\x30\x17\x33\xd0\x11\xc2\xcd\xe9\xbd\xb0\x75\x1a\x08\xea\xb0\xdd\xb6\x9b\x6f\x00\xd9\xc0\xf3\xde\x10\xe2\x0c\xdb\x17\x23\x76\xc3\x05\x7a\x50\xaa\xce\x65\xc6\x82\x5e\x29\x40\x68\xb3\xc1\xad\x69\x4e\x8f\x28\x02\xf8\x9e\xc8\xe7\x36\xb3\xc6\x57\x4d\xde\x73\x0b\x07\x2d\x4a\x93\x6c\xcc\x6f\x1d\xe8\xb2\x68\x54\xfa\xa5\x3b\x9e\x41\x9d\x9d\xf7\xb4\x0b\x74\xc3\x5c\x65\xff\x22\x92\x99\xf5\xfb\x42\xb3\xab\x0b\xa5\x6d\x6f\x77\x57\x07\xe7\x17\xc7\xef\x4e\x37\xab\x28\x72\x85\x24\x8e\xd1\xdf\x2e\xde\x9d\x46\xf9\xf4\x1f\x58\xc7\x4f\x88\xfc\x3c\x87\x6f\x24\x1c\x74\xd7\x02\x79\x14\xe8\x22\xc2\x62\x40\x23\x84\xad\xef\xb8\x4f\x4f\x6a\x61\xa4\xd9\x68\x81\x37\xcb\x39\x25\x3d\xc6\xf4\x5a\x77\xa3\x43\x22\x0b\x36\x35\xfd\x05\x2e\x9f\xcc\x02\x72\xcb\x04\xa3\xa9\xd7\x14\x1e\xe7\x5f\x19\x6e\x98\x84\x28\x87\x55\xce\xbb\xcf\xff\xbb\x40\x5e\xae\x92\x06\x3c\x7a\x07\x03\xbe\xab\x28\x10\x69\xe8\x5a\x56\xc9\x13\x0c\x94\xa1\x57\x4d\x9c\xa6\x55\x4a\xaa\xc2\xdb\x4a\x1d\x69\x56\x21\x98\x0e\x4f\xed\xb9\xe4\x78\x72\x9c\x96\x81\x48\x8a\x89\xb1\xf8\x2d\x22\x09\x3a\x41\x34\x76\x23\x05\x00\xda\x2b\xfd\xc3\x54\x5a\x83\x99\x9a\x84\x8a\x3b\x7f\x82\xc8\x64\x82\xeb\xf7\x8f\x04\x36\xa6\x05\xa6\x73\x37\xc9\x94\xb5\xd4\xa1\xaf\xbe\x16\xd2\xec\xdf\x6f\x0d\xa8\x43\xaf\x19\x8e\x46\x35\x5d\x5e\x80\x33\x39\x32\xc7\x9c\x11\xe5\x4f\xbf\x30\xf5\x21\xa7\x98\x72\x37\x8f\x11\xf8\xa2\x74\x41\xf5\x68\x6e\x6c\x95\x97\x5e\x61\xb3\xb8\xb8\x11\x9b\x2f\xd2\x88\x17\x4e\xd3\x4e\x78\x1a\x4e\x75\x43\x6b\x9e\xc9\x74\x4b\x7b\xc5\x4c\x34\x67\xb2\x37\x2b\x82\x7e\x00\x11\xb8\xf3\x3a\xbe\x56\xcd\x11\x93\x88\xd2\x66\x13\x8d\xfe\x0d\x62\x99\x77\x28\xef\xa0\xa8\x24\xd9\x49\xee\x6c\x4a\x66\xfb\x33\x29\x2c\xaa\xf9\x77\x3c\x03\x3b\x78\x8c\xc0\x79\x4c\xc8\x97\xf1\x98\xc5\x28\x7f\x9e\xb3\x85\x96\x0e\x80\x25\x3c\x04\xda\xd6\xf0\xe3\xf8\xfc\xf4\xf8\xf4\x88\x69\x98\x78\xa3\xc5\xd5\x4f\xae\x98\x75\x6a\x30\x9f\xc6\xde\xf2\xf1\x12\xa7\xa4\x3d\x8c\x07\xde\xa6\xf3\xdb\xc5\x23\xe6\x06\x5e\x43\x9b\x78\x9e\xcc\x48\xd4\x7f\x37\x04\x20\x2a\x02\xd6\xd1\x7d\xca\x99\xb6\x08\x8e\x44\xab\x59\xd2\x54\xc8\x8f\xc8\x69\x5b\xf0\x57\xc4\xdd\x97\xb7\x30\x2e\x90\x5f\x62\x86\x05\x92\xed\x69\xcb\x0f\x86\x30\x31\x43\xb8\x12\xa4\xd3\x98\x2a\xa6\x92\xab\x57\x46\x3f\x88\x77\x55\xd2\x59\x4b\x2e\x21\x99\xd3\x41\x06\xc2\x65\x93\x98\x9d\x77\xc6\x78\x49\xbc\x8d\xda\x25\x99\x18\x70\x34\x22\xa2\xbb\xcf\xbf\x11\xb2\x92\xf1\x60\x54\x58\x89\x72\x67\xaa\x29\x7d\x94\x29\xbb\x98\x29\x93\x9a\xc0\x59\x11\x07\xb1\xb2\xa4\x13\x60\x18\x61\x4e\x9c\x35\xfc\xb0\xf6\xc5\x44\x94\x2f\x94\xdb\xfc\x54\x68\x0e\x86\xa1\x64\x46\x4f\x46\x90\x35\xa2\x28\x02\x41\x6e\x66\x34\x77\xa9\xd6\xd1\x7d\x83\x75\x09\xe3\x2d\x3c\xca\xae\xdc\x96\x7c\x65\x31\xb4\x16\xf8\x56\x2f\xfa\xee\xdb\x6f\xf1\xf7\xbf\xbc\xfc\x76\xc7\xe4\x0d\x77\xe5\xe2\xed\x34\x5e\xd1\x99\x1a\x58\x3b\x04\x86\x61\x0e\xe7\xd5\x2d\xc5\xa1\xf1\x2d\x97\x38\x41\x7b\x8b\xbc\x9e\x81\x79\x84\xf9\x2a\x1e\x5f\x94\x60\x22\xaa\x78\x1a\x97\x60\x32\xc7\x30\x53\x77\x59\xfe\xb0\x48\x66\x73\xcb\xf7\xd0\xe9\xcb\x20\xf4\x39\xb3\x70\xc6\x97\x7b\x0d\xa1\x3e\x2d\xaa\x9d\x26\x86\x12\x94\xf2\x15\x5a\x7e\x78\x35\x69\xcd\x2c\xaf\x88\x52\x43\x39\x4f\xcc\xa5\x0b\xf3\xc2\x89\xef\xb9\xe0\xeb\x1c\x4c\x1b\x93\x6f\x31\xff\x0b\xee\x5e\x2e\x3b\xbc\x15\xf1\xb9\x07\x19\x0c\xf1\xa6\xeb\xdd\xa8\x75\xfb\xc4\xc6\x72\x99\xdc\x16\x3e\x53\x19\x6d\x23\x33\xf7\x33\xec\xe5\xf4\x62\xf0\x4f\xf0\x6a\x22\x91\x88\x54\x5a\x87\x98\xfa\x5c\xb0\x86\xa4\x15\x51\x46\x7b\xd4\x34\x2d\x7d\x6c\x51\x30\x29\x83\x89\xeb\x18\x53\xb2\x63\xda\xac\x71\x77\xcf\xca\xcf\xbf\x82\x73\x6b\xb6\xe1\xc6\x5c\x53\x34\x21\x9b\xc6\xd9\x1d\x7c\xb2\xb8\xb1\x2f\x62\xaa\xc6\x07\xcb\x74\x17\x1a\x97\x36\xab\xe7\xc7\x94\xfe\xde\x4d\x74\xf1\x79\x63\x13\x17\xc8\x4b\x0d\x0c\x91\x58\xc9\x3b\xd5\x14\x79\x78\x75\xd9\xd4\xc6\xe6\x52\x6a\x7b\xff\xb3\x7c\x5e\xb6\x88\x60\xff\xe7\xc5\xdf\x0d\xe2\x28\x3a\x89\x41\x9c\x28\xf5\xcc\x5f\xce\x76\x1f\x8c\xd3\xd1\xff\x62\xcc\x67\x84\x7c\xe4\x51\x5c\x55\xc9\x72\x55\xd9\x0e\x96\xf1\x2c\x31\xb4\x63\xf1\x75\xdf\x3c\x7e\x6f\x11\x58\x7e\xa9\x62\x32\x35\x98\x3d\x38\x03\xaf\xb1\xc8\x1f\x0d\xc7\x6d\xeb\x1d\x78\xc9\x93\x32\x37\x1d\x5d\x61\x26\x6e\xd0\x77\xec\xed\x85\x2a\x57\xc2\xa6\x63\x50\x72\xc8\x89\x2c\x6e\x3c\x4f\xbe\xe1\x18\x1c\x61\xb8\x7b\xc4\x21\xee\xbc\xf3\xa3\x68\x43\xe3\x5c\xae\x6c\xc6\xf1\x35\xbc\xb7\xac\x56\x93\xf4\xbf\x9a\x39\xe9\x94\x0c\xd9\xd6\x9e\xac\xb1\x14\x94\x88\xdc\x4e\x49\x6b\x1b\x8b\xec\xab\x59\x8b\x29\x6e\x8b\xbd\xf6\xc2\x0e\xb8\xdf\x50\x38\xdd\x3c\x43\xe1\xac\xc7\x5a\x3b\x71\x50\xf2\x33\x94\x9a\x73\xc5\x95\x47\xf9\x88\x62\xa7\xc3\x75\x66\x26\xf5\xa9\xc6\x4c\x8b\x0a\x71\xe1\x18\x45\xfe\xbe\x03\xea\x6b\x96\xc0\x8e\xf2\x5b\x3c\xfd\xb8\xe4\xf0\xb2\x25\xd0\x4f\xd9\xb5\xb3\xd9\x1d\xe2\x2e\x15\x98\xee\x12\x15\x34\x3b\x33\xa9\xba\x74\x74\xb2\x30\x22\x2c\xe7\x5d\x26\xa1\x95\x3e\xeb\x7e\x08\xb2\xd6\x1d\x61\xb7\xa5\xb6\x25\x47\x33\xe3\xf2\xdf\xf1\xf4\xa9\x76\x2f\x66\x53\xd3\x9b\x96\x74\xb6\x2c\xb2\x98\x08\x79\x1b\xef\xe9\xfb\x96\x0d\xf0\x48\x38\xa7\x89\xb1\x33\x48\x44\x40\xbc\x94\x8c\x76\x28\x7b\x0b\xf8\x36\x5b\x62\xb4\xb2\xc0\xdc\x3e\x62\x87\x29\xd2\x65\x0c\x6b\x02\x0d\xcb\x35\x66\x01\x39\x46\x18\x5f\x49\xca\x27\x5e\x2d\x28\xe3\xbc\x63\x9a\x28\xab\x30\x45\x73\xb0\xa4\x82\x6b\x68\x11\xee\x5f\xda\x95\x2b\xcb\x06\xaf\xbb\xc5\xad\x0a\x36\xfc\x8e\x9e\xc4\xda\x2c\x09\x22\x89\xfb\xcd\x32\x99\x71\xe8\x63\x45\x77\xea\x18\x53\xfd\x8e\xff\x7b\x37\x8a\x7e\x4c\x5c\xad\x08\xe4\x56\x30\x16\x55\x1e\xb7\x00\x2e\xe2\x54\xab\x19\x46\x36\xcb\x1f\x32\xf3\x90\xb3\x71\x58\xe7\x94\xea\x01\xcd\x66\x54\x9d\x01\x5e\x52\x4b\x85\x69\x42\x85\x5e\x98\xa3\x7f\x37\x7a\x87\x3e\x5a\x68\xa3\x5b\xa6\x73\x74\xb2\x67\x3b\xa6\xb3\xd2\x72\xc8\x82\xb2\x3c\x1a\xcc\x21\x0e\xee\x58\x6b\xcd\xec\x3e\x13\xf3\x78\x2f\x50\xc8\x60\x78\xad\x35\x7e\xca\xda\x8b\xae\xf5\xb5\x0b\xf5\x02\x5b\x52\xf7\xdd\x33\x61\x83\x43\xd9\x08\xc8\xb5\x6d\x96\xa8\xb5\x2d\x18\xcc\x45\x59\xd1\x37\x22\xcb\x4b\x04\xea\x68\x39\x1d\x2b\xd9\x0d\x7a\x0a\x3e\xb9\x50\x63\x0c\x18\xf0\x38\x28\x98\x27\x5a\x40\x15\x2d\x53\xb2\x13\x3d\xe4\x53\xde\x64\xa2\xab\xf6\x12\xc4\x42\xa8\x04\x21\x61\x62\x00\x19\xa0\x5d\x7f\x34\x2a\x34\x87\xae\x52\xc5\x15\x2f\x46\xe2\xc7\xe1\x19\x64\x6a\x9d\xc4\x4b\x68\xea\xde\x6b\x4a\x60\xef\xea\xe5\xe8\x6c\x81\xb0\x38\xca\x26\x01\x59\xf2\xcf\x66\x8f\xbb\x60\xec\x0b\xa2\x8f\x47\x8c\x6a\x46\x06\x97\x5a\xda\x95\xca\x97\x0c\xc2\xb2\x68\x2c\x15\x3d\xe4\x0c\xb2\x40\x04\xc9\x42\xb1\x19\x45\xf6\x5a\x0e\x64\xe1\x86\xe6\x6e\x2f\x8c\x86\xa6\x1a\x83\x3d\x96\x5d\xe4\xd3\x78\x31\xeb\x71\x92\x65\xd9\xf2\xf4\xd0\xc6\xb7\xc3\x27\x42\xa6\xd7\x41\x45\x8c\x8b\x4a\x8b\xc2\x0c\x53\xdf\x78\xc2\x09\x96\x3f\xc6\x05\xfa\x2f\xaf\x50\x59\x26\x6c\xc5\x44\xe3\x26\xf5\x10\x53\xa5\x21\x92\xc9\x7b\xa4\x6c\x3c\x53\x0a\xf1\xb0\xad\x1a\xa3\x1f\xa6\xa1\x43\x2a\x80\x32\x31\x0c\xae\x4d\x50\xa8\x9c\x0d\x40\xfb\x59\x72\x7d\x57\xbd\xa2\x6d\x93\x3f\x0b\x79\x9e\x52\xd2\x2f\x46\x7e\xa3\x84\xde\x69\x4e\xf4\xb5\xea\x79\xd7\x8c\x54\x18\xb9\x10\x91\xca\x75\x3c\x25\x44\x05\x4b\xfd\x23\x16\x01\x2a\x3f\x4e\x1f\x3f\x1a\x24\x84\x06\xa2\xb2\xc3\x78\x5f\x53\xe2\x2f\xad\x3a\xa9\x0b\x3a\x3a\x0c\xc9\x0b\x2b\xc7\x18\xec\x8a\xc9\x24\x29\xae\xb3\x4e\x01\x81\x5b\xe3\x87\xd8\xe1\xa0\x84\x49\xdb\x82\x85\x52\x51\xb1\x80\x55\x8d\x78\x2d\xf0\xc0\xf3\x19\xb1\x52\x1f\x1e\x63\xad\x6a\x57\x3a\xa2\xac\x66\xe0\x5c\x2b\x0a\x5f\x4f\xce\x4f\x46\x6f\xe2\x7a\x05\xbe\x7c\x8a\xb6\x3d\xda\x1f\x5f\x1e\x1c\x47\x78\xdd\x9f\xa4\x53\x71\xab\xd8\x7a\xa5\x4d\x54\x3f\x7a\xaa\xe0\xb7\x85\xf4\x32\xa4\xfa\xf7\x18\x77\xa4\x4d\x4a\xca\x92\xde\xa4\x1a\x54\xd8\x48\x7f\x20\xce\x4b\xe9\xb2\x11\x23\x76\xba\xf5\x77\xfd\x1e\x8b\x48\x81\xb5\xc2\x94\x3d\x7b\x63\x25\x21\xde\x01\xf8\xd9\xf7\xc7\x67\xa3\x31\x35\xb7\x75\x79\xd8\x39\xb4\x17\xd6\xfd\xdd\xfe\xf4\x76\x72\x72\x79\x7c\x36\x3e\xbf\xfc\xf3\xe1\xbb\xf3\xb7\x23\x98\xc7\x71\xb4\xf7\xee\xf4\xf2\xe0\xf4\x32\x7a\x73\xbc\xbf\x7f\x70\xfa\xb3\xd2\xe5\x4f\xc7\xa7\x6f\xc6\x27\x97\xd1\xdb\x83\x37\xe7\x30\xf9\x27\xc7\x47\x07\xe7\x11\x0a\x99\x9c\x8c\xcf\xf1\x7d\x9c\x46\xe3\xc9\xc5\xd1\xc1\xeb\x93\x83\xd3\xfd\x83\xcb\x9f\x15\x05\xce\xce\x8f\xaf\xe0\xe1\x88\x7a\x5e\xd3\xa3\xf7\xec\x40\xe9\x7d\x4c\xde\xa5\x2a\xbf\x4b\x76\xab\xc9\x9d\x2f\xd0\xea\x1a\xc2\xb1\x9f\xed\x71\xed\x27\x93\x2e\x50\xee\xee\xee\xfe\x1c\xfd\x64\xfe\x6e\x1e\xd4\x7a\x66\x79\x8e\x60\xec\x67\x71\x8c\xa3\x9f\xc6\x22\x30\x61\x81\xe2\x2f\xe7\xe6\xb9\x7e\xfd\xd8\x2e\xa9\x59\xbe\x64\x66\xb4\x96\x55\xae\x41\x8e\xc7\x60\x1d\x6b\x85\xe7\x05\xf6\x7f\xad\x15\x18\x08\xb5\x4d\xfe\xa0\xa6\x2b\x3e\xd5\xb0\x1d\x61\xe6\xb3\xd6\x78\x40\x2d\x29\xcb\xfa\x57\x56\xeb\x8a\x46\x05\x8b\xe7\xa8\x4d\xc0\x85\x8c\xcb\x5b\x75\x0c\x8e\x6d\x95\xe9\x01\x88\x9d\x4b\x15\xa6\x8d\x02\x99\xb5\x94\x46\x88\x99\x33\x1c\x69\x37\x60\xb2\x75\x4d\x98\xfb\xc1\xf1\x35\x78\x14\x71\xb0\xa0\xe6\x14\xa6\xd2\x59\x68\x1c\x73\xb7\x9a\x2c\x21\x9c\xda\x91\xae\x2d\x3b\xe8\xaf\x1c\xd0\x4d\xbb\x97\xee\x3c\xd7\x2f\xce\x98\x36\xf5\x7a\xdc\x3d\xd0\x2f\x00\x11\x2e\x74\x84\x40\x24\x8d\x3a\x75\x6f\x70\x9a\xc0\x0b\x9b\x27\x04\x93\x01\xaf\x14\xda\xf5\x4b\xbc\x5e\xd5\x8a\x90\xbd\xb3\x89\xd2\x24\xb8\x80\x30\xba\x8f\xb7\x8e\xc5\x93\x02\x0f\xa0\xe6\x7a\x25\xd7\xf1\xb4\x04\x37\xe2\xa9\xbf\x2d\x1c\xe9\xaf\x8b\x74\x15\x40\xd7\xbc\x4e\x64\xdb\x52\xb1\x1d\x52\x26\x56\x4d\x5f\xe2\x5f\xfb\x9b\xa6\x65\xd8\x02\x18\x42\x94\xa0\x1d\x00\x29\xda\xa6\x08\xbe\x78\xa5\xbd\x29\x6c\xa6\xad\x1b\x6e\xa7\x2c\x9a\x61\x70\x92\xe1\xa8\x11\xce\xfe\xd1\xe6\x8f\xf3\x73\x42\x2d\x3b\xb9\x3b\x54\x79\x4d\xb8\x0e\xf9\x91\x1d\x2e\x00\x02\x67\x90\x87\xcc\xfe\x51\xcd\x38\x53\x52\x82\xec\x59\xb4\x43\x26\xc8\xd1\x77\x26\xf2\xa4\xfb\x3b\x4b\xe1\x67\xab\x4e\x7d\xc8\x9a\x60\xa2\xbf\x5f\xdf\xd8\xa8\x0d\x69\x3a\x62\xa5\xfe\x4e\x07\xa1\x9e\x1e\x44\x20\x01\xb7\x0c\x0f\x60\x70\x42\x7b\xa7\xa5\x39\x03\x32\x2d\xcd\xb9\xda\x7a\x5a\x64\xe4\x6e\x2a\xf4\x51\xec\x0e\x99\x17\x7f\x42\x9a\xb3\xda\x9c\x04\x25\x70\xc5\xcd\xd5\x62\x73\x46\x94\xba\xc8\x1f\xb4\x25\x99\x66\x44\x2c\xd1\xdf\x8e\x73\x0a\x55\x63\x86\x0d\xf1\x38\xaa\x35\xa6\xaa\x07\x04\x8e\x83\x73\xc4\x0a\x1e\x7c\x34\xe8\xbb\xf2\xd6\xe7\xac\xc5\x3a\x58\x1a\xcc\xb0\x53\xa8\xad\x57\x5c\x4e\x48\x32\xb9\xe3\xaf\xe9\x96\x43\xbb\xe0\xa7\x50\x92\x96\xb0\x2a\x45\xa4\xfb\x5b\xf2\x86\x1c\x81\x01\xe6\x5a\x79\x70\xb4\x03\x8f\xbe\xc4\xe2\xb0\xc9\xf5\x6d\x4e\x21\x3b\x7b\xed\x0c\x9d\x14\x8f\x5e\x82\xeb\xbe\x33\xce\x3a\x44\x7f\x0a\x6b\x80\x40\x8c\x14\xb8\xf8\x81\x85\x67\x2c\x1c\x83\x31\xe6\x26\x18\xa3\x5d\x78\xc5\xdc\xdc\xea\x5f\x45\x5a\x77\xfd\xc3\xc1\x13\x9d\x0e\x72\x20\x48\x8d\x0e\x70\xb8\x29\x12\x0a\xdd\xad\xe2\x54\x5b\x1f\x77\x39\x06\x90\xe1\xc1\x94\xa3\x25\xd3\x04\x69\xe6\x94\xd5\xd2\x4d\x32\x82\x2f\x5c\x11\xdc\xf7\x6c\xa5\x7c\x38\xbd\x72\x8d\xb3\x09\xe7\xf0\x8d\xba\xb0\xb4\xdb\xb0\x89\x83\xfb\x90\xcc\x37\x19\x0c\x55\x18\xe5\x3a\x6f\x4a\xa7\x87\xf8\x8e\xfb\x7b\x26\xa6\x79\x22\xde\x27\xc4\x0b\xaf\x74\xa7\x86\x86\x18\x44\xb2\x6e\x15\x27\x5c\x2a\xda\xdb\x5b\x6e\x21\x55\x24\x76\x4c\xcd\x4f\x2c\x92\xec\xe9\xc1\x82\x70\x24\xae\x15\xe6\x90\x34\xf2\xc9\x23\x34\x4c\x0e\x54\xb0\x00\xe1\xc9\xf0\x66\x4a\x01\x85\x1f\xfc\x92\x56\x8d\x85\xbc\x83\xbb\x74\xf5\xb1\x74\xd5\xe4\xf0\x11\x2e\x2e\xa7\x7e\x55\xa2\x53\x7f\x6f\x93\xa2\x44\xbe\xec\xad\xba\x0b\x0e\x4e\x73\xa1\x8e\xc3\xcc\x8a\xb6\xb9\x66\xe9\x6d\x7b\xed\x95\xa7\x19\x15\x8b\x8e\xd2\x0c\x5e\x40\x5a\x71\x75\x5b\xd8\x40\x0d\xea\x53\xa5\x11\x99\x0b\x62\xaf\x60\xae\xf2\x2c\xbe\x5d\x26\x2b\xac\x3e\x9b\x3a\xd0\x67\xb8\xcb\x7b\x8b\xec\x32\xb6\x7f\xef\xf0\xe3\xc5\xe5\xf8\xe8\xf8\xf4\xe8\xe3\xe5\xf1\xdb\x83\x77\x93\x4b\x63\xa2\xd4\xd7\xe5\x2b\xe2\xd0\x5d\xdd\x7d\x20\x28\x7a\x2b\x35\xcf\x2f\x27\x67\xcf\xa4\xa6\x22\xba\x57\xcd\x05\x58\x76\x6d\x3b\x7c\x9d\x70\x2d\x0c\xd5\x7f\x5f\xc4\x08\xd2\x30\xd1\x7a\x8d\xf1\x8e\xa2\x7b\x2e\xa8\x1f\x10\x55\xaf\xf8\x2c\xa5\x2d\x47\x16\x55\x46\x36\xeb\x40\x5b\x96\x64\x44\x54\x57\x62\x9a\xcc\xd1\x90\x28\xeb\x0b\x09\x0f\xd4\xa6\xf3\x84\x78\x0c\x94\xa6\xcb\x10\xe1\xed\x45\xd0\x4c\x71\x53\xb5\xbc\xaf\xb4\x55\x3c\xae\xc0\xc6\x7a\xaa\xee\xa9\x19\x92\x0c\xc4\x65\x7a\x6d\xaf\xa3\xb4\x9d\x95\x3c\xd2\xd7\xf0\x68\x69\x9f\xd4\x24\x6a\x6a\x60\xed\x38\x55\x8f\x8a\x2b\xce\x5b\xf0\xa7\xc4\x24\xc0\xfb\x09\xec\x28\x7c\x5f\x44\xb5\xa6\xe6\x89\x64\xd7\x4a\xe5\x05\x73\xf5\xc4\x9f\x4c\x7f\xaf\x3a\x73\x83\x9f\xd8\xa4\xb6\xd5\xe6\xaa\xc9\x9d\xae\x34\xc7\x63\x84\xd2\x3e\x50\x4a\x09\x7d\x1f\x7b\xcd\x48\x97\x86\xea\xf2\x26\xcf\xc7\xde\xe8\xac\x16\xfa\x31\x10\xed\xf5\x46\x30\x4f\xec\x58\x3f\xf9\x6a\xaa\x07\xb4\x3d\x0b\x69\x87\xac\xd3\xba\x65\x39\x33\x3f\xf7\x37\x66\xb0\xb2\x16\x8f\x3c\x33\x3f\xf7\x36\xfe\x67\xa8\xa2\x7e\x6f\xfa\xad\xf2\x69\x22\x16\x56\x48\xb5\x37\x63\xcd\x75\x1f\x41\x19\x28\x83\xeb\x2f\x7e\xa2\x1b\x52\x8b\xe2\xb6\xe4\x69\x63\x6b\x0a\x7c\x8f\x2c\xea\xd9\x4c\x33\xb3\x92\x6b\x3f\x43\x5c\x54\x91\x4e\x89\xaf\x14\x63\x23\x1f\x69\xfa\x5e\x18\x56\xe5\x8d\xc7\xdd\x96\x69\xfd\x94\xaf\x27\x92\xed\xed\xd7\x93\x47\xc9\x20\x5b\x8a\x0b\x91\x72\x87\x58\xb8\x05\xf3\x15\x3a\x30\xf7\x37\xdc\x8e\xfa\x44\x93\x45\x46\x46\x13\x22\xbf\x86\x9a\x7e\x29\x3d\x4a\x58\xf8\x46\x3c\x25\xc3\x44\x69\xef\xaa\x7d\x83\x1e\x96\x76\x97\xa8\x9e\x42\x1b\xfb\x19\x16\x14\x30\xc9\x76\x07\xd0\x2c\x73\x13\xf6\x14\x96\x22\xc8\x83\xa0\xa0\x35\x53\xa3\xd8\x26\x0e\xa2\x69\x1b\x3d\x86\x49\xb8\x54\x9d\xd2\x3a\xd5\x5f\x6f\x09\xcb\x57\x69\x15\x62\x7f\xe5\x9c\x82\x40\x43\xce\x3d\x57\xcf\x4d\xc1\x64\x72\x35\x70\x46\x92\xd7\xc9\xd4\x42\xcb\x65\x79\x6b\xcb\x94\x78\x41\x07\x8c\x93\x07\xa2\x6a\x17\x17\x6f\x46\x13\x97\x9d\x54\x13\xa4\xd7\x5d\x7b\x49\xbc\x4e\x0f\xbb\xad\xe9\x15\x4f\x73\x3c\x5f\x5b\xf4\xcf\xc5\xb6\x4c\x7e\xc7\xb6\xaa\x84\xa3\x8a\x6b\xfa\xff\xa2\x2e\xbf\xe2\xe0\x37\xd3\xc3\xce\xfe\x8d\x7a\x1b\xab\x74\xed\x4d\x32\x1f\x31\x37\xeb\x6f\xcb\x01\xfb\xbd\x7a\x83\x1e\xd4\xb7\x99\xeb\x8d\x87\xba\xcd\x40\xbf\xf0\xc5\xf6\xbd\xd0\x61\x1d\xe3\x19\xc9\x7f\xab\x1b\x76\x6c\xc0\x2c\xdb\x8c\x99\x6e\xab\xb2\x2f\xeb\x79\x58\xbf\x55\xe0\x36\xf6\xa2\xd2\x6f\x62\xa9\xd0\x8f\xee\x07\x5d\x50\x25\x78\x6d\xef\x08\xf8\xd6\xe2\xfc\xea\x0d\x6b\x75\xb7\x0b\xf8\xe1\xe0\xb3\x20\x53\xae\x1e\x5f\xc0\xdf\xb5\xef\x9c\xdb\x46\x31\x41\xfe\x5f\xc2\x41\x99\xab\xa1\xae\x11\x16\x65\x88\xa1\x7e\x19\x4d\x96\x0b\x30\x2c\x6a\x34\x07\xf3\xfb\xb5\xa9\x50\xb7\xd1\x8a\x2a\xc1\x6c\x1e\xbb\x1d\x52\xfe\x07\xe3\xd1\x8a\xb4\xcb\x47\x05\x56\x51\x67\x98\x15\x92\x99\x72\x15\x95\xe6\x63\xd5\xb0\x27\x63\x65\x1d\x04\xa2\x52\x31\x8a\xea\xf3\xaf\xca\x10\xeb\x2c\x1c\x4e\x42\x51\xa1\x80\x52\xbd\x39\xad\x05\x34\xd1\xd6\x16\xb4\x51\x56\x16\x36\xd2\xbe\x1f\x6c\xa5\x7c\x3e\x75\x19\xcf\xd5\xe3\xa0\xdc\x30\xea\xe7\x5b\xc4\x13\xaa\x0e\x0b\x33\x04\xe8\x0d\x2d\xc1\x9d\x22\xe1\x7e\x53\xbe\x83\xfb\x60\xe2\xaa\x49\x6b\xed\x6d\xfa\xa8\xfa\xae\x7f\x8b\xfb\x5b\xfc\x8b\xeb\xaa\x08\xf2\xf4\xd3\xa7\xe8\x1b\xa2\x9c\xe3\x4e\x5e\x31\x0f\x4b\x2a\x7d\x5e\x54\x98\x2e\xf5\xe9\x93\x56\x0d\xaa\x57\xd6\xe8\x6a\x8d\x2c\x4d\xad\xbd\x43\xc3\xb8\xb3\x4a\xf5\x0e\xcd\x53\x88\x60\x5d\x2f\x2a\x44\xf6\xd1\x10\x16\xa6\xf3\xf0\x45\x3e\xc4\x5c\xb4\xbd\xe2\x14\x81\xa3\xbc\x31\x79\x47\xb9\x25\xb6\x0b\x41\x74\x0c\xf1\x8c\x95\x8a\x5c\x7b\x8b\x79\xc5\xc4\xaa\x47\x79\x63\x12\x7d\x99\xaa\x7a\x48\x55\xf3\xee\xc6\x9c\x58\x88\xd0\x94\xf1\xfb\xda\xf5\x7e\x6f\x23\x86\x0f\x1b\x0c\xb5\x02\x37\xc0\x96\x0c\xe1\x31\x04\x39\x61\x44\x4f\xf7\x79\x72\x65\x1c\xce\x47\xef\x67\x3f\x2d\xef\x26\xf8\xa9\x23\xcb\xe0\x4d\x24\x7f\x11\x52\x2b\xbd\x3b\xbf\x99\xcc\xb4\xdf\x4e\xed\x0d\x6c\xb0\x51\x31\x80\x07\x68\x3d\x09\x83\xf9\x73\x99\x52\x56\x71\x20\x7a\xd1\x7b\xeb\x2c\xa5\x83\x2d\x1f\xd0\xa1\x79\x15\x1e\x33\x90\x61\xe1\xf1\x12\x13\x4b\x2e\xeb\xca\xb5\x90\x1d\x0f\x4f\xe0\x4d\x2b\x5d\x9f\x75\xaa\xe9\x29\x5a\x10\x26\xc3\x4f\x35\x2b\x6d\x32\x7b\xd1\x2e\xab\x3c\xeb\xcf\x73\x17\x06\x1f\xfd\x5d\xd3\x7d\xcf\x87\xec\x43\x45\xff\xc7\x33\xf3\xba\x59\x94\xdc\x60\xe9\xa3\x07\xcc\xcf\xc2\xa8\xfb\x07\x6c\x89\x35\x82\xad\xae\x1f\xfe\x3f\x39\xbd\x54\x6d\xc7\xe4\xa4\xe0\x97\x2a\x95\x70\x6d\x25\x76\xce\x21\x15\xbc\x71\x69\xeb\x3c\x0a\x77\x2b\x16\x7e\x22\xd0\x8a\x79\x37\x56\x93\xe6\xab\x41\x32\x88\x3e\xfa\x08\x57\x4d\xbd\x21\xa5\x9f\xf1\x09\xc6\xb5\xaa\x6e\xa5\xaa\x91\xe5\x6c\x0a\xbf\xce\xd6\x54\x35\xe7\x4a\x20\xff\x49\x41\xce\xc2\x0e\xfc\x3b\x13\xa2\x74\x86\xd8\xf6\xcf\x1a\x3e\xb2\x8c\xfc\x62\xf2\x8d\x0a\x4f\x9c\x6e\x12\x97\x74\x7f\xf1\x5f\x88\x82\xa7\xea\x58\x52\xab\xd2\x82\xb0\x39\x6b\xbe\xbb\xac\x7a\x26\xd0\x55\x8d\x66\xc6\x11\x14\xd5\x60\x1d\xc9\x1a\x0b\xc0\xad\x21\xa5\x8b\x96\x64\x06\xea\x2d\x88\xc0\x7c\x0b\x3a\x2c\x6f\x9e\x79\x31\xd6\x5f\x44\xdb\xd5\x12\xd7\xff\xe9\x7d\x1d\x22\x2f\xa4\x2f\xe3\x64\x0a\x34\x9b\xd9\xe2\x31\x7a\xc8\x0b\x98\xc1\x9a\xca\x98\xee\x1d\x46\xde\x96\x8f\xb6\xf1\x6d\xfc\x4b\xba\xac\x97\x8e\x92\x95\xf9\x21\x1c\xab\x6c\x63\x27\xd7\xb9\x64\x07\x68\x63\x89\x6e\xbb\x5a\x18\x72\x59\xdb\xcd\x7f\x6e\xab\xc7\x58\x92\x34\xb0\x93\xbd\x13\x57\x23\x0b\x9a\xdb\xb6\xf8\xf5\xf8\xcf\xf9\xb5\xb4\x5a\xdd\xe0\xa3\x13\x4e\xa7\x3c\xc4\x7c\x19\x79\x44\x5e\x96\x6c\xe0\x92\x11\x2a\xb9\x4d\x4b\x0a\x81\x66\xb6\xc0\xaf\x74\xb0\xc4\x4c\x27\x44\xfc\x94\x94\xf1\xd2\x37\xe8\x26\xdb\x72\xe0\x05\x2f\x38\xe3\xd0\xf2\xdd\x71\xf6\x8a\xbe\xf8\xda\x0d\x08\x32\x83\xc0\x7a\x81\x46\x69\xb0\x3a\x5c\x1f\xc9\xb2\xb9\x09\xc3\x1f\xd6\xee\xc1\x5e\x23\xd9\x82\xbd\x56\x6a\x4f\x60\x51\x16\x70\x4c\xc2\x56\xe6\x9f\x96\x87\x71\x00\xfa\x3d\x2c\xc2\x8f\x53\xad\x03\xa9\x22\x39\xa4\xb9\xfc\x17\x69\x41\xb4\x79\xcf\xf3\x66\x86\x1d\xfc\x2c\x30\xc7\x9d\xc6\x98\x53\x97\xc3\x09\x4d\x4d\x6a\x50\x7a\xc4\x0c\x98\x24\x2e\xa6\x7c\x68\xde\xa0\xc7\xb2\xbe\xc6\x6a\x34\x9b\x8c\xf0\x21\x2e\xc4\x73\xa5\x6d\x3e\xd0\x59\x13\x8e\x68\xeb\x72\xc6\x58\x24\x94\x59\x14\x18\x94\x48\xc0\x13\x5d\x81\xae\x98\x92\x37\x90\xf7\x74\x24\xcf\x08\x03\xc6\x50\x3a\x4c\x05\x3a\x05\x91\x74\x7a\x2f\x03\x25\xea\x07\x68\xb7\x9d\x56\x0d\xa5\xb6\x50\x63\x30\x02\xb4\xa7\x69\x2f\xda\x33\xd0\xb5\xcf\xc1\xfc\x0d\x7f\xab\xe0\x23\x9d\x60\x08\xe1\xd3\xa7\xb7\x8d\x50\xc9\x8e\x8f\x12\x6b\x3c\x17\xf5\xc2\xe2\x76\x2c\x39\x5d\x69\x9e\x33\x75\xe5\x1d\x45\xab\xfd\xc9\xb8\xb8\x3b\x91\x0f\x1d\x20\xd3\x7f\x9a\x67\x88\xe7\xb8\x36\x4d\xc6\x0c\xa5\x0f\x9e\x4f\xd7\x8c\xcb\x40\x54\x24\x16\x02\x1f\x4c\x60\x74\x2d\xe4\x5e\xab\x4d\x73\x84\x7c\x03\xda\x3b\xc2\x0b\x3b\xc2\x36\xe6\x61\xdd\x28\xb5\x97\x77\xce\x57\xaa\xc6\xb2\xb3\x8d\xa6\x6a\xc7\xd6\xd8\xdb\x04\xef\xf0\xf5\x6b\x57\x98\xd8\xee\x86\x34\x97\x9a\x4b\xe7\x9e\xf0\xa9\xe7\x42\x02\x9d\xa6\xf1\x9a\xc0\xa7\xd6\x22\xd1\x82\xce\x81\x2e\xe8\x8d\x4b\x42\x46\x70\x95\x68\x3d\xb6\xda\x07\xfa\xaf\x5a\x36\x7b\xd7\x1e\xea\x7a\x8e\x74\x79\xe1\xff\xd2\x3c\x50\x10\xa8\xd5\x63\x34\xe0\x90\x6d\xe0\x2c\xe0\x75\xde\xb0\xfb\x5d\xef\xb2\x4f\x13\xb4\x94\xbd\xba\x88\x07\x8d\x42\xb1\x6a\xfa\xb4\x64\x45\xd0\xcf\xf1\xa9\xd8\xf4\xdd\xd3\x6c\xfe\xe8\x7a\x90\xf7\x0a\xc7\x22\xfe\x9e\xe0\x8f\xbf\xf8\x5f\x59\x67\x91\xea\x83\xdd\x5c\x68\x13\x4c\xfa\xff\x7e\xfe\xbf\x00\x00\x00\xff\xff\x8f\x06\x38\x20\x0c\x03\x03\x00") + +func cfI18nResourcesDeDeAllJsonBytes() ([]byte, error) { + return bindataRead( + _cfI18nResourcesDeDeAllJson, + "cf/i18n/resources/de-de.all.json", + ) +} + +func cfI18nResourcesDeDeAllJson() (*asset, error) { + bytes, err := cfI18nResourcesDeDeAllJsonBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "cf/i18n/resources/de-de.all.json", size: 197388, mode: os.FileMode(420), modTime: time.Unix(1456502789, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _cfI18nResourcesEnUsAllJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xbd\xfb\x77\xdb\x48\x76\x27\xfe\xfb\xfe\x15\x58\xe7\x9b\x23\x77\xbe\xa2\x6c\x77\x77\x72\xf6\x28\x67\xcf\x84\x96\x68\x59\xdb\x7a\x45\x0f\x4f\x7a\x5b\x7d\xd4\x10\x09\x49\x18\x93\x00\x06\x00\x25\x73\x3a\xce\xdf\xbe\xf7\x51\x05\x02\x64\xdd\xaa\x02\x48\xca\xee\x89\x27\x27\x6d\x11\xa8\xfb\xb9\xb7\x0a\xf5\xb8\x55\x75\x1f\xbf\xfc\x8f\x20\xf8\x1d\xfe\x3f\x08\x5e\xc4\xa3\x17\xbb\xc1\x8b\xeb\xe4\x3a\xb9\x3c\x3c\xdb\xbd\x4e\x5e\x6c\xf3\xf3\x32\x0f\x93\x62\x1c\x96\x71\x9a\x2c\x14\x80\xf7\x9f\xb7\x4d\x00\x3f\xa7\xd3\x3c\xf8\x3f\x17\xa7\x27\x41\x51\xe6\x71\x72\x1f\x14\xb3\xa4\x0c\x3f\x05\x71\x11\xc4\xc9\x63\x38\x8e\x47\x3b\x41\x70\x96\xa7\x59\x94\xd7\x5e\x95\x0f\x71\xb1\x1b\x04\xc3\xbb\xa0\x88\xca\x5e\x3e\x4d\x12\x20\xed\x45\xc9\x63\x9c\xa7\xc9\x24\x4a\xca\xde\x63\x98\xc7\xe1\xed\x38\xea\xdd\xe7\xe9\x34\x0b\xb6\x7e\xbf\x7e\x91\x84\x93\xe8\xfa\xc5\xee\xf5\x0b\x80\x9d\xc2\x5f\xdb\xcb\x8f\x3e\x6f\x59\xaa\xf2\xd5\x89\xba\xd1\x46\x2d\xca\xf0\xfe\x0f\xd2\xa8\x6b\x15\x55\x68\xd4\x7f\x0a\x2e\x1f\xa2\x22\x02\x7e\xf9\x63\x3c\x8c\x82\x6c\x0c\x55\x09\x1e\xc2\xc7\x28\x08\x93\x20\x2c\x8a\x74\x18\x87\x65\x34\x0a\x86\x69\x51\xee\x04\x7b\x79\x04\xd5\x84\xea\x84\x15\x45\x9c\x80\x9c\x09\xfc\xf1\x14\x8f\xc7\xf0\x6b\x08\x15\xc7\x7a\x30\x85\xd8\x44\x1b\x67\x2c\x54\xb8\x9f\x65\xf0\x49\xc2\x1c\xa0\x2d\x03\xbc\x59\xca\x02\xf5\xfb\xef\x3b\xf0\xcf\x09\xb4\xf7\xe7\xcf\xc1\x53\x58\x68\xaa\x60\x5a\xa0\xb4\x4a\x9e\xc9\x24\x4c\x46\xc1\x6f\x50\x78\x8f\xff\xfe\xfc\xf9\x37\x07\xf7\x95\x80\x05\x81\x4f\xd2\x20\xcc\xe2\x20\x4a\x46\x59\x1a\x27\x25\x76\x32\xf9\x03\x19\x0b\x0b\xc0\xe7\xe9\xb4\x8c\x82\x32\x0d\x6e\xa3\x60\x9a\x4c\xc2\x2c\x03\x41\x41\xc0\x24\x2d\x03\xf8\x2c\x39\xf4\xdc\xf1\x2c\x50\xcf\xa1\x58\xf9\x00\x5f\x39\xcb\xc6\xf1\x90\x18\xca\x42\xac\x0c\x2c\x08\x8c\xd3\x77\x10\x5c\x41\xff\xdb\x82\xc1\x36\x09\xf3\x8f\x51\x09\x3d\x10\x3a\x53\xaf\x08\x2e\x06\xe7\x1f\x0e\xf7\x06\x5b\x08\xf8\x18\x47\x4f\xc1\x28\x2a\x86\x79\x9c\x21\x62\x11\xa4\x77\xd0\xd7\x46\xf1\x63\x3c\x9a\x86\x63\xd5\x6d\xe1\x59\x18\xdc\xc7\x8f\x51\xa2\x7b\xa7\x5c\xa5\x67\x60\x6d\xab\x74\xbf\x28\xe2\xfb\x24\xc8\xd3\x71\x54\xc0\xc8\x29\x1f\x60\x0e\x81\xde\xc3\x6d\x09\x52\xe5\xd0\xdd\x70\xf2\x49\xf3\xfb\x1e\x16\xda\x0a\xb0\x87\x99\xcb\x14\x19\x88\xcd\xa5\xec\xd5\xdd\x14\x53\x5b\x45\xa9\x85\x11\xe1\xdd\x65\x98\xdf\x47\x65\x35\x40\xa8\x71\x4b\x7a\x16\x24\xd0\xc4\x04\x68\x97\xbf\x25\x96\x97\x58\x12\x04\xb4\x81\xa7\x30\x36\x04\x9b\x08\x53\xd5\xf7\xc6\x29\x2c\x2f\x41\x2f\x0c\xfa\x67\x87\x41\xaf\x57\x7c\x8c\xb3\x5e\x51\x8c\x7b\xb4\x3c\x11\xd7\x2d\xc0\xa2\xa2\x38\x13\x58\x4a\x01\xff\x62\x9a\x65\x79\x54\xf0\x1a\x16\x44\x79\x9e\xe6\xf6\x6a\x3c\x9b\x14\xc6\xa6\x80\xbf\xf6\xde\xdd\x9c\xf4\x8f\x07\x41\x38\x85\xfe\x88\x2b\xe6\xbf\x45\x9f\xc2\x49\x36\x8e\x76\x60\x5e\x0d\xae\x5f\x5c\x5f\x5f\xbf\xc8\x60\x21\x7a\x4a\xf3\x11\xfe\x7d\xfd\x22\x78\x09\xa3\x31\xcc\xa2\xe0\xaf\xd3\xb4\x84\x9e\x1c\xdf\x61\x2d\x60\x42\x4a\x02\x5d\xf0\x3b\xa1\xd2\x9b\xe3\xd7\xb5\x7a\x93\x59\x05\x82\x9c\xf0\x73\x28\x36\x77\xd0\xdc\xfa\x95\x1a\xae\x21\xf7\xec\xef\xc4\x45\x6b\x83\x0c\x5d\x15\x1c\xa6\xd9\xac\x57\x80\xbe\x05\x53\xe8\xc5\xe9\xd5\xf9\xde\xa0\xd7\x3f\x3b\x0b\x2e\xfb\xe7\x07\x83\x4b\xfa\xf3\x97\x5e\xaa\x7f\x9e\x9e\x1f\xfc\x0a\xbf\x0b\xfd\xfb\xe2\xac\xbf\x37\xc0\x27\xbd\x24\xed\x41\xcf\xc1\x45\xf6\x57\x9f\x5a\x6e\x84\xab\xab\xaa\x3c\x56\x5e\xa6\x93\xb8\xc4\x9e\x90\x63\x2b\xd3\x54\xa9\x5b\x0f\xc7\x00\x17\x82\x25\x3b\xca\xc3\x61\x09\x2b\x03\xac\x90\xbd\x5e\x85\x41\xda\x52\x96\xa7\x93\xac\xa4\x86\xbf\x4d\xcb\x07\xaf\xef\xba\x49\xe6\x7e\x15\x87\x71\x5f\xa4\xc1\xcb\x45\x30\x58\x0f\x41\x90\x60\x9a\x8f\x51\x82\xf4\xb6\x0c\xa1\x6c\x18\xa4\x49\xd4\x2b\x63\x90\x71\x49\x3e\x8f\x41\xba\x6e\x86\x9e\x15\x9c\x2e\x0f\x9c\x5e\xd6\x79\x6e\xf0\xff\xaa\xeb\x67\xbc\x62\x85\x37\x36\x3b\x6d\x88\xef\x4a\xd5\xcd\xc2\x7f\xfe\xe7\xa7\xf4\x7c\x3f\x78\x59\x64\xd1\x30\xbe\x9b\x09\xe3\x0b\x76\x01\xb0\xca\x4f\x71\x23\x58\xac\x5e\xd9\xae\x5c\x5d\x55\xcd\xa6\xc5\x03\x2c\xd3\x67\xfc\xeb\x97\xde\x6d\xf0\xf6\xea\xf0\x68\x1f\xa6\xbc\x9f\xe8\x11\xce\x7b\xc3\x60\xef\xf4\xf8\xb8\x7f\xb2\x8f\x3f\x46\xc1\xfe\xe9\x71\xff\xf0\x04\xff\xbe\x0b\xe0\xe9\xe1\xbb\xc1\xc5\xe5\xcd\x59\xff\xf2\x3d\xcd\x91\xa3\x74\xf8\x31\xca\x7b\xf1\x24\xbc\x8f\xa0\xe8\xde\x4f\x83\xf3\x9b\xc3\xe3\xfe\xc1\xc0\x6b\xa2\x7e\x5e\x71\xbc\x1a\x67\x19\xd7\xbb\x22\x46\x52\x89\xe9\x29\xed\x1b\xc2\x31\xcc\xc1\xf3\x59\x6b\x1c\x17\x25\xee\x1a\x68\xf3\xd8\x1b\x45\xe3\x18\x26\x74\xdc\x3d\x85\xf7\xa8\x36\x85\x25\x4f\x73\xb0\xe1\x7a\xca\xe3\xb2\x84\x7d\x85\xda\x57\x7d\xd8\xeb\x9f\xdd\xa8\x0d\xca\x45\x50\x3b\x94\x08\xf4\xa1\x04\x8d\x91\x30\x99\xc1\xb4\x3e\x85\x1e\x54\xdb\x88\x15\xd2\x7e\xe8\x6b\x93\xb2\x45\x53\xaa\xed\x56\x8f\x47\x4f\x3c\x04\x59\x93\xbb\xf8\x7e\x9a\x13\x16\x8c\x9f\x1c\x86\x12\xac\x83\x78\xe2\x03\x35\x22\x4d\x95\x8f\x84\xd2\xdb\xbf\x44\xc3\x12\x1e\xf7\xc6\x71\x12\xed\x5c\x27\xb5\xaf\x3c\xcd\x40\x9d\x05\x50\x75\xc8\x01\x5d\xd3\xfb\x8c\x07\xcf\x9d\xa4\xf6\xbc\x8b\xa1\xe2\x20\x20\x2e\x55\x74\x1c\xb5\xa2\xf0\x3b\x01\xf1\xba\x7c\xc0\xd5\x0e\xa6\x42\xd5\xfa\x35\x3a\xe6\x18\x26\xf8\x8d\xf0\x44\xe7\xb6\x48\xc7\xb8\x99\x87\xc6\xcf\x23\xec\x00\x8f\x73\x52\x96\xcf\xd5\x10\xd8\xdd\x6f\x2e\x4f\x6f\xde\x1d\x1e\x0d\x54\x5d\x07\x3c\xa5\x61\x4f\x59\x12\x71\x97\x4a\xfc\x4e\xff\x85\xff\x5d\xbf\x18\x8e\xa7\x05\x88\x76\x93\xa4\xb0\xab\x86\xa6\x9b\xbf\xe3\xd7\xd0\x1d\x4a\x7c\xfc\xcf\xdb\x8d\xe7\x93\x68\x92\xe6\xb3\x9b\xc9\x2d\xbe\x7b\xf3\xfa\xfb\x1f\xf5\xdb\xcf\xf4\xc7\xe7\x56\x3d\xfb\x5b\xa7\xf9\xd6\x69\xa8\xd3\x7c\x81\x89\x66\x57\xd5\x5f\x37\xd6\x6d\x9c\x8c\xaa\xa6\xaa\x56\x48\x35\x77\xde\x1c\x9e\x5c\x5c\xf6\x4f\xf6\x06\xff\x8d\x7b\x93\x7f\x03\xad\xda\xcb\xb2\x28\x9f\xc4\x45\x81\x6b\x10\x76\x98\xeb\x17\x79\x14\x8e\x7a\x69\x32\x9e\x81\xca\xfd\xe5\x66\x99\x6f\x3d\xe6\x8f\xdc\x63\xbe\x82\x29\x66\x88\xd7\x36\xf3\xf9\x58\x35\x44\x70\x76\xd4\x3f\xf9\x03\x75\x9b\xf5\xf7\x9a\x55\xdb\xe9\x6b\x5d\xd5\xbe\x86\x49\xea\x5b\x9f\xfb\xef\xd5\xe7\xa4\x69\xee\x0c\x6b\x5f\x3c\xa4\xd3\xf1\x88\x1a\x29\xf8\x5b\x9c\x51\x43\x6c\xcf\xcf\xee\xea\x0f\x71\x57\x18\x8c\xd3\x61\x38\x0e\x46\x71\x0e\x35\x00\xb6\x3b\xc1\x59\x5a\xc4\xf4\xc9\xe2\x02\x5e\x67\xf4\xeb\x31\xa2\x13\xce\xfb\x28\xdf\xc6\x2b\xa9\x02\xfa\x41\x9c\xc2\x36\x74\xb6\x4d\x27\x27\x50\xb2\x48\xe9\xae\xf6\x2e\x4f\x27\x00\xf9\x14\xc1\x66\x16\xb8\x3d\xc4\xf7\x0f\x91\x7c\x29\xfe\x75\xcb\x2c\x36\x33\x1e\x4b\x4c\xa6\xe3\x32\xc6\x9e\x00\xbb\xe9\xea\x70\x6c\x12\x26\xf1\x1d\xd0\xca\x96\x34\xde\xe4\x12\x73\x1a\x20\x3c\x08\x47\xdc\xdd\x3b\x2c\xde\x87\xa5\x6e\x72\x36\x3f\x08\xf0\x86\x1d\x85\xc9\xf3\x70\xc6\xd2\xd4\xfa\x35\x8e\xd8\x02\x07\x3d\x5f\xcd\xde\xf2\x6d\x7c\x14\xe4\xd3\x71\x64\x3b\xe6\xf8\xfa\x44\xdd\x54\xa3\x32\x02\x4d\x50\x35\x61\x49\xfe\x95\x04\x66\x5c\x2a\xfe\x36\x2c\xa2\xe0\x54\x2d\x03\x05\xab\x75\x78\x31\x81\x1d\x18\xbb\x33\xea\x41\x44\x59\xfc\x75\x1a\xe6\x51\x70\x9b\x87\xc3\x8f\xd8\xeb\xf1\x65\xdd\xb8\xe4\x21\x06\xf1\xd4\x7a\x82\x05\xf3\xe8\xaf\x53\x18\x48\x74\x9c\x5d\xaa\x5a\x00\x63\x35\xdf\x7d\xa0\x49\xee\x2f\x05\x0c\x2d\xaa\x9e\x3a\x51\xe5\xa9\xee\x17\x35\x31\xcd\xa7\x35\xd0\xd2\xf2\xb4\x4c\x87\xe9\x98\x55\xb4\x72\x98\xe1\xd2\x32\x7f\x0d\xd5\x2c\xe3\x84\x7a\x09\x97\x78\xf3\x7a\xe7\xfb\x1f\x7f\xdc\x79\xb3\xf3\xe6\x7f\x35\x4b\x66\x30\x38\x95\xa2\xf7\xc3\x0f\xaf\xff\x45\xe9\x78\x7a\x12\xfc\x75\x73\xdd\xee\xdb\xc7\x7c\xfe\x8f\x29\x0d\xcc\x0f\x68\x11\x02\x8a\x47\xfa\x44\xe7\x98\x78\x31\x11\x6a\x7b\x0a\xbd\xaa\xf3\x43\xc9\x1e\xa3\x25\x88\x24\xc8\x2f\xbd\x38\x38\xb9\x3a\xae\xd4\x83\x0b\x3c\x18\xff\x18\xec\x1f\x5e\xfc\x84\x7f\x4d\x82\xe3\xc1\xf1\xe9\xf9\xcf\x74\x5c\xfe\x90\x16\x25\x5d\x2a\xbc\x3f\xbd\xb8\xc4\x27\x59\xa0\x8f\xd2\x8b\x00\xc8\xf7\x88\xa4\x0c\x2e\x0f\x8f\x07\xa7\x57\x54\x62\x1a\xbc\x1f\xf4\x8f\x40\xdb\xd8\x7b\x3f\xd8\xfb\xe9\xe6\xf2\xe7\x33\xbe\x2c\xcd\xd1\x1a\xa8\x47\x1d\xf4\x1c\x8a\x0e\xdc\x67\xe7\x5f\x9b\xa0\xe6\x06\x0d\x47\x38\x38\xe1\x2b\x88\x9f\xad\x56\xc2\x0c\x31\x4a\x23\xb6\x8a\x8a\x3e\xe1\xc9\x39\xde\xd9\x40\xf7\xcf\x52\x09\x50\x2c\x6f\x86\xc7\x23\x73\x09\x8a\xde\x99\xc9\x50\xff\x18\xe3\xc6\x74\xa6\xcd\xd7\x24\x10\x43\x49\x0f\xc8\x14\xed\xbe\xbc\x20\xb9\xa4\x08\x19\x4d\xb2\x72\x66\x01\xe2\xf7\x22\x39\x36\xa4\x56\xe2\x41\x4b\xdb\x0e\x60\x1e\xc1\x49\xad\x71\x57\xbc\x1d\x44\x3b\xf7\x3b\xc1\x43\x59\x66\xbb\xaf\x5e\xcd\xd2\x69\x7e\x83\x2d\x8e\xd7\x71\x16\xce\x2b\x43\xdb\x85\x7e\x0c\xe3\x31\xcd\x03\x30\x45\x22\x89\xdc\x05\x2d\x14\x56\x16\x79\x54\x64\x69\x32\x82\xd9\x1f\x14\x53\x96\x7d\x12\x7e\x84\xc9\x7c\x0a\x33\x74\x5c\xb2\x8e\xca\xf5\xcb\xc6\xd3\x7b\x85\x2a\x2a\x52\x2b\xa2\x9a\x45\x45\xc4\x3b\xbc\x0d\x92\xb8\xce\x0b\x98\x01\x72\xd8\xa4\x3c\x56\xca\xb3\xba\xbb\x42\x8e\xa0\x7a\x83\x96\x1d\x15\x12\xb0\x9b\xd0\x6c\xc9\xf5\xe2\x8c\x6a\x05\xab\x88\x5e\xf0\x2a\x11\xf5\x6a\xa7\x9a\x08\xc0\x47\x61\x19\x8a\x06\x89\x1d\x90\x8c\x22\x6d\xcd\x7b\x6b\x1e\xdd\xc7\xb8\xd5\x23\xeb\x5d\x32\x52\xdb\x09\x2e\x22\x36\xf7\x7a\x88\xc6\x99\xd4\xc7\x5a\x41\x18\x85\xf8\xae\x1a\xf2\x34\xaf\x89\xfa\xf8\x72\x39\x23\xdc\x3f\xfd\x53\x1f\xef\x16\x91\x6a\x37\x50\xed\x44\x9a\x05\x28\x33\x21\x7e\x9d\xea\xf6\xf1\x76\x06\xfb\x2c\x2a\x4a\x07\x03\xb0\x95\xcd\x71\xb7\x3b\x22\x6b\xa8\x34\x07\x7d\xe7\x10\xcd\x95\xc7\x63\x52\x5a\xd0\xac\x20\xd3\x70\x65\x80\x03\x36\x48\x9f\xa0\x8f\xc6\xc5\xc7\x9d\x7f\xfa\x27\x54\x50\xf6\x53\x7c\x1c\x3c\x85\x09\x6d\xc3\x62\x45\x4d\xa7\x00\xdc\xa1\x7f\xff\x7d\x87\x45\xfa\xfc\xf9\x4f\xc1\xcb\x19\x2a\x71\xa2\x65\xcb\x1f\xb0\x22\xc6\x0f\xd2\xaf\x6c\x9e\xf1\xe4\x07\xf0\xd2\x31\x83\xb2\xbd\x11\xab\x31\x7b\xe3\x74\x3a\x0a\xde\x61\x0f\xce\xa5\x49\xbd\x03\x90\x59\xa0\xfd\xfd\x57\xe7\xa0\x43\x7c\xc0\x83\x93\xab\x83\xc3\x13\x89\xdf\x52\x39\x3f\xb8\xe0\x7c\x70\x76\x7a\x71\x78\x09\x4a\x8a\x2f\x72\x9d\x44\x60\xf2\x01\x75\xa1\x7d\x11\x50\xbd\x36\x13\x1f\x1d\xf6\x2f\x24\x4a\x7a\x67\x26\x3b\x3b\xac\x4c\xc9\x25\xea\x7a\x11\x27\x48\xf0\xb2\x5a\xf2\x0a\x58\xf3\xc2\x2c\xde\xa9\xd9\xb7\x48\xe3\xa0\x0d\x82\x53\x84\x5d\x0f\x26\xbb\x1e\x30\x6c\xeb\x1f\x0f\xd4\xef\xcf\xd2\x31\xaa\x83\xa8\x03\xa3\xe0\x25\xbe\x7f\x8c\xf2\x82\x26\x06\x7e\xfd\x81\x7f\x7e\xfe\xec\xd3\x88\xed\x31\xfd\xc4\x6c\xdf\x18\xee\x96\x38\x13\xfb\x2d\xbe\x32\x13\x0d\x87\x68\x4d\x4c\xb6\x5f\x73\x73\xfb\x0c\x14\xd4\x78\x38\x1d\x87\x39\xec\x45\xd3\x8f\x91\x64\xe9\xec\x4b\xed\x62\xad\x8f\x68\x69\x77\xb2\x88\xa1\x5f\xa6\x77\x77\x11\x7a\x1a\xb9\x65\x69\x07\x27\x08\x87\x3b\x6b\xdc\xd1\x2b\xcf\x2f\xa0\x1b\x4e\xf1\x38\x31\x20\xc7\xa4\x82\xf6\x2a\xf0\x55\xb4\x49\xd9\x67\xd1\x5b\xaa\x13\x94\x43\x28\xe5\x39\xb5\x80\x84\x40\x0d\x1c\xa7\x44\xbe\x38\x66\x71\x46\xb0\x68\x92\x41\x7e\x4d\x03\x25\xb5\x4e\x5c\x94\x2c\x14\x16\x16\x78\x2e\x9c\x6b\x47\x19\x3c\xd6\xc9\x32\x2b\x03\x53\x79\x09\x9e\xbe\x0b\x95\x85\x1a\x5f\x9d\x1f\xc1\xf8\x46\xa2\x45\x07\x25\x90\x35\xcd\xef\xf1\xd9\x69\x7e\xaf\x9e\xbd\x62\xeb\x48\x7c\x78\x81\x7f\xa8\xc7\xdc\x78\x57\x55\xe3\xed\xec\x48\x4a\xda\xb3\xb1\x37\x57\x7e\x1c\x43\xd9\xa6\x6b\x95\x56\x88\xd5\xe7\xb9\x8d\x50\x3e\xa5\xd1\xb0\x63\x12\x7c\x3e\x3e\x46\xdb\x7b\xa7\x35\x8c\x57\x21\x22\xed\x04\xc1\x79\x44\x23\x0e\x01\x16\x60\xb5\x2e\xe2\x80\xc7\x5a\x8e\xa2\x1c\x9b\x00\xa0\x68\x0f\xc6\xa7\x6c\x58\x80\x2f\x96\x94\x52\x26\x36\xe9\x1f\xbb\x52\x2d\x3e\x14\x4a\xdd\x90\x95\x0c\x94\x59\x86\xad\x4a\xe3\xe4\x4e\xb1\x05\xf5\xf8\x19\x74\xd4\x21\x9d\x6f\x96\x39\xaa\xbd\x4a\x00\x14\x56\xa2\x22\xb9\xa0\x6a\x49\x4d\xa9\x05\xbe\xaa\x78\xbd\x62\x71\xf2\x08\x13\xbd\xa5\x91\x40\x80\xf7\xe9\x53\xf4\x88\xb7\x33\xa8\x2d\xab\xa3\xd6\xbb\x38\x87\x1d\xe1\xdd\x94\x35\x71\x00\x43\x8f\x47\xe2\x19\xc4\x93\x0c\xf5\x54\x98\xbe\x1b\xb2\xe2\x2b\xda\xd2\xe0\x8f\x65\x89\x59\xb6\x76\xbd\xe3\x5b\x4b\xda\x5a\x52\xe8\x92\x35\xf7\x3c\x3a\xb9\x56\xab\x2a\x6e\xb9\xf4\xce\x33\xa4\x15\x39\xae\x2c\x52\x81\x06\x26\x31\xe9\xa4\x60\x25\xc8\xb5\x09\x49\x9f\x45\xf6\x50\x5b\x09\xb2\xbb\x90\xb0\x87\x5d\x7f\x5b\xca\xa0\x6b\x14\x74\x1d\xed\x29\x83\x4a\x82\xa6\x4f\xc1\xc5\xc5\x7b\xf5\x21\x14\x49\x64\xf5\x83\x74\x10\x09\x8c\x8a\x34\x18\x45\xe3\xa8\x8c\xc8\xdc\x5a\x79\xe9\xd2\x72\x2e\x7f\x19\x1b\x8d\x99\x0d\xaf\xfd\x93\x29\x8c\xef\xdb\x48\xf9\x41\x46\x78\x7d\x0e\x32\xea\xdf\xca\x73\xdc\x56\xc3\xb6\x30\x66\x61\x40\x33\x91\x18\xe0\x2b\x91\x88\x16\xd1\x98\x4f\xe1\xd5\xa5\xd5\x5d\x1c\x8d\xa5\x03\x49\x2b\x89\xc8\xa4\xa1\x33\x35\x6f\x00\xc4\x25\xc1\x45\xe6\xc7\x8c\xc4\x7c\x4a\xf3\x8f\x64\x7e\xf0\x31\xce\xb2\xb9\x66\x47\x76\x28\xc8\xce\x53\x02\x2f\x2c\x7f\xb1\xd4\x28\x62\x67\x00\x58\x61\x50\x5f\xe4\x51\xc6\x85\xbc\x5b\xc6\x0f\x4c\x12\x0c\xf6\xb2\xe4\xdb\x8a\xdf\x12\x4d\x2f\x46\x71\x78\x9f\xa4\xb0\xfa\x0c\x0b\xbe\x8d\x1d\xa7\xf7\x74\x4f\x29\x8b\xe3\x0f\x21\x09\xa1\x1d\x21\x82\x87\x28\x1c\xe3\x55\xf1\x43\x34\xfc\x18\x94\xb3\x2c\x52\x87\x25\x5b\x78\x75\xc9\xfe\xb8\x49\x9a\x44\x5b\xe2\x11\x41\x27\x2c\xa7\x58\x55\xc8\x87\x18\x96\xf0\x4f\x1e\xbc\x17\x08\x24\x06\x85\x78\x94\x43\xef\xcc\x64\xec\xd3\x1e\xf2\x65\xa9\xda\x4a\x59\xa6\x72\xa9\xb8\x1d\x9c\xf7\x30\x4c\x33\x8a\xee\xe2\x84\x0d\x7b\xe8\x73\x5a\xa7\x33\x7f\x00\x1f\x01\xd0\xdd\x9e\x69\x70\xd7\xeb\xc7\x73\x81\xc6\xca\x86\x27\xdf\x56\x5c\x8c\x24\x16\x26\x30\x3d\x7e\x40\x4b\x3e\x2b\x6c\x55\xc8\x02\xc4\xb3\xcd\x98\x76\x96\xe7\xf0\x2f\xef\x49\x91\x7d\xb0\x14\xb0\x60\xbe\x31\xe5\xc0\x01\xb0\x3d\x85\xa7\x96\x2d\xef\x1a\x39\x74\xae\x02\x03\x59\xf1\x6b\x9b\x6b\x7e\x4c\x5b\xec\x6a\x7b\xdd\x10\x71\xb5\xda\x6e\x40\x98\x4d\x36\xcc\x97\xa8\x7f\xb7\x6a\x2e\x9c\x69\x01\x82\x7e\x72\x43\x4f\x58\x8c\xaa\x65\x0b\xd5\xa6\x73\x11\xe0\x9f\x30\x89\xff\x46\xb5\xa9\xa4\x98\xfa\x9c\xeb\x3c\xab\x0c\xae\x66\xa8\xcd\x8f\x40\xfb\xef\xf8\x87\x5a\xd0\xeb\xac\x3b\x9e\x60\xad\x9b\x8d\xb9\x32\x65\x89\xf6\x09\xb4\x69\x05\xed\x39\x7d\x4a\xc6\x69\x38\xe2\xab\xbd\x19\xdb\x36\xd1\xf5\x32\x5d\x6e\x25\x51\x89\xd6\x24\x18\x24\xc3\x22\xf7\x0a\x88\x1e\x22\x4e\xe2\xfb\x3c\xe4\x33\x3d\xa5\x1d\x1d\xaa\x75\x7a\x7f\x1e\xee\xc6\xda\xae\x5d\xe1\x44\xe1\xd4\xd5\x28\x59\xcb\xc1\x86\x8b\x0e\x17\xce\xe0\x0f\xfe\x16\xbf\xe1\xfe\x4b\xef\xbd\x7e\x5b\x54\xea\x7e\xd3\xd7\xd6\x77\x79\xa4\x0d\xe6\x2a\xc5\xe3\xb7\x65\xa9\x34\x55\x2d\x6e\x55\xa8\xc2\x5c\x05\x7b\x68\x42\x3e\x54\x37\xa9\xe1\x68\x02\xeb\x75\x01\x95\x2f\x41\x4b\x8a\xef\xe8\x40\x03\x76\x77\xc9\x47\xde\xe3\x51\x30\x31\x8e\x72\x62\x6b\xa9\x3f\x7e\xdd\xcc\x9f\x6d\x8a\x27\x46\x25\xaa\x7a\x11\x4f\x97\xa0\x46\xf6\x1a\xa1\x27\xa4\x46\xf1\xa0\x74\xb1\x44\xcb\x13\xb9\x7f\x2e\x95\x73\xc2\xa1\xa2\x0c\x23\x3e\xfa\x94\xe1\x4e\x0e\x83\xc3\xb1\x55\x0b\xea\xec\xb7\x21\x68\xce\x31\x29\x6d\x79\xd4\x0b\x6b\xd2\xef\xe8\x58\x84\x14\x15\xe8\xb7\x7a\x38\x9d\xeb\xe9\xeb\xd7\x3f\x0c\xf5\x15\x19\xfd\x8a\x30\x14\x00\x3f\xc7\x5a\xeb\x67\xa9\x7a\x06\x93\xa9\x7e\x54\xa8\x47\x34\x31\xf1\xc3\xdf\x54\x34\x8b\x4a\x1a\x3c\x3f\x5b\x14\xc7\xa3\x3d\xfe\x4e\x2a\x2a\x7e\xd0\x34\x57\xeb\x11\x0d\x2a\xe8\x5b\xa3\x78\xa4\x4c\x96\xd8\x44\x9f\x6d\x0b\x52\xb4\x3a\xc0\x60\x21\xc3\x74\x24\xea\xa4\x5d\xe1\x8c\xc2\xbd\x3d\x3c\x3a\x3a\x3c\x39\xc0\xf0\x01\xfd\x83\xc1\xb9\xc0\x73\xb1\x94\x19\x4a\x47\x50\x90\x6e\x54\x6b\x05\xcc\x00\x31\x9a\xee\x2e\xae\xff\xce\x5d\x8d\x93\xac\x1d\x33\x3c\xc0\xd2\x36\x57\x8b\x97\x8e\x2a\xe6\x1c\x46\x36\xc1\xb3\x2e\x7d\x37\x59\x8f\x16\xd0\x56\xc8\x55\xd9\x6d\xac\x72\xfa\x9a\xf3\x99\x2a\x67\x64\x67\xaf\xdc\x42\xc4\x47\xfa\xe2\x74\xe2\xe3\x12\x53\x26\x6c\xcd\xd0\x76\xb1\xea\xa6\x93\xd9\x0d\xb1\x24\xde\x85\xd9\xb0\xe7\x85\x44\x20\x6c\xd2\xdb\xa8\x7c\x8a\x22\x32\xa9\x6a\xae\xc8\x34\x89\x35\x0f\xf2\xd4\x3c\x42\xe7\x78\x16\xd6\x2b\xc1\x5a\x85\x9d\x84\x33\xa8\x17\x9a\x90\xa9\x13\x2b\x3e\x56\x5e\xbe\xef\x45\x6f\x85\x31\x1b\x03\xde\xce\x96\x1b\x59\xd2\x42\x76\x82\x05\xdb\xb3\x2c\x4f\x87\x51\x34\xfa\x93\xa3\xb6\x5f\x4e\x2e\x6b\x73\x2d\xf3\xf7\xe6\xd8\xfe\x82\xdc\x73\x07\xfb\x75\xc8\x66\x6d\x36\xbf\x3d\xe6\x28\xba\x0b\xa7\x63\xfd\xa5\xf5\xec\xeb\x67\x2f\xb2\x09\x4e\x6b\xa8\x52\x35\xcd\x6e\xa2\x16\x22\xb8\x43\x70\xee\x14\x62\x5f\x58\x8b\x71\x47\xcb\xbe\xfb\x85\x84\x6a\xd9\x50\xeb\x94\xc5\xe7\xe8\xe2\x4b\x48\x62\x6d\x92\xfa\xe4\x52\x67\xea\xae\x82\x8d\xd2\xcc\x72\x1a\x8f\x47\x19\x6a\xff\x50\xbc\xfa\xa1\x05\x6f\x18\x8e\x4b\xac\x5b\x20\xb4\x17\xc1\xef\xea\xae\x15\x84\x59\x88\x59\x89\x67\x56\xb0\x4a\xe1\x7c\xa0\xaf\x46\xc3\x44\x7b\x12\x6b\x4f\xdd\x69\x12\x93\xde\x37\x81\x8d\xdc\x34\x8f\x28\xda\xd6\x38\xfe\x18\x05\xc7\xdb\xc1\xf1\xdb\xed\xe0\x80\x1c\x95\x0f\xde\x4a\x82\xae\x9b\x8d\xb1\x32\x55\x78\xd2\xd1\xa8\xc7\xc6\x1b\x3d\x72\x5f\x41\x6b\x69\x7e\x03\x9d\x04\x77\x99\x83\xff\xe8\x1f\x9f\x1d\x0d\xd8\x0f\x10\xa3\xce\x2e\x10\x9c\xe5\xf1\x23\x6c\x01\xcf\xf1\x6f\xe5\x71\x33\x99\x65\xfc\x50\x7b\xdd\xbc\xc2\x3f\x5e\x09\xf5\xfd\x12\x92\xd8\x9b\x04\x6f\xf7\x55\x60\xe5\xa2\x78\x08\x28\x3c\x29\xbd\x72\xd5\x40\x26\xb4\x33\xcc\xe2\xe0\x17\xa8\xa4\xe4\xb7\xba\x5c\xce\x01\x97\x55\xc1\x56\x9c\x88\xb5\xa2\x76\x50\x0c\x63\x7b\x75\x31\x38\xa7\x5f\x67\xfd\x8b\x8b\x3f\x9f\x9e\xef\xe3\x67\x71\xb1\x90\x09\xad\x0c\x29\x76\x0c\x7b\x0e\xea\x49\x97\x03\x11\x2e\x47\x63\xf8\xa5\x77\xb7\xec\xb2\x38\x0f\x66\x78\xd6\x3f\x87\xbf\x2f\x07\xe7\x17\x37\xfd\x8b\x1b\xf4\xb1\xfd\xb5\xd6\x9d\x2e\x76\x97\x43\xd6\x34\xd9\xd6\x03\x45\x4e\x66\x78\xb6\xca\xe1\xf7\xf2\xa0\xc6\x72\x32\x83\xb6\x5c\x01\x69\xc8\xee\xb8\xe8\x7f\xbb\x12\x0a\x86\xef\x20\x47\x2f\x0a\xd6\x41\x70\xf3\x58\x1d\x87\x49\xf0\x67\xc0\x4b\x9f\x8a\xe0\x2c\x7d\x8a\xf2\x8b\x07\xd8\x44\x91\xd7\xca\x28\x9d\x62\x1a\x05\x0a\xee\x39\xda\x0e\x38\xa6\x29\x07\xb0\x40\xbf\xdc\xdf\x31\xd8\x29\xc3\x5e\x23\xf0\xb5\x82\x86\x7f\x3f\x2b\x7f\xdd\x1a\xb6\x32\x43\x0b\x8e\xd0\x97\x04\xd1\xd9\x31\x5a\x40\xdf\xb2\x81\x4b\x66\xd2\xdf\x7a\xc9\xb7\x5e\x52\xef\x25\x1e\x53\x89\xca\xc9\xa2\xd5\x77\x95\x32\xe4\x62\xb0\x77\x75\x7e\x78\xf9\xf3\xcd\xc1\xf9\xe9\xd5\x99\x57\x6f\xf3\x02\x72\x0b\x64\xa5\x0f\x4e\xcf\x0f\x78\xfd\xf0\x11\xc9\x17\xca\x47\x28\x57\xb0\x2e\x61\xac\xf8\x89\xd9\x15\xdc\x43\x70\x95\x1d\x66\xe5\xcf\xeb\x07\x64\x17\x48\x6b\x97\x92\x3e\x6c\x28\x68\x05\x24\x63\x21\x1e\xdf\x34\x6b\xe9\x39\x0e\x66\x33\xf2\xaa\x57\xfe\xf4\xd2\x6c\x55\x27\x9f\xcc\x70\x32\x6a\xcc\x0e\xb5\xff\xfd\x43\xfd\x45\x1b\x0c\x25\xc8\x5d\x9a\x02\x06\xbf\xaf\xbb\x8f\xbd\x82\x17\x8e\xb6\xf8\xfb\xa8\xa3\xfd\x33\x52\xd0\x2b\xac\x51\x58\xcc\x92\x21\x45\x47\x07\x66\x3a\x84\x02\x0c\x83\x9b\xe3\xc3\x93\xab\x4b\x8e\xcb\xd0\x83\x86\x82\xc1\xf2\xb2\xcc\xa7\x51\xf0\x9f\xc1\x5d\x38\x2e\xf0\x5f\x94\xe1\x55\x99\xbe\xc2\x85\xe0\x3b\x2a\x37\x4c\xc7\xa0\xe8\x37\xca\xf1\x0b\x8a\x84\x04\x08\x47\xa7\x7b\xfd\xa3\x01\xbc\xdb\x3b\x1a\xf4\xcf\xbf\x73\x8d\xd5\xaf\x46\x4c\x7b\x63\x72\xbc\x2e\x58\x4f\x7b\x3a\x34\x52\x3d\xae\x75\x16\xbc\xd2\x22\xf0\x95\x16\x16\xa4\x20\x66\x74\xab\x55\xd1\xec\xcc\x26\x63\x31\x60\xcc\x66\x78\xf9\x54\xab\x9a\x19\xe6\xe1\xb9\x69\x04\x04\xe4\xcb\x7a\x78\x4a\xe3\x82\x1d\x44\xfe\xb3\xd7\x1b\xc5\x05\xfe\xe5\x59\x8d\x8e\xd8\x3e\x62\x8f\xd2\x09\x06\xff\xc7\x15\x87\x87\xaf\x9f\x44\xcb\x64\x3e\xcc\xf0\x6c\x05\x48\xfc\x58\xe8\xc2\x3e\xc0\x6c\x97\xf2\xef\x57\xa7\x97\x7d\x8a\x8a\x72\x09\x7f\x1c\xdd\xcc\x63\xa3\xc4\x81\x5e\xb0\x6a\x0f\x73\x8e\x6d\x72\xa1\x02\xa4\x2c\xac\x6c\x3c\x54\x78\x83\x98\x85\x71\xb5\x16\xf6\xc8\x9e\xdd\xf3\xc3\x7d\x01\xb9\x7c\x9a\x8b\x27\x4c\xd2\x30\x6a\x93\xb6\x51\xcd\xf6\x9b\xca\xeb\xb0\x93\x19\x6f\xa8\xa5\xd9\x7c\xe9\x7f\x96\xe9\xdd\x89\xbb\xa8\xa9\x37\x71\xe9\xd1\xce\x1a\xd1\x17\x16\x94\x05\x74\x9f\x35\xf3\xdb\x07\xd8\xf4\x07\xf0\x19\x00\x76\xf5\x5b\x07\x8a\x44\x4d\xf6\xe6\xfc\x0a\x5a\x9b\x62\x46\xfa\x7d\xda\x6e\xd0\x7e\x42\xfb\x04\xba\x14\x14\x72\x8e\xfc\xd4\x3f\xb8\xf0\x9c\xb9\xd6\xc5\xac\x45\xc5\xc8\x40\xa5\x57\xa6\x1f\xa3\x24\x38\xea\xbf\x1d\x1c\x05\x67\xe7\xa7\x1f\x0e\xf7\x07\xe7\x30\x6f\xfe\x34\xf0\x5c\x99\x7c\xc1\xda\x08\xc6\x6e\xee\x55\xf5\xdf\x9e\x03\xc2\xf9\xf2\x11\x19\x1e\x7b\xe2\x88\x55\xe7\x89\xc3\x14\x36\xc3\xed\x9a\x7b\x35\x4e\x6d\xaa\xf4\x31\x9a\x2d\x7f\x4e\xfd\xe0\xa7\xc1\xcf\xb6\x13\x96\xe0\x19\x33\x03\xb4\x15\xfb\xab\x8d\x87\xbb\xc9\xa8\xdd\x1d\x1a\x69\xa5\x60\xb8\x3e\xd1\xbb\x97\xce\xff\x2d\xc2\x4e\x66\xa3\x5b\xf8\x0f\xfe\xa9\xbe\x5f\x13\xbf\x01\x8f\xdf\xad\x0d\xdc\x7f\xbd\x42\x5f\x2b\x1a\x29\xaf\xca\x49\xf6\x4a\x5f\xe8\xdf\xf0\x17\xa4\xa3\xb9\x76\x83\xf4\xdb\xd8\xf9\x36\x76\xbe\x8d\x9d\x6a\xec\x78\x2d\x3b\x0f\x61\x1e\x8d\xf4\xb6\xb1\xcd\x4e\xd3\x48\xe9\xc5\x92\xb4\x49\xd6\xb1\x31\x95\xa1\xca\x61\xf8\x57\x7e\xd4\xa3\x4d\x99\xef\xea\xec\x05\xe5\x2d\xd4\xc2\xb6\xd0\xb8\x09\xac\x47\xf6\x7c\x86\x8d\xea\x17\x90\xcb\xa7\xb9\xc8\xb6\x7d\x49\xfb\xf1\xab\x92\x40\xeb\xcb\xb6\xa7\x83\x0e\x2f\xaa\xc2\x75\xed\x37\x0b\xf6\xce\x07\xfb\x83\x93\xcb\xc3\xfe\x11\xd5\x77\x1c\x5c\xfc\x7c\x71\x74\x7a\x70\xb3\x7f\x0e\xfd\xf4\x06\xaf\x7e\xe7\x0d\xa5\xd3\x7a\xd1\x63\x35\x71\x9c\x85\x85\xca\x83\x0d\xd3\x24\x4e\x6b\x14\x08\x18\x7a\x3c\x47\xb0\x9b\xcf\x74\xe4\x2e\x5d\xd4\xa3\x8c\xcc\xcd\xfd\x83\x49\x3a\x8a\x8c\x33\x85\x67\x4d\x28\x75\x20\x49\xb1\x3d\x17\x63\x7b\xce\x7c\x9b\xb9\x5f\xbf\x68\x48\x6d\x90\x92\x82\x1d\xd1\xdc\x07\x82\xb2\x0c\x35\xb3\xd2\x25\x2f\x85\x15\x65\xc6\xd9\x0e\x66\xaa\x37\xf3\xa5\xe9\x0d\x2d\x57\xf0\xec\xfb\xf9\xb3\xef\x6b\xeb\xd5\x85\xca\x14\x18\x2e\xac\x09\xf5\xe5\x8a\xae\xaf\x56\x13\x6c\x71\x85\xb0\x4d\xe6\x66\x54\xd8\x0e\x8f\x6e\x7b\x13\xbc\x69\xa3\x8f\xa3\x2d\xd4\xb6\x6b\xe9\x1d\xbb\xa2\x55\x67\x9f\xf3\x2f\x58\x2c\xdf\x50\x3a\x01\x73\x68\xaf\x79\xa6\xaa\x71\x50\xcc\x8a\x71\x7a\xbf\xfb\xea\x95\x63\xbf\x2f\x22\x36\xaf\x43\x61\xd4\xe8\xd0\x76\x0d\x40\x82\x3c\x8a\x93\xe9\xa7\x57\xc7\xe1\xb0\x73\x93\x62\xdf\xd1\x8d\x4a\x7d\x85\x1c\x7a\xa8\xfb\xcc\x5b\x78\x17\x7f\x70\x96\xc9\x5a\x27\x32\xdd\x87\x76\xff\xb2\x74\x4d\x5a\x49\xa2\x6f\x4a\x59\x9a\x6b\x94\x67\x21\x83\xe9\x2e\x3f\x50\x52\xe9\x9b\xda\x86\x60\xf3\x4b\xe0\x15\x5a\x67\x55\xa9\x5c\x86\x00\xdf\xe6\xda\x6f\x73\xed\xb7\xb9\xf6\xdb\x5c\xfb\x6d\xae\x5d\xc7\x5c\x6b\x57\x6b\x31\x62\x22\x5d\x18\x82\x56\xff\x88\xb3\xe4\x7f\x80\x1a\x7f\xf9\xfe\x94\xf2\x05\xbf\xc7\x24\x00\xfb\x83\x73\x95\x3b\xb8\x0f\x7b\x19\xd4\xdc\xa1\x83\x64\xd3\x32\xc0\x61\xa5\x27\xd0\xb7\x33\x6d\xfd\x3f\x4f\xb5\x80\xd8\x5b\x2a\xb3\x78\x94\xdf\xa5\xf9\x04\x86\xf9\xc1\xe0\x52\x6f\xd5\xd5\xa6\x1f\x66\x5a\x14\x60\x27\x38\xbc\xa3\x20\xdc\x84\x87\x21\xd2\x74\x6a\x8f\xc7\x38\x0c\x7a\x23\x4c\x13\x74\x86\xb6\x04\x3a\x3b\xae\xc2\xa4\x40\x7b\x45\x09\x3b\xd9\x6d\x1d\x6b\x8d\xdc\x71\x61\x44\xf5\x2e\x67\x19\x77\x09\x4d\x53\x44\xa5\xb2\xee\xd6\xee\x59\xaf\x70\xc4\xed\x50\x64\x37\x74\x8e\x49\x1f\xa3\x3c\xc7\xb3\x8a\x07\x00\xc4\x89\x94\x0c\x74\xa1\x21\x14\x34\xa1\xe9\x28\x34\x30\xd7\x3e\xa4\x23\x55\xe4\x3f\x76\x54\x53\xbc\x4b\x73\x8a\x55\x33\x4a\x87\x94\x59\x9a\xd8\x54\xc1\xed\x1f\xe3\x22\x2e\xb5\x49\x6b\x98\xc5\x50\xaa\xd8\x19\x62\x34\xe6\x3b\x0e\xc6\x8c\x8e\xff\x3b\xcb\xf7\x39\xc3\x3b\xfe\x56\xd7\x2f\x5e\x3d\x7e\xff\x0a\x93\x09\x5d\xbf\x00\xa6\xd4\x9e\xf0\xa1\x93\xc0\xf8\x3f\x10\xfc\xfa\x45\xbd\x35\x76\x1b\x75\xff\xd4\x7b\x7a\x7a\xea\x61\x2b\xf6\x00\x3b\x4a\xd0\xc3\x12\x93\x83\x5b\x00\x47\xc1\xd6\x5f\xff\x37\xf6\xc6\x5d\xba\x63\xd1\x83\xd1\x2c\xde\x28\xf8\xb7\x57\x75\xe3\x01\xd7\xba\xff\xad\x33\x7e\xeb\x8c\xcf\xd7\x19\xad\x13\xa3\x8a\xd4\x56\xb3\x0c\xb9\x83\xb5\xd0\x75\x66\x22\x51\x79\xb0\x32\x9a\x72\xa0\x9d\xab\x17\x4b\x99\xda\x87\x75\xe3\x08\xad\x05\x53\x03\x9d\x0f\x3b\x65\xbf\xd1\x82\x51\x83\xc2\x8f\x45\xf6\x10\x26\x91\x32\xa4\x2d\x5a\xb1\x32\x50\xfa\xb0\x6c\x1e\x91\xf9\xb2\x5b\xa2\xf2\x61\xc5\xf7\xe2\xfe\xe6\x01\x84\x2c\xdb\x08\x34\x50\x7d\x4d\x03\x2c\xb6\x01\x22\x5e\xe3\xd2\x9e\x6c\xf2\x1a\x78\xcb\x76\x78\x5d\x61\x57\x37\x61\xfc\xd6\xd2\xeb\x6b\x69\x9f\x2e\x6d\x37\x8e\xf0\x1f\x4f\x1e\x38\x7e\xe2\x88\xa7\x0d\xfe\x92\xd8\x20\x5a\x08\x61\x31\x58\x68\x2d\x8d\x0b\xab\x8d\x58\x66\x8b\x84\xf6\x22\x59\x70\xda\x88\xe3\x71\xf7\xda\x18\x9a\xc6\x91\x69\xbe\xf0\x6a\x57\x9f\x4d\x0a\xe2\xd5\x20\x86\x7b\xb1\x36\x9f\x45\x24\xf7\x62\xde\xb8\x10\xf3\xe6\xb9\x48\xe5\xcd\x4a\x2d\xa0\xb5\xeb\xb6\x9e\xd6\xbc\xda\xf0\xb6\xc2\xf8\x08\xd3\xbc\x53\xf2\xe7\x6e\xa0\xb3\xb3\x63\x13\xde\xde\x5d\x14\x96\xd3\x1c\xfe\x1d\x87\xf7\xc1\xbb\x41\xff\xf2\xea\xdc\xcb\xaf\xd1\x4d\xef\xc5\x1e\x5d\x22\x3d\xfd\x12\x8d\x24\x4e\x26\x5d\xfd\x36\xed\xb4\x56\xb6\x7c\xa2\xdb\xb9\x65\x9d\xe4\x3e\xcc\x5b\xb4\xab\x89\xc2\xc1\xe2\xd1\x1f\xfb\xd1\x17\xf4\x11\x76\x73\x85\x37\xee\x42\x69\x2b\x74\xd7\x0f\xd1\xf1\x0b\xd4\xc9\x5c\xce\x3e\xcd\xb2\x76\x58\xd8\x6a\x16\xb5\x1d\xa1\x56\x13\xe7\x77\xe8\xb8\x16\x94\xf4\x7f\x14\x06\x0c\x57\x83\xcb\x94\x23\x0e\x71\x92\x09\x3c\x9b\x28\x15\x10\x26\xb5\xa1\xb0\x3b\x55\x80\x8d\x94\x93\x50\xec\xc7\xd1\x7d\x4a\x81\xbd\xa2\x64\xb4\x4d\x4e\x78\xd5\xe1\x07\xf4\x11\xd7\x9d\xcb\x57\x23\xa6\xb5\x31\xef\xa3\xb2\xc7\x41\x97\x7b\x1c\x74\xd9\xb3\xdf\xc9\x74\x56\x76\x98\x8e\x2f\xf8\x65\xef\xf4\xf8\xb8\x7f\xb2\xef\x9a\xd0\x17\x0a\x5b\x81\x55\x32\x06\xe5\xf2\xae\xdc\x65\x7a\xd8\xe6\xaf\x2e\x4f\x5f\xa9\x64\x67\xff\x49\xb6\x9c\xff\x89\x47\xf0\x73\xff\x79\x7e\x47\x7f\x7f\x57\x29\x12\xc0\xe0\x2c\x4f\x27\x99\x0a\xbd\x42\x26\x38\xf9\x84\x6d\xa8\xa6\xc9\x18\xa3\xda\x6f\xf5\xee\xb6\xea\x07\x59\xe6\x53\x9d\x05\xb9\xfe\xeb\xd5\xbe\x0a\x90\x59\xbc\x52\xde\xf9\xa0\xcf\xdf\x86\xb9\x50\xde\x70\x53\xd0\xa4\xbb\x19\xe3\x8d\xc1\x4d\x38\x19\xfd\xcb\x8f\x02\x06\xd4\xf6\x78\xd6\x23\xc7\x7f\x45\x1a\x0d\x1f\x5c\xbb\xb5\x6f\xed\xd9\xb6\x3d\xad\xdd\x13\x07\x75\x3d\x1c\x83\x6b\x3a\x5c\x2e\x6f\x87\xa7\xf8\x86\xbf\xf4\x42\x3c\x9a\xd4\xb7\xb3\xd3\x4a\x0b\xd2\x09\x8a\xd9\x2c\xe7\xd7\xba\x5d\x55\xc1\x8b\xf9\xaf\x1e\xb1\x0a\xd6\xc4\xc4\x55\x11\xd8\x22\xbb\x05\xc1\x42\x2e\x20\xef\x35\xb4\x59\xd6\x0a\x3b\x09\x33\xb5\x89\xaf\x26\xf6\x75\xf8\x94\xcc\x61\x27\x33\x74\xa4\x5b\xc7\x49\x86\x15\x73\xb5\xd3\x8c\x96\xd0\xab\x9f\x1d\x7d\x6b\xf6\x0d\x35\xbb\xbd\xb3\x73\xac\xe4\x6a\xe7\xac\x2d\x52\x8b\xe0\xf1\x8d\xb6\xf9\xc0\x3f\xab\x03\x0f\xfc\x1b\x7d\x57\x1e\xbf\x9f\xbf\xfe\x9e\x1e\x79\x4c\x2f\xeb\xe6\x66\xad\x5a\x3a\x3f\xb5\x71\x88\x55\x2f\x69\x87\xf4\x72\xb8\xf4\xf2\xb4\x84\x42\xb4\x8d\x2d\xfc\x00\x6b\x65\xad\xb0\x74\xaf\x2d\x45\x8e\x5c\x28\x64\x07\xe2\x2c\xbe\x2e\x24\x55\xca\x0e\x35\xcd\xef\x97\xbf\xf9\xd2\x69\x8f\x8b\x95\x27\x4a\x0b\x51\x74\x4e\xcb\xca\x2b\x8b\x56\x37\xd5\xf7\x5c\x9a\x6b\x2b\x28\xab\x50\xb5\xdb\x0c\x07\xcf\x7a\x49\x37\xa4\xeb\xe3\xa9\x42\x56\x20\xce\x47\x6e\x0e\x4b\x65\x0a\x49\x65\x28\x5f\x8b\x4a\xe5\x9c\x20\xd6\xce\xce\x51\x39\x9a\x4b\xab\xf5\xe6\x64\xf0\xe7\x1b\x4f\x7d\xc2\x4a\xea\xc1\xd4\x74\xf5\x38\x47\x6a\x3e\xf2\x12\xa5\x15\xa0\x8f\x80\xfa\xf6\x10\xc9\xdd\x53\x94\x40\xe4\xc3\x48\x3c\xf2\x47\x90\x96\x93\x44\x27\xc8\x16\x42\x0a\xc7\xee\x75\x58\x7e\xd4\x4a\x4e\x7f\x54\x2f\x51\x6b\xc7\xc2\x04\xe1\x11\x44\xc7\x4a\xea\x60\x9a\xa5\x3d\x9d\xf2\xfd\x97\xfa\x2e\x71\xf9\xb4\x9e\x06\x6c\xad\x38\x94\xae\x8d\x56\xa7\x88\x6b\x63\xe4\xa8\x10\x06\xc0\x89\x7c\x37\x16\x4b\xc5\xdd\xe0\x79\xd9\x0a\xbc\x5e\xdc\x07\x9c\xa2\x74\x54\xeb\x63\x35\x43\x1d\x9e\xec\x0f\xfe\xc3\x8f\x9f\x15\xc1\x2e\x82\x0a\x0d\x15\x25\x8f\x71\x9e\x26\x68\x3c\xd3\x7b\x0c\xf3\x98\x0e\x5d\xe9\x72\xd1\x25\x81\x1b\xc0\x2a\x40\x41\x91\x54\x6a\xa6\x24\xf3\xa3\x38\x32\x72\xfe\x18\xec\x1f\x5e\xfc\xb4\xe8\x79\xe3\xbc\x77\xe8\x0c\x6b\x17\x76\x85\x50\x4d\x2b\x44\x67\x92\x66\x47\x27\x47\x81\xcc\x87\x59\xed\x0a\xd5\xa5\x96\x98\x28\xbc\x58\xb8\xae\x10\xc5\xdb\xc3\x4e\xf7\x97\x9b\xe2\xea\x5b\xd5\x65\x0f\x31\x1f\x4e\x05\xb1\xf2\xaf\xda\x4a\x5c\x1c\x55\x29\x7b\xf5\x1b\x93\x60\x70\xf2\xe1\xe6\x43\xff\xbc\xf9\xe3\x43\xff\xe8\xca\xdd\x31\xfd\x91\x9c\x22\x19\x0f\xbc\x55\x6e\xc2\xff\xe4\xc4\x84\x1e\xe2\xf8\xa0\x38\x45\xc1\x6d\x1f\x25\x02\xab\x6e\x3a\x51\xb5\x3a\x3f\x65\xbb\x7c\x0f\x29\x1c\x00\x4e\x01\x78\xbb\x81\x34\xb4\xe5\xf0\xe4\x6a\xa2\x72\xb2\x72\xcf\xfb\xfe\xbe\xd4\x1e\x32\xae\x95\x9d\xb3\x72\xcb\x97\xe5\xf4\x6a\xf1\xde\xdc\x43\x6e\x5f\x24\x4f\x91\x96\x3b\x07\xeb\x7e\x2d\xfa\x98\x27\x90\x5b\x20\x15\x75\xf0\x99\x3a\xc0\x5a\xd9\xd9\x2b\x87\x96\x21\x3d\x15\x85\xb9\x75\x7c\x30\x17\xb5\x9d\xf5\x5c\x9d\x77\xb1\xa9\x95\x74\x43\xd6\x3b\xe0\x0d\xf5\x3a\x1f\x65\xd6\x4a\xea\xcb\xd4\xa9\x3c\xd4\x8b\x7a\x80\x16\xc5\x03\xfb\x54\x47\x23\x7f\x73\x09\x2b\xa9\x07\xd3\xea\x2c\xcf\xff\xdb\x2c\xd1\xb8\xd9\x78\x35\x95\xab\x91\x6a\x76\x12\xa4\xf5\xd6\x77\x06\x3d\x4a\xa2\xcb\xc1\x83\x55\xb6\x7d\xfc\x71\x14\xfc\x82\x71\x44\x6f\x54\x0e\xc0\xdd\x5f\x71\xd5\xdb\xc5\xa3\x69\xfa\x0f\xfe\xa2\xd3\x7b\x4c\xd5\x4c\x07\xda\x3d\x0a\xf1\x40\xf2\xcd\x5f\xe0\xc9\x0e\xf4\xf8\xe8\x13\xe8\xb9\xd5\x1b\x65\xb6\xdf\xcb\x8a\x68\x3a\x4a\x7b\x65\x39\xa3\xc7\x77\x69\x8e\x7e\xf0\xcd\x87\xda\x82\xa6\xf6\xd8\xd5\x20\x7f\x5f\x95\x75\x7d\xd8\x9e\x25\xd3\xd8\x52\x31\x27\x18\x1b\xd6\x8c\x7c\x77\xb6\x46\x12\x3b\x93\x12\xcf\xb6\x40\x07\xf5\x3b\x15\x5b\x2a\xee\x06\x77\x0e\x98\xd2\x1d\xa8\xd6\xbd\xae\xb8\x99\xb8\x00\x5c\x02\xf8\x9f\x2f\xb4\x39\x5d\x28\xca\xd4\x3b\xaa\x7e\xb3\xac\x15\x96\x13\xe9\x9b\x6e\x92\x1d\x3c\x2c\x84\x56\x86\xd3\xa4\x55\xc8\x74\xf3\xd5\xa3\xc5\x14\xd5\x88\xef\x1f\x1b\xdd\x51\xeb\xaf\x5d\x7a\xaf\xa6\x5f\x43\x20\xf2\x56\x50\x3e\x42\xad\x27\x18\x79\x4b\x30\x3f\xc1\x1c\x31\xc3\x7d\x45\x72\xc1\x78\x09\xb3\x86\x20\xe3\xad\xa0\x1c\x42\x2d\x98\xed\xb0\x5d\x92\xcf\x66\xca\x4a\xea\x60\xba\x21\x4b\x85\x3a\xf0\xfa\x6c\x15\x1c\xa8\xab\x59\x2b\xb4\x06\x5f\xdd\x4c\xe4\x5b\xf3\x6f\xb8\xf9\x1d\x9d\xdf\x7a\xd8\xe6\xfc\x76\x76\x6a\x0f\xd6\x2b\x9d\x89\x79\x41\x78\x08\xb1\xb4\x93\xf5\x3e\x1f\x73\xd3\x7b\xb3\x5f\xf1\xec\xa6\x15\x94\x4b\xa8\x95\x8e\x38\xdc\xf4\x76\xf6\xd9\x48\x8a\xe9\xfe\x8b\x0a\x67\xc2\x26\xd9\x3a\xb8\x3b\xcd\x08\x4b\xd1\xdd\x03\x8e\xc3\xff\x11\x1e\x4d\x13\xfc\xc3\xa5\x7f\x6e\x8e\xaf\x4f\x75\xdb\x47\x42\xff\xa5\x97\xd0\x9d\xae\x9e\x14\x57\x89\x36\x87\xf6\xc0\xbd\xca\x69\xa4\x7d\x94\xbc\x3f\x48\x25\x7c\x3e\xc4\x26\x42\x5f\xaf\x04\xed\x27\xb4\x25\x2c\x14\xb6\x2f\x5a\xd8\x89\x59\xa1\x02\xdf\xd8\xd7\xeb\xe6\xd6\xa2\x6a\x2b\x06\xbf\x6e\x09\xd6\x46\xb0\x16\x21\xa9\xdb\x09\xd9\x06\xd8\x4b\x60\xbb\x8b\x5f\x1c\x1c\xf7\xff\xa3\xa7\xbf\x65\xcf\x1c\xd2\xd2\x63\xb4\x3e\xcb\x4c\xf3\x07\xa9\x8b\xcf\x67\xf9\x3b\x08\xf0\xd6\xae\x26\x5f\x47\x80\xb7\xd6\x32\x3f\x57\x80\xb7\xd6\x82\x79\x05\x78\xb3\xa2\xae\x23\x1a\x59\x37\x5e\x7e\xe1\xdf\x9c\x80\xad\xc3\xbf\xb9\x10\x7d\xc2\xbf\xf9\xcd\x54\xdf\x86\xf7\xb7\xe1\xfd\x6d\x78\xff\x11\x87\xb7\xb4\x78\x5f\x9e\xe3\x5e\x7a\x70\x7e\x7e\x7a\x8e\x43\xb6\x7f\x79\x78\x72\x10\xc0\x38\xa5\xe8\x6b\x98\x8b\xfb\x0c\x2a\xfd\xf9\x33\x7c\x20\xf8\x7b\x90\xe7\x62\x46\xfe\x6e\x58\x66\xb1\xc2\x84\xb2\x7d\x53\x65\x31\xb4\x7d\x30\x77\xc5\x49\xef\x02\xd4\x4d\xaa\x91\x43\xba\x89\x24\x52\x6b\x1c\x51\x9c\x75\x88\xf2\x9c\x62\x04\x2f\xf7\x39\x5c\xde\x6e\x15\x3e\x21\x1a\x7d\xb7\x0e\xe1\x04\x64\x49\x64\x6c\x7f\x15\x42\x4d\xc3\x68\x06\xdb\xd5\x13\x32\xca\x43\x8f\xf3\x5b\x4e\x82\x5f\x70\x5e\xf5\xbb\x38\xe7\xec\xea\x0c\x20\x3a\x0e\xad\x99\x8b\xad\x2a\xe4\x1b\x3f\x09\xf3\x8f\x51\x09\xad\x31\xac\xd8\x71\x20\x3f\x4c\xc3\x18\xaa\xbb\x3f\x58\xad\x48\xaf\xb7\x0b\xdd\x01\xcf\x29\x1e\x7e\x26\xa8\x3e\x86\xdd\x63\xff\x66\x74\x78\x86\x11\x77\xc1\xd0\x2a\xa7\xfe\x0a\xf2\xae\xc8\xc0\x56\x81\x35\x8c\xb3\xf5\x8c\x78\x44\x29\xd4\x9a\x78\x9b\xc2\x8a\x88\xa7\x5f\xd4\x7b\xf8\x20\x2c\x48\x29\x19\x4a\xb1\x63\x17\xc4\x0f\xc2\x5b\x08\x9c\x37\xd9\x2e\x01\x1a\x18\x91\xe0\xc1\x3e\x9f\xd5\xc1\x93\x36\xb2\xb8\x90\xbc\x44\xaa\x4e\x17\x6f\xe3\x92\x87\x16\xd6\xeb\x15\x57\xcf\x57\x1a\x07\x88\x59\x90\x87\x30\xb9\xa7\xb4\x2f\x8f\x71\xf4\x44\x51\x28\x2a\x8f\x80\x61\x3a\x4d\xca\x6d\x9c\x9c\x3e\x2a\xcb\x31\xba\x0f\xe6\xe8\x9d\x93\x68\x92\xe6\x33\x7e\x42\xdd\x96\x43\x5a\x48\xa2\xae\x9b\x8d\xad\x32\xf5\x7e\xc9\x34\x4b\x73\x99\x5d\x4c\x1f\x00\x9b\x00\x14\xb7\x48\x6b\x4d\x76\x56\xcd\xa2\x32\x28\x6a\x8d\xba\xd8\xce\x8e\xd8\x23\x4c\x45\x05\xd0\x68\xf8\x11\x4b\x62\xf5\x48\xef\xb1\xa1\x9a\xca\x9a\x61\x31\x3e\x6a\xf0\x8e\x03\xa4\x52\x70\xd5\x47\xd0\xd8\x71\xfa\x80\x51\xd1\xcf\xe2\x0f\x11\xe8\x2a\x14\x96\x35\xce\x61\x26\xd9\x3b\x6a\x14\xd8\x1b\xc7\xc7\x71\x02\x83\x26\xa0\x30\xaf\x61\x1e\x61\xac\xd2\x1c\x34\xc4\xf1\x0c\x63\xa4\x34\x8b\x12\xd6\x0e\xc6\x59\x99\x66\xf7\x79\x38\x8a\x82\x59\x3a\xcd\x11\xb3\x19\xc3\x75\xb7\x52\xe3\xee\x61\x22\x9d\xde\xd2\x15\x58\x3d\x90\x2b\xfc\x88\xff\x61\xa4\x83\x4f\x48\x8d\xf0\x77\x50\x33\xf3\x27\x53\x21\xc2\xdf\x47\x63\x71\xf4\xd6\x8b\x58\x41\x70\xc5\x72\x80\x50\x11\x2b\xc8\x6f\xd8\x0a\xfc\xf7\xe7\xcf\xbf\x61\x76\x2b\x4a\x5e\xc5\x17\xf8\xb7\x11\xf6\x44\x75\xab\x8f\x21\x85\x61\xa6\x83\xad\x23\xed\x51\xf7\xde\x69\x9b\xbd\x57\xe1\x38\x0e\x0b\x68\xed\x73\x76\xe0\x44\x80\x05\x58\x55\xd2\x05\x9f\xc0\xa4\x35\x82\x31\x5a\xdb\x15\x97\x85\x2e\xc0\x8b\x36\x2d\x44\x45\x24\x0e\x9f\x3f\x7a\xb5\x5a\x7d\x2c\x94\xbb\x21\x2d\xf2\x52\x52\x6c\xe1\xce\x85\xfe\x64\xcd\x66\x4b\x0d\x07\x58\x01\xc6\xa3\xa0\x84\x71\x55\xd9\x6b\xd0\x24\x26\x50\xe9\x10\xcf\x89\x96\x17\x7e\x60\xb4\x19\x2e\x5e\xaf\x5a\x9c\x3c\xa6\x1f\x6d\xcd\x04\x02\xbc\x07\xb5\xfb\x11\xcf\x1f\x60\x8c\x05\xc5\x03\x89\xc2\x9a\xec\xdd\x14\x13\xb4\xc1\x40\x82\xc1\x59\xea\x88\xd5\xf1\x04\x96\xa8\x12\x75\xa0\x86\xac\xf8\x2a\xfa\x04\x3a\x1d\xfe\x58\x96\x98\x65\x6b\xdb\x43\xbe\xb5\xa5\xad\x2d\xad\xdd\x12\x04\xce\xa7\x09\xa6\xc0\x83\xda\x50\xb0\x33\x95\xec\x6e\x14\xdd\xc5\x09\x8c\x00\x50\x2b\xb0\x32\xf0\x30\x85\xe5\xdc\xf5\x65\x5a\xc3\x49\xc2\x65\x68\xc4\x81\x88\xd0\x3a\xac\x07\x15\x0f\xe1\x9b\x80\x4e\x91\xb0\x21\xea\x63\x36\x4e\x42\xf8\x8c\xb6\xd8\xf0\x9d\xf1\x2c\xe2\x51\xea\x41\xc4\xc0\xd5\x7e\x3e\x63\x28\x1f\xdb\x6d\xee\x1f\x18\x81\xbd\x0c\x3f\xe2\xc9\xdb\xd3\x03\x1e\x6e\x59\xb4\x87\x15\x51\x05\x51\x93\x24\x1a\xd2\x09\xe2\x68\x3a\xc9\x10\x3d\x8f\x86\xb0\x9c\x72\x04\x20\xd2\xd9\xb2\x8c\x97\xe6\x4c\x6d\xa3\xa8\x33\xdf\xe3\xb3\xd3\xfc\x5e\x3d\x7b\xa5\x34\x4e\xdc\x73\xe1\x1f\xea\x31\x8c\x34\x78\x72\xa5\x8e\xc3\x60\x2d\xde\xd9\x91\x2d\x2d\xbe\x84\x28\xae\x46\x29\xc3\x98\x86\xd2\x97\x6c\x8d\x67\x90\x41\x68\x86\x6c\x46\xdd\x0d\x74\x26\x00\xba\xcb\xd3\x89\x66\x7d\x41\x8f\x40\x00\x40\xc4\xdc\x06\x6c\x5b\xac\x5e\x5e\xd2\x2f\x7e\xb9\x9a\x64\x62\xdb\x7c\x71\xc1\x84\x06\xc3\x79\x1a\xb7\x92\x78\x9e\x83\xfc\xf5\x6e\x67\xf1\x28\xe2\x3a\x19\xe4\x79\x9a\xef\x06\xae\x23\xcc\x15\x10\x1d\x22\x0e\xa1\x11\x9b\x33\xda\x6e\xa0\x8f\x41\x53\x1f\x89\x9c\x00\x0e\x01\x46\x78\x09\x41\x27\xd9\x38\xb7\x2a\x2d\x3e\xc0\x84\x9f\xf8\x6d\x47\xa0\xfd\x0f\x4b\xd8\xb2\xfe\x4f\xa7\x20\xde\x40\x0e\x81\xee\xb0\x89\xc3\x2a\xab\x07\xdb\x55\x39\xb9\x9b\xa9\xbc\x58\x41\xaf\xc4\x1e\x35\xa2\xb5\xb9\x1a\xcd\x5b\xd8\x37\x61\xb1\x8c\xef\xa2\x42\x0c\xfb\xd6\x01\xc9\x47\xa4\x71\x4a\x8e\xfb\x88\x72\x95\x14\xd3\x0c\xfd\x71\xa2\xd1\x11\x3d\x25\xd5\x08\x33\xe1\x7e\x4c\x60\x23\xa4\x8a\x16\xb8\x05\xdb\xb5\xcc\x62\x6b\x82\xf7\x11\x9e\x4e\x19\x28\x35\x09\xe9\xf4\xf3\x11\x72\x06\x2f\xb8\x45\xfc\xc4\xf4\x01\xf2\x11\x48\x1a\xab\x38\x8e\xf5\x78\xae\x7f\x2f\x3f\xe9\x5a\xa3\x7a\x89\xda\x98\xf8\xaa\xf9\x11\xfa\xce\xdf\x78\x13\xc3\x13\xa5\xb7\x8c\xde\x70\x0e\xe1\xa0\xb2\x31\x68\xec\x7f\x8b\xea\xa7\xbb\x4e\x19\xcc\x54\xde\xac\xf8\x7a\x4b\x3e\x48\xb5\x91\x38\x98\xa8\x05\x89\x33\xde\xf0\x81\x87\xdf\xfc\x2f\x12\xca\x0c\x93\xad\x52\xdf\xeb\x96\xd1\x24\xe3\xcb\x53\xd4\x1f\xa6\x19\x1e\x63\xd8\x58\xba\x48\xed\x4c\xd3\x0c\xb6\x41\xf3\x53\x54\xab\xe2\x6d\x21\xb1\x33\x79\xca\x63\x90\xee\x6f\x71\xe6\x85\xbf\x50\xda\x0c\xad\xef\xc0\x2b\x39\x24\xd4\xe5\x82\x76\x40\x65\xa2\x8b\xe9\xc5\x59\xed\xc0\xa6\x04\x3c\xd8\x10\x4e\x0b\x51\x76\x4f\x6a\x2f\xd6\xb0\xa3\x2a\xf5\x56\x0b\x88\x46\xc1\xed\x2c\xc0\x4d\x2a\xc0\x15\xc1\x4b\xba\xa2\xa6\x1c\xdd\xe2\x85\x5c\x67\x3c\xbb\x78\x49\xf4\x44\x47\xb7\x2e\xb6\x55\x39\x3b\x1c\x50\x83\x80\x7c\xb6\x4a\xcd\x44\xdb\x21\xcb\x71\xba\x9b\xd0\xce\x50\xdb\x9c\x06\x56\x5f\x45\xa1\xb4\x0b\x9a\xe7\x79\x34\xa6\x0c\xac\x61\x19\x2d\x14\x7e\x2c\xd8\x14\xd2\x17\x5e\x95\xf6\x83\x76\x5d\x14\x88\xe5\x1d\xf0\xb6\x8b\xc1\x66\x21\x3b\x10\xa6\xf0\xe2\xaf\x4e\xc9\xff\x79\xe1\x6a\x35\x3c\x3d\x10\xac\x22\x70\x04\x73\xad\xa6\xd5\xee\x66\x78\x90\x3d\xc0\xf6\xe3\x36\x82\xd9\x31\x9b\x16\x0f\x78\x63\x39\x1d\x0e\xa3\xa2\xa0\x73\x20\x87\x68\xab\x20\x3b\x44\x86\x71\xee\x64\x8e\x65\xec\x30\x23\x14\x0e\xa3\x81\x61\xfa\x34\x3e\x7d\x51\x97\xcd\xdb\xea\x57\xc4\xbb\x5e\xfc\x81\x11\xca\xf2\xb2\x90\x75\xcd\x15\x51\x3d\x45\xc5\x3d\xc6\x6d\xcc\x07\x6c\xe1\x90\xee\xdc\xe8\x75\x16\xce\xd0\xf9\x98\x34\x8e\x16\x32\x7a\xc2\xd9\x84\xc3\x80\x48\xed\x6e\xe7\x9c\x74\x32\x3b\x92\x73\xb1\x63\xe1\x06\x5c\xef\xbb\x8a\xa8\x2c\xc9\x94\x01\xa3\xf3\x43\x29\x9b\x0c\xed\xc1\x1c\x82\xad\xf7\x60\xc4\x29\xfa\x9a\xd9\xd9\x2b\x37\xd7\x8e\x80\xf0\xad\xfe\x71\xe2\x2b\xac\x8b\xdc\xce\x5c\x2d\xfb\x78\x25\x4f\x7f\xa9\x5a\x60\xf7\x59\xaa\x71\x87\x96\x5c\x15\xde\x2e\xfc\x3a\x24\x5c\x83\x18\x6c\x4e\x0f\x44\xff\x8e\x7f\x74\x17\xc5\x1b\xc7\x2e\x0e\xaf\x59\x40\xf4\x5e\x79\x3d\x7a\x31\x17\xa8\x3c\x59\x5d\x9d\x1f\x49\x9f\x75\x7d\xc3\x72\xcd\xdc\xec\x55\x6b\xaa\x74\x48\xad\x9f\xdc\xd0\x93\x0a\x74\x5a\x81\xba\xe4\xef\x02\xe9\x12\x72\x51\x31\x54\x08\x7b\x3c\xcf\x62\x85\xbd\x9a\xd6\x1f\xc8\x4f\x20\xe5\x83\x03\x00\xdd\x3f\x77\x2b\xac\x8e\x62\x35\x26\x76\x43\xf7\x59\xb3\xe4\x1d\xd9\xf9\x55\xae\xb2\x17\x5a\x3a\x40\x6a\xbd\x7c\x75\xed\x3e\x9b\x14\xc1\xaf\x11\x50\xf7\x99\x33\xff\x29\x9a\xd5\x56\x1c\x8b\x94\x87\xea\xd1\x5a\x5a\x61\xa3\x32\x38\x9a\x81\xd2\xef\x49\xcb\x6e\x97\xae\xdc\x1a\xd0\x21\x20\x7d\x71\xe3\x4a\xb7\x2e\x9d\x63\x1d\x2c\x7c\x2a\xb1\xd0\x6d\x4d\x3d\xbc\x63\x3f\x5a\x11\xde\x2e\x3c\x1b\xd4\xe9\x8c\xe4\xe2\xa1\xf3\xc6\xe7\x8c\x67\x93\xc3\xa3\x39\xaa\x3b\xc4\x76\xd2\x1b\xc8\x24\x66\xda\x8b\x23\x78\x8a\xf2\x08\x36\xa7\x7f\x51\x77\xc0\xca\x5a\x0d\xcd\x51\xc2\xfb\xd0\x62\x01\xd3\x06\xc2\x25\xc4\xf6\xbc\xdd\xe3\x64\x8c\x17\x6c\x64\x73\xa0\xfc\x70\xb6\xe9\xc2\x01\x2d\x4c\xb2\xb4\x88\x2a\x43\xa9\x0f\x7b\xfd\x33\xed\x3d\x75\x11\xd4\xc2\x72\x05\x3a\x2c\x17\x0d\xaf\x5b\x34\xac\xab\xa7\x66\x17\xed\x05\xbf\x98\x3c\xe6\xe6\x51\x3b\xd3\x33\x87\x55\xea\x62\x31\x2b\x98\xb6\x32\x0d\x46\x31\x9f\xf6\x4f\xc2\x72\xf8\xe0\x80\x16\x88\x04\x46\x45\x09\xdb\xea\x9a\x65\xf3\x8c\xef\xb6\x5e\x46\x3b\xf7\x3b\xe8\xb2\x53\xbd\xfa\x0e\x1b\xf5\x20\x2e\x29\x8f\x19\xbf\xde\x72\x59\x47\xfe\x25\x7c\x0c\xe7\x08\x3b\x50\x6c\xab\x01\x43\x77\x69\x21\xe8\x39\xb0\x6e\x3d\xe0\x8b\x32\xbc\xef\x8e\xfd\x0f\x8f\x3f\xec\xfc\xb0\xf3\x7a\x8b\xbe\xdb\x96\xfe\x01\x90\xdf\xb1\xa9\x27\x74\x72\x2c\x5f\xf6\xe2\xda\x95\x42\x11\xe0\x71\xf4\x76\x65\xe4\xbd\xa5\x2e\x6c\xb7\x50\x9c\xad\x64\x3a\x1e\x8b\x61\x50\xbf\xb5\x9d\x47\xdb\xd9\xba\xdd\x43\x14\xa2\xb9\x1a\x1b\xbf\x0d\xc7\xd3\x51\xa4\x07\xa7\x8a\xd9\xb8\xdd\x30\x05\x63\x36\x31\x1a\x83\x01\x93\x18\xe6\xad\xa0\x8c\x27\x72\x7c\xce\xf5\x32\x31\x56\x84\x03\xab\x5c\x08\x12\xe8\xb7\x66\xd2\xb0\x78\xb8\x4d\xc3\x7c\xb4\x5b\x6d\x49\x25\x18\x43\x49\x33\x24\xd9\xca\xa9\x5b\x91\x3c\x52\x66\x30\xa4\xc9\x48\xd0\x16\x0a\x37\x0b\x5e\x45\xdb\x33\x32\xd2\x09\xec\xc8\x53\xca\x7d\xf5\x66\x28\x68\x07\xb4\x5a\x71\x2c\x96\xb2\x43\xd9\xeb\xdd\x28\x64\x07\xa2\x03\x0a\x17\x10\x17\xb2\x03\x79\x5f\x11\xd9\x28\xfc\x58\x58\xaf\x88\xa4\xd2\x7e\xd0\x8e\xd3\x6a\xb9\xbc\x1f\xbc\x9c\x9a\xc0\x58\xd4\x01\x5a\xdf\xe7\x38\x61\x1b\x85\x1d\xc0\x96\x0b\xad\x85\x42\x1e\x40\x6a\x5b\x43\x46\xb5\xf1\xdc\x08\x3d\x01\x95\x21\xbe\xe7\x59\xb1\x5e\x8e\x2d\xe8\xc6\x63\x7b\x20\xe4\xb5\xb2\xb0\x57\xc2\x72\x25\xdc\x2c\x63\x85\xa1\xfb\xe8\xec\x21\x44\xbb\x62\x1a\x4e\x45\xf0\x32\xde\x89\x76\x40\xb8\xb4\x88\xf8\x12\x0c\x3d\x48\x58\x79\xca\xb2\x88\x6c\x67\xf8\x42\x42\xba\x08\x5f\x0f\xb6\x55\x6c\x9b\xff\x57\xb3\x8c\x03\x46\xbe\xa4\x6b\x96\xb1\xc1\x0c\x71\xa4\xa1\x89\xb1\x1d\x69\x5e\xcc\x02\x56\xf8\x5e\x98\x8b\xc5\x65\xf0\xe7\xbb\xfe\xd9\x18\x3b\x7b\xe5\xba\x5d\xff\x78\x93\xdb\x99\xaf\x7c\x50\xd4\x05\xc9\x2e\xd2\x17\x38\xc1\x7b\x1e\xde\xf6\x6a\xaf\x70\xf2\xd5\x0e\xc3\x2e\xc6\x8a\x77\x59\xed\x71\xec\xe2\x54\x57\x3e\xe7\xf8\x87\x17\x67\x13\x89\x27\x13\x52\xcd\xdb\xb0\xa8\x08\xec\x0c\xd6\x77\x97\xb4\x12\xa4\x4b\x48\x9f\x2b\x20\xb7\x5c\x5e\x28\x7e\xa2\xac\x70\x8b\xd4\x0d\xcb\x4f\xac\x67\x3b\x2b\x7d\x0e\xce\x8e\x2a\xcb\x67\xe9\x5d\xbe\x45\x3b\x34\x1f\xd1\xaa\x23\xd8\xa6\x41\xf2\xfc\x39\x5f\xb4\x75\x6c\xf6\x35\xb0\xb0\x57\xc2\x74\x8c\xdc\x51\xd8\x36\x50\x82\x50\xc5\x30\x8f\x29\x50\xc4\x6e\xad\xa7\xd5\x1e\x5b\x86\xbf\x07\xa9\x99\x29\x07\x82\x40\x13\xa9\xa8\x28\xb4\xd9\x52\x75\x86\x53\xb7\x2d\x97\x78\xb7\x40\xf0\x11\x81\xe2\x51\xe9\x01\x57\x5b\xf7\xab\x58\x07\x29\x9f\x4f\x6b\xab\x58\x3f\xb1\x5a\xa3\xfa\x8b\x5a\x55\xb5\x8e\xd9\x46\x2a\x33\x80\x55\x80\x79\x7e\x15\x94\x38\x1d\xfa\x7c\x20\x33\x8d\x95\x0d\x66\xa2\x61\xa3\xdd\xa8\x7e\x84\xef\x60\x24\x51\x59\x59\x91\xbd\xde\xdc\x4e\x1d\x77\xb5\xec\x13\x4e\x56\xd0\xa4\x00\x72\xa0\x7e\x07\x73\x7f\x1c\xa7\x38\x78\x68\x8b\xf6\x71\xc1\x5d\x14\x96\x53\xd8\x73\x16\x29\xef\x3f\x39\x07\xd2\x43\xf8\xd8\xf8\x90\xb0\x4b\xc7\x33\xd0\x69\xc1\xd4\x8a\xc8\x43\xdc\xf5\xf0\xb1\x54\x47\xd9\x40\x22\x00\x86\xc6\xc1\x2e\xff\x3b\x3a\x2d\x87\x89\x41\xbf\x5e\x5a\xe3\x5a\x2c\x34\x1b\xe2\xe6\x57\x35\x6c\x1b\x18\xbd\x1c\xba\x0a\x38\x8b\x2c\xee\x6a\xe3\xbc\xc6\xcf\xb9\xe5\xdb\x1c\xc3\x0d\x54\x10\xbb\xc6\x2a\x7b\x9a\xe7\x61\xee\x5d\x71\x43\x37\x72\x09\xb1\xe6\xda\x6f\x4a\x02\x47\x13\xe0\x64\xaa\x3c\xfa\xf8\x6e\xe9\x1f\x8b\x2d\x1f\xc1\x25\xba\x96\xec\x58\x05\xeb\xca\xb4\x49\x2d\xb2\xc6\xc8\x72\xc1\xc5\xc5\xfb\xba\x0e\x51\x9d\x73\x5a\x98\xda\xe9\x24\x76\x1f\x55\xb0\x26\xbe\xeb\xfb\xfe\x9f\xff\xe5\x78\x3b\x78\xf3\xfa\xfb\x1f\xf1\x9f\x03\xf1\x78\xd2\x49\x27\xb1\x83\x7e\x33\x0b\x38\x0f\x2b\x5b\xc9\x97\x30\x5f\x57\xfe\xe6\x32\x3b\x07\x9d\x99\x5d\xaa\x3c\x88\xc7\x69\x8e\xde\x73\xb0\x4f\xce\xa6\x92\xaf\xab\x50\xd8\x06\xcc\x89\xe1\xe8\x16\x85\x32\xc5\xe9\xc8\x1a\x76\x0e\x22\x95\x8d\xd5\x24\xcc\xf4\x65\x0d\x39\x9c\x2b\xb7\x21\xe5\x5b\x30\x49\x61\x4d\x54\xc7\xc3\xb4\xc6\x67\x79\xf4\x18\xa7\xd0\x3e\xe4\x73\x51\x70\x64\x09\xab\x8b\xd2\xfa\xf9\xd8\xaa\xc3\x19\xce\x94\x4d\x7e\x78\x87\x0e\x2c\x88\x60\xd1\x67\x9c\x74\x02\xbb\x21\x6c\xb3\x7b\xf1\x84\x7c\x20\xd2\xca\x8d\x8c\x3b\x2d\x2a\x14\xaf\x46\xb5\x22\x3d\x9c\x87\xc4\x3e\xdf\x09\x4b\x12\x6b\x8a\xb6\x21\x84\x8d\x9e\x3d\xee\x4b\x5b\x0b\x85\xc0\x82\x0e\x40\x59\xb8\x5a\x3c\x54\xb9\x76\x52\x79\x0b\x7c\xb1\x6b\x45\x83\xd7\x02\x31\x47\xb8\x0a\xc2\x12\xdd\x3e\x61\x72\x0c\xe3\x71\x34\xd2\x41\x05\xd0\xab\x1f\x43\xe4\x5e\x71\xa0\x23\xba\x69\xa7\x00\x24\xdb\x55\x9c\x9b\x82\x7a\x43\xf8\x08\x74\x6c\x5a\x83\x9d\x11\xe7\xba\xfb\xf8\x31\xa2\xf6\x11\x67\xe7\x67\xe1\x6d\xad\x76\x15\x47\x45\xc5\x33\xd8\x2a\x02\xca\x48\x5d\x4c\x27\xc1\x28\x8d\x8a\xb9\x95\x0d\xb9\x0d\x05\x93\xa8\x0c\x47\xa1\x7c\x27\xbc\x2a\xac\x59\xd8\xe9\x24\x6b\x04\x46\xc1\x76\x88\xa0\xdd\x70\x88\x73\xa4\x10\x49\x1e\x0f\x4a\x23\xcb\xc1\xc9\x87\xc3\xf3\xd3\x93\xe3\xc1\xc9\x65\xf0\xa1\x7f\x7e\xd8\x7f\x7b\x34\x08\x28\xab\x86\x64\x11\x61\xa3\xf0\x66\x71\x21\x75\x62\xa1\xb0\x19\xb8\x0a\xe7\x2c\x81\xcd\x0b\x38\x00\x82\xa5\x00\xc8\x45\x15\xf2\x78\x74\x8b\xf1\x98\xef\xd3\xf1\xc8\x5d\x6e\x48\x31\xa2\xf3\x70\x72\x73\x7f\x7b\xfd\x62\xf7\x47\x73\xfc\xe7\x45\x9a\xff\x7a\x85\x11\x2d\x48\x65\x78\x55\x4e\xb2\x57\xfa\x7e\xe1\x66\x98\x26\x77\xf1\xbd\x18\xf6\xb9\x89\x53\x06\xd7\x2f\x30\x62\xea\x76\x7a\x87\x81\x65\xee\x8b\xeb\x17\xce\x76\xf9\x7b\xad\xb7\xfb\x73\x1f\xc5\xc9\xf4\xd3\xab\xe3\x70\xc8\x3f\x6b\x4c\x1a\x39\x02\x29\x95\x63\xa3\x92\x19\x06\x24\x29\x30\x12\x61\x41\xc1\xbe\x73\x18\x66\xe4\x0f\x5d\x8b\x6f\xfe\x67\x80\x48\x9f\x8a\x40\x87\xc6\x02\x66\x51\x1b\x3e\xd7\x2f\x7e\xbf\xbe\x6e\xb2\xba\x46\x66\xd7\x75\x76\xf0\xe3\x73\x15\x0a\x5e\x73\x3c\x4b\x9f\xa2\xfc\xe2\x21\x1a\x8f\x5b\xd6\xcb\x8b\x1d\xd6\xaf\x6c\x7c\x11\x0b\xa8\xcf\xd7\xf5\xe9\xa0\xdf\xbe\xd4\x57\xf1\xa5\x56\x19\x52\x1c\x6f\xa2\xe2\x3e\xba\xad\xfe\x2c\xe2\xf1\x23\x28\x94\xf2\x2c\xe2\xff\x95\xbc\x99\xa8\x6f\xa6\xf8\x5c\x13\xa7\x36\x9f\xa7\x4d\x6d\x16\xf9\xe8\x1a\xb5\xc6\xf2\x9b\x2b\xbb\x60\x57\xf3\x67\xd0\x6e\xe1\xf8\xf6\xb9\xff\x7e\x3e\xb7\x79\x70\xb3\x3e\x5e\xe5\x5a\xe0\xdd\x79\x75\x94\xa8\x6c\x6f\xb5\xaf\x7d\x91\xc1\x6c\x24\x1a\x98\x75\xc3\xb2\x89\xf5\xfe\xf2\xf2\x0c\x9d\x06\x3e\xcd\x74\xd8\x65\x0c\x38\xac\x81\xec\x62\x38\x68\x6d\x6c\xbb\xdf\x52\xb5\x00\xf0\x10\x60\x4d\x77\x54\x2b\x82\x7a\x0b\xda\xe6\x86\xca\x9f\xde\xc6\x1e\xc4\x54\x89\x25\xf9\x7c\xc9\xce\x6c\xa9\xb4\x0d\xba\xdd\x9d\x94\x83\xc8\xc6\xa8\x79\x93\x54\x3b\xff\x70\x5f\x46\xb5\x41\x70\x89\xb0\xc9\x5b\xa8\xb5\xb3\x91\x2b\xf3\x5c\x77\x50\x1b\x62\xe6\x55\xb1\x55\x2f\x84\xda\xd6\x6d\x7d\xfc\xd6\x5f\xbd\x15\xef\x9f\x9e\x87\xb7\x6f\xb5\x9f\xf7\xf6\xe9\x19\x05\xb0\x37\x40\xbb\xbb\x27\x27\x59\x3b\x66\x3e\x37\x4f\x9e\xc4\x02\xe3\xc7\xb9\xa7\x22\x34\xcc\x87\x50\x5d\xc8\x06\x4f\x61\xa1\xa2\x10\x96\x32\x63\x2f\x62\x33\x63\x3c\x74\x55\xdf\xd6\x68\x35\x8a\x15\x38\xb8\x3a\xdc\xdf\xda\x95\x82\xfc\xb4\x82\xb0\x08\x41\x8b\x13\x07\x84\x26\xed\xcb\xca\x6e\xa9\xb0\x05\x78\xa8\xfd\x74\xe7\xe1\x87\xe2\x71\xe4\xa8\x8f\x48\xe4\xc3\x48\x09\xe5\xce\x5e\xe6\xa6\xf3\x61\x57\xaa\xe0\x8d\xce\x48\xc3\x6e\x3a\x1f\x76\xd6\xc8\x92\xe6\xb2\x5e\xb0\x06\x9b\xb5\x1d\x8f\x60\xc5\xad\x61\x2c\xc2\x8c\x8c\x96\xf4\xdc\x8f\xbd\x45\xf1\x06\xf1\x11\xc4\x6c\x4a\xef\x13\x56\xb4\x03\x90\x4d\x20\xf1\x5e\xdd\xce\x5e\x26\xeb\xc4\x8c\xe7\xd2\x8e\x2c\x15\xb1\x8d\x71\x15\x93\x9e\x06\xe2\x7c\x1c\xca\x37\x0b\x4e\x3a\x2f\x76\xbc\xcf\xed\xc0\xcf\x40\x68\x61\x18\x49\x6b\x94\x95\x9b\x4c\xd5\x85\x95\xc7\x27\x74\xd1\x5a\xd8\xde\x71\x92\xbd\xda\x0d\x21\xea\x99\xfe\xe3\xc5\x87\xbe\x15\x7b\x76\x85\xf3\x5c\x09\x3c\xc8\x3d\x98\xaf\x3a\x67\xb4\xc1\xf1\x10\xc7\x11\xe6\x5c\x28\xec\x01\xbc\xa8\x69\xcc\x27\x57\x1f\x3b\xe5\x6e\x58\x2b\x88\xb5\xa2\x24\x7e\xcc\x4d\xe6\xfe\x2d\x05\x70\x40\xd8\x84\x48\xf3\xa7\x30\x27\x10\x1c\xb2\x0e\x15\x6b\xb9\xb4\x05\xfa\x9e\x83\x44\x92\x85\xd5\x10\xb3\x2b\xdb\xb1\x0d\xc5\x3d\xc1\x31\x16\xa7\x78\x27\x2d\x94\xf6\x80\xae\x1d\xf4\xc0\x8c\x36\x99\x50\x26\x05\x2f\x36\x66\x4a\x0f\x96\x3a\xb9\x15\x25\xcf\x64\x83\x21\xb6\x50\x80\x4f\xf9\x0e\xd4\x3e\x4e\x8b\xeb\x25\x83\x27\x94\x87\x50\x14\x64\x1c\x5b\xcd\x8b\xef\xbc\xb4\x07\x34\x96\x63\xe1\x1e\xbf\x7f\x45\x1f\xc6\xaf\x81\x4d\x74\x1e\xec\xf0\x04\x14\xa3\x49\xb0\x7b\x53\x8b\x3e\x69\x24\xf4\x60\xa8\x9a\x5c\x5b\x8e\xb0\xc8\x68\x4c\xe2\xc9\xd7\x46\xef\xc1\x9e\xa3\x6c\x70\xa6\x8d\x88\xd3\x3c\x54\x3e\x1e\x3e\x6a\x71\x1b\x1c\x8b\x38\xe4\x88\x8e\xf1\xf8\x11\xeb\xfc\x6c\x4f\x1f\x3c\x38\x1a\xc1\x42\x66\x61\x06\x83\xad\x78\x08\x49\x15\xc1\x2c\xe4\x56\x0e\x8b\x65\x2d\xb0\x18\x08\x7f\x3e\x3b\x51\x0e\x20\x6a\x01\x2b\xbe\x48\xe4\xc1\xc8\x2b\x4e\xbf\x95\xc4\xc2\x24\x83\x8a\x7b\xb5\x50\xa3\xa0\x07\xa0\x8a\xf6\xe2\x85\xa9\xcb\xda\x60\xa3\x1c\xf3\x44\xf8\x1e\x31\x18\x8a\xdb\xc0\xf3\x54\x1f\x80\xe0\x85\x3a\xb6\x19\x25\xa0\xa3\x8c\x6c\x34\x3b\x6e\x79\x8f\x94\xb6\x58\x2d\xc5\x5a\x49\x8e\x0e\x8c\xe7\x93\x0d\x8e\xb9\x28\x77\xf4\x73\x3b\xa5\x85\x25\xda\x3d\x2c\x9f\xd8\x78\x2a\x3f\x4e\x62\x0f\xc6\x7a\x37\xe6\xc5\xa8\x2a\xdc\x02\x98\xda\xa2\x15\x3a\x53\xb4\x65\xe1\xf7\xa1\x1c\xa4\x56\xa6\x77\x40\xf4\x40\x8b\xe1\xdc\x39\xd8\xc9\x4e\x20\xb2\x32\x4a\xc2\xc9\xaa\xe7\x39\xde\x20\x56\x41\x68\x06\x21\x9d\xc6\xfd\x0d\x9b\x65\xfd\x60\x2b\xad\x02\x15\x8a\xe6\xa7\xf0\xae\x67\x4b\x30\xab\x60\x45\x3a\x7e\xa4\xde\x81\x06\xeb\xfe\xa3\x50\x24\xb3\x32\x2b\xf3\x38\x22\xb2\xa2\x84\xcf\xe3\xec\x48\x4b\xc5\x5b\x80\xfb\x4f\x9f\x76\x4a\x0b\xcb\x22\x7c\xac\x4f\x45\xde\x0c\x6d\x74\x16\x76\x64\x4b\xb9\xea\x20\xf1\x06\xf1\x11\x84\x3d\x4d\x6e\xc8\x80\xfa\xa6\x9c\x65\x91\xfb\x8c\xca\x45\x6b\x65\x8b\x67\xd4\x0b\x5b\x2d\xaf\xcc\x4d\xfe\xf4\x5e\xec\x57\x6b\x7f\x5f\x14\x8b\x28\x98\x40\x89\x54\xf4\xb4\xed\x9d\x82\x9d\xd2\xc2\xf2\x6f\x71\x96\x2d\x34\x9d\x95\x91\xa9\xbc\x05\xde\x78\x88\x83\x5e\x04\xec\x87\x8b\xe1\x35\x39\x8a\x68\x58\xb0\x3d\x46\x7e\x4f\x9e\x1e\x7c\x57\x78\x96\x16\x14\xf5\x6a\x0b\x1a\xb5\xac\xff\xac\x32\x97\x87\x98\xb2\xa9\x8c\xee\xa3\x7c\x27\x08\xde\xe1\x2e\x00\x53\xdb\x16\xb3\xa4\x0c\x3f\x41\x57\x1c\x67\xdb\x94\x89\xe4\xb7\xe1\x9d\xb6\xca\x9a\x7f\x9e\xde\xc3\x6f\xe2\x95\xde\x1f\x43\x78\xb9\xe1\xed\x53\xb0\x75\xc6\xdd\x0d\x4e\x52\x8e\xbd\x49\x11\x2e\x1d\xce\x69\x56\x12\x1b\x13\x5c\xde\x46\x68\x7d\x16\x3c\x85\xdc\x77\x89\x0a\x6a\x3f\x0c\xfe\x92\xde\x92\xb2\x0d\x45\xc9\xc9\x67\x0b\xfb\x35\x86\x40\x2b\xa4\x78\xad\x2b\x82\xda\x04\xf5\x19\x7f\xce\xb1\xc6\x5e\x6f\x05\xb9\xbd\xd1\x2a\xcf\xfe\x65\x91\x4a\x39\x07\x42\xa3\xdd\x5b\x94\x8c\xb2\x14\xba\x84\xc4\xaa\x25\x8a\x20\x4a\xc6\x1b\xff\xfa\xb9\x16\x9b\x23\x85\x7c\xbe\x94\xde\x61\xec\xa5\x57\x9c\x95\x39\x0b\xe3\xbc\x50\x79\x4f\x83\x74\x48\x39\x63\x46\xf5\x94\x97\x41\x12\x85\x39\x28\x0a\xd8\xb4\x3f\x4f\xc6\x17\x09\x4c\x10\x51\x09\xcd\x2b\x56\xe2\xb9\xf8\x7b\x57\xbf\x68\xf0\x6f\x21\xf7\x02\xa1\x9d\x61\xb5\x1a\x54\x44\x45\xa4\x2b\x1b\xfc\xef\xeb\xe9\xeb\xd7\x3f\x44\x9c\x0a\x7b\x9b\x66\x8c\xb8\x24\xfb\x01\x8a\xce\x72\x09\xeb\xe8\xe7\xcf\xe2\x6c\xb5\x4e\x16\xce\x4a\x9c\xe5\x29\x6c\xcd\xcb\xd9\x02\xa7\xdb\x34\x1d\x47\xa1\x18\x33\xbb\x0d\x42\x57\x11\x74\xef\x29\x40\xef\x4b\xee\xc5\xd4\x92\x5d\x90\xba\x8a\x94\x4c\x27\xb7\x98\x62\x7e\xb1\xb5\x75\x71\xff\x0f\xbb\x22\x03\x63\x05\xde\xf5\x0f\x8f\x06\xfb\x02\x73\xf5\xd2\x4c\x38\xe8\x5f\x5e\x9d\x0f\x82\x77\x47\xfd\x03\xc9\x3d\xad\x59\xc6\x0c\x43\xde\x87\x01\x47\xb3\xd4\x77\x2f\x79\xca\xae\x87\x68\x48\x20\x2e\x63\x3e\x94\x36\x96\x77\x51\x39\x7c\x68\x68\x6b\x85\x8f\xad\x83\x2f\xb5\x17\x6b\xbe\xde\xeb\xc4\xd7\x48\xea\xc5\x34\x7a\x04\x05\xa5\xf0\xd2\xae\xbd\x48\xbd\x98\xc2\xc7\xe9\xb1\xe9\x28\x2e\xc7\xf4\x99\xf8\x86\xed\x1c\xfe\xbc\x4c\x95\x83\xbb\x0a\x81\xd1\xa1\x39\xba\xe3\xfb\x8a\xdf\xad\xc5\x0c\x84\x5e\x0c\x69\xf3\x9d\x73\x38\xb9\xf9\x47\xf6\x66\x2b\x92\xfb\x33\xef\xca\xb5\x3d\x3b\xba\xed\x34\x7c\x3d\xba\xfc\x5c\x53\xff\x58\x8d\x87\x7f\x35\xea\x03\xd2\xe7\x0a\xbc\x25\x88\x4d\x10\x98\xf6\x54\x2e\x61\x74\x48\xe1\x5a\xaa\x98\xe0\x37\xda\xed\xd9\x76\xe6\xde\x1a\xc6\x4f\x18\xad\xa5\x6d\x63\xd0\x62\xe5\x53\x8e\x57\x06\x91\x31\x49\x84\x6b\xba\x5f\x01\xd7\x21\xae\xba\x3c\xb2\xdd\xa1\x08\x85\x1d\xc0\x1c\xb3\x81\x0f\x4c\x7d\xbf\x80\x89\xc6\xcc\x46\x99\xe7\xe3\x2d\x30\xff\xf9\x6e\x1c\x62\xfc\x3b\x15\x51\x6a\x24\x29\x16\x1e\x84\xed\x18\xb2\xf3\x40\x7b\x7e\x15\x9d\x8d\x9d\x74\x03\x55\xbd\x36\x13\xe3\xdd\x35\x25\x4b\xa7\x3d\x29\xe5\xba\xc7\x04\x0b\x93\xf0\x23\x6c\xb2\x51\x1a\x72\x56\xc0\x52\xd1\xa7\x98\x5c\x9e\x4a\x15\xc5\x20\x0b\xa1\xe5\x41\x56\x7c\x99\xd9\x6e\xe9\xd7\xcb\xc3\x5c\x8d\x14\xc3\xfa\xdf\x2a\xdb\x10\x4c\x54\x81\xdb\x5b\x72\x3e\xb3\x67\x6a\xf7\x20\xb4\x30\x1c\x71\xc8\xe9\x97\x23\x0e\x3d\x92\xe5\x29\x85\x8b\x80\xf9\xa0\x8e\x20\xc5\xd3\x68\x87\xe1\x12\x03\x77\x88\xad\x2b\x6e\xa7\xb4\xb0\x54\x21\x2f\xd8\x59\x84\x6e\xec\x5b\xf3\xf6\x84\xb0\x08\x31\x89\xef\xf3\xb0\x5b\xc5\x1d\xa4\x16\xa6\x6d\x02\x09\xda\x28\x2c\x2c\x60\xb4\xf2\xe4\xc6\xa9\x66\xb5\x84\xdc\x35\xac\xac\xec\x94\x16\x96\xd3\xa4\xf3\xe0\x71\x90\x1a\x99\x1e\x0c\x2e\x2f\x0f\x4f\x0e\x82\x8b\xcb\xfe\xf9\xa5\xb8\xb9\x5a\x2c\x65\x86\x3a\x3a\x7d\xdb\x3f\x0a\x4e\xcf\x2e\x0f\x4f\x4f\xc4\x40\x1d\x8b\xa5\xcc\x50\x51\x09\xfb\xc2\xea\x5a\xa9\x4a\x6b\x44\x46\x9d\xc5\x43\x30\x1c\xc7\xa8\xdc\x4b\x2c\x3c\xa9\x45\xd6\x38\x0b\x2e\x5f\x0c\xf0\x09\x0f\x7e\x50\x5b\x34\x7e\x7f\x7a\x89\x3d\x9b\x71\x61\x5a\x04\xb6\x39\x51\xe1\x9b\x60\x19\xff\x18\x95\xa0\xf5\x0d\x23\xd9\xab\xc4\x9b\xdc\xce\x1c\x93\x64\x6f\x24\x50\xfe\x3a\x39\x58\xab\x50\xdb\xea\xee\xec\x88\xe6\xd1\x52\x69\x2b\xb4\xda\xcd\x5a\xd2\xea\xb5\x69\x89\xb6\x68\x56\xd1\xa2\x9a\x6f\x4f\x15\x6f\x2d\xf8\x7d\xe3\xf9\x0f\x9e\x8f\xbf\xbd\xfa\xb4\xe5\xdf\x04\x5f\x67\x0f\xda\x28\x6b\x6b\xa5\xd9\xde\xe7\xf9\xbf\xf5\xe6\xf8\x5a\xab\x2b\xcd\xab\x96\x2b\x5f\x2f\x52\x2b\x53\xb6\xf9\x4c\x57\x72\x8d\xec\x86\xe5\x27\xd6\xfa\xb2\x04\xac\x05\xda\x53\x68\x57\x88\xf4\x8e\xc9\x50\x37\xc0\xc8\x5a\xa1\x2f\x90\x75\xe4\x59\x58\xbb\x2a\x5d\x3c\x53\x0d\xd7\xc4\xc7\x5a\x1d\xc9\xbb\xdc\x39\xef\x5b\x08\xad\x0c\x79\xa3\x55\xcc\x73\x60\xa1\x65\x75\x11\x97\x69\x1e\xc3\xac\x0a\x00\xae\xc9\xcc\x03\xc0\x5f\x80\x8a\x76\x16\x48\x17\xa1\x6e\x3a\x2b\x3b\x63\xe6\x06\x1a\xa1\xed\x67\xd0\x76\x58\x6e\xb1\xda\xc4\x31\xf0\x20\xb4\x32\x6c\x1c\x76\x2f\x91\x07\x3e\x5d\xce\x0b\xc2\x2d\xc4\x2a\xdc\x57\x62\x6b\x5c\xfb\x3c\xd5\x83\x36\x22\xae\x81\x4f\xe7\xea\xac\x5d\xee\x4e\x02\x4e\xb5\x86\x46\x91\xa5\x9b\x0b\x79\xa0\xb2\x6d\xf0\xc3\x03\x7c\x76\xe2\xd9\xf7\xbb\xe3\x5a\xc5\x6d\x02\x15\x6d\x35\x16\x27\xb9\x83\xb9\x4a\x3e\xc4\x71\x2b\xda\x4f\x08\x1e\x00\x6d\x04\xa0\xfc\xd3\x55\xde\xa1\xb7\xf4\x17\x76\x83\xa4\x19\xf1\x49\x75\x92\xea\x77\x27\x8d\x74\xa3\xac\xd7\x54\xe9\xe5\x78\x21\x5f\xbe\x35\xd6\x29\xd3\x46\x9b\xe9\xd9\xdb\x60\x43\x15\xdc\x54\x3d\xd6\x20\xee\x73\x74\xc3\x67\xe8\x56\x5f\x74\x98\x7d\xc9\xf1\xb4\xb9\x81\xb3\xe6\x11\x52\xb9\xb2\x14\xdd\x36\x54\x2d\x80\xbc\x04\xe2\xf1\xd4\x6d\xf3\xe4\x87\xe1\x25\x06\x45\x99\xc2\x3d\x80\xba\xed\xf0\x09\x93\xd6\xb1\xe5\xd6\xc2\x6a\xfd\x95\xda\x50\x05\x7c\x85\x5d\xbe\x66\xd8\x58\x6e\xc3\xe7\xe0\xec\x57\xe5\x67\xab\xe1\xa6\x2b\x64\xc8\xae\xd8\x7d\x7f\xde\x16\xcd\x57\xb4\x4e\x6a\xb9\x8b\xdc\xcd\xbc\x30\x65\x6d\xb4\x36\xb6\x7b\xe2\xeb\x8c\x6b\x17\x17\xfd\xc6\xc8\x6b\xe0\x02\xff\x42\xa7\x81\x46\xc7\xa9\x16\xcd\x75\xdf\x05\x6c\x90\xb1\xbb\xc2\xc5\x73\x56\x72\x7d\xcc\xac\x15\x63\xe3\x3f\x73\xb6\xd0\x57\xd2\x81\xb6\x7f\xce\xdd\xb5\xb3\xe9\x5c\x99\x4e\xd3\x62\x07\x40\xa3\x80\x14\xce\x99\xbc\xc6\x29\x77\xcc\x70\x3c\x1d\xd1\xda\xc1\x31\x27\xd8\x65\xe5\x36\x1d\xcd\xb6\x31\xcc\xef\xd6\xbf\x6d\xc1\x42\x89\x79\xbb\xa2\x51\x70\x3b\xc3\x70\xb3\x64\x4e\x05\x1f\x14\xc9\xd1\xbd\x99\x08\x2b\x2f\x74\xa1\x12\x1b\x66\x2a\x57\x74\x12\x95\x0f\xe9\x28\x78\x79\x30\xb8\xdc\x3e\x3b\xbd\x80\xff\x5c\x5d\x6e\xef\x0f\x8e\x06\x97\x83\xed\xa8\x1c\x4a\xc6\x51\x7e\xb4\x66\xb6\x69\x51\x92\xa8\x9c\xa9\x68\x32\xeb\x15\xd3\x5b\xbe\xf0\x16\xb9\xd9\x48\xec\x4c\xf4\x81\x14\x27\xc4\x7a\xa9\xfc\xd6\x94\xd9\xc7\x43\x88\x7f\xaa\xcb\x76\x27\xf3\x36\x50\x76\xa1\xa6\xca\xe7\x6e\x98\x4e\x30\xd3\x4f\x65\xe8\x14\xec\x9f\x1e\xf7\x0f\x4f\xc8\x7e\x92\x62\x54\xcf\x6a\x0c\xd1\x5b\x22\x16\x53\x93\xad\x07\x7b\x33\x62\xb3\x09\xd2\xa6\x04\x57\xe8\x1e\xa2\xe3\xd0\x1a\xc1\x04\xd0\x80\xf0\x12\xcb\x4c\x69\x64\x79\x78\x72\x71\xd9\x3f\x3a\x1a\xec\x07\x67\x47\x57\x07\x20\xf7\xde\xe9\xf1\x71\xff\x64\x5f\x72\x31\x91\xcb\x9b\xe1\xef\x13\x74\xb0\x6c\x84\x98\x90\x90\x4d\x45\xcd\xa0\x6a\xc2\xa9\xa2\x30\xa8\x48\x28\x7a\x06\xb2\xa6\xdd\xf3\x24\x96\x18\xa7\x39\x06\xf1\x09\xae\x8a\xf0\x3e\xc2\x1c\x04\x32\x97\xa5\x92\x3e\x90\x3b\xfe\x98\x3b\xfe\xa0\x41\x3f\x99\x7b\xca\xc6\x45\x40\xf9\x53\xe8\xe2\x4f\xa5\x20\xa4\xc2\xe3\x59\x10\x41\xe3\xa4\xd0\x83\xda\x88\xd1\x11\xdc\x4f\xf0\xbd\x2a\x0a\x57\x02\x33\xda\x38\xbc\x2f\x60\x52\xfd\x34\x8c\xb2\x32\xe8\xdd\x7d\x87\x31\xd0\x91\xc7\xad\x8a\x2a\x0f\x5d\xff\xe9\x01\x0d\x7d\x39\x45\x5f\x30\x99\x8e\xcb\x38\x1b\x47\x6c\xaa\xc5\xb7\x8c\xcd\x0e\x26\xad\xd2\x5f\x40\x10\xbf\x06\x79\x3f\xe8\x1f\x5d\xbe\xbf\xd9\x7b\x3f\xd8\xfb\xe9\xe6\xf2\xe7\xb3\x01\x60\x17\xc4\xf8\xfa\x05\x86\x94\xbb\x7e\x81\x0d\x7f\xfd\x22\x49\x93\xe8\xfa\xc5\x35\x34\xb5\xff\x87\xec\x84\xed\x27\xf6\x49\x3a\xef\x23\x7a\x25\x6a\xd3\xc7\x44\xfa\xd5\xd8\x93\x42\x0b\x25\x44\x25\xb3\x0b\x92\x9f\x48\xe7\xda\x25\x7d\x0b\xfa\x04\xe5\x6e\x44\xcb\xb3\xf9\x1f\x64\xd6\xb3\x85\xaa\xa0\xe6\x57\xb4\x69\xb0\xae\xf0\x2b\x0b\xbf\x11\x91\xd7\x20\xa8\xbe\x44\xab\x4c\x69\xd7\x21\xa8\x0f\x68\x4b\x41\xfb\x67\x67\xc1\xc5\xe0\xfc\xc3\xe1\xde\xe0\x86\x16\xdb\x93\xbd\xc1\xea\x92\xfa\xa1\xb6\x17\x95\xb3\xef\xe0\xc4\xa8\xd4\x9e\x75\x48\xea\x06\x5d\x45\xd0\xe5\x59\x6e\xbd\x32\x7b\xe0\xaf\x22\xfe\x46\xfa\x46\x1b\xf8\xce\xc2\xcf\x81\x56\x10\xb1\x06\xb2\x06\x41\x56\x6c\xaf\x05\xa0\x96\x02\xbd\xbd\x3a\x3c\xda\x3f\xeb\x43\x2f\x41\xb4\xed\xe0\x64\xf0\xe7\x9b\xe6\xb3\xd5\xbf\x6d\x17\x1e\x2d\xab\xa1\xc7\xe8\x46\xfa\x66\x2b\xf0\x8e\x82\x53\x54\x98\x95\x7a\x84\x8c\xd4\x52\xa4\xa3\xfe\xdb\xc1\xd1\x76\x70\x76\x7e\xfa\xe1\x70\x7f\x70\x4e\xf5\xbe\x3c\xfd\x69\xb0\x86\x79\xb5\x05\xf4\xaa\x42\xaf\x5d\xd4\x15\x05\x3c\x3d\x3f\x68\xac\x26\x2b\x09\x67\x05\x5b\x51\xb0\x55\x1b\xce\x85\xd7\x5e\x3c\x35\x6d\xfc\xfb\xd5\xe9\x65\x7f\x2d\xf2\xd9\x01\x5b\x0a\x78\x3e\x38\x3b\x9d\x2f\x5d\x57\xe7\x47\xab\x8b\xe8\x01\xd9\x52\xc8\x8b\xc1\xde\xd5\xf9\xe1\xe5\xcf\x37\x94\x27\x9a\x60\xcf\xfa\xa0\x20\x5c\x9e\xde\xa0\x37\xf3\xcd\xf9\xd5\xd1\xe0\xe2\xe6\xdd\xe1\xd1\x1a\xa6\xcb\x55\x78\xad\x54\xad\xed\xaa\xef\x5d\x9c\xf5\xd7\x31\xf1\xb7\x84\x6f\x2d\x3c\xaf\x25\x6f\xcf\x61\x06\x3c\xe7\x65\xb1\xf9\x6c\x1d\x35\x68\xcf\x63\xc5\x6a\x5c\xc1\x03\x1e\x5f\x67\xfd\x8b\x8b\x3f\x9f\x9e\xef\x6f\xaf\x67\x54\x74\x66\xd4\xb1\x42\xd5\x1a\xaf\x1f\xfc\x34\xf8\x79\x7d\xb5\xf0\x43\x5f\x55\x74\xec\xad\xf5\x6f\xbe\x3e\xa5\x68\x05\x56\xeb\xa8\xd4\x66\xbf\x89\x93\x43\xdb\x2a\x9c\x5e\x9d\xef\x0d\x7a\xb8\x01\xbe\xec\x9f\x1f\x0c\x2e\xe9\xcf\xd5\xe5\xf6\x83\x6d\x2b\x2c\xcf\x6e\x6b\x54\x09\xdc\x88\x9d\x45\x5c\x93\x52\xe0\x04\xec\x22\x60\x6f\xbe\xa1\xa5\x9f\x04\xdd\x5b\xcf\x9e\xaa\x35\x83\x2e\x15\x60\x1d\x84\x06\xf5\xfc\xe7\x7a\x44\xf7\x83\xee\x2e\xf4\xaa\xfb\x6b\x0b\x54\x4b\xa1\xe6\xcb\x14\xa8\x0f\xdb\xc1\xf9\xe9\x3a\x74\x2c\x2f\xd0\xd5\x04\xa5\x16\xd8\x90\xbc\x56\xec\x96\x62\xaf\xba\x6f\x5e\x71\xb7\x8c\x3e\xbb\x74\xfa\xba\x6a\x8f\x13\x81\xda\x0b\x74\x83\x38\xdb\xea\x66\xfd\x66\x11\xb4\xdb\x17\xf4\x84\x6d\x2b\xec\x6a\x32\xad\xc2\xba\x0a\x55\xa0\xaa\x45\x81\x79\x70\x2e\xcd\x54\xc4\xde\xd5\xdb\xac\x03\x8b\x96\x95\x78\x48\x8b\x92\x10\x55\xce\xb0\x95\x45\x76\x02\xb6\x14\x30\x1d\x8f\x6a\x3d\x1b\x70\x93\xe8\xc9\xd8\xd5\xbb\x89\xdb\x12\xbe\x83\xf0\x68\x19\xc5\x5f\x0f\xa1\xf5\xaf\xf5\x48\xee\x8b\xdd\x56\xec\xfc\x7e\x13\x33\x80\x27\x6c\x4b\x61\x95\x65\xee\x76\xc3\xa8\x7a\x7b\xd9\x4b\x79\x65\xf1\x3b\x33\x6a\x5b\x21\x32\xe1\x5c\xcb\x92\x60\x81\x6a\x29\xd4\xe3\x1b\xbd\x2f\xc3\x3f\xab\x43\x4d\xfc\xfb\xa8\x7f\x12\x3c\x7e\x3f\x7f\xfd\x3d\x3f\x5a\xb9\xbd\xd7\xc0\xd2\xa7\x92\x52\x78\xa4\xa5\x62\x0e\x30\x1d\xf7\x70\x12\x96\xbb\xf3\x38\xfa\x78\x60\x85\xc1\xde\x30\x96\xff\x75\x09\xff\x97\x7c\x08\xc7\xf1\x48\x95\xe6\xf8\x6e\xe1\x24\xa3\x94\x35\xbf\x5c\x27\x80\x8e\xff\x09\xd0\x56\x21\x4f\xcb\x74\x98\x8e\xaf\x81\xcd\xf5\x8b\x72\x98\x5d\xbf\xd8\xd6\xef\x46\x94\xee\x83\x44\xe5\xd7\x6f\x5e\xef\x7c\xff\xe3\x8f\x3b\x6f\x76\xde\xfc\xaf\x5a\x31\x34\x77\x28\xb8\xc0\x0f\x3f\xbc\xfe\x97\xeb\x17\xf8\x02\x04\xf9\xd5\x59\xe5\x3f\x54\x65\x84\x0f\xc3\xa1\xd4\xf6\x8e\x0e\x95\xa7\xbc\x58\xe9\xa5\x82\x36\xc0\xb9\xe7\x3d\xb6\xc8\x19\xfd\xc5\xb9\x9d\x64\x6b\x59\x2f\x52\x99\x29\x4c\x2a\x36\x60\x7c\x6d\x25\x0e\x8e\xa3\x49\x9a\xcf\x1c\x18\xba\x94\x1d\x4a\xdb\xd2\x84\x41\x92\x26\xbd\x24\xba\x07\x9c\xc7\x48\xa7\x23\x70\xb1\x70\x50\x0b\xac\x1f\xa9\x93\x61\xe7\x33\xa6\x2c\x12\x99\xba\xe8\xac\xec\xce\x55\xa8\x57\xfc\xd7\x62\x58\x63\x2c\x6c\x05\xbe\xb8\x38\x0a\xf6\x22\x95\x17\x17\x0d\x6e\x30\xa7\x00\x99\xde\x5c\xc6\xd9\x71\x54\x38\x2c\x79\x5a\x81\x58\x05\xe1\xec\x06\x1d\x5a\xd4\x42\x68\x67\xe8\xce\x18\x65\x2c\x6a\x05\xa5\xc0\x7a\xf7\x53\x15\xb9\x10\xe6\x99\xc7\x78\xa4\xec\x83\x7b\x43\xb2\x71\xdb\x09\xce\xc6\x51\x08\x82\xaa\x97\xd0\xfb\x6a\x3d\x23\xbd\xfd\x0b\x4e\x78\x94\x91\x8e\x78\x6a\xcb\x6e\x00\x2e\x41\x49\xa1\x18\x69\xcb\x04\xf2\x50\xff\xc2\x62\x59\x1b\x6b\x9e\x97\x0d\x3d\x44\x30\x66\x08\xbb\x45\x6c\x05\x3d\x3d\x33\x51\x91\x51\x0a\xeb\x2f\x9a\x02\x52\xf0\x51\x47\x55\x3b\x82\xda\x05\x8d\x8b\x8f\xec\x2b\x44\x0b\xcf\x3e\xfc\x54\xce\x4b\xed\x02\x25\x77\xc7\x5b\x51\xbc\x35\x48\xe4\x12\x82\x83\x68\xf5\x28\x88\x56\x8f\x82\x68\x65\x61\x1e\x4e\x08\x8e\xdf\xed\xe1\x2b\x0e\xe4\xef\x90\xa6\x1d\x96\x55\xac\x4a\x0f\x1e\xa6\xd3\x84\x73\x59\xe9\xf9\xbf\xd8\xc3\x47\x58\xc3\xc3\x46\xa1\xda\xba\xc0\x1b\x5b\x8f\x15\x65\x23\xcc\xfc\x2a\x36\xa1\x85\x32\x18\xc7\x93\x98\x59\xf2\xca\x79\x84\xbf\x5b\xf4\x80\xf6\x78\x5e\xe2\x35\x1a\xa1\x51\xfd\x95\x5b\xb9\x13\xf4\x9a\x84\x1e\xa3\x17\x77\xf9\x10\x26\xf5\x92\xea\x13\xaf\x4d\x7c\x2b\x13\x6b\x45\x48\x05\x76\x39\x1c\x09\x85\xad\xc0\xda\xbe\x7a\x27\x98\x27\x92\x81\x87\x52\xd0\x53\x27\x99\x9d\x99\xa1\x27\xb6\xed\xd6\x7e\x18\xad\xc5\xe8\x30\xc0\xd6\x33\xae\x04\x94\xae\x2b\x51\x6b\x38\xab\x70\xf5\x08\x54\xc1\xfd\x34\x1e\x11\xe4\x01\xfc\xe1\x14\xc4\x4a\x6a\x65\x8a\xb1\x7c\x29\x84\x72\xb5\x44\x5c\xf2\x93\x16\xdf\xc6\x0f\xc3\x2a\xc6\x3c\x64\x24\xe5\xd7\x6d\xa4\xb9\xe1\x3c\xbb\x17\x94\x85\x07\xf6\xa8\x5e\xf9\xf8\x56\xc7\x95\xc4\x8d\x4b\x3e\x5b\x84\x41\x09\x7a\x39\x3b\x4d\x6e\xd3\x93\x88\x93\x10\xdc\xa9\x80\xf4\x1c\xc4\x53\x05\x7a\x27\xa7\x4f\xcb\xb9\xc9\x8a\xb0\xed\x84\x2d\xa2\x31\xea\xa3\xf8\x62\x08\xf3\xe3\x3d\x9f\x7e\x29\x76\x98\x2c\xaa\xc8\x22\x8e\x78\x4d\x3d\xbb\x68\x2f\x77\x07\x0e\xc6\x2a\x1c\x85\x30\x97\x9f\xc2\x37\x63\x96\x66\x29\x16\x0a\x99\x81\x30\x97\x13\x9e\x0c\xe8\x10\xc9\xf3\x84\x69\xdc\x88\x12\xb6\x93\xce\xc1\xee\x31\x8c\xc7\xf4\xfd\x94\xf6\xac\x92\xf8\x4b\x41\xb6\x3d\x08\xdb\x31\x24\xa1\xd9\xed\x0f\x7d\x80\x6a\xa1\x05\xd3\x9c\xb2\x16\x22\xcd\x68\x54\x7f\x15\x8b\xb9\x16\xd6\xcd\xc5\x5e\x95\x79\xf8\x68\x97\x38\xb5\x92\x76\x48\x8c\x2b\xe9\x02\xa3\x32\x76\x18\x15\x52\x4e\x75\x87\x21\x7b\x45\x2b\xc7\x6e\xe5\xe3\xaa\x1f\xd6\x83\xec\xb8\x38\x77\x85\xb5\x0b\xbb\x10\xc1\xcd\x25\xc4\x62\x71\x17\x78\xf3\xc0\xbc\xd3\xd8\xf2\x03\x71\x08\x52\xc5\x7e\x08\xc9\x81\xdd\xc9\x73\xb1\xbc\x03\x9e\xa3\x14\xbc\x0c\xd5\x31\x7c\x8c\x19\xd6\xb2\x9c\x93\x71\xb2\xbf\x5c\x50\xcc\x8a\x32\x9a\x6c\x2b\xef\x73\xda\xd4\x27\x98\xc9\x1f\xe7\x25\x0c\x74\xa0\x5e\x83\x4a\x5a\xa2\x77\x5e\x90\x4f\x29\x62\xbd\xe8\x37\xfd\x4c\xcc\xed\x15\xa7\x94\xa6\x34\x72\xd5\x3c\xd4\x66\x9a\xb0\x13\xbb\x19\xd7\x42\x37\xd6\xbe\x59\x7a\xd7\x69\x74\xb5\x07\xb4\x0b\x58\x85\x4b\x20\x1f\x5d\x77\x8f\x5b\x2a\x6f\x81\xaf\xa6\xd7\xf4\xee\x2e\xa2\xec\x83\x9a\xb0\x16\x8f\xc7\xca\xd0\x0f\xc1\x47\x04\x9e\x7f\x74\x02\x28\x15\xf4\xc5\x8f\xb7\x99\xd4\x87\xe9\x14\x0f\x3d\x5b\xf1\x6a\x50\xc8\x2c\x6a\x89\x01\x6a\x33\x8c\xe3\xf3\xc9\x44\x32\xa3\x2a\xc4\x72\xb8\x34\xbf\xd9\x58\xd9\xc8\x64\x66\x8d\xe0\xb5\x36\xf8\x66\x41\x19\x70\x31\xec\xa7\xaa\xb9\xca\x24\xba\xf8\x96\x32\x84\x4d\x93\x44\xe5\xa0\xa8\x32\xa3\xda\x24\x59\x13\x87\xf6\x55\x28\xc3\x7b\x0e\x02\x55\xea\x30\xfb\x2b\xc9\x6b\x83\xb3\x09\xd7\x88\x68\x57\x70\x08\x16\x87\x00\x66\x12\x0f\x26\xf3\xa0\x74\x5e\x0c\x6a\xc5\xdd\xe0\x2a\xca\x9c\x0f\xb0\x2e\x2a\x82\x62\x43\xaa\xfb\x35\x58\x33\xf8\x52\xad\x90\xaf\xe2\xac\x24\x66\x26\x98\x9b\x2b\xc0\xdb\x47\xfc\x58\x4f\x61\x3e\xd2\x5a\xab\x4a\x18\x1f\x5c\x3e\xc0\xea\x8a\x47\xfa\xb4\x4a\xde\x62\x0a\xa9\xbb\x38\x01\x68\x4a\xcb\x4d\xc7\x49\x29\x8c\x45\x51\xa4\xf5\x31\x90\x2a\xf0\x91\xfa\xdd\x3c\x09\x38\x26\xbd\xcb\x29\x51\x06\xe7\xdf\x97\x97\x65\x2f\x5a\x81\x2d\x87\x07\x0a\xc4\x9b\xd7\x7a\x09\x3b\x44\x2a\x06\xc2\x68\x14\x91\x40\xee\xa1\xa9\x22\xdc\xa3\x17\xd2\x65\xff\x42\x21\x11\x88\x42\x42\x4c\x4b\x4b\xff\x6a\x16\x12\x81\x72\xbc\xfb\x84\xb1\xaf\x73\x6e\x57\x01\x27\xe8\x22\x85\x6f\x8f\x6c\x71\x46\xda\x61\x08\x62\xa4\x1f\x29\x86\x53\x46\x07\x1d\x58\x90\x6f\xa3\xb7\x96\x43\xca\x37\x2f\x76\x44\x99\x3a\x03\x1a\x05\x3c\xc6\x64\x78\x21\x54\x24\x9b\xe9\xec\x5d\x4a\x2b\x18\xa6\x23\x75\xef\x88\xb9\xa5\x16\x12\x82\x87\x49\x0a\x3d\x16\x53\xe3\x5f\x25\x74\xa0\x9b\x3e\xc2\x77\x8d\x41\xa7\x4c\xb6\x79\x43\x04\x80\xbd\x0a\x89\x23\x62\x3c\xc5\x14\xb8\x9f\x53\x85\x91\x0e\x3a\x07\x95\xbe\xf5\xd7\x23\x9f\xad\xf9\x70\x74\xf4\xaa\x0b\xc8\x65\x6b\xa5\x4a\x1b\x02\xd1\xf6\xde\x91\x82\x6f\xaf\x6f\x17\x40\x59\x40\x9a\x5c\x68\x92\xdf\x2a\x1a\x96\x55\xd0\x2e\xc9\x78\x16\x3c\xc6\x45\x8c\x60\x18\x95\xa8\xa1\x4b\x21\x6f\xcb\x4e\x71\x4d\xe0\x82\xe0\xb5\x98\x27\x2a\xb3\x28\x10\x4c\x69\x95\xbd\x9b\x8e\x01\x19\xb6\x4c\xa2\x60\x5e\xc4\x1e\x8c\xe3\xa2\x96\x42\x72\xe1\x04\x60\x14\xa3\x1d\x0f\x0c\xb5\x6d\xa8\x6f\xe3\x9a\x39\x8a\xb1\xf7\xa9\xd4\x67\x6c\x1b\x06\x73\x88\xbe\x2f\xf0\x12\x7a\x23\x8c\x85\x0a\x67\x6a\x13\x96\x6a\x95\x1a\xbb\x55\x89\x0b\xa2\x9c\xf9\xcd\x45\x25\xb0\xfa\x14\x3c\x85\x71\xc9\xa9\xea\x74\x36\xa5\xaa\x5b\xd3\xc8\x9b\x66\xb8\x5b\x86\x79\x36\x99\xca\x6b\x66\x07\x20\x4f\x81\xe6\x8b\xb0\x52\x21\x3b\x49\x63\x47\x91\x44\x89\x27\xd3\x49\x10\x4e\xe8\x06\x15\x26\x3b\x75\x8d\xc1\x1f\xb3\x9a\xdd\xe6\xd7\xb1\xf0\xe2\x21\x7c\xd4\xc1\xe3\xde\xbc\xfe\xfe\xc7\xe3\xed\xe0\xcd\x01\xfc\xff\xeb\x03\xe9\xf0\x62\xdd\x5c\x9e\xa3\x2a\x3b\x41\xef\x0d\x2e\x6c\x30\x35\xa3\xd5\x21\xa2\x4c\x13\x3a\xa0\xc6\x1b\x37\xe2\x21\x2f\x1f\xcf\x2f\xc9\xd7\xd2\x24\xc1\xcb\xfd\xe8\x2e\x9c\x8e\xcb\xdd\xf9\xbb\x67\xea\x16\xdd\xc5\xb3\x36\x1e\x0d\xaf\x97\x78\xa4\x1d\x81\xe6\x35\x2a\xbe\xa3\xb1\x86\x46\x85\x30\xf3\xd0\x00\x5c\xd8\xea\xf1\x44\xb0\x1d\x90\x32\xa0\xec\xa7\x82\x02\x27\x4a\x75\x37\x56\xc0\xdc\x38\x23\x0a\xc9\x74\xef\x79\x78\x9b\xab\x5d\xbb\xc6\x54\xed\xfc\xfd\x3f\xff\x0b\x36\xb3\x6e\x6d\xf1\x73\x7a\x50\x0a\x2c\xc9\xac\x4d\x5d\x9a\xda\xed\xe4\xcc\x65\xcd\xb0\x94\xf6\x36\x32\x9c\x28\x57\x0a\x5c\x23\x5c\xf7\x5c\x83\x93\x78\x77\x07\x34\x0a\x88\x6e\x4f\x02\x2b\x7a\x25\x12\x49\x9b\x1d\x7e\x67\x26\x83\x55\x59\xa2\xc2\x57\x22\x11\x29\xc0\x30\xac\xee\x61\x7f\x1d\xe5\x8d\xfb\x1c\x0b\x9e\x8d\xaa\x0b\x2b\x8c\x57\xa7\x72\x67\xcf\x6f\x96\xd4\x39\x32\xac\xfd\x94\x68\x38\x92\x82\x62\xae\x07\xdb\x2c\x76\xf4\x14\x9c\xa9\xe0\x5a\x12\xf7\x7a\x11\x11\x24\xb1\x7c\x1f\xfd\xda\x4c\x9c\x06\xff\x58\xb0\xc6\x26\xd1\xd7\x4a\x48\x10\xfd\xb3\xc3\xf9\x6e\xb3\x88\x60\xa2\xbc\x02\x05\x0f\x37\x73\xb0\x1f\x8d\x93\xcb\x38\xc3\xcd\x9e\xba\x39\x87\xc2\xea\x01\xea\x5e\x7c\xfe\x09\xdd\x5d\xd3\x4b\xcb\xe2\xda\xd9\x48\x95\x09\x87\xbc\x23\x83\x8d\x42\x02\x9b\xb1\x9f\xd3\x29\xdb\x01\x8d\x38\x95\xbd\x3e\x34\xc3\xe1\x09\x7b\x2f\xb5\x6b\xb8\x5b\xce\x2b\xa0\x07\xb3\xbe\x21\xe0\x44\x74\x09\x85\x03\x4e\x02\x98\x0b\xa0\x12\xb5\x2c\x14\x55\x11\x15\x78\x11\x3b\x54\x23\x9a\x3c\xbc\xb4\xb4\xcd\x57\x2d\xf5\xea\x4d\xad\x70\xcf\x40\x6e\x05\x4c\x73\xe4\x1f\xa9\xdd\xbf\x74\x15\xc4\x8f\x90\xc5\xc2\xa8\xd2\xf6\xba\x18\xed\xb7\x39\x7a\x2c\xed\xd1\x05\x4d\x16\x2d\xab\xb2\xd8\xaa\x3d\x25\xd9\xde\xf0\xe9\x91\x4d\x08\x2b\x9d\x85\x9d\x73\x2e\xac\x95\x91\x60\xe6\x26\x04\x2e\xb0\xa5\x92\x12\x24\x5b\xbe\x14\xc1\x53\x44\x41\x84\x47\xe2\x64\x6f\x2a\x2a\x81\xea\xab\x28\x87\x90\xcd\x62\x12\x98\x25\xbd\xb2\x0c\x6d\x23\x92\x18\x71\x78\xda\x6a\xa9\xa5\xa0\xa5\x4b\x75\xb6\x0c\x58\x4f\x7a\x89\x3d\x3a\x53\x92\xe5\x11\xdd\x47\xea\x53\xa1\x6d\x3c\xfd\xa2\x3e\xa6\x42\xe9\x2e\xad\x3b\x0d\x3a\x59\xba\xf5\xc0\xdb\x84\xaf\xd2\xed\x1a\xc0\xdf\x71\x9c\xfe\x39\x13\xbb\xa0\xed\xa0\x6c\x42\xad\x2e\xcb\x26\x44\x90\xdb\xda\xd2\xbf\x3a\x60\x59\xc4\x72\x8e\xce\x5a\x19\x09\xa6\x99\x8e\xd4\x81\x67\x2a\x6c\x05\xf6\x43\x74\x42\xa9\x0b\xd9\x66\x7e\x7a\xda\xad\xdf\x46\x68\x9d\x18\x59\xd6\x1c\x1f\x62\x17\xe3\xc5\x3b\x59\x2f\x86\x26\x22\x89\x51\x81\xe2\x90\xd3\xce\x43\x58\x78\x54\x4a\x28\x2f\xc2\x7b\x99\x66\x19\x0a\xca\x80\xcd\xd4\x5f\x8e\xaf\x6c\x2e\xee\x02\xc7\xf4\xd8\xad\x72\x47\xbb\x05\x68\x0f\xe9\x23\xe4\xef\xc6\x1c\xde\xa8\x5b\x6c\x40\xfc\x75\x31\x73\x55\x6c\x6e\xcf\xe3\xf9\x71\x17\x09\x1c\x0c\x7c\x71\x9d\x70\x6b\x58\xaf\xd6\xb0\x50\xb5\x5b\x93\x5d\x2b\x7d\x27\x34\xab\x68\x98\x3e\xab\x88\xef\x13\xf9\x24\x63\xb9\xa0\x03\xd0\xf5\xfd\xea\xa5\x44\x28\x65\xd6\xd2\x69\x6a\xf7\x21\x76\x31\x5e\xc8\x7f\xec\xc5\xcf\x40\x23\xb2\x21\x7b\xc8\xf9\xcd\x67\xb7\x7a\xb6\x00\x91\x04\xa1\x0b\x58\x6d\x02\xd2\x49\x0a\x6f\x04\x41\x84\x32\x18\xb3\xc1\x44\x9c\xcc\xf7\x7d\x7b\xef\xe8\x74\xa6\xd9\xaf\xa1\x1c\x16\x12\x45\x69\x8f\x24\x89\x14\xed\xf2\x05\x1f\x1e\x5c\xe3\x2e\x3d\x28\xd2\x09\x9f\x67\xcb\xcc\x2d\x34\x66\x36\xd3\xc9\x2d\xda\x9a\xdc\xcd\x0f\x75\x25\x70\x43\x49\x23\xe4\xe9\x4f\x02\x02\xbc\x30\x13\x9c\x5d\x1e\x9e\x9e\x48\x99\x6d\xf4\x5b\x33\xe9\xf9\x41\xd0\xdf\x3f\x3e\x3c\x91\x88\xab\xf7\x32\xf9\xd5\xfe\xe1\xe5\xe9\xb9\x0d\x40\x95\x10\x21\x8e\xfb\x27\xfd\x83\x81\x0d\x42\x97\x90\x20\xc4\xca\xe3\x2b\x33\x91\x68\xac\x79\x2a\x59\x64\x9e\xa2\x7e\x4f\xa6\xcf\xec\x71\x5d\xd4\xed\x38\x6b\x77\x29\x32\xae\x1f\xb9\xc8\xbc\x71\xb2\x13\x8e\x31\xc3\xd8\x8c\x7d\xa7\xa5\x4e\xe7\xa2\xf2\x63\xd5\xf4\xd3\x26\x6f\x0c\xfe\xcd\x27\x51\x68\x30\xe1\xcb\xdf\x07\xaa\x8b\x50\xd2\x7c\xe2\x24\x93\x98\x49\x57\x25\xf4\x4a\x22\x72\x99\x91\x9f\x3a\x0d\xc3\x4f\xd9\xf2\x27\xaa\x9c\xfc\x47\x7c\xed\xa8\x8d\xb7\x2a\x63\x0a\x89\x83\x37\x7d\x3b\xf6\x95\xff\xd0\x6a\x52\x48\x30\x76\x61\xb4\x95\x13\xcc\x9d\x0b\x86\x4e\x64\x6b\xc2\x23\x08\x16\xad\x38\x4f\x13\xca\x60\x13\xde\xe1\x4e\x76\xc1\x6a\x2a\x1b\x47\xb2\x51\xc4\x66\x78\x19\xab\x75\x16\xc6\xa3\xa6\xe9\x91\x20\x93\xa1\xa0\x00\x58\x14\xec\x36\x09\x4c\x39\x55\x33\x05\x80\x80\x76\x67\x63\x22\xbc\xc0\x9a\x6f\x94\x2b\xc9\xf5\x12\xcf\x9a\x8e\x28\xc4\x5a\xc0\x3b\x0b\x5e\x53\x03\xd7\x2f\xb8\x07\xb8\x28\xb8\xe5\xe6\xce\x7e\x6b\xa7\xdf\x06\xd0\xe5\x2a\x93\xde\xf9\xbc\x34\x09\xcb\xe1\x83\x03\xd8\x4a\x2a\x30\x85\x81\xd8\x48\x9d\x28\xb2\x58\x2a\x28\x03\x96\x7c\xe0\x5e\x8d\x63\x72\x30\xc3\xc0\x24\x7f\x8b\xf9\x18\x5e\x0f\x23\x5c\xf2\xe8\xc0\x77\x3e\xac\x9c\x93\xc8\x3a\x39\x58\xab\xd0\x00\xd7\xb8\x0e\xa1\xcc\x34\x56\x36\x0e\x83\xba\xa5\x62\x32\x58\xeb\x34\x8a\x2e\x2a\x33\xab\x28\xc7\x78\x5f\x38\x4c\x62\x9c\xd0\x02\x8a\x05\xc2\xb3\x39\x8c\xa8\x09\x66\x8c\x7b\x7a\x88\xd8\x84\x4f\x25\x82\x54\x36\x7f\x63\xad\x60\xa8\x6c\x79\x92\x58\x6b\xe4\x60\xae\x02\x5e\xb3\x2d\xa8\x1c\xba\x6f\x4b\x57\x6f\x92\xac\x5d\xa0\x64\xa1\xe6\x24\xb5\x5b\xc1\x79\xb6\x3d\xdb\xee\xdb\x9f\xbe\x25\x7b\x3c\x6d\x4c\x52\x83\x95\x0a\xf6\x4a\x36\x61\x69\x2d\x92\x0f\xa6\x28\xe6\xae\x11\xd3\x22\x83\x40\x20\x32\x28\x6a\x6a\x27\xa7\xf0\x85\x05\xa3\x8c\x87\xd3\x71\x98\xfb\xb8\x05\xb6\xc3\x10\xc4\x20\x93\xd8\xe1\x43\x9a\x16\x73\x8b\x58\xcc\x2a\x8c\x3d\x1b\xef\x92\xf1\xef\x9d\xe0\x6d\x8a\xf3\x32\xdd\x60\x85\x79\x44\x9d\x30\xc3\x21\x52\x96\x3c\xaa\x6f\x39\x59\x5b\x54\x99\xdf\x16\x68\xbc\xa2\x8c\xc5\x25\xed\xf8\x99\x98\xdb\x2a\xce\x9b\xf8\x20\xbc\x0f\x45\xaf\x10\x53\x49\x1b\xa4\x36\x2f\x66\xc3\x1c\x3c\x6b\xab\x59\x73\xd7\xbf\x48\x3d\x74\x56\xab\xad\xdc\x06\x18\x09\x15\x22\x75\xd9\x62\x83\x55\x2f\x61\x83\x88\xd9\xbb\x49\x49\x83\x43\x10\x5d\x9d\xec\xa0\x02\x8d\x8d\x0d\xd9\x70\x57\xa1\x0c\x8d\x5b\x2e\x3b\x4f\x1f\x80\xd6\x02\xa0\x91\xb7\xda\xf7\x92\xb5\x46\x07\x11\x96\x20\x6c\x42\xa0\x89\x18\xc1\x8c\x82\xeb\x17\x0d\xbf\x96\xeb\x17\x0b\x3b\xf0\xca\x26\x1e\x0f\x81\x95\xd1\x1f\x91\xca\x43\x76\x8d\x2c\xec\x95\xa0\x7c\xe7\xc0\x40\xcd\xe1\x98\x0e\x1a\x6d\x6c\x2b\x6f\x0e\x5c\xfe\x66\xb0\xe5\x09\x4e\x2f\x76\x25\xdf\x86\x8e\x60\x36\xc1\x16\x3f\x4d\xc3\x51\x62\x9a\xc4\xda\x8f\xcf\xd1\x82\xfe\x30\x6d\x84\x79\x84\x07\x1f\x60\xbb\x11\x63\xa4\x9e\x26\x66\x57\xc1\xfc\x20\xcd\x42\xe6\x68\x8b\x83\xc6\x73\x3a\x7b\xfd\x28\x0e\xef\x93\xb4\x80\xf5\x89\x96\xe0\xa2\x1c\xc9\x9e\x74\xbe\xd4\x16\xd6\x18\xd0\x27\x0c\xc6\x74\xd4\x73\xa7\x0c\x73\x70\x0e\x5f\x50\xe8\x17\xf4\xf7\xb0\x72\x77\xac\x54\x7c\xe5\x23\xa2\x77\x9a\x29\xcf\xb1\xfb\x83\x7e\x70\x1b\x0e\x61\x3c\x8a\x53\xd9\x73\x8b\x61\x69\x0c\x2c\xfa\xc8\x1f\xd2\x2a\x6d\xbd\x9c\x1f\x1c\x8a\x76\xc0\x76\x66\x68\xe3\xfd\x14\x72\xa0\xf8\x92\x17\x4b\x79\xce\x6d\x8d\x23\x88\x93\xc2\x08\x46\x6f\xbe\x09\xac\x87\xd0\x2c\xa3\xf4\x29\x19\xa7\x21\xde\x66\xa8\x71\x8e\x6b\x62\x34\xa9\xed\xc8\xe4\x09\xa3\x1b\x98\x24\x18\x9b\xe0\xd1\x5e\x82\xbc\xaa\x40\x41\xc3\xfb\xaf\x70\xbc\x1b\xfc\x63\x81\xa1\xd0\xc8\xc8\x1f\x97\x6d\x59\x9e\x16\x18\x92\x18\x14\x30\xca\x14\x3d\x6a\x6e\xa6\x36\x8f\xcf\xc6\xce\xbd\x1c\xa9\x89\x8f\x47\x41\xf7\x49\xee\xd1\x20\x7f\x9a\xa1\x57\x30\xda\x2e\x29\x15\x84\x9a\x09\x4a\x71\x98\xa4\x12\xa7\x54\xfc\x54\xe2\x14\xf3\x25\x44\x91\x1a\x05\x75\x27\xc9\x64\xbe\x7a\x6d\x26\x9e\xe6\xea\xae\x8e\xb7\x15\xb5\xd8\x7c\x5c\x19\xd9\x1d\xd7\x8b\xd4\x97\x69\x63\xd7\xd7\x8a\xe7\x12\xa5\xc0\xb2\x78\xc0\xd0\xc8\x2a\x03\x01\x9a\x00\x60\xa0\x5d\x6d\xb4\x46\x7e\x02\xbc\xca\xab\x90\x06\xa2\x00\x6d\x71\x6c\xe2\xa0\x47\x31\xe7\x7c\x0f\x5e\x62\xaf\x47\x3c\xfc\x97\x67\x59\xdd\x79\xbe\xdb\x15\x23\x7e\xb5\xc7\x31\x8a\x43\xd1\x51\x83\x7d\xbc\xb4\xe4\xd4\x17\xd0\xae\xf4\xac\xcd\x0d\x49\x4b\x10\x8b\x20\xd8\x8a\x74\xb9\xae\x4d\x7e\xa1\xb9\x61\x8d\xd6\xfe\x9c\x68\x1d\x86\xa9\xf5\x55\x60\x1d\xba\x65\x4c\x29\xa4\x1f\x9e\x39\x4f\xc7\x25\x2f\x49\x84\x40\x07\x91\x30\x17\xeb\x63\x73\x0a\x48\x22\xb9\xcf\x3c\x17\xf7\xee\x55\xe7\xbd\xd1\x97\xab\xfc\x5a\xf8\x5b\xaa\xbf\xd0\x65\xbc\xf6\x3b\x3e\x94\x46\x96\xe7\x83\x7f\xbf\x1a\x5c\x5c\x4a\xf7\x53\xd5\x6b\x81\xf8\xe2\xec\xf4\xe4\x42\x74\x04\x9a\xbf\x37\x93\x9f\x1e\x0d\x2e\xe4\x71\x5d\xbd\x16\x88\xaf\x2e\x07\xd2\x45\xad\x7a\x69\x26\x84\x01\xd8\x23\xef\xec\xb9\x49\x3d\xf6\xe7\x38\xb9\x4b\x69\xad\xc1\xcd\x4f\x6e\x89\x30\xd8\x02\x40\x12\x00\xb5\xed\x51\x84\xb7\x3a\x40\x99\xc1\xbc\x19\xa9\x78\x99\xc5\x9f\x78\x25\x9d\x64\x72\xd8\x59\x7f\x7a\x0f\xf6\xea\xc0\xf1\x38\x85\xdf\x1c\x7d\xb9\xfa\xa9\xa7\x2c\x8c\xf7\x08\x1a\xdd\x0c\xcf\x22\xee\xb1\x57\xa7\xc3\x38\xd4\x3a\x0a\x2c\xd0\x7f\xf2\x92\x73\x2d\x8c\xd6\x51\xa1\x35\x89\x6b\x17\x46\x1d\x46\x1a\x4c\xea\x1a\xc1\x57\xd9\x63\x2f\x53\xe7\x9d\xa7\xe3\xd1\xf2\x91\x27\x74\x2e\xf4\x79\x88\x9e\x96\x5e\xfd\xe9\x7a\xfa\xfa\xf5\x0f\xd2\x51\xce\x17\x10\xc4\xd6\x20\x19\x28\x2d\xcb\x2e\x8b\xcb\xfa\x12\x0b\xb2\x37\x4e\xa7\xa3\xe0\x1d\x6a\x90\xf9\xcc\xf1\xc1\x56\x42\xf6\x17\x59\x9b\x2c\x2e\x1f\xcf\xaf\x28\x71\x3b\x60\x41\xe0\x61\x14\x3f\xd2\x79\xe9\x3c\x7d\xc3\x10\x94\x71\xbe\xd5\x53\xa1\x42\x44\xa1\xbc\x88\x25\xc6\x53\xd8\xea\x3d\x46\x50\x2b\xa5\xb0\xcf\x63\x84\x71\xa4\xd5\x18\xd3\x48\x51\xee\x80\xc2\x50\x21\x8a\x52\x7d\x8b\xfa\xbe\x56\xd5\x26\x21\xc5\x78\x51\x67\x04\xac\x4d\x2e\x18\x05\xcb\x15\xf9\x12\xc2\xb4\x6f\x98\x79\x28\x93\xaf\xa9\x85\x9e\x41\x2a\xa1\xa9\x94\x20\x8b\xf1\x18\xa5\x9b\x5c\x0b\x81\x9d\x81\x0a\xfd\x87\xb9\x54\xa8\x46\x1c\x6a\xc6\xc5\x45\xa0\xb2\xb3\x9a\xe6\x2a\x74\xaa\xa2\x49\x2c\xdb\x29\x07\x91\x95\x11\x45\x01\xae\x39\xca\xf1\x55\x00\x7c\x08\x07\x2f\x99\xce\xca\x2e\x69\x18\x73\x3a\x78\x2c\x14\x76\x00\xa3\x06\xd5\xf2\xd3\x08\x44\x32\xa3\x45\x03\x60\x9c\x72\x3f\x84\x79\x7d\xba\x5d\x74\x1f\x43\x45\x3e\x5d\xb4\xfa\x7a\xa5\x3a\x05\xce\xd8\xf8\x87\x56\x60\x0a\x7c\xb2\xc7\x57\xca\x57\x20\x8a\x6d\x17\xff\x05\x05\xb2\x37\x50\xde\xc8\x35\xc4\x42\x50\x04\x34\x8c\xa1\x4e\xdd\x84\x91\x6a\x82\xf0\x63\x10\xa7\x29\x0a\x3f\x26\x81\x3a\xb7\xce\x33\x4b\xb3\xd1\xa6\xf9\x22\x2d\xd0\xb1\xa2\x53\xd6\x19\x29\xef\xd3\xba\x3a\x22\x72\x4f\x1c\x87\x5b\xcf\x2a\x42\x9b\x46\x68\x2d\xb2\x85\x01\x27\x4c\x9c\x7b\xed\x8a\xc0\x4b\x05\xed\x80\x9e\x4a\x80\xb9\xb4\x1f\xb4\x23\x5e\xac\x5c\xde\x01\x6f\xf1\x71\x59\x28\x64\x05\xb2\xaf\xb3\xf5\x32\x0e\x18\x39\xfa\x6e\xb3\x8c\x0c\xa3\xce\x3e\x9b\x1d\xb6\xda\x44\x6d\x76\x0c\x3d\x13\x7b\x7b\xe5\xe7\x71\xc0\x78\x4b\xf9\x56\xff\x5e\x14\x66\xe1\x85\x47\xc5\x56\x81\xb6\x0b\xbd\xd4\x1c\x8b\x4d\xd6\xe1\x33\x74\xc2\xb4\x8b\xd9\x1c\xbb\xaa\x15\x3c\xd1\x5d\xe2\xae\x84\xed\x27\xf6\xd2\x56\x77\xf1\x70\x61\xe3\xca\xd7\x17\x13\xc8\xd1\x40\x1a\x09\x8f\x60\x6a\x60\x73\x71\x6a\x0f\x4d\xc2\x74\x6c\x86\x0d\xb1\x15\x2a\x9b\xa5\x36\x23\xa4\xf9\x7b\x91\x3c\x87\x0d\xa6\x36\xe5\xbc\xb8\x78\xcf\xf6\x34\xe3\xf4\x89\x4d\xc6\x5c\xcb\x89\x2f\x7d\x1b\xf6\x9c\x11\x67\x84\x77\xf8\x0b\x61\xe3\x94\xb1\x16\x85\x21\x76\xac\x9d\xab\x23\x8b\x22\xf3\x06\x59\xbc\x27\x6f\x14\x11\x40\xd8\x68\x23\x2b\xa2\xe9\x28\xed\x95\xe5\x8c\x9a\xcc\x6a\xd8\x66\xa7\x11\xd8\xa0\x15\xbd\x73\x25\x6f\x14\xb2\x00\x19\x57\xc1\xcd\xcd\x2a\x1b\x64\x29\x57\x32\x2f\x3d\x5a\x6b\x5e\xc8\x06\x84\xb2\x9b\x4e\x50\x31\xf4\xcf\x5d\xa3\xef\x35\x6a\xe7\xbd\xc2\xac\x95\x89\x50\x91\x32\x8f\x23\x3e\x1d\x88\x93\x51\xfc\x18\x8f\xa6\xe1\xb8\x32\x3a\xa0\x20\xe7\x74\x9d\x00\x3c\xcb\xa9\x74\x8d\xdb\x16\xc5\x25\x0a\xa5\xe3\xcc\xc6\x21\x5b\xc9\x9f\xf6\xab\x68\xf6\x95\xd1\x77\x95\x59\x07\x6d\x7f\x2d\x03\x6a\x05\xc8\x76\x42\x72\x32\x2f\xf8\x1a\x5b\x05\x65\x6f\xdb\x09\x82\x3e\x86\x87\xa2\xa9\x89\x53\x76\x72\xa0\x18\x6a\x01\xb4\x89\xca\xa6\x73\x1b\x76\x8a\x48\x5b\x90\x59\x47\x1e\xa1\x29\xaf\x3c\x66\x9e\x8b\x7f\x97\xea\xc3\x98\x35\xb1\x5f\x60\x46\x97\x7f\x6b\xa8\x6c\x67\x6e\x5d\xaa\xa6\x34\x1f\x0f\x86\xd5\x56\x6e\x0d\x55\x5c\x99\xeb\x0a\x55\xed\x7d\x8c\x66\x5f\xa6\xba\xab\x71\xee\x54\x65\x5c\x50\x7c\x58\xd2\x0a\xb4\x96\xaa\xae\xc2\xb1\x53\x15\x31\xef\x54\xc5\x50\xe6\xa7\xd3\x53\xad\x5e\xc3\x15\x18\xda\x2b\x58\x99\x92\xd6\xd6\x97\xa2\xbe\xc0\xe0\xcb\x28\x1c\xb2\xd7\x44\xaf\x9e\x7b\xd1\x55\x95\x55\xa0\xed\x42\x9b\xdc\xe4\x3a\xfb\x85\xae\x8a\xda\x5e\xd4\xce\x9e\xa0\xab\xa2\xba\x45\xcd\xa7\xe3\x5a\x42\x30\x9e\x19\x9a\xf1\xa1\x16\x6d\x23\xaa\x81\xe5\x23\xf3\x2a\xf0\x36\xe1\x69\x23\x59\xf5\x29\xc4\xc6\x2e\x85\xb1\x37\xaa\x3c\xa1\x6d\x0e\x4f\x56\xc1\xf4\x17\x13\x48\xdf\x31\xd2\x3b\x00\x6e\x79\xbe\xd3\x15\xcf\x25\x5e\xb7\x41\xd0\x4d\xf4\x35\xf2\xea\x52\x2d\xf7\x80\x59\x5f\xb5\x3a\xf2\x32\x57\x4b\x9f\xf5\xbf\x4f\x8b\x52\x1d\x2e\xc2\xaf\x7d\x8a\x71\xa9\x76\x2c\xf0\x7b\x80\x96\x77\x11\x6d\x6e\x24\x99\xdb\x03\x75\x15\xe8\xd5\xef\x3a\x74\xe9\xda\x44\x93\x21\xed\x42\xd2\x1f\x40\xf4\x14\xb2\x85\xe2\x2d\x19\x8b\x97\xcb\xae\x9d\x06\xc3\x25\x90\xc2\x25\xf0\xaa\xf0\x76\xe1\xf9\x46\xca\xcb\x1e\xd8\x4e\xe3\xc3\xa6\xe6\x2a\xd6\xa6\x16\xea\x73\xf9\x89\xb5\x22\x0f\xb9\x1a\x3a\xfd\xb7\xfe\x24\xf9\x01\xfe\x04\x8e\x55\x7a\x17\x9b\x80\x1e\xd4\x32\x6b\xeb\x17\xb1\x34\x3d\x4e\x10\xe8\xa4\x74\x75\x7e\xa8\xf3\x5d\x55\x3e\x09\x75\x9f\x51\x1d\x7e\x18\x27\x16\x2c\x1b\x4e\x4b\x18\x17\x65\x3c\x44\x13\x2f\x5b\xbb\xaf\x89\x81\xb9\x02\xb8\xb4\x4b\xbc\xe9\x9d\x40\xc6\xf3\xfd\xa0\x36\x31\x7e\xd0\x13\x23\x35\xba\x98\xd8\xcc\x8b\xd4\xc8\xf4\x62\xb0\x07\xd5\xba\xfc\x39\x38\x38\x3f\xbd\x3a\x13\xe0\x17\x0a\x09\x40\xe7\x1f\x0e\xf7\x06\xd6\xc8\x53\xcd\x32\x36\x18\xc9\xa4\xb8\x7a\x6d\x26\x3e\xeb\xbb\x24\xa8\x95\xb0\x41\x58\xe3\x5f\x35\xcb\x58\x60\xf6\x07\x1f\x06\x47\xa7\x67\x62\x14\xac\xc5\x52\x16\x28\x7b\x38\xad\x66\x19\x19\x46\x6c\x56\x7e\x69\x26\xbc\x78\xaf\x9c\x49\x3a\x9d\xa7\x7b\x93\x9b\x99\xc3\x38\x7b\xd6\xd3\xe3\x0d\x32\x34\x57\x50\x2b\xfd\xf6\x01\xbe\x54\xcc\x0e\x56\xcd\xd8\x7a\x4f\x71\x73\xaf\x26\x6d\x2f\x3f\x86\xf6\x38\x5d\xc5\x81\x67\x94\x8d\xf1\x66\xe2\x48\xf5\xd2\x0d\x4b\x10\x6b\x1c\x0d\xab\x20\x9c\xc1\x4b\xd8\x82\xd1\x09\x01\x68\xa4\xb8\xda\xe1\x84\xff\x31\xce\xbe\x93\x3f\x85\x27\xb9\x95\x39\xf7\xa6\xae\xbc\x5d\xd4\x02\x6b\x4a\x00\x44\x6d\xb4\xcd\xff\x50\x0a\xc3\xdd\xe0\xcd\xeb\xd7\xdf\x6f\x07\x13\x9d\x4d\x47\x85\x1c\x29\x74\x82\x75\x36\x7e\xba\x8d\x86\xe1\x94\x3d\xce\xab\x00\x6f\x59\x2d\xaa\x96\x6c\xab\xf1\x0c\x8c\x3d\x2a\xac\x76\x87\xcc\xf8\xc7\xd7\x3f\x2c\x49\x82\x8f\x2a\x51\x30\xf3\x83\x0e\x8b\x81\x69\x6f\xd3\x3c\xfe\x1b\xc7\xc5\xc8\x54\x80\x1b\xda\xa2\x55\x2e\xf0\x9c\x38\xc2\xab\x01\x9e\x45\x90\x0e\x0d\xb2\x1b\xf4\xd9\x93\x06\xda\x78\x14\x25\x14\x4d\x9f\xd8\x8f\x52\xe2\x4e\x31\x43\xb3\x3c\x7e\x8c\xc7\x91\xf2\x30\x8c\x3e\xc1\x20\x24\x3f\x8d\xb8\x70\xc5\x25\x79\x26\xe6\x6d\x2b\x8e\x1b\xa6\x3c\xbf\xa0\x47\x7b\xf0\xe4\xf3\xe7\xe6\xf7\xe0\xf7\xfd\x2c\x1e\xe0\x43\x5d\x62\x52\xcb\x3c\x05\x2f\x1a\x5e\x1c\xed\xeb\xbf\x01\x19\xc4\x66\xc0\xdd\x04\x5d\x53\x5d\xd2\x35\x15\xd0\x1e\x85\xb7\xd1\x98\xe7\x4f\xed\xa1\xbb\x34\xc1\xdb\x3e\x6a\x57\x44\xab\x88\x6f\x2b\xb3\x97\x13\x93\x1b\x9d\x4b\x1e\x27\xb9\x95\xb9\xde\x5a\xe9\xd9\x86\x66\x1e\x1d\xcc\xd7\xc1\xd9\x4e\x6b\x65\x6b\xf1\x9a\x71\xed\xd4\x5a\x41\x78\x0b\x61\xdc\x69\xb6\xfc\x12\xed\xf1\xbc\xc4\xdb\x5d\x32\x16\xf2\x94\xc3\x40\x68\x65\x28\x45\x70\x37\x84\x0d\x5b\xf9\x40\x60\xb3\x3c\xad\xd5\xac\xfc\x9f\x9a\x3c\xae\x93\xcb\xc3\xb3\xdd\xe0\xf0\x0e\xe3\xb8\xd0\x3a\x54\xe6\x33\x3a\xd9\x4b\x95\x03\x55\x18\x3c\xbe\x59\xf2\xa2\xda\xa6\xe2\x94\x39\x49\x6f\x9e\x7b\x19\x1d\x1a\xbb\xaa\xfe\x7c\x72\xf8\x35\x87\xef\xc0\x33\x10\x58\x19\x2c\x99\xba\xb5\x1b\x55\x4e\x72\x1b\xf3\xfa\x10\xf0\x5d\xb9\xac\x64\x36\x66\xd2\x41\x48\xf5\xda\x4a\x2c\x2b\xc2\xfa\xbd\x40\x5e\x2e\x7a\xbe\xf0\x55\x8b\xcd\x42\xc7\x41\x24\x32\xd2\x3e\xe5\x68\x52\x35\x8e\x76\xb0\x93\x1e\x9d\xee\xf5\x8f\x06\xb8\x04\x6c\xed\x1d\x0d\xfa\xe7\x5b\xdb\x94\x4d\x3f\x4e\xa7\x85\x2a\xc6\x7a\x0e\x3a\xb9\x5a\x14\xa6\x75\x60\x8b\x62\xb3\xf5\xc6\x0d\x85\x67\xbc\x29\x67\x99\x32\xa8\x41\xc5\x8a\x63\xc6\x6d\xa1\x21\x1c\x27\xe0\x4b\xd2\x24\x92\xb2\x31\x74\xc3\x12\xc5\x82\x22\x8f\x71\xf4\x34\x0f\xa7\x16\xa3\x47\x96\x85\xb7\x40\xe0\x66\x50\x4f\x03\x5e\xcf\x7f\xe4\xc3\x4b\xa4\x95\xd8\xaa\x20\x1c\x75\x67\x2f\xb2\xea\x1c\xa8\x9f\xd6\x33\x09\x5f\x72\x2b\xf3\x46\xbf\xc6\x50\x31\x95\x8b\x13\x05\xde\x57\x4f\x3e\x84\xe3\x69\xc4\x81\x63\x96\xb3\x78\x6d\xee\xd4\xe5\xab\x92\xd1\xda\x8c\x7f\x35\xc5\x78\x50\xb1\x07\x0c\xc6\xb8\x3e\x17\x66\x6b\x81\xb6\x0a\xbd\x96\x9b\xd6\x8e\x60\x56\xc1\x36\x7e\xc7\xba\x01\x46\xad\x2b\xb4\xd6\xdb\xd5\x0d\x30\x32\x57\xe8\x01\xb5\xac\x90\xf6\xdc\xe8\x7f\xae\x12\xec\x93\x25\x82\xd5\x33\xc7\x83\x50\x64\xc8\x8a\x1f\x95\x5f\xbc\x7d\x55\xc1\x84\xba\x0f\xb2\x75\xc1\x0b\xc2\xa7\x4f\xf3\xe8\x47\x4d\x4b\x0e\x51\x20\x0b\x89\x85\xc9\x78\xbc\x90\xcb\xc5\xad\xd8\x38\xe9\x64\x76\x0f\xd1\xd8\x0a\x4b\xef\x65\x72\x8c\xc6\x92\x4f\xf8\xcc\x9f\xf8\x29\xc3\xac\x97\xe1\xdc\x42\x0b\xbb\x4a\xd4\xe3\x98\x74\x14\x93\x8f\xb3\xe7\x6c\x03\xb1\x8e\xed\x83\xfd\x26\x8b\xf2\x90\xe7\x1f\xf5\x9a\xf3\x6e\xc0\x2b\x18\xc7\x94\xc8\x53\x8a\x27\xf4\x25\x24\x91\x9b\x44\x07\xa9\xb1\x09\x5b\x95\xb1\xc3\xe0\xd9\x42\x81\xa1\xeb\xf0\x9c\xd4\x85\xd7\x2c\x2c\x03\x53\xf8\x91\x51\x54\x86\xf1\x58\xf5\x91\x7a\xf0\xe3\xc5\x1d\x96\x8d\x6b\x4b\x24\x59\x24\x5e\x18\x5d\x8d\x56\x2b\x25\x43\xe5\xd1\x90\x12\x3c\x80\xd6\xc0\xe9\x4a\x6d\x88\xcb\x85\x65\xe0\xa5\x8d\xb8\x4b\x5c\x33\x81\x9b\x01\x1e\x0e\xf8\x62\x57\x65\x2d\xb0\x6c\x09\xea\x02\x9c\x97\x72\x41\xf9\x7d\xac\xa5\xb2\x2e\x58\xef\xbe\x6e\x2a\x2e\x82\xe3\x28\xae\x2c\xf4\x69\xef\xc4\xce\x0f\xcf\xa4\xf6\x3e\xa3\x04\xd6\x26\x58\xb6\xe4\x5f\x8f\x6a\xed\xb7\x30\x3f\xa7\x0c\xe6\x66\xf8\x18\x67\x2a\x50\x9c\xf6\x14\xa5\x9b\xa7\x32\xb5\x05\xc0\x70\x51\xc9\xac\x1e\xd2\xa2\xa4\xb1\x49\xa1\x7e\x6c\xbe\x5b\x62\x71\x19\xbc\x91\x46\x44\x29\x86\xf5\x54\xfb\x98\x22\xb9\xc4\xa9\x2d\x9d\x80\x82\x38\x8a\x46\xff\xd3\xc6\xbb\x03\x9a\x59\x34\xdb\xce\xda\xb2\x73\xa6\xef\xba\x96\xa0\x90\x9d\xa0\x5c\x42\x89\xe7\x53\xf5\x22\x16\x90\x15\x52\x8f\xb5\x00\xb0\x08\xb0\x38\x64\xfc\x5b\xd2\x4e\x29\xb3\xb4\x36\x99\xd8\x58\x18\xb3\x99\xf3\x30\xa8\x54\x36\xa4\x9f\x51\x30\x48\xa0\xa7\x83\x31\x7a\x45\xf7\xc7\x3a\x1b\xf8\x76\x15\x70\x94\x8b\xe3\x3d\xa1\x0a\x1f\x89\x09\xab\xd4\xac\xfb\x94\xe6\x14\x34\xa9\x0a\x3d\x2c\xce\x54\xcf\x2c\x85\xb9\x29\x48\x59\xe5\x39\xe6\x99\xd5\xe8\x67\xe0\x2c\x55\xf9\xbe\xa3\x61\x9c\x17\xa9\xc4\xd4\xe5\xd2\x79\xe1\x74\xe8\x54\x25\x60\x0d\xc3\x6c\x93\xe9\xb4\xbc\x4e\xd4\x4d\x46\xbf\x66\x0c\x45\xf7\x13\xb7\xec\x25\x12\xd5\x63\x90\xe7\xf1\xfd\x43\x19\xe0\xd1\xe9\x0e\xdd\x2b\xc2\x00\xc3\x39\x18\x76\xb2\x23\xbc\x19\xd6\xc7\x00\x58\x80\x33\xce\xe2\xaf\xff\xef\xec\xf4\xfc\xd2\x78\x04\x20\xf6\xeb\xaf\x4c\x4a\x4b\x53\x4e\x93\x79\xac\xfc\x4a\x4a\x43\xae\x5d\x1c\x9b\x93\x34\x8f\xea\xdb\x3e\x6b\xed\x57\x02\x96\x05\x8e\x46\x7c\x6b\xc2\x7f\xcb\x37\x2c\xc6\xb2\x32\xec\xf3\x9a\xc4\x6d\x90\xa3\x5c\xc5\x69\xa6\x6d\x3a\xb6\xf9\xee\x2e\x0d\x92\x29\x7a\xca\xa4\x18\xdd\x97\x1f\xe8\xdb\x11\xf6\xac\x56\xc5\x6d\xb5\xe8\x0e\x2a\x09\x2a\xa6\x4f\xe2\x77\x22\xd9\xb4\xd0\x1f\xbb\xb4\xdc\x5d\x2f\x17\x14\x00\xd3\xcc\x35\x55\xcd\x4b\x88\x10\xd9\x33\x77\xab\xcd\x71\x34\x57\x91\x93\x32\x2b\x8b\x94\x91\xb8\x64\x2c\x16\x33\x82\xe1\xfc\x20\xc6\x26\x56\x2f\x2d\x84\xf0\x9b\xd2\x20\xef\xbd\xbb\x39\xe9\x1f\x0f\x94\x42\xd0\xa3\x8c\xcd\xda\x58\xa4\xa7\xdd\x74\x39\x83\xdc\x47\xde\xd4\xce\x93\x4a\x17\x3a\xdd\xfa\x3c\xe1\x0a\x14\xdc\x7b\x47\x4b\xa9\x55\xb2\xcd\x73\x17\xab\x1e\xec\xa9\xf8\xf4\x4f\x31\x8c\x3b\x32\x6a\x83\x35\x66\xc6\xf6\x5c\x2a\x56\xbd\x3e\x97\xaf\xa9\xb0\x05\x4c\xd0\x65\x4c\x7e\x72\x33\xba\xfe\x57\x29\x3d\xe5\xdb\xd3\x0d\x31\x93\x2b\x56\xb3\x4d\xb8\x8d\x1e\x62\xd8\xc6\x86\xa0\x0d\xe5\xd1\x13\x85\x79\xa4\x80\xd4\x7f\x9d\xc6\x39\x45\x33\x78\x7f\x79\x79\x86\x46\x41\x9f\x66\xdb\xbc\xc3\x62\x0f\xd7\x87\xb2\xcc\x8a\x1b\x7a\x6e\x3e\xc3\x27\x43\xb7\x1c\x15\x44\xa8\x05\xcc\x57\x3b\xc1\x60\x5c\x44\xdb\x2a\xc7\x1e\xa5\xda\x49\xa2\x12\x55\x49\xdc\x13\x24\x11\xd9\x02\x5a\x5b\xe8\x2b\x96\x5a\x6e\x6a\x5b\xbe\xfd\x3b\x0e\xbb\xd7\x21\x8b\xff\x5a\xa0\x65\xa1\x75\xda\xf3\x7e\x16\x37\x11\x70\xf7\x16\x27\xd3\xa8\xba\x22\x81\x9d\x1c\xde\x06\x34\x37\xda\x36\xa1\x57\x85\x76\x0b\xbd\xf7\xae\x02\x6e\xcc\xd5\xc4\x25\x02\xdd\x09\x20\xe9\x43\x36\x6e\x70\xab\x5c\x14\x38\x7d\x44\x77\x77\xf0\x65\x7d\xaa\xb1\x3e\x66\x3e\x15\x53\x61\x6c\x16\x74\xbc\x30\xd1\x5e\x58\x38\x9f\x6d\xa6\x96\x1b\xe1\xec\x51\xe5\x46\x17\x59\x7b\xb5\xba\xa3\xcb\xa2\xcf\x87\xe0\x55\x36\x82\xa5\xaa\x0a\x28\xd7\xe4\x36\xa5\x97\x6c\x10\xec\x0a\xeb\xb8\x3a\xae\x59\xdc\xf0\x9e\x15\x36\xfc\x43\x54\xec\x16\x4b\x09\x50\xb0\x06\xa1\x61\x49\xed\x2a\x62\x9c\xde\x7b\x5c\xf8\xf9\x50\x0a\x2c\x6b\x36\x2d\x75\xfd\x4b\x56\x75\x2c\x14\x76\x16\x26\x7d\xce\xcd\x46\xa0\x32\xb3\xd2\xe9\x9d\x1a\xb7\xfd\x75\x37\xa4\xca\x58\x37\x2c\x6b\x21\x26\x60\x15\x8c\x3e\xd1\xe2\xc7\x77\x33\x65\xcc\x99\xa5\x31\xd5\x4e\x75\x5b\x63\xc8\x25\x3e\xf7\xd2\x07\xb1\x18\x45\xaa\xce\x57\x20\x99\xb9\xc9\xa0\x0c\x1d\xe1\xfc\xae\x13\xd6\x0d\xc8\xca\x1e\xc7\xac\xf1\xa0\x0f\x54\xa5\x51\xc4\x21\x37\x54\x20\xf0\xf9\x01\x96\xfc\x35\xd7\xcc\x45\xac\x4a\x9a\x8f\xc8\xc5\x2c\x78\x7a\x88\x87\xdc\x02\xd5\xf8\xe5\xb4\xa7\xa4\x83\x40\xbf\x1a\x4d\xf3\x66\x48\x4b\x74\xf4\xec\x61\xca\x62\x9b\x63\xc7\x7a\x79\x88\xd5\xa0\x8b\xd4\x9a\x7b\x70\x2d\x39\xad\x0e\x20\x01\xc3\x4f\xd4\xf9\x5b\x20\x74\x15\x81\x93\xef\x88\x36\x21\x6d\x10\xbc\x45\x80\x01\xb4\x72\x3b\xc8\x18\xdd\xc5\xe8\xd0\x16\x32\x86\x28\x46\x2e\x3a\x8f\x43\x57\x84\x75\x6d\x47\x9d\x61\xf1\x16\x88\x15\xf5\xb4\x28\xf1\x26\x8c\xa7\x83\x1e\x28\xf4\xa7\x17\x97\xb4\x01\x04\x8e\xb8\x14\xf6\x7a\x20\xea\x28\x9d\xf4\x18\x1c\x56\xbe\xfb\x28\x89\xf2\xf9\x1c\xc3\xcf\x29\x15\xdc\x03\x4c\x47\x19\xe5\xfc\xb2\xe5\xa6\xfb\x1a\x25\x15\x9b\xb4\xb2\xe8\xac\x2b\xc7\xa0\x43\x4f\xc7\xa3\x40\xe5\xe0\xce\x31\x48\x8f\x65\xd3\xd9\x12\x45\x12\x05\xf7\x5b\xe4\xf3\x55\xad\x0d\xf3\x24\xdb\x34\xbd\x63\x23\x66\x99\x45\x0c\x6f\x04\x87\x08\x65\x4a\xd9\xeb\x67\x2a\xb3\x56\xc1\x79\xf2\x29\x28\x53\x95\x83\x96\x0c\x7e\x55\x86\x64\xfc\x6a\x6e\xb1\xba\xa1\x5a\x44\xc5\xda\x24\xca\x67\x4a\xf9\xc5\xd5\xf2\x60\xe0\x49\x35\xaa\x79\x18\x5f\xf3\x2a\x1f\x83\x56\xb7\x2b\x85\xe0\xec\x0c\xb7\x56\xe1\xd8\xa3\x2b\xcd\x51\xb7\x41\x2d\x31\xce\x64\x55\x72\x9d\x2c\x84\x4a\xa0\x3d\x39\x9b\xcd\x61\x40\x2d\xb4\xef\x43\x3f\xc3\x3c\x2d\x8a\x6a\xbe\x84\x41\xbc\x8f\x26\xe7\xd4\xd3\x4a\x3e\x70\xc9\x6b\x69\x2e\xe6\xb1\x8c\x38\x43\xd6\x36\x8d\x4d\x2a\x46\x87\x4b\xd8\x19\xf0\x20\x50\x69\x2a\x73\x8e\xd3\x84\x46\x0b\xdd\x0c\x5c\x27\x7d\xde\x4c\x04\x7a\x57\x11\x3c\x85\x89\x3a\xb5\xad\x12\x46\x99\x2d\xfc\xfe\x24\x7f\xf1\xbf\x93\xea\xc9\x1f\x4f\x9b\x03\xa1\x93\x48\xb2\x55\xea\x3c\x9f\xd5\xc5\x25\xce\x08\x1f\xa3\x59\x21\x0f\xdc\x56\x20\x16\x41\x48\x7b\xd7\xd3\x3f\xa6\x8d\x0e\x75\x86\xbe\x4a\xb7\x27\x9b\x20\xbb\x24\xfe\x28\xb2\x28\xf4\x6d\xd8\xb1\x58\x69\xcb\xea\x16\x00\x4f\xfa\x76\x02\xf1\x4b\xb0\x8d\x4e\xfd\x58\x42\xca\x33\xb5\x76\x36\xe6\xca\xf0\x95\x1d\x2b\x2f\x94\x01\x94\x8e\xe9\x74\x06\x20\x49\x36\x07\x95\xc0\x2a\x53\x5b\xe6\x70\x34\xea\xb1\x22\xde\xc3\xbc\x3f\x5b\x5c\xa7\x7b\xbc\x19\xcc\x95\x3f\x72\x26\x99\x7f\xb5\x45\x31\x8b\x02\x5f\x77\x1c\x1c\xc3\x08\x14\x13\x14\x35\x8a\x58\x40\xc2\x49\x3a\xe5\xe4\x90\x13\x2a\x1b\xbc\x8c\x76\xee\x77\x82\x37\xaf\xbf\xff\xf1\x78\x3b\x78\x73\x00\xff\xff\xfa\x40\xba\x13\x6f\x05\xd1\x46\x08\x1d\x5e\x00\xaf\xc7\xc9\xf7\x79\x0d\x52\x79\x62\x5a\xc4\x4c\xa6\x93\x5b\x8c\xb5\x78\xa7\xa6\x39\x2b\xff\xa5\xc2\x5e\xc0\x8b\x66\x91\xbe\x3c\x96\xe9\xcc\xec\x72\x6c\x01\xaf\x21\x62\x28\x69\x84\xbc\xea\xf7\xe7\x7a\x9e\x8a\x25\xc4\x99\x52\x86\x69\x72\x17\xdf\xd3\x56\x57\x60\xe2\x47\x6b\x66\x7b\x7e\x84\x03\x86\x77\x9d\xd5\xe9\x4e\x75\x72\x38\xbf\xcc\xa0\x29\xe8\x16\xbd\x03\x60\xc2\x9c\x88\x0e\xcc\xdd\xf1\xdc\xe2\x55\xf9\xc8\xe6\x90\xdc\x27\x2a\x30\x78\xf1\x14\xc2\x4e\x7a\xb4\x13\x5c\x80\x6e\x3c\xa9\x6d\x83\x10\x49\x1b\x1f\xd0\x5d\x83\x4f\x05\xd6\xcc\xd1\x5c\xc5\x8b\xfe\xc1\x40\x12\x86\xde\xc9\x64\xd2\xed\xa3\x7a\x29\x10\x0e\xce\xad\xd1\x8d\x6a\x05\x44\x00\x29\x04\x10\xbf\x33\x93\x25\xfa\x7a\x4f\xa5\x5a\x35\x1d\xc2\xed\x90\x1a\xc9\x31\x0a\x44\x65\xb5\x0b\x92\x53\x24\xbe\x9f\x4a\x93\x88\xcc\x57\x28\x64\x82\x4a\x54\xa4\xc2\x65\xb0\x7a\x02\x6b\x6e\x06\xdd\x57\x1c\x89\x2b\x20\xba\x44\x9c\xe2\x1e\xb4\xa4\x3c\x8e\x92\x62\x23\x95\x76\x40\xb3\x5e\xb8\xad\xb6\xbb\x5b\x7a\x93\xbd\xe5\xe9\x4e\xdc\x01\xc8\x29\x10\x27\xd5\x8f\x82\xbd\x3d\xda\x01\x7f\x88\xf2\x82\x6c\xe3\x0c\xc1\xd5\x7c\xc4\x6a\x05\xe7\x10\x2e\xbd\x45\x33\x49\x7d\x84\x48\x07\x0c\x38\xe6\xa3\xea\xf0\x91\x76\x45\xd5\x2f\x8f\x6e\xdc\x1e\xd1\x21\x62\x16\xe6\xc5\x62\x65\xf9\x6e\xef\xec\x50\xfd\x84\xaf\xe2\x94\xcb\x13\x46\x12\x86\xf3\x6e\x87\xca\x3e\x5f\xa5\xf5\xb3\xdd\x9d\xda\x69\xac\x6c\xe6\x99\x4f\x8c\xfe\x8f\x04\xb4\xa2\x89\xf9\x46\x58\x09\x95\xba\xe5\x3b\xf4\xa6\x3f\x97\x5f\x13\x7a\x90\xb6\x67\xca\x91\x85\x4b\x56\x91\x9a\x01\x86\xb1\xa7\x9a\xcc\x1f\xba\x08\xd8\x85\xcd\xda\x2b\x53\x4b\xfc\xb1\xc9\xca\x18\xd9\xb8\x2a\xb3\xe0\xec\xa3\xbe\x2a\x4d\xb7\x6e\x11\x6d\xc4\x9d\x18\xdb\x6e\x0f\xfd\x68\x6d\x6c\x87\x58\x7a\x3c\x96\x55\xcd\xc5\x62\x16\x30\xa3\x85\x18\x8f\x54\x29\x16\xc6\xa6\x2c\xd6\xbe\xa0\x40\x8e\x06\x9a\x84\xb3\x00\xd6\xc3\xc7\x88\x6d\x06\x26\xf0\x5f\x8e\x11\xb6\x70\xf6\xfe\x38\x1d\xe3\x29\x39\x2c\x12\xff\x1a\xd0\xde\x2f\x5e\xde\x38\xc9\x81\x7a\x94\xed\x57\x51\x57\x51\x68\x2d\xde\x4f\x1b\x67\x17\x50\x6e\x18\x45\x23\xe9\x5c\xe4\xab\x17\xdb\xd1\xd8\xa6\x9c\x98\xfe\xd2\x6c\xbe\x73\x7e\x69\xf9\x1c\xcd\x57\xb8\x23\x39\x92\xc8\xca\x0e\x77\x61\xfd\x20\x96\xd3\xc2\x91\xe3\x68\x53\xdc\x36\x51\xb5\x6a\x35\x79\x96\xaa\x89\xdc\xd6\x54\x35\x78\x01\xdd\x27\x4c\xd4\x1e\x89\x63\x93\x53\xef\xa9\x3a\xcc\x06\xaa\xd8\x8e\xab\x50\xd5\xe8\x53\x16\x0d\xf1\x08\x9f\xaf\x51\xf0\x5c\x39\x1d\x92\x7b\xce\x68\x97\xb6\xa4\xea\xbe\x44\x94\xda\x1b\x40\x10\x80\x06\xa7\x4a\x06\xa1\xcd\x1c\xd0\x51\x4d\x39\x0a\xb1\x49\x52\x10\xe6\xf7\x53\xb4\xaf\x14\xc5\x68\x09\x63\x17\x06\xbf\x82\x02\xa9\x8c\x35\x4e\x9c\xea\xb6\x17\xb1\xc0\x78\x9c\xa2\x97\x51\xdd\x8a\x82\x0d\xc9\x68\x6b\xc3\x96\x58\xb2\x52\xe7\x45\x2c\x30\x2e\x0c\x61\x76\x6c\x95\x94\xca\x4b\xf0\x5d\x03\x6a\x78\x91\x5a\x98\x5a\xa2\x5e\xd0\xe0\x59\x21\xa8\xc6\x1a\x19\x98\x2b\xc0\x86\x77\xee\x24\xcd\x86\x82\x76\x40\xaf\x10\x1d\x52\x69\x17\x34\xaf\xb5\x61\x95\x0c\xce\x0d\xbf\x44\xe1\xc7\xc2\x9a\x62\x5a\x2a\xed\x07\xed\x08\xeb\x2d\x97\xb7\xc2\x27\x35\xc3\xfb\xa8\x48\xa7\xb9\xde\x8b\x3b\xd8\xc8\x74\xbe\xec\x6a\xfb\x7e\x7f\x5e\x75\x22\x1b\x23\xa3\x6b\x84\x67\x13\x3a\x68\x2d\x6c\xd9\x5f\x4c\xfd\x2d\xaf\x4b\xc6\xb2\x32\x2c\xd6\xfb\x1f\x0b\x43\x48\x37\x0c\xc0\xf5\x8f\x85\x78\xf6\xe4\x45\x6b\x67\x1b\xb2\x61\x94\x72\x39\x28\xe8\xf0\xea\x91\xec\x16\xe8\xc1\x68\x6f\xaf\x7e\x7c\x85\xb6\x40\x49\xf4\x14\xe5\x3b\x18\x28\x38\xaf\x3c\x69\x95\x45\x7e\x5c\x10\xad\x52\x4f\x9b\xa4\xe2\x7c\xf6\x05\x24\x71\x34\xc9\xb3\xc4\x60\xd8\x18\x3b\x7b\xe5\x1a\x09\xc4\xbd\xf3\x8f\x7b\x93\xdb\x99\x1b\x8f\x00\x3b\x34\x99\x37\x8e\x5d\x1c\x0f\x55\xd7\x57\x7d\x5e\x05\xd2\x25\xe4\xe2\x42\xd5\x72\x93\xda\x1e\xc8\x4f\xa0\xdb\xc5\x78\xcf\x1d\x3e\x64\x2b\x2c\x3f\xb1\x0c\xdb\xed\x25\x4c\xef\xee\xde\x0d\xd4\x21\xa8\xe1\x34\xbc\x63\xeb\xf9\x23\xd9\x45\x6a\x04\xcc\xfe\x02\x87\x7c\xcf\x2e\x87\xd0\x1c\xe3\x34\xac\xce\x1a\xd1\x0a\xa0\x20\x65\x9a\x96\x71\xce\xf5\x25\x56\xc0\x4d\xe9\x60\xd9\x75\x5e\xf6\xa5\x77\xb0\xaf\x2f\x40\x3e\xec\x16\xcb\xbb\xe1\xff\x6f\x9c\xbd\x83\x86\x79\x3b\x83\xed\x20\x86\xd2\x87\x47\xf8\x7b\x0f\x0d\x66\x70\xd7\x12\xcb\x09\x9c\xda\xe3\x98\xc5\x11\x63\xda\x5e\x49\xc1\x6b\x0d\x1e\x56\x2d\xc2\x1c\xf8\x52\x5b\x59\xd7\xfc\xf0\x28\x0e\x2e\x05\x20\x2f\xd9\xbd\x4b\x29\x3b\x38\x18\x28\x86\x93\xed\xaa\xab\x2b\x9c\x28\x5c\x88\xb7\xf5\x3d\xba\xad\xcf\xc2\xa2\x78\x4a\x73\x3a\x47\x1e\xa7\xf7\xb1\xad\x41\xac\x64\x12\xb3\xda\xac\x50\x86\xa2\xb7\x81\xa1\xa0\x0c\xf8\x3b\x7a\x82\x61\x7d\x79\x56\xf0\xbd\xbd\xf7\x21\x15\x99\x3a\x1d\xe1\x17\x0a\x89\x40\x36\x7a\x0b\x19\xae\x07\x16\x4a\x7a\x2d\x10\xf3\xdd\x41\x3d\xa6\x4e\x35\xb5\x89\x3e\x47\x2e\x2a\x0b\xab\xbc\x91\xd0\x90\x4e\xd5\xad\x4c\x4c\xe5\x2d\xf0\x1c\x47\xe7\x77\x8a\xf1\xe0\x31\xcb\x5a\x69\x8c\x6c\x3e\x0c\xce\x2f\x0e\x4f\x4f\xa4\xef\x54\xbd\x36\x13\x63\xcc\xb1\xe0\xff\x5c\x9c\x9e\x04\xe9\xed\x5f\x30\xfb\x90\x8a\x36\x55\x53\x49\x7a\x2a\xd6\xd1\x50\x59\xad\x4d\x73\x36\x90\xc9\xc2\x1c\x24\x2b\x61\xaf\xb3\x3d\x1f\x0a\x2a\x22\x78\x9c\xf4\xc6\x68\xd7\x91\x92\xef\x54\x48\x1f\x64\x27\x78\x47\x51\x22\x75\xba\x64\x65\x62\x1c\x8d\x2c\xb8\x45\x84\xe7\x61\x43\x3a\xcb\xe4\xb7\x3a\x05\xb4\x25\xd6\xa4\xd4\xb8\x7f\xa7\x95\x7d\x9e\x0f\x1b\x27\xff\x0d\x3e\xe8\x97\xad\xa4\xf4\x21\xa7\x6c\x76\x44\x41\xf7\xb7\x40\xed\xeb\xe9\x3d\x42\x8f\x7c\x3d\xb7\x74\x66\xad\xdb\x28\x48\xa2\x7b\x60\xf8\x28\x4d\xbd\x1d\xc1\x04\xc1\x94\xb3\xf7\x89\x3c\xd5\x37\xcb\x98\x61\x38\xd4\xc4\x99\x5a\xa0\x25\xa0\x85\x52\x12\x54\x21\xab\x48\xfa\xad\x99\x14\x15\x14\x34\x8b\xdd\x26\xb3\xf4\xbc\x54\x3e\x1e\xea\x16\xa0\xe0\x68\x58\xda\x3b\x41\x5c\x86\x5a\xc3\x18\x85\xf9\x73\xff\xfc\xe4\xf0\xe4\x80\x43\xb9\xf0\x12\x8d\x1d\x9a\x14\xa7\x4a\x91\x41\xbf\x88\xea\xba\x87\x7b\x2d\x79\x5b\xe1\x79\xd4\x43\x7c\xff\x30\x9e\xa1\xcf\xd5\x10\x68\xc2\xfb\x68\x44\x50\x3f\x37\x00\xf0\x7a\x1e\x3e\xf2\x63\xcc\x7e\x89\x68\xee\x86\xb3\x59\x41\x02\xab\x97\x18\xf9\x31\xe7\x81\xc1\xec\x8b\x87\x68\x3c\x06\xfc\x02\x9d\x73\x31\x92\x96\xd0\x10\x7f\xa8\x2a\x58\x3f\x42\x40\x8e\x1e\x2a\xbc\x5d\x4a\x9e\x28\x30\xae\x0b\x0e\x6f\xc7\xa6\x44\x8d\x83\x05\x65\x36\xda\xf4\xf5\x5c\x8e\x06\x8c\x5a\x1c\xf4\x94\xe4\x1e\x48\xe6\x31\x76\xd2\x2a\x05\x1e\xc3\x50\xa3\xf1\x45\x50\xf0\xfd\xeb\xd7\xf8\xfe\xc7\x37\xaf\xb7\xb5\xe7\xe3\x32\x2e\xde\x4a\xde\x46\x51\xa2\x33\x84\x6c\x93\x05\x06\x07\x30\xcd\x1e\xe8\xcc\x13\x9b\xa3\xc0\xd6\xd8\x1b\xa7\xd3\x11\xcc\x6e\xd3\x64\x94\xcf\xb6\x8a\x00\x76\xc6\xe1\x6d\x58\xc0\x8c\xd7\x87\x06\xfa\x98\xa4\x4f\xe3\x68\x74\x5f\x79\x9c\x2f\xf1\xd2\xa6\xd6\xec\x29\x35\xe2\xdb\xa0\x06\x68\x3d\x46\x60\xd5\x4c\x7c\xf9\x5b\xa8\x71\x51\x45\x32\x16\xdd\x93\xbe\x7d\x88\x67\xff\x10\xcf\x37\x20\xaa\xc4\x4a\xe6\xef\xc0\x0d\x8c\xd7\xdd\x4b\x0e\x20\xec\xe3\xb2\xe1\x26\xee\xd6\xb2\x73\x19\xeb\x4d\xab\xdb\x1b\x63\xea\x06\x61\x59\x46\x93\xac\xac\x18\x4c\xc2\x51\xa4\x43\xfa\x84\x43\x53\x3b\xfe\x6b\x65\xb7\x52\xcf\x88\x48\x7d\x12\x5d\xbd\x46\xb0\xed\xc9\xd3\x99\x0e\xc7\xb8\xf0\x0d\x6a\x7e\x6a\xaa\x6d\x96\x64\x85\x96\xb8\x43\xcf\x2c\x23\x17\xca\xb3\x05\xf3\xa9\x36\xa6\xc2\x90\x9e\x4a\xf9\xe5\xc6\xd7\xf1\xc4\x7a\x78\xe4\xdb\xe3\x23\xdf\x74\xe9\xa5\x92\x86\xea\x39\xc9\x2a\x9f\xc7\x21\x7c\xb7\x64\x2a\xfa\x3b\x7f\xeb\x78\xdf\x3a\xde\x86\x3b\x5e\xab\x09\x2f\xc6\x0f\x5b\xe2\x19\x06\x85\x96\x6c\x7c\x95\x7f\x5d\x68\x80\x5a\x70\xba\xdb\x48\x37\x32\x3a\x20\x53\xec\x35\xbe\xea\x2e\x8c\xa9\xfe\x9a\x94\xe1\x18\x18\xa2\x33\x13\xc5\x97\xc8\xe3\x49\x98\xcf\xc8\xcd\x72\x88\x6e\x12\xf3\x98\x12\x75\x21\xc9\xdf\x32\x1b\x93\x37\xed\xd2\x77\x21\x37\xaa\x18\xdb\x62\x42\x39\x66\xb0\x39\x1e\xdf\x04\xea\xf4\x5b\x67\xd8\xc4\x8b\x51\xb5\xea\x59\x09\xbf\xa7\x92\x18\x8f\x3f\x42\x33\x4f\x73\x9f\xa4\x3e\x0c\x3c\xf0\xee\x95\xa4\x03\x32\xfa\x7b\x27\x08\xfe\x1c\xcd\xa3\x8c\xa3\x4f\xb5\xee\x4e\xaa\x78\x65\x1b\x43\x61\x8f\xa6\x6c\x99\x33\x4a\x9f\x12\x5d\x68\xfe\x81\x31\x5b\x1a\xa5\x75\x18\x8d\x28\x04\x38\x7c\xa4\x05\x11\x6e\x23\xa4\x56\x41\x9a\x77\x82\x53\x5c\x42\x6d\xa3\x7c\x12\xdf\x63\xe8\x89\xd1\xb6\x66\x56\x54\xc1\x11\x41\x58\xae\x0d\x3a\x5d\x5a\x87\x6b\xdb\xc9\xed\x5b\x27\xfb\xd6\xc9\x3a\x74\x32\xf3\x44\x16\xe6\x38\xb3\xee\x62\xd8\x29\x8e\x0f\x88\x6e\x8f\xcd\x08\x26\x1c\xa7\x08\x0d\x49\x6a\x45\x8a\x46\x99\x42\x45\xcb\xac\x92\x01\xc8\xbb\xbf\xcd\x31\xb4\x57\x50\xc5\xd9\x41\x2f\x5b\xce\x5c\xa6\xce\x39\x60\xff\x7d\x83\xd9\x1b\x8a\x9b\xdb\xd9\x8d\xbe\x0f\x97\x6c\x5d\xba\xa2\xd9\x45\x63\xab\x51\xcc\x96\x83\x80\x78\x46\xe0\x62\x6f\xa0\x30\xb3\xc8\x63\xe8\xb4\xd0\x86\xb0\xa0\xa7\x23\x8a\x7f\xfa\xee\x10\x73\x48\xce\xa3\x75\x17\xe5\x08\xd6\x6a\x89\xa1\x37\xbd\x85\xbd\x8e\xab\xfc\x88\x27\x4c\x34\xf0\x54\x0a\xb3\xbb\x58\xb2\x7c\xf4\x20\x34\x32\xfc\xbf\x98\x98\x23\x1f\x3e\xc4\x8f\xd1\xfc\x3e\x44\x1d\xfc\x79\x18\x13\x7a\x93\x1b\x99\xff\x72\x7c\x75\x74\x79\x78\xd6\x3f\xbf\x7c\xf5\xee\xf4\xfc\xb8\xb7\xdf\xbf\xec\x07\x7b\xa7\x27\x97\x83\x93\xcb\xe0\xfd\xe1\xfe\xfe\xe0\xe4\x57\x81\xb1\x17\xa9\x99\xe9\xd9\xf9\xe1\x87\xfe\xe5\x20\x20\x12\x07\x17\x63\x59\x33\xac\x29\x9e\x6b\x21\x02\x0b\xa5\xcd\xd0\xf7\xe3\xf4\x16\x66\x45\x15\x01\xe8\xd7\x4a\xa1\xfb\x45\x5b\x26\x17\x3b\x3b\x3b\xbf\x06\xbf\xe8\xe7\xba\xa0\xc4\xbc\x33\x9e\x51\x3c\x1e\xd9\x02\x2f\xf5\x52\x20\x2c\x53\xc9\x22\x93\xdf\x99\xc9\xc6\xd2\x7d\x30\xbe\x91\x48\xd2\x27\xd1\xc7\x4a\xbf\x15\x48\x3d\xd2\x7c\xf8\x64\xf4\x90\xbd\xc8\x44\x1f\x31\xb4\x4a\x18\xe6\x61\xf1\x20\x8b\x5e\x2b\x21\x41\x88\x42\x8b\xd1\xa7\xc9\xd4\x48\x07\x44\xba\x83\x39\x53\xe6\x6f\x28\x69\x84\x9c\x87\x69\x15\x90\x6a\x05\xcc\x00\xa4\x2f\xec\xce\x6d\x8d\x24\x9c\xa5\x72\x66\x38\x3d\x33\x49\x57\x7d\xb5\x02\x66\x00\x34\x64\x20\x8d\x06\x8d\x1c\xc4\x06\x5a\x2a\x66\x04\x1b\x66\x53\x81\x1e\xdf\x98\x49\xac\xfd\xc2\xda\x27\xe8\x65\x2c\x26\xa4\xab\x5e\x1b\x89\x47\xf3\x74\xd6\x02\x7d\xbd\x84\x00\x41\x79\xee\x44\x72\x7e\x6b\x26\x8d\x0b\xfb\x58\xae\x15\x90\x00\xa4\xb5\x8c\x5e\x89\x44\x52\x3f\xe1\x77\x66\x32\x2f\xd3\x04\x2f\x2b\x04\xf6\x19\x10\x11\xe8\xa5\x85\x70\xc9\xd9\x80\x52\xd1\xa8\xf8\x5d\x5c\x64\x9b\x83\xbe\xc3\x86\xff\x29\xa9\x1e\xca\x32\xaf\x84\xaa\xb3\x86\x5c\x27\x68\x59\xf2\xdb\xf0\xae\x3a\x62\x20\xda\x1e\x17\xfb\xad\x16\xcd\xab\x01\x2a\x1d\xaa\x5a\xa4\x6a\x0a\xa0\xa4\x6a\xa2\x76\xa8\xab\x0f\xaa\x58\xd7\xe5\x4a\xd6\xc1\xec\x75\x14\x93\xf8\x54\xaf\x05\xe2\x27\xb9\x0f\x3d\x09\x3d\x88\x3d\x82\xa4\xf1\xa6\xdf\x0a\xa4\x14\xc6\x9a\x0c\x98\xce\x72\xdc\xea\x96\x33\x6d\xc8\x54\x3c\xd4\xc3\x3c\x62\x6a\x11\x91\x43\x2b\x10\xb3\x20\x8f\xb2\x17\x18\xbf\x33\x92\xf1\x82\x16\xc0\x6e\x85\x93\xf8\xdc\xdd\xa1\x6e\x5b\x60\xe6\xba\x68\xf8\x90\xd2\x2e\xbe\xba\x3f\x03\x94\x7c\x56\x73\x5e\x6b\xe6\xfd\x37\xf3\x5e\x23\x03\x73\x05\x00\xde\x62\x3c\x54\xbd\x36\x13\xe7\x11\x6d\xdf\xb3\x30\x96\xbe\x7e\xa3\x88\x11\x64\xd9\xbf\x01\x06\x8e\x80\x66\x2e\xeb\x0f\xab\xb5\x30\xd8\x52\xb6\xe1\x50\x27\xf3\x67\x46\x79\xcb\x38\x0d\x4e\x1b\x66\x75\x32\x33\xb3\xb4\x10\xa5\xc7\x57\x46\xa2\xea\xf6\x4a\x85\x2f\x1b\xc7\x93\x58\x42\x31\x97\xb5\xc2\x92\x36\xa5\x9d\x9f\x0f\xd1\xb2\x01\x2d\x38\xa1\xd5\x8a\x34\xe1\xf0\x98\x9f\xe2\xb2\xd1\x1d\xb7\x71\x35\x2b\x6f\x8a\x79\x56\x1e\x2c\xc2\x49\x7a\xc4\xd1\xb0\x31\x76\xd6\xca\x49\x7a\x88\x23\x3a\x5a\xf5\x5a\x9a\x8a\x6b\x05\x04\x00\xca\x51\x19\xc4\xc9\x43\x04\x9b\x77\xce\x86\x07\x0b\x8d\xb6\xbb\x13\x61\x1d\x64\x56\x66\x8f\x95\xcd\x8a\x9e\x56\xf7\xde\xdd\x5c\x5c\xf6\x0f\x0e\x4f\x0e\x6e\x2e\x0f\x8f\x07\xa7\x57\x97\x7a\x86\xb1\x7c\xa7\x4e\x60\x9d\x04\x3b\xbf\xbc\x3a\x5b\x9b\x60\x02\x98\x51\xb0\x71\x78\x1b\x49\x4b\x12\xbf\x13\xc8\xd0\xb2\x49\x1f\xea\x8a\xf4\x8d\x42\x32\xd0\x34\xe3\x5d\x83\xd4\xc7\x16\x0a\x99\x81\x70\x7c\x8b\xeb\xb7\x7e\x6b\x26\x4d\x31\x18\xbb\x44\xc9\x2f\x8d\x84\x13\x5b\xb4\xc9\x89\x25\xce\x24\xbf\x93\xaa\xab\xdf\x1a\x49\x2d\xeb\x9c\xbc\xc6\x25\x69\x12\xdc\x86\x45\x3c\xac\x8e\x88\x25\x88\xe5\x82\x12\xa0\x28\x05\xbe\x12\x88\x4a\x4e\x58\x5b\x99\xb6\xa9\x2d\x35\xe8\x06\x96\xf5\xc0\x49\x66\x64\x26\x7b\x4f\x8b\xce\xd1\x96\x48\xf1\x72\x00\x78\xd2\x66\x25\x2a\x7a\x67\x24\x43\x55\xa2\x3a\xdc\xa7\xa3\x7a\x01\xc3\x50\x50\x00\x2c\x1f\x44\x08\x78\x65\x26\x02\x3c\x89\x08\x5f\x89\x44\xa2\xb4\x16\x01\xd3\x22\xb6\x4c\x16\xd5\x6b\x33\x31\x5b\x5b\x4a\xc7\x68\xd5\x6b\x23\xf1\x5f\x6d\x79\x79\xff\x6a\xc9\xc8\x8b\xf6\x78\x2a\x1e\xad\x54\xe1\x46\x11\x01\x44\x77\xd6\xc2\x92\x1c\x70\xb1\x94\x0f\x94\x54\xa5\xa5\x62\x22\x58\x4c\x81\xad\xcb\x32\x8f\x6f\x29\xc8\x1f\xee\xf2\x6f\xa8\x45\xb6\x74\xec\x51\x0b\x0f\x1f\x6a\x6f\xd6\x95\x1e\xd1\x85\xb3\x81\xd8\x9b\x31\xcf\xb6\x5d\xb8\x2e\x52\x7a\xb3\x24\x5b\xfd\x2e\x1c\x17\x08\xcd\x0c\x6d\x71\x78\x6d\x71\x77\x95\x31\x85\x44\xa9\xde\x1a\x49\xbd\x62\x27\xf8\x84\x4c\x50\x13\x9d\x88\xc0\x6f\x6d\xa4\xee\x20\x0b\xbe\xb1\x15\x3c\x9d\xf6\xfd\xfc\xf3\x97\xee\x71\x3d\xd1\x84\x6f\x55\xb3\xbd\x73\x00\x61\x09\x2b\x84\x65\x0d\x68\x14\xb1\x81\xf4\xac\x61\x27\x16\x0a\xd9\x80\x1c\xcd\x22\xb5\x06\x1d\x45\x49\xa4\xfc\xd2\x4c\x18\x5b\xbe\x6b\x2c\x7f\x4c\x8b\x27\x9b\xc5\x2d\xad\xe6\x10\x2b\x6e\xa7\x9a\x65\x64\x18\x3b\x80\x48\x5a\x3c\x54\x51\xfa\x6b\x47\x02\x78\x9a\x6c\x39\xfc\x72\x51\x75\x61\x85\x7b\x39\xae\x6b\x37\xa6\x35\xfa\x36\xec\xed\xa7\x7c\x0e\xa2\x0e\x8c\xba\x56\x73\x99\xdc\x87\x79\xd5\x38\x77\xe2\x85\xa3\x8d\xa2\x15\x8b\x96\x15\xeb\xf8\xdd\x74\x3b\x78\x57\xa8\x4e\xd0\x86\x41\xcb\xea\x74\xfb\x3e\xb8\x93\xa9\xb7\xb8\x27\xb3\x65\x32\x5f\x66\xb5\xd6\x68\xc1\xab\x41\x65\x66\x55\x5a\xae\x14\xd5\x4b\x89\x90\x32\x87\xcb\xa4\xfc\x5a\x22\x16\xf5\x67\x8b\xd6\xcc\xc7\x65\x16\xba\xa9\xb4\xac\x60\x3e\x6a\x79\xb2\x50\x6f\x6d\xa4\x41\x48\x66\xaa\x6f\x60\xc7\xca\xe9\xe9\xec\x58\xcb\xc5\x8d\xe0\xe8\x9d\x2c\x00\xd1\x2b\x33\x11\x65\x47\xf0\x38\x38\x35\x14\x34\x03\xce\x32\x51\x0a\x7c\x65\x24\x9a\x26\x68\xbe\x9c\xe8\xb0\xe9\xa5\xa4\xbd\x2c\x97\x13\xe0\xec\xc7\x3e\xf3\xf7\x66\x72\xd1\xe5\x7e\x2a\xb9\xdc\xc3\x0b\xa9\x2b\xd1\x2b\x91\x48\x1a\x2d\xfc\xce\x4c\x56\x84\xf7\xe2\x26\x4f\xbd\x14\x08\x45\x5d\x8c\x5e\x89\x44\x55\xd4\x29\x0b\xf5\xbc\x8c\x11\xe6\xd1\xea\x50\xf7\x68\x73\xa8\x9b\x89\xea\xdf\x4c\xd2\xfc\x7e\xe7\xb4\x00\xca\xf8\xef\xf3\xe7\xe0\x25\xc5\x65\x62\x2e\xbb\x1c\x07\x22\x56\x5e\x7c\x17\x25\x1a\xef\x7f\xfe\x2c\xe5\x48\xe9\x86\x25\x89\xb5\xf7\x4e\xc7\xf8\xc8\x62\x99\x61\xa3\x94\x13\xca\x16\xbc\x60\xb9\x9c\x13\xee\x29\xe4\xe4\xb5\x25\x9b\xd2\x1e\xa4\x8d\xca\x1e\xa4\x55\x48\x2a\x0f\x96\xfe\x58\xa2\x58\x18\x22\xe3\xf4\x4e\x19\xfa\x16\x80\xa9\xed\x5b\xa5\x2b\x6b\x07\x91\xc8\x88\x8d\x46\x74\x48\x0e\xbb\x85\x89\x5c\x5e\x82\xdf\x8f\x8b\x8f\x57\x38\x38\x31\x0a\xd8\x5d\xa0\x9e\xa8\xe8\x37\x32\x17\x3b\x99\xc8\x0c\x26\x49\x2d\x98\xe5\xda\xdb\x54\x52\x82\x5c\xbe\x74\x55\xd9\x18\xe7\x69\xaa\x75\x73\x37\x73\x22\x53\xc0\x8e\x9a\xfb\x4b\xc1\xb9\xfa\x38\x6d\xe5\x3c\x64\x87\xe5\x6b\x6e\x9e\xb5\xa5\xd2\xc8\xec\xba\xa4\xff\x63\xa6\x6f\x9b\x39\x5b\xb5\xf1\x71\xf0\x84\xe9\x23\xf1\x18\xfa\x1a\x29\xcf\xa6\xc5\x43\x25\xcc\xf5\x0b\x52\x0e\x29\xbb\x83\xb6\xb6\xc6\xf1\xa0\x92\x16\x56\x29\x6a\xd9\xff\x48\x19\x90\x16\x55\x1e\x30\x15\xc6\x10\xb3\x8b\x90\x41\x85\xae\xb6\x90\x84\x1a\x5d\xc6\x4d\x4e\xe6\xf3\x64\xb3\x0d\x14\x73\x9c\x17\xa8\x57\x56\x3e\xa8\xac\x19\x55\xd0\x17\xfb\x47\xfa\xd6\x54\x8d\xa6\x72\x75\xaa\xa4\x99\x59\xbc\x53\xb0\x9e\xce\x70\x92\x70\xef\xd8\x3c\x1d\x67\x9b\x64\x3c\x0b\x9e\xd2\x1c\x3e\xde\x94\x72\xd1\xed\xbd\x0b\x6a\x2b\x1f\x4e\x45\xc7\xe1\xa7\x78\x32\x9d\xcc\x63\x14\xb2\x53\xf5\x3c\x9a\x61\x63\x71\x94\xa3\x29\x6e\x9e\xaf\xbb\xba\x55\x04\xc7\x65\x76\x3a\x96\x63\x85\xf7\xff\xaf\xa5\xa2\x6b\xe6\x28\x56\x71\xcc\x1e\x2e\x55\xac\x29\xf6\x02\xb0\x48\x28\x10\x48\x0c\x8e\xa3\x49\x73\x85\x82\x07\xce\x75\xcd\x46\x24\x32\x82\x51\x3d\xbe\x84\x4d\x04\x10\xe9\x9f\xc6\x2c\xe0\x16\xb6\xde\x10\x92\x10\xa7\xfa\xe2\x5a\xa1\x58\x0d\x84\xe5\xf2\xbe\xf0\x98\x33\x28\x4f\xef\x73\xd9\xc6\xdc\x41\xe4\xcb\xa8\x98\x0e\x31\xa9\x41\x9b\xaa\xcc\x49\x24\x26\x4d\x8b\xb5\x2a\x55\x5a\x88\x29\xe1\xd8\xc9\x95\xcc\xd6\xd8\x64\x41\x66\xdc\x0e\xa6\xab\x30\x2b\x0a\xd1\x8a\xb9\xb7\xfd\x9f\x17\xa9\xc4\xb4\x1e\x68\xf4\x25\x8f\x31\x58\x3a\x8f\x70\xef\xfb\xf9\xf3\x71\x63\x33\xbf\x5d\xb7\x3a\x6a\x94\x0b\x8c\x26\x53\xdb\x55\xd8\xaa\x42\x97\xd3\x09\x6d\xe7\x91\x0f\xab\x57\x5a\xff\xda\x0e\xea\xf7\xd6\x34\x89\x9d\xa4\xc9\x5b\xb4\x2c\xd0\x24\x7d\xb6\x5f\xb6\xee\xc7\xfe\xe0\xf5\x92\x3e\xd7\x39\xdf\xa5\xe9\x79\x97\xe7\x45\x4a\x5f\xa9\x1f\xcd\xdd\xfd\xec\xb7\x72\x1d\xc1\x24\xc1\x2e\xd4\xf9\x9b\xa6\x74\x1c\xd7\xd9\x28\xda\xb2\xa0\xef\xbb\xcf\x46\xf1\xd6\x3e\xe1\x0b\x60\x11\xa0\x5c\x98\x3b\x77\xaa\x0d\x86\x61\x7b\x91\xe6\xf5\x37\x4d\xb5\x92\x8c\x1e\x6b\xce\xad\x7c\x9a\x68\x51\x0a\x9e\x83\xb9\x54\x71\xbd\x0c\xe3\xca\x4f\xea\x21\x28\xc0\x3c\x50\xe0\xe1\xa7\xfa\xf0\x59\xea\x38\x72\x85\x56\x01\x45\x41\xff\xc7\xaf\xff\x2f\x00\x00\xff\xff\x2c\x1d\x5b\x19\xab\x08\x03\x00") + +func cfI18nResourcesEnUsAllJsonBytes() ([]byte, error) { + return bindataRead( + _cfI18nResourcesEnUsAllJson, + "cf/i18n/resources/en-us.all.json", + ) +} + +func cfI18nResourcesEnUsAllJson() (*asset, error) { + bytes, err := cfI18nResourcesEnUsAllJsonBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "cf/i18n/resources/en-us.all.json", size: 198827, mode: os.FileMode(420), modTime: time.Unix(1456502789, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _cfI18nResourcesEsEsAllJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xbd\x4d\x73\x23\x47\x92\x20\x7a\x7f\xbf\x22\xb7\xf6\x8d\x55\xa9\x0d\x60\x49\xea\x9e\xb1\x35\xae\xad\xf5\x40\x24\xaa\x8a\x2d\x92\x60\x03\x64\xf5\x68\xc4\x36\x76\x12\x19\x04\x53\x95\xc8\x44\xe7\x07\x28\x48\x53\xf3\x0f\xf6\xf0\x6c\x6e\xef\xa6\x63\x1f\x74\x18\xeb\x5b\x5f\xd6\x6c\xf9\xc7\x9e\x7f\x44\x44\x46\x7e\x44\x7e\x00\x20\x4b\x33\x6f\x7b\x6c\x54\x04\x90\xe9\xee\xe1\x11\xe1\xe1\xe1\x9f\xdf\xfe\x5f\x8e\xf3\x23\xfc\xbf\xe3\xbc\xf0\xbd\x17\x87\xce\x8b\xeb\xf0\x3a\xbc\x3c\xb9\x38\xbc\x0e\x5f\x0c\xf8\xfb\x34\x76\xc3\x24\x70\x53\x3f\x0a\xd5\x03\x47\x93\xf3\xd9\xf8\x77\x13\x7c\x08\x9e\xf9\x38\xa8\x03\xf2\x4d\x94\xc5\xce\xef\x66\x93\x73\x27\x49\x63\x3f\x5c\x38\xc9\x26\x4c\xdd\xef\x1d\x3f\x71\xfc\x70\xed\x06\xbe\x77\xe0\x38\x17\x71\xb4\x12\xb1\xf1\x53\x7a\xef\x27\x87\x8e\x33\xbf\x73\x12\x91\x0e\xe3\x2c\x0c\xe1\xd5\xa1\x08\xd7\x7e\x1c\x85\x4b\x11\xa6\xc3\xb5\x1b\xfb\xee\x6d\x20\x86\x8b\x38\xca\x56\xce\xcb\x1f\xaf\x5f\x84\xee\x52\x5c\xbf\x38\xbc\x7e\x01\x60\x33\xf8\x6b\x50\xfd\xea\xe3\xcb\x86\xe1\x9c\xba\x4e\xe2\x23\x05\x40\x80\x27\x00\x73\xec\x0b\x26\x3d\x8c\x1c\x91\x38\xeb\xc7\x9f\x80\x5c\xf7\xc0\x31\x1f\x9c\x47\x71\x2c\xe6\xa9\x8b\x0f\x04\xf8\xfd\x22\xf3\x81\x3e\x71\xf8\x24\xc4\x3f\x29\x9b\x93\xd4\x5d\xfc\x87\x65\xf3\x5e\x89\xb7\xb0\xf9\x57\xce\xe5\xbd\x48\x88\xe4\xb5\x3f\x17\xce\x2a\x80\xc1\x39\xf7\xee\x5a\x38\x6e\xe8\xb8\x49\x12\xcd\x7d\x37\x15\x1e\x50\x9b\xa4\x07\xce\x51\x2c\x60\xe0\x30\x17\xae\x7e\xc3\x0f\x81\xce\x10\xfe\x78\xf0\x83\x00\x3e\xcd\x61\xd6\x70\x12\xf8\x0d\x2b\xd3\x7e\xe5\x8c\x93\x34\x4a\x08\xa1\x50\x5c\x03\x80\x7e\xe4\xa4\xc0\x06\x11\x3a\x59\x48\x20\x80\x10\x22\xc2\x8b\x88\x7d\x73\xa0\x60\xee\x3f\xfe\x35\xc4\x57\xb2\xd0\x55\xf8\x7d\xb7\x00\xc3\x73\xe3\xc7\x9f\x9c\x20\x5b\xb8\xb1\x83\x1c\x06\x30\x04\xec\xc0\xc6\x88\xd1\x6a\x05\xeb\xcc\x8d\x61\xac\x0d\x02\x02\x9f\xf2\x43\x1f\xc9\x71\xed\x22\x02\x9f\xfa\xf1\xc7\x03\xf8\xe7\x1c\x26\xe2\xe3\x47\xe7\xc1\x4d\x14\x70\x27\x4b\x90\x7f\x92\x43\xcb\xa5\x1b\x7a\xce\x9f\xe0\xe1\x23\xfe\xfb\xe3\xc7\x3f\x35\xa0\x87\xf1\xbb\x65\xd8\x30\x79\xf7\xae\x22\x2a\x02\x98\x21\x0f\x17\xa1\xb9\x69\x54\x05\x6e\x21\xfa\x3c\x02\xd8\xbe\x23\x42\x6f\x15\xc1\x12\xc5\x15\x68\x9f\x3d\x78\x98\xf1\x02\x2a\x5c\x8e\x73\x1f\x50\xa3\x4c\x78\xfc\x5b\xe8\xac\xb2\x10\xf0\xde\xf9\xa1\x1b\xe0\x9c\x00\x54\x2b\xd7\xa7\x51\x06\xa4\xc2\xd3\xb7\x38\x99\x4b\x18\x1c\x70\x08\x38\x13\x46\xa9\x03\x0b\x29\x86\x25\x1f\x6c\x1c\xf9\x3d\x3c\x96\xde\x23\xbc\x55\xe0\xcf\x89\x18\x3b\x81\xc0\xa9\x38\x83\xbd\xf5\xe7\x0c\x17\x05\x90\x91\xd0\x76\x0b\x60\xed\x44\x21\xad\x0d\xda\x99\x29\xfc\x61\xfe\xe0\x01\x83\xe7\x69\xe6\x06\xb8\xd9\x04\x31\x33\x40\x9e\x23\x42\x5a\x75\xd6\x91\xe0\xc9\xe2\x38\x57\x80\xeb\x25\x6c\xdf\xa5\x1b\x7f\x10\x29\xac\x6d\xd8\x17\xc3\xc4\x99\x8d\xa7\xef\x4f\x8e\xc6\x2f\x71\x08\x6b\x5f\x3c\x10\x3d\xb1\xbf\x42\x7a\x13\x27\xba\x83\xe9\xf3\xfc\xb5\xef\x01\x62\xb9\x03\xe1\x3b\xd7\x59\xf8\x6b\xd8\x07\x72\xa3\xd9\xc7\xaa\xce\x2c\xe7\x2a\xf5\x03\xdc\x92\x4d\x14\xac\xdc\xd8\x75\xd6\x20\x32\x25\x09\x38\x6c\xde\x7f\x72\x27\xe6\xa4\xf0\xd7\x59\x68\xec\x2a\x91\x8a\x78\x09\x13\x0b\x9b\xb1\x91\x11\xa3\x04\xc4\x59\xe8\xc4\x11\x02\x79\xf0\xd3\x7b\x90\x54\xb0\x0c\x79\x46\x81\x49\x31\x2d\xdc\x74\x18\xc5\x8b\x21\x3e\xf4\xd2\xc1\x7d\x50\xff\x4c\xb2\x82\x31\xf0\x53\xed\x2c\x18\x21\x5e\x21\x11\xe3\xf4\xb5\xe1\xdd\x74\xc0\xda\x34\x52\x9a\x71\x84\xf0\xe6\xd2\x8d\x17\x22\xd5\x5b\x8d\x26\x3b\xa5\xef\x9c\x10\xa6\x9c\x00\xf6\x98\xc3\x7a\x98\x34\x7d\x9e\x1f\xfb\x0b\x3f\x06\xcc\x2e\x4e\x8f\x40\xd0\x30\x3b\x61\x26\xd6\x51\x37\x62\x6d\x44\x02\x5f\x7a\x92\xd8\x48\x9a\x8b\x00\xdd\xd0\xff\x41\x8a\x6c\xa4\xd0\x6d\xa4\x30\x93\x1b\x28\x88\xe0\xe8\x73\x86\xae\x33\xba\x38\x71\x86\xc3\xe4\x83\xbf\x1a\x26\x49\x30\xa4\x73\x9f\x88\x7a\x09\xb0\xe9\x51\x94\x5a\x0d\x4f\xc1\x00\x93\x6c\xb5\x8a\x45\xc2\xca\x81\x23\xe2\x38\x8a\xfb\x6d\xa6\x4e\xd4\x74\x21\x86\x78\x04\xe4\xc4\xfe\xd2\x8f\x59\x4e\x33\x39\xb5\x3c\x81\xbf\x8e\xde\xdc\x9c\x8f\xce\xc6\x8e\x9b\xc1\x1e\xc2\x63\xfd\x1f\xc5\xf7\xee\x72\x15\x88\x03\x38\x3c\x9c\xeb\x17\xd7\xd7\xd7\x2f\x56\x70\x4c\x3f\x44\xb1\x87\x7f\x5f\xbf\x70\x5e\xc1\xc6\x76\x57\x02\x44\x5f\x94\xe2\x7e\xbe\x43\xa6\x82\x54\x05\xc1\x2c\x1f\xfc\xcc\x32\xfa\xdd\xf0\xc1\x03\xa0\x01\xe0\x49\xe7\xa3\xc8\xcd\x90\x7f\x3f\xc0\x09\x41\x22\x14\xb6\x22\x20\x4b\xc4\xe3\xbf\xbb\x9f\x6d\x3d\xd8\xe5\x46\x0f\x01\xf1\xe2\x5a\x91\x83\xbc\x83\xb5\xa0\x7e\x92\x02\xc7\xe5\x1d\xf7\x99\xf5\x38\xdd\x02\xa1\x5c\x12\x7a\xa4\x34\x9d\xc6\xd0\x58\xe4\xe4\x5b\xf2\x33\xdb\x71\x6b\xe0\x9e\x47\xab\xcd\x30\x01\x5d\x17\x00\xcf\x26\x57\xd3\xa3\xf1\x70\x74\x71\xe1\x5c\x8e\xa6\x6f\xc7\x97\xf4\xe7\xb7\xc3\x48\x7d\x9c\x4c\xdf\xfe\x11\x3e\x27\xea\xf3\xec\x62\x74\x34\xc6\x6f\x86\x61\x34\x8c\x05\xe9\x18\x7f\xb4\x8e\xb8\x95\x16\x5e\xe7\xaf\x60\x78\x29\x2e\x9a\x18\x59\x42\x92\x59\x71\x01\x77\x13\x3f\x04\x2a\x82\x88\xe1\xac\x84\x23\x0a\x4e\xe8\xe1\x50\xc3\x20\x35\x70\x15\x47\xcb\x55\x4a\xd3\x72\x1b\xa5\xf7\x9d\x26\xc1\x40\x0e\xab\x26\x80\x03\x7a\x79\x1b\x0b\x3a\x82\x92\x0c\xd4\xde\x08\x64\x75\x71\x25\x31\xff\x59\xf5\x81\x3b\x80\x48\x94\x5e\x08\x78\x97\xae\x41\xa2\x6b\x12\x88\xda\x6e\x04\xf3\x08\x68\x50\x0f\x20\x18\xee\xf2\x36\x4a\xba\xcc\x96\x94\x04\xb0\xb1\x23\xe7\x55\x79\xc8\x70\x6c\x92\xdc\x8b\x03\xe4\x53\x74\x9b\xba\xf0\x2c\xc8\xc0\x50\x0c\x53\x1f\x38\x59\xe1\x62\x87\x8d\x58\x8b\x10\x70\xad\xa2\x58\xab\x32\xb0\xe0\xae\xa6\xa7\x3c\x12\xc0\x0a\xda\x73\x4c\xc2\xd7\x64\x15\x28\x66\xa0\xc3\x14\x39\x86\xb7\x0e\x66\x5a\xfb\x9e\x94\x74\x64\xd5\x6d\x32\x5c\x6d\x2d\x87\xba\x2f\x8b\x6d\x10\x77\x16\x48\xdd\xe7\xdd\x46\xc5\x93\x49\xa6\x9e\x78\x9f\x42\x40\x35\x92\xb0\x72\xff\xfe\xef\x1f\xa2\xe9\xb1\xf3\x2a\x59\xc1\x2d\xe0\x6e\x63\x91\x1b\x80\x19\xb4\x8c\x0c\xd5\xea\x64\xf7\x81\xe7\x58\x05\xa3\xf5\x51\xcf\xef\x26\x33\x00\x44\xa4\x69\xe9\xb6\xe9\x57\x59\x72\x0f\xa7\xfa\x05\x7f\xfa\x76\x78\xeb\x7c\x75\x75\x72\x7a\x0c\xb2\xf7\x6b\xfa\x0a\x05\xf0\xdc\x39\x9a\x9c\x9d\x8d\xce\x8f\xf1\x83\xe7\x1c\x4f\xce\x46\x27\xe7\xf8\xf7\x9d\x03\xdf\x9e\xbc\x19\xcf\x2e\x6f\x2e\x46\x97\xef\x48\x58\x7b\xd1\xfc\x83\x88\x87\xfe\xd2\x5d\x08\x78\xf4\xe8\xeb\xf1\xf4\xe6\xe4\x6c\xf4\x76\xbc\x83\xec\x26\x22\xab\xe8\xfa\x03\x9c\xd0\xb5\xc4\x0d\x40\xac\xe7\x32\x2d\xf0\x93\x14\x2f\x25\x74\x65\x1d\x7a\x22\x00\x05\x06\x6f\xb3\xa9\xbb\x40\xb5\xca\x4d\x59\x08\xc2\x35\xee\x21\xf6\x53\x10\x41\xea\xb6\xf6\xfe\x68\x74\x71\x23\x6f\x1f\x33\xc7\x30\x65\x38\xca\x94\x41\x5b\xc4\x0d\x37\x70\x52\x64\xb0\x64\x8c\xeb\x5d\x62\xbb\xf3\x10\x95\x24\xfe\xf8\xa2\x36\x30\x24\x22\x5b\x05\x90\x5e\xb2\x08\xcc\x1f\xff\xea\xf9\x8b\x08\xaf\x32\x44\x33\x5c\x5d\x60\x5b\x00\x46\x18\x89\xbe\x1e\xd2\x55\xe8\xd6\x07\x59\x1a\x4a\xf1\xa0\x89\x03\x10\xb8\x4e\x62\xb8\x2e\x16\x87\xc2\x5b\x0b\xae\x49\x7f\xce\x7c\x90\xb7\xc6\x1d\x11\x5e\x08\xdc\x1f\xe0\x2e\x69\xb9\x23\xd5\xf3\x58\x5e\xf3\x86\x72\x41\xcf\x71\xd1\xde\xf9\x8b\x2c\xa6\x51\x13\xba\x25\x5e\xbf\xf0\x86\xe6\x20\x81\xa0\x55\xb2\x8d\x29\xba\xfd\x4e\xcc\x53\xf8\x7a\x18\xf8\xa1\x38\xb8\x0e\x8d\x55\x91\xad\x40\xf5\x04\xa0\xd2\x58\x03\xcb\xb4\xb3\xc9\x08\x0d\x5b\xb6\xe5\x70\xe7\x07\x74\x3b\xc6\x13\x8e\x4c\x73\x3b\x12\x7f\xe0\x10\xae\xcb\x7b\x3c\x24\x41\x44\xca\xc5\x63\xbc\xc7\x18\xdd\x10\x97\x18\x5a\xa6\x6e\xe1\x0c\x47\xdb\x01\xcc\x24\xde\xde\x51\x0f\xd1\xaf\x32\x7d\x6d\x8c\xc0\xed\x71\x73\x39\xb9\x79\x73\x72\x3a\x96\x63\x1d\xb3\x98\xc1\x85\x5e\x21\xf1\x90\x9e\xf8\x91\xfe\x0b\xff\xbb\x7e\x31\x0f\x32\xd0\xdf\xe3\x9b\x30\x82\xab\x34\xb0\x2e\xff\x8d\x7f\x86\xd5\x9c\xe2\xd7\x7f\x3f\x28\x7c\xbf\x14\xcb\x28\xde\xdc\x2c\x6f\xf1\xb7\x2f\x3e\xff\xf2\x37\xea\xd7\x8f\xf4\xc7\xc7\xad\x96\x7c\x10\x91\xac\x7f\xfc\x09\xb8\x15\xd3\x62\xcf\x67\x40\xae\x49\x9c\x9a\xc7\x9f\x61\x6e\x78\x2f\xe4\x97\x7a\x36\xb5\xe1\x20\x81\x75\x34\x60\x36\x57\xd2\x2f\xc1\xe3\xcf\xa1\x70\xf7\xbf\xa6\x1a\x36\x2f\x08\xe7\xf9\xbd\xbf\x8e\x68\x73\xe2\x1a\x13\xe1\xc2\xdd\xff\xe8\xe4\x92\x3b\x85\xd5\xf8\xf8\x33\x89\x0a\x77\x3e\x17\xa0\x65\xb9\x81\xa6\xc0\x13\x05\xbc\xab\x4c\xf0\x46\x25\x11\x53\x7e\x8d\x57\x24\x68\x60\x6a\x41\xba\x7c\x3d\x97\xc0\xb6\x59\x8e\xdf\x09\x58\x8e\x44\x46\xcd\x00\x9e\x6d\x41\x7e\x02\x21\x76\x28\x39\xa0\xd8\x75\xeb\x87\x9e\x66\x96\x3e\x89\xa5\x2c\xbe\x39\x39\x9f\x5d\x8e\xce\x8f\xc6\xff\x3f\x16\x6f\xdd\x19\xb4\xab\xd8\x5b\xa1\x05\x30\x49\xf0\x78\xc6\x05\x73\xfd\x22\x16\xae\x37\x8c\xc2\x60\x03\xca\xf7\x2f\x56\x82\x3d\xe7\x82\xea\x2d\xdb\x9e\x64\xec\x9f\x56\xbe\xed\xb6\x1e\xfb\xc9\xbd\x0e\x2b\xf2\x17\x20\xc2\xd0\x71\x65\x48\x7c\xc9\x0a\xe7\xe2\x74\x74\xfe\x1f\x48\x90\xed\x5f\x8e\xed\xca\xa7\xff\x4c\x6a\xdc\x33\x0a\xc0\xa7\x5f\x8e\xbf\x00\x15\xef\x79\x25\xe0\x53\xac\xe4\x5f\xb6\x06\x78\x81\x3b\x39\xb9\x8f\xb2\xc0\xa3\x0d\xef\xfc\xe0\xaf\x68\x53\x0f\x72\x33\xa8\xf9\x25\x5e\xf4\xe1\xb4\x9b\xa3\x63\xd8\xc7\xe0\x07\x40\x7b\xe0\x5c\x44\x89\x4f\xe2\xc7\x4f\xe0\xe7\x15\x7d\x5a\x0b\x32\xdf\x2e\x44\x3c\x40\x77\x1c\xcc\x4c\xec\x47\xb1\x9f\x6e\x06\x64\x57\x82\x27\x93\x88\xdc\xe9\x77\x71\xb4\x04\x90\x0f\x22\x49\x11\xdb\xbd\xbf\xb8\x17\xf6\xb8\x83\xda\xe5\xe0\x89\x5b\x35\xe7\x7a\x5d\x00\xcd\x03\x65\x57\x75\x4b\x3f\xc0\xfc\xc3\x17\x6a\x00\x7e\xc4\x23\xa2\xe8\x04\x24\x5e\x2d\x57\x32\xb3\xa1\x09\x3a\x52\x63\x8a\x06\xda\x5f\x2e\xd0\xc8\xc0\x63\xf2\x5c\xcf\xd9\xa0\x15\x22\x8a\x3d\x11\x12\x61\xb0\x69\x22\xe4\xc5\xf2\xf1\xa7\xc4\x6e\x44\xb8\x40\x8b\xcf\x32\x0b\x52\x1f\x85\x9d\xbb\x5a\x69\xfb\xe2\xd2\x0d\xfd\x3b\x40\x65\x8f\x75\xc2\xb5\x15\xae\xd1\x08\x8c\xb6\x10\xb2\x1d\x91\xc9\x23\x61\x38\xd2\x4a\x48\x70\x7c\x00\x14\x59\x03\xa2\xd4\x71\xc0\x47\x8e\xc7\xc2\x7d\x0b\x45\xf6\x24\x55\x0b\x89\x83\x4f\x30\x4e\x66\x81\xc3\x8a\x63\x77\xc3\xe3\x32\xa4\x38\x9e\x4f\x09\x1e\x71\x9e\x34\xdd\x50\x48\x85\x70\xe2\x2c\x10\x4d\x56\xa3\xea\xe4\x1b\xa6\x74\xcf\xdd\x87\x06\x74\x0c\xab\x29\xc6\x17\x73\x3b\xfc\xd2\x4d\x63\xff\x07\x65\x82\x47\xde\xf2\x66\x4e\x78\x48\x28\x04\xe5\x38\x5c\x34\x3e\x25\x00\x7e\x01\xff\xd8\x67\x7e\x57\x8e\x33\x04\x3a\xab\x0d\xa6\x13\xf9\x3b\x31\x9e\xe1\xd2\xe3\x5f\xb9\xb0\xa2\x27\x52\x23\x4a\x58\x17\x45\xd7\x0e\xee\x59\xdc\xc1\xa8\x9e\xd1\x9b\xc9\x9f\x33\x37\x16\xce\x2d\xc8\xf9\x0f\xb8\xd1\xf1\x47\x33\xee\xe8\xde\x07\xf2\xa4\x6a\x85\x0f\xc6\xe2\xcf\x19\x6c\x3d\x72\x24\xa4\x72\x14\x80\x58\x0a\xcc\xf7\x74\xde\x7f\x97\x00\x8f\x69\x78\xd2\x70\xcc\x92\xf2\x5b\x29\xd7\x72\xa9\x08\xca\x63\x1c\xa5\xd1\x3c\x0a\x58\x73\x4c\xe7\x2b\x3c\xd6\xf2\x9f\x61\x98\xa9\x1f\xd2\x12\xe2\x27\xbe\xf8\xfc\xe0\xcb\xdf\xfc\xe6\xe0\x8b\x83\x2f\xfe\x5b\xf1\x49\x58\x45\xa9\xd4\x3f\x7f\xfd\xeb\xcf\xff\x41\xaa\x9e\x4a\x86\xfe\xf1\x53\xad\x49\xd8\xe7\xe6\x69\x67\xae\x4d\x22\x6c\x97\xf5\x49\xb0\x27\x7c\x2e\xdd\xba\x14\x66\xc3\x6f\x70\x60\x8d\x9e\x73\x54\x44\x40\xc2\x3d\xfe\x35\xc0\xb0\x21\xb2\xb2\x86\x20\x02\x13\x34\xd0\x27\x78\x7c\x8b\x9c\x44\xbc\x0b\xcd\x61\xf0\xf7\x02\xbd\x27\x1b\xfc\x49\x9e\x7c\xf7\xfe\x77\x91\x11\x0b\xe6\x54\x8f\x48\x05\x83\xa6\xbf\x70\x46\x7e\xd2\x99\xb7\xed\xe2\xf7\x18\x09\x04\x0a\x7b\xf4\x40\x96\x66\x74\x18\xb9\x2a\x5a\x46\xe9\x10\xfc\xa5\x2d\xf0\x05\x81\xc0\xba\x98\xf3\x9b\x74\x0f\x02\x66\x4b\x2f\x4f\x05\x86\x8d\x8e\x6f\x87\xbe\x73\x7e\x75\xa6\x75\x91\x19\xfa\x28\x3e\x38\xc7\x27\xb3\xaf\xf1\xaf\xa5\x73\x36\x3e\x9b\x4c\xbf\x21\xcf\xc5\x7d\x94\xa4\xe4\xdd\x79\x37\x99\x5d\xe2\x37\x2b\x47\x79\x35\x12\x07\x5e\x3f\xa2\x57\x52\xe7\xf2\xe4\x6c\x3c\xb9\xa2\x27\x32\xe7\xdd\x78\x74\x0a\xaa\xcd\xd1\xbb\xf1\xd1\xd7\x37\x97\xdf\x5c\xb0\xc7\x3a\xc6\xd8\xaf\x21\x49\xa6\x29\x3c\x3a\x6e\xf1\x57\x7c\x22\x42\xad\xe7\x9e\xeb\xa1\xf0\x05\x5e\x5b\x27\xc7\x7d\xfc\x77\xd7\xf3\x29\x26\x6f\x19\x39\x36\xfe\x7b\x91\xe0\x78\x37\xf1\x3d\xfa\x58\xf0\x04\x86\xfd\xb5\x8a\x6c\x50\x31\x6e\x0d\x9f\x14\x0c\x16\x1f\x05\xe5\x02\xf5\x10\x0b\x02\x74\xaf\xd8\x80\x91\x13\xc3\xf2\x1e\x6a\x63\x01\x5e\xa5\x37\x2a\x76\xd1\x06\x65\xe3\x96\xa2\x10\xbb\x40\x8c\x30\xa6\xaf\x15\x22\x46\x9c\x85\x7e\x13\x44\xd8\xfd\xe9\xc6\x06\x87\x05\xd1\xda\x85\x8b\x43\x03\x08\xe4\xbe\xba\xec\x82\xd6\x0a\xb7\x95\x40\xa0\x38\x2b\xb8\xf4\x41\x77\x3b\x58\x1c\x38\xf7\x69\xba\x3a\x7c\xfd\x7a\x13\x65\xf1\x0d\xf2\x1e\x5d\x92\x4d\x53\x95\x28\x2d\x52\xca\xa3\xca\x55\x08\x7e\x83\xef\x0e\x1c\xf1\x9d\x05\x78\x33\xd9\x6b\xd7\x0f\x48\x7c\xc0\x71\x88\xaf\xd8\x97\xa3\x0e\x78\xf4\xfc\x64\x15\x85\x3e\xbe\x24\xf4\x4b\x8d\x58\x62\x81\x6f\x78\x70\xd8\x83\xb6\xce\xbc\x59\xba\x1f\xe0\x50\xca\xe0\x40\xf6\x53\x56\xdc\x99\x7f\xab\x20\x5b\x48\x52\xac\x7a\x58\x18\x29\x88\x70\x72\x8f\x12\xb1\x78\xfc\x5b\x2c\xf8\xf8\x20\x3f\x2e\xf1\xcc\x58\xd8\x1c\x9d\x48\x70\xd5\xcd\xce\x42\x2f\x12\x7b\x87\x6e\xc4\x06\xd4\x32\x70\x35\x64\xa7\xb0\x75\x69\xc5\x70\x29\x5a\xeb\x0b\x86\x74\x7f\xe6\x44\x89\xc4\xba\xe6\xd0\xcf\x88\x21\x92\x48\x76\x60\xb8\x22\x8d\x11\x25\x96\x20\xb8\x17\x17\x34\x4c\x38\x4d\x94\xca\xa3\x47\xa4\xf4\x1d\xc5\x39\xcf\xf1\xdc\xd4\xb5\xf1\x78\xac\x8f\x4d\x13\x66\xcd\xe8\xc9\x42\x80\x37\x6a\x17\xcf\x7b\x35\xd1\x5e\x64\xd3\x3e\x5f\xe6\x1b\x06\xb4\x00\x94\x43\x31\x45\x87\x53\x18\xe0\x81\x33\x13\x1c\x31\x77\x2f\x82\x95\x6d\x25\xbe\xcc\x37\x86\x0a\x52\x66\x50\x31\x1d\xec\x47\x51\x98\xc0\xa5\xc6\x84\x53\x4b\xc9\x67\x5a\x98\x90\x3c\xb4\xaa\xfd\x9f\xa1\x34\x61\x91\x69\x19\xd3\xaf\x7e\x35\x42\x97\x35\xbe\x70\xe8\x48\x6e\x91\xae\x09\xea\xad\x8b\x53\xad\x9d\xda\xb7\x1b\xb8\x2f\xd1\xa3\x64\x68\x83\xeb\x74\x8c\x37\x6e\x8f\x22\xc8\xa2\x18\x54\xa2\x13\x0c\x47\x0f\x02\x52\x63\x31\x0c\x64\xa5\xc0\xa5\x0e\x6e\x6b\x27\x7a\x80\xa5\xed\x27\x1f\x0e\x7e\xf5\x2b\x54\x60\x8e\x23\xfc\xda\x79\x70\x43\xba\xbe\xfa\xf2\x6d\xb2\xaa\xf1\x8a\xff\xf1\xc7\x03\x26\xe9\xe3\xc7\xdf\x3a\xaf\x36\xa8\xd6\x5b\xe3\x86\x70\x20\x30\xb5\x78\x01\x3d\x74\x4e\x29\xba\x9e\xb1\xa3\x42\xc4\x83\x81\x2f\x17\xb1\x7b\xab\xdd\xe0\x40\x78\x04\xb3\xce\xc3\x02\xe1\x2d\x23\x9f\xc3\x48\x9b\x60\xdc\xf0\x07\x57\x8d\x4b\x80\x46\xa6\x82\x4c\x02\x03\x3e\x06\x35\x82\x1a\x02\xaf\xba\xf0\x04\xb2\x6c\x11\xc9\x11\xfe\xef\xff\x75\x0c\x7b\x5b\xc6\xe9\x07\x70\xe1\x14\x41\xfd\xd0\x12\xe7\xf1\xaf\x8e\x2d\x12\x69\xa4\x83\xe5\xd1\xb6\x0a\xac\x8a\x02\xe6\x17\x87\x78\xb1\xd6\x74\x14\x44\x99\xe7\xbc\xc1\xdd\x12\xdb\x8e\x84\x2b\xd0\x77\xef\x05\xdc\x6d\x96\x3e\x51\x8b\x7b\x94\x0c\x64\x74\xef\xe6\xe5\x98\xa8\x30\x29\x06\x0e\xf7\x13\x52\xa8\x8a\xe0\xeb\xc9\x3c\x3e\x7e\x3d\x05\x25\xe4\x3d\x9a\x79\xae\xde\x9e\x9c\x5b\xa8\x18\x3d\xfe\x3f\xa3\xe3\x93\xe9\xeb\xf1\xe9\xc9\xd9\xc9\xf9\x68\xaa\x9e\xee\x06\xd4\x99\x8e\x2f\x26\xb3\x93\x4b\xd0\x75\xba\xc2\x1f\x9f\xe6\x2f\x9d\x4c\x9c\x63\x05\x6a\x66\x43\xf9\x1e\x15\xac\x63\x1b\x78\xf8\xf5\x9f\x47\xc7\x13\xcb\xcb\xa7\x27\xa3\x59\xaf\xa8\x13\x8c\x98\x55\x89\x07\x96\x17\x2f\x8a\x49\x05\x01\xc5\xe2\xb6\x43\x73\x5e\xe9\x53\x3b\x81\x93\x15\x73\x11\x8c\x58\x22\xdb\x3e\xaa\x45\xe6\xbc\x32\x4e\xe9\x5a\x60\xad\xd4\x1c\xf6\xc1\x77\xd8\x01\x1e\xa7\x82\xf8\x63\xf9\xf9\xa3\xcd\xec\x5c\x8f\xa0\xfa\xf6\x16\x18\x9d\x57\xf8\xfb\x5a\xc4\x09\x89\x4f\xfe\xf9\x3d\x7f\xfc\xf8\xb1\x17\x87\xeb\x80\x13\x24\x19\xd6\x59\x7c\xca\xc0\xd1\x8d\xec\x1d\xb8\xd4\xce\xa2\x8b\x9e\x2b\x1e\xaf\xef\x32\x3a\x30\x4f\xf8\x00\xb1\x93\xfa\xf3\x0c\xa5\xe4\x6d\x1c\x7d\x10\xb6\x30\xf5\x91\xb4\x13\xa0\x94\xca\x13\xa8\x32\x19\x95\xbb\x14\x9e\xef\xc6\xc5\x74\x8d\x56\x2a\x94\x95\x9a\xee\x4c\x65\x62\xd4\x8f\xd1\xdd\x9d\xc0\x54\xbc\x0e\x64\x15\x82\xf1\x8c\x04\x12\xce\x0a\x00\x30\x69\x29\x61\x4b\xd3\x6a\x49\x10\x18\xcd\xd1\xee\x83\xf6\x26\x99\x7e\x08\xef\xce\x33\x34\x09\x3b\x94\x0b\x97\xd0\x5d\x0c\xe6\x4a\x05\x20\x7e\xb4\xa6\xec\x8d\x3c\x00\xa5\x0c\xb5\x40\xc4\x22\xce\x56\x91\xcc\x41\x5b\x64\x6c\x91\x45\xab\x04\x28\x60\x19\x3f\xc4\x37\xb8\x12\xf0\x16\x32\x65\xfa\x5e\x89\x4c\xa4\xb2\x00\xa7\x0f\x8d\x45\x12\xe1\x03\xbd\x04\xcc\xa4\xa3\x9b\xa9\x2c\x02\xaf\xa7\xd1\x03\x85\x85\xf2\x3d\x0c\x6d\x9d\x34\x53\xdb\xa9\x39\xa2\xab\x2c\x59\xc8\x29\xcb\xa4\x5e\x3b\xb7\x68\xb5\x8c\x0e\xdd\x01\xb1\x4a\xf7\x42\x3b\xe5\x6a\xd5\x8a\x4c\x26\x71\x01\x02\x65\x87\xa7\x04\x38\x2b\x1a\x5a\x1d\x84\x03\xb8\x00\xaf\x80\x00\x41\x64\xe5\x94\x39\x18\x71\x14\x2f\xf0\xbb\x49\xbc\x90\xdf\xbd\xe6\xa0\x5c\xfc\x72\x86\x7f\xc8\xaf\x79\xb6\xae\x34\x43\x0f\x0e\x6c\x6a\xe6\xc8\xcb\x27\x2b\x90\x84\x6b\x2a\x68\x4b\x04\x35\xd9\x7b\x6c\xfc\xaa\xa1\x46\x25\xf5\x94\xe8\x51\x53\x5c\xa4\xa8\x9e\x1f\x01\x9a\xf3\x8b\xe9\x7f\xea\x12\x21\xe7\xfd\x56\x20\xc7\xa4\xd2\xc9\x99\x77\xb0\x2e\xd8\x64\x7c\xf4\x46\xa9\x5c\xaf\x5d\x84\x74\xe0\x38\x53\x41\xd2\x01\x01\x94\xc0\x2a\xe5\xac\x05\x7c\x48\x3e\x8e\x18\x27\x05\x40\xd1\xad\x95\x2d\xca\xf8\x00\xbb\xa0\xa5\xde\xdc\x70\xaf\x71\xeb\xc6\xe5\xe5\x5a\xa5\x8e\xe9\xc4\xbb\xae\xd4\x3a\x43\xaf\x74\xe3\xe0\x31\xe1\x5c\xc1\x38\x69\xc4\x11\x0f\x90\x65\x16\x40\xab\xcf\x9f\x24\x44\x36\x0c\x34\xcb\xf7\xee\x2d\xe8\xc7\x29\x4a\xcd\x4c\xfd\xc8\x0b\x03\x63\xa3\x6d\x37\xd7\xfa\xc9\xc2\xe9\x28\x4c\x02\x45\xcf\xf3\x30\x5f\x6a\xed\x99\x97\xc6\x4b\xa0\xff\x1b\xb8\x4a\xcc\xc9\x9e\x9f\xc6\x78\x3b\x91\x9c\xc5\x59\xb0\xbd\x45\x0c\x87\x39\x0b\x8d\xbb\x87\xaf\x14\xfb\xc2\x8c\xf9\xe1\x1a\x8e\xa4\x86\xd9\x07\x02\xde\x45\x0f\x62\x8d\x3e\x3b\xbc\xd4\x48\xd7\xc2\x9d\x1f\xc3\xe5\xf9\x2e\xe3\x0b\x13\x00\xc3\x7c\x5d\xc2\xe9\xf8\xcb\x15\x2a\xef\x70\xdc\x14\x68\xc5\x9f\xe8\xc2\x86\x1f\xaa\x14\x33\x6d\x7d\x57\x48\xfd\xf4\x07\x4d\xec\xbc\x88\x3c\xb2\x96\xe3\xa9\x1a\xe2\x8c\x7a\x22\xa9\xb9\xc6\x54\x29\x44\x2f\x25\xf9\xb5\xfd\x30\xe3\xc9\x1f\x18\xf7\x1f\xb4\xdd\xc9\x57\xe5\x3d\x63\x1d\xcd\x19\x62\xfd\xa2\x83\x6b\x35\x3c\x2b\x96\xb7\x6e\xbc\x20\x03\x92\xbf\x44\xaf\x22\xf9\x2d\x81\xf7\x2b\x10\xff\x3c\x47\xa9\xba\xbe\x01\x28\xe6\x2d\x49\xe7\xae\x64\xf3\x25\x39\xb4\xde\x93\x47\x81\x91\x9e\x4a\xbe\x1b\xa9\x17\xe0\x5d\x59\x5d\xc6\xc9\x31\x91\xf8\x3a\xb0\x3b\x20\xf1\x66\xb3\x96\x5c\x46\x78\x11\x0d\xcc\x44\x70\xc3\xb3\xbf\x71\x79\x93\x85\x0c\x15\x81\xca\xbb\x59\x1a\xa1\x99\x1b\x7d\x11\x79\x86\x21\x26\xb2\xee\x8f\x70\xda\x06\xf6\x7c\xc8\x6d\x09\x47\x07\x70\x31\x2b\x72\x07\x92\x41\x5d\x7a\x12\x6e\x4b\xb8\x4f\xcb\xef\x0a\xf1\x7b\xe2\x78\x95\xf8\x1e\x3c\x8f\x1e\x9c\xd9\xec\x9d\x5c\x0b\x92\x2a\xd1\x98\xbb\x7b\xc1\x5e\x17\xda\x59\xd2\x29\x87\x10\x94\x12\x2c\xcf\x71\x1b\x42\x0a\x3f\x08\x04\x56\x39\x08\x75\xa2\x3b\xa9\x30\xb6\x39\x9c\xa9\xec\xd1\xd4\x5d\xde\xfa\x8f\x7f\x91\x1e\xb9\x2c\x75\x93\x52\x2a\xbb\x6d\x72\x58\xfb\x59\x66\x20\x95\x41\x80\x70\xf6\xaf\xc0\x00\x0e\x18\xae\xfa\x2c\x6b\x3c\x34\x8c\x7b\x26\x58\x00\x51\x1c\x04\xa7\xa2\xd5\x64\xfc\xba\x61\xca\x97\x93\xe2\x63\x2d\x6c\x01\x2d\xa9\xdf\x6d\x0a\x5e\x20\xd5\xc4\x67\xef\x89\xf4\x10\xdf\xf9\x22\xb0\x59\x82\xcf\xf5\xe5\x04\x75\x32\x3e\x1c\xe6\x70\x97\xc7\xbc\xbd\xc0\x5f\xb8\x0d\x1e\x95\x4a\x79\x87\xa2\x0b\xc7\x76\x30\xd5\x15\x6f\xd0\xce\x1c\x9b\xc4\xad\xa8\xae\x38\xc0\x87\x28\xfe\x40\x81\x31\x1f\xfc\xd5\x2a\xd7\x79\x29\xde\x08\x91\x75\xc7\xcf\xe3\x4e\xd1\x20\xf8\x1d\xdc\x12\x01\x26\xf9\x6b\x05\x6a\x33\x41\xa9\xd8\x86\x54\x6a\x7b\x10\x2a\x37\x3a\xe7\xf5\xa4\xac\xcb\xb2\x20\xe0\x87\xfa\x70\x4a\xed\x6f\x9d\x5c\xe3\xb8\x35\xf0\x6c\xb4\xc1\x80\xc8\x84\x83\x4b\x03\x23\x85\xe0\x82\xbc\x08\x23\x50\x30\xe6\x09\x87\x45\x04\xd1\x82\x02\x06\x5a\xae\x24\x22\xe0\x57\x1f\xff\x8a\xef\xf2\x7d\x8c\x73\x49\x33\xba\x8f\x21\x8e\x42\xb8\x10\x99\xfd\xc9\xb6\x6d\x5f\x4c\x2a\xdd\xc9\xb9\x17\x6e\x80\xb1\x1c\xf7\x62\xfe\xc1\x49\x37\x2b\x21\xad\x57\x2f\xd1\xc3\xcc\xf9\xee\x21\x08\xdd\x97\x36\xa3\xca\xa5\xbf\x92\x66\x5b\xd0\x09\xa2\xdb\x7c\xea\x50\x00\x6a\x7f\x84\x99\xa9\x24\x4d\x5a\x03\x8d\x42\x63\x68\x25\x56\xd7\x7d\xf1\x41\xf9\xf8\xde\x42\xd1\xe3\xff\x0c\x3d\x94\xfb\x9e\x28\xd6\x69\x31\x68\xb0\x62\x4a\x6c\xd6\x32\xcb\x1b\x5c\x72\xc2\x65\x77\xb7\xbc\x64\xda\x4f\x13\x2a\x14\x21\x45\x16\xf9\xcf\xeb\x0a\x16\xb4\x60\xe2\x1b\x23\xe3\xf3\xc4\x9d\x1f\x72\x18\x1b\x2d\xa8\x26\xd1\x69\xe2\xe6\xf7\xf4\x4c\xcd\x25\x30\x7d\xff\x73\xdb\xa5\x65\x91\x1c\x2c\x59\xc1\x24\xa0\x19\xa0\x95\x02\x7c\xbe\x82\x4f\x26\x4f\x36\xe3\xe3\x63\x64\x4b\x74\xa5\x53\xa2\x23\x52\x90\xe9\xef\x31\xce\xd4\x82\x06\x7e\x43\x1d\x88\x90\x59\x4d\x5e\x04\x88\x85\x66\x40\xd7\xfd\x29\xfc\xcb\x86\x02\x1c\x81\x53\xa9\x06\x92\x5b\x0b\xb8\x1a\x07\xdc\xd2\xe1\xdb\x06\x43\x00\xe1\xd7\x33\x8a\x03\xce\xb1\xb8\x81\xce\x4c\xad\x20\xe2\xcc\xc3\x22\x67\x6a\xb0\x6e\x3d\x2c\x06\xd4\x38\x2a\xc3\x0a\xc2\x5f\x93\xed\x41\xdb\x41\x0a\xf4\xee\x85\x03\x05\x9a\x3a\x30\xa0\x60\x18\x29\x92\xa8\x4c\x23\x15\x22\x9f\x92\x61\xbf\x14\xbe\x6c\x3b\xf8\x92\x71\x12\x20\xa8\x6f\x6e\xe8\x1b\x66\x88\x5e\x14\x89\xe4\x75\xce\x0c\x45\x55\x4a\xa6\xf8\x8a\x75\xb3\x33\x33\x6a\xec\x9b\x75\xc4\xb8\x81\xb9\x00\x14\x39\x16\x06\x95\x68\xab\x9a\x47\xbb\x30\xc8\x90\xf1\xf0\xee\xef\xf1\x0f\xa9\x92\x98\x8c\xd9\xd2\x66\x58\xe4\x41\x45\xf8\x97\x10\x16\x07\xbf\xad\x59\x30\x4d\x31\x64\x86\xec\x2c\xc0\xf0\xe8\x21\x0c\x22\x60\x36\x79\x87\x37\x1c\x34\x49\x21\x0f\xe4\x4a\x08\x45\x8a\x81\x4e\x58\x3c\xc7\x3e\x8a\x13\x36\x8f\x84\xa4\x61\x24\x73\x58\x95\x6c\x67\x50\x3a\x90\x74\x3c\x4b\xf5\x43\x5e\x04\xe4\x90\x4f\x24\x96\x8e\xe4\x2e\xfd\x45\xec\xb2\x79\x57\x6a\x7e\x27\x52\x0d\x39\xce\x2b\x6a\x35\x71\xdc\xa0\x95\x60\xc5\x5d\x40\x59\x09\x93\x21\x03\x14\x8e\x0b\x77\x52\x32\xdb\x5c\xc0\x1f\x3c\x2b\x7f\xc2\xdb\xaf\xba\xf9\xfe\xa9\xac\xac\xfe\x49\x05\x52\xdc\xc5\x42\x45\xe4\x6a\x9d\xea\x4f\x55\xaa\xd4\x5b\x46\x99\x3d\x57\x56\xe5\xc3\x90\x89\x14\x0d\x69\x14\x61\xe0\x7a\x4b\xd0\x28\x30\x9a\x02\xee\x30\x58\x76\x03\x6d\x71\x70\xb7\x0e\x3f\xf0\x0d\x9b\xea\x27\x72\xd9\x21\xeb\xba\xcc\xa3\x08\xc6\x41\xfd\xd0\x4c\xdf\x4d\xcd\xd8\x38\xc2\x03\x27\x2b\xf3\x53\xae\xdc\x97\x2b\x80\x0d\xa3\x03\xc4\x9e\x2c\x69\xc2\xf5\xfa\x1c\xe7\x02\xe8\x58\x60\xc8\x91\x08\x39\x95\x09\xad\x5a\x54\xe6\x2e\x30\xc6\xea\xa1\x0f\xcb\x77\x56\x70\x77\x49\x5c\x19\x46\x94\x2a\xa3\xaf\x1c\x6c\xfd\x3c\x66\x68\xfd\x4c\x51\xad\x15\x2c\xf9\x41\x03\x1e\x16\xca\xdb\xd8\xb8\x94\xa5\xfc\x22\xad\x76\x25\xbc\x75\xf9\x99\x30\x32\x2b\xd0\xb4\x22\xc7\xe0\x2a\xbb\xa0\x50\xa8\x60\xe1\xda\x57\xa4\x01\x0c\x6f\x13\x20\x87\xc4\xf7\x2b\xbc\x09\x23\x17\x39\x6c\x0b\xef\x39\x70\x31\xf8\x40\x96\x7a\x74\xe3\x0c\x5d\x63\xfc\x07\xaa\x46\x2a\x55\x0a\xfb\x93\x59\xf9\xea\x3a\xfb\xfc\xf3\x5f\xcf\x95\x3f\x95\x3e\x09\x2c\xcf\xc1\xdf\x23\xdf\xd4\x77\x91\xfc\x0e\xa4\xaf\xfa\x2a\x91\x5f\x91\xb8\xe4\x2f\xff\x24\x8b\xe0\x68\x6a\xd0\x26\x5c\x26\xa7\xe1\x7e\xa8\x18\xc2\x92\xe4\x1e\xb6\x82\xeb\x65\x73\x8e\x0c\x7e\x9f\x89\x80\xe2\xa0\xcb\xa5\x81\xb8\xf8\x5d\x14\x60\xfd\x3b\x03\x46\x9c\xf0\xc8\x2b\xb5\xbf\x9e\x98\x03\x45\x72\xca\xc4\x6e\x2c\x94\xda\x27\x3f\x8a\xe5\x61\x47\x5b\x13\x6b\xfc\xf9\x9e\x8c\xdf\xe3\x6c\x15\x0e\x93\xc1\xc0\x43\xaa\x47\x34\x8f\x3c\x9b\x2a\x3d\x96\xa6\x35\xdc\x56\x78\x5f\xc3\x28\xa1\xbc\x8c\x9b\x0a\x23\x23\xb8\xfe\xc2\x97\x75\x27\x71\xd3\x72\xb9\x0d\xf2\x4d\xfa\x20\xb8\x2d\x5a\xf8\x57\x27\xa7\xa7\x27\xe7\x6f\xb1\x56\xc9\xe8\xed\x78\x6a\x21\xe2\xed\x78\x76\x39\x99\x62\xb0\xca\x9b\xd1\xd1\xe5\xd5\x74\x74\x74\xf2\xf8\x6f\x96\x20\x19\x5d\x91\xc5\xe6\x87\xbf\x18\xfd\xfe\x6a\x7c\x39\x9e\x21\xb8\xa3\xc9\xd9\xc5\xc9\x69\x23\x38\x1f\xd3\x10\xca\xea\x51\xeb\xcd\x6e\x4c\xc6\x09\xba\xe8\xd4\x28\x34\xed\x77\x39\x2b\x5a\xb4\x42\xaa\x20\xc4\xb2\xdf\x5b\x96\xcf\xc4\xe2\x4a\x68\xb0\x54\xee\x71\xb3\x90\xca\x96\xe4\x9a\xd1\x8b\x75\x4e\x72\xe9\x08\xe3\x9c\x03\x2e\xaf\x14\xcb\x82\x5a\xf2\x82\x4f\xc5\x25\x0b\xbe\xf4\xa7\x1b\xb8\x72\xb8\xff\x72\x06\x9e\x87\x63\x58\x6c\xb1\x7a\xd8\xa5\x5a\xba\xb4\xd0\xc8\xaa\xd7\xcb\x06\xd2\x04\xae\xc9\xe3\x9e\xb3\xc3\x56\x4f\xb7\xc5\xf7\x4e\x88\xe7\x88\x0b\x1d\xbd\xbd\x69\xc6\x59\xbb\x15\xe9\x83\x10\xa4\xb7\x17\x95\x02\x3a\x19\x8a\xf6\x56\x29\xd6\xc8\x74\x6a\x17\x60\x68\x29\x9c\x53\xf9\x9e\x58\xd4\x80\xdd\xd4\x9b\x62\x1f\x7f\xb6\x9c\xd5\x8a\xd0\xa5\xbb\x81\xa1\x62\x6c\xa7\xb4\x26\xb2\x9f\xa0\x1a\x77\x80\xf9\x58\x01\xc7\xc7\xde\x6e\xaa\x93\x62\x53\x82\x0e\x9c\x52\x50\xe8\x2a\x8e\xe6\x42\x78\xbf\xb5\x8c\xf4\x93\xd3\xe5\xbc\xda\xbc\xb6\xc5\x6d\x2a\xe2\xaa\x54\x74\xc6\xdb\x3f\x5c\xa3\xe3\x75\xbc\x99\xe2\x6e\x37\x63\x4f\xdc\xb9\x59\xa0\x58\xad\x24\x6f\xb7\x10\x9f\x31\xaf\x4f\x74\x63\x75\xbd\xfd\x92\xfb\x6b\x8d\x66\x2e\xf4\x6d\xc1\x0c\xe6\x11\x5e\xca\xd7\x85\x82\x36\x45\x45\xa1\x73\x38\x50\xbf\x11\x6b\x29\xfb\x84\x83\x74\xb7\x0c\x6c\xca\x47\xc2\x6b\xcb\xba\xa4\xf6\x12\x15\xd4\x71\x99\x19\x1c\xd0\xe2\xd4\x4a\x98\x35\x4a\xa8\xce\xbe\xd1\x23\x5e\xa8\x9b\x5d\xc8\xce\xbf\x7d\xf2\xad\x8b\x65\xa4\x99\x69\x4f\xcc\xac\x0e\x56\x14\xc5\x29\x53\xa2\x99\x54\x74\x18\x59\xfe\xae\x5b\x79\xb5\x1e\x67\xe6\x07\xde\x0a\xaf\x4b\xf0\xb8\xfe\xa0\x6d\x43\x66\x2e\x84\xfd\x50\x5c\xb9\x70\x36\xa4\x42\xb9\x89\xfc\x20\xe7\x50\x19\xa4\x4e\x9b\xd8\x82\x9c\x6e\x2e\xd1\x7e\xf4\xb4\x39\x4b\xbf\xda\xa4\x68\xa9\x83\xd3\x09\x85\x98\xf2\x6f\xbb\xa1\xaa\x24\xa0\xb2\xe3\xb3\xd0\x27\x75\x72\x09\x37\xe2\x2c\x16\x54\x8c\x30\xf0\x3f\x08\xe7\x6c\xe0\x9c\x7d\x35\x70\xde\x52\xa1\x82\xb7\x5f\xd9\x6f\x9f\x73\xc4\x21\x43\x30\x6f\x37\xec\xe1\xce\x6b\x08\xc8\xa4\x7f\xbe\x11\x11\x3a\xf9\x28\x6a\x82\x9e\x94\x66\x0a\x97\x13\x21\xa6\xda\xf1\xe8\xea\xc4\x9e\x37\xe4\x98\x9d\x21\x25\x6b\x61\x20\x3f\xff\x02\xcb\x07\xef\xad\xe3\x7f\x1a\x9d\x5d\x9c\x8e\x39\xd5\x15\x8b\x50\x97\x5e\xb8\x88\xfd\x35\x5c\xa7\xa7\xf8\xb7\x4c\x31\x5b\x6e\x56\xfc\xa5\x4a\x33\x7b\x8d\x7f\xbc\xee\x75\x52\x6a\xfa\x30\x6c\x42\x16\x4c\x4f\x92\x7b\x87\x8a\x12\xd3\x4f\xdb\x81\x5b\xf9\xce\xb7\x30\x32\x5b\xca\x74\xdb\xdb\x2b\x5d\x6f\x68\x3b\x00\x58\x0b\xfa\x6a\x36\x9e\xd2\xa7\x8b\xd1\x6c\xf6\x87\xc9\xf4\x18\xd9\xbc\x15\x38\x2a\x84\xc4\xa9\xae\x4a\xaa\x72\x6d\xd0\x6a\x09\x90\x6f\x87\x77\xd5\xd4\xd5\xbc\xbe\xe8\xc5\x68\x0a\x7f\x5f\x8e\xa7\xb3\x9b\xd1\xec\x06\xf3\xac\xff\x68\x4c\xfe\xec\xb0\x5a\x7f\xa9\x88\xd6\xac\xa1\xba\xdc\xa0\x19\x95\x8b\x78\xc6\x8e\x81\x72\xb9\x01\x06\xee\x00\x69\xce\xf9\xf8\x98\x81\xbd\x13\x14\x2c\x37\x43\x09\x85\x54\x5c\x86\xc0\xe5\xb5\x65\x4e\x42\xe7\x0f\x00\x2f\x7a\x48\x9c\x8b\xe8\x41\xc4\xb3\x7b\xb8\x76\x50\xb6\x95\x17\x65\xd8\x1c\x85\x6a\xef\x7a\x58\x6d\x03\x0b\x01\x73\xfd\x1f\x4c\xcf\xfe\x11\x2b\x04\x33\xd8\x6b\x04\x7c\x2d\x41\xc3\xbf\x1f\x65\xda\xb6\x01\x5b\x06\xe0\x39\xa7\x98\x71\x84\xd0\xb9\x32\x82\x05\xfa\xcb\x26\xe0\xb6\x48\xf4\x2e\x6b\x47\x36\xdb\x51\x7a\x92\xec\xfc\x32\x1b\x1f\x5d\x4d\x4f\x2e\xbf\xb9\x79\x3b\x9d\x5c\x5d\x6c\x0f\xbe\x11\xac\x33\x99\xbe\xe5\xed\xbc\x0b\x82\xb6\x22\x60\x96\xc5\xbd\x03\x4a\xd9\x38\xe7\x09\x58\xa6\x8e\x24\xdb\x09\xdb\xfc\x3a\x45\x76\xf0\x36\xa0\xcd\xad\x44\x01\x6c\x7a\xca\x83\x97\x19\xf0\xb6\x4d\x6d\xbe\xbe\xdc\xe0\x9e\x2d\x6c\x22\xe3\x7f\xff\xd5\xfc\xa1\x0f\x0c\x49\xc8\x5d\x14\x01\x0c\xfe\xdd\xcc\x71\x7a\x0d\x3f\x58\x46\xde\x32\xc6\x16\xc6\x50\xad\x27\xe4\x83\x9b\x6c\xc2\x39\x95\x4b\x07\x08\x2a\x3b\x1f\xd6\xca\xcd\xd9\xc9\xf9\xd5\x25\xa7\xfc\x0f\x01\x35\xac\xa8\x57\x69\x9c\x09\xe7\x5f\x9c\x3b\x37\x48\xf0\x5f\xa4\xfc\x75\x1a\xbd\x46\x09\xf4\x19\x3d\x37\x8f\x30\x20\xa0\xf0\x1c\xff\x40\x15\x7b\x00\xc2\xe9\xe4\x68\x74\x3a\x86\xdf\x8e\x4e\xc7\xa3\xe9\x67\xdb\xad\x39\x59\xe7\x09\x04\xe7\x50\x15\xde\x31\xab\x45\xaf\x9c\xd7\x8a\x32\xb6\x01\xe3\x83\x54\x37\x8b\xcc\xc0\xfa\x9d\x83\xcd\x32\xb0\xd6\x09\xe9\x44\x81\x5e\x9d\x79\x7d\x6a\x5a\x52\x0e\x25\xfe\x9d\x4c\x68\xa1\x71\xe0\xfd\xbf\x0c\x87\x9e\x9f\xe0\x5f\x3b\x61\xf4\xa2\x25\xd6\xb8\x47\x31\x21\xa7\x79\x07\x60\x78\x8b\x00\x48\xbb\x80\x60\x3f\xed\xef\xaf\x26\x97\x23\x2a\x08\x71\x09\x7f\x9c\xde\xe4\x65\x21\x7c\x47\x49\x1d\xe3\xcb\x98\xeb\x4f\xcc\x64\x6d\x88\x92\x78\xe2\x15\xc7\x3a\xce\xca\xf5\xb5\x40\x1b\x52\x80\xeb\x4e\xdc\xe3\x4d\x42\xf2\xd5\x90\x04\xb5\xc7\x7f\x37\xf9\x60\x82\x5d\x6e\x58\x25\xb3\x89\x88\xca\xff\x1a\x64\x46\x2b\xdc\xb2\x06\x51\x84\x4b\x5f\x1d\xec\x11\x7a\x49\x4a\x95\xa0\x77\x11\x52\xbf\xa4\x09\xd8\x89\xf1\xe1\x93\x30\x3c\xec\xce\xe8\x2e\x0b\xbd\x59\xc9\x50\x75\xef\xf0\xd4\xbf\x99\x5e\x01\x57\xa9\x04\xde\x2e\x3b\xab\x5b\xcd\x3d\x8b\xe2\xc1\x75\x61\x46\x6f\x67\x3b\x6d\x6e\x25\x26\xf0\x3e\x31\x4c\xa3\x0f\x22\x74\x4e\x47\x5f\x8d\x4f\x9d\x8b\xe9\xe4\xfd\xc9\xf1\x78\x0a\xc2\xe9\xeb\xf1\x4e\x02\x53\xa1\xe0\x5c\x51\x3d\xbe\xaf\xa6\x00\x78\x5a\xbd\xc3\x50\x12\x1d\xac\x64\x79\x53\x9b\x47\xa0\xbc\xee\x65\x88\x1f\xc4\xa6\xca\x5c\xf5\xc5\xd7\xe3\x6f\x9a\xae\x2f\xce\x33\x16\xc3\xef\x4b\xf6\x2f\xb6\x0a\xeb\x53\x56\x92\xde\x82\x49\x3b\x95\x60\xed\x52\xbf\xb7\x62\xe4\x68\x20\x76\xb9\xf1\x6e\xe1\x3f\xf8\xa7\x9c\xbf\x22\xfc\x02\x78\x9c\xb7\x3e\xe0\xfe\xf5\x35\xc6\xde\xd3\x06\x7a\x9d\x2e\x57\xaf\x95\xf3\xe2\x86\x67\x90\xee\xbd\x3b\xed\xa8\x7b\x37\x16\x9e\x52\xab\x76\x57\xa9\x58\xb4\xf3\x01\x87\x6d\xa4\x64\xff\xa8\x3f\xf3\x57\x43\x52\x94\x76\x13\x01\x24\x4b\x8a\x6a\x57\xad\x92\x65\x16\xe7\xfa\x64\x0a\x17\x85\xf7\x54\xe4\xe2\xae\x10\x87\xaa\x14\x63\xf9\xd8\x31\x4f\x9a\x95\x73\x34\x1d\x1f\x8f\xcf\x2f\x4f\x46\xa7\x34\xc2\xc0\x99\x7d\x33\x3b\x9d\xbc\xbd\x39\x9e\xc2\x24\xdf\xa0\xc1\x2b\x67\x8d\x6a\x33\x42\x5f\xcb\x2d\x75\xe1\x26\xb2\x65\x28\x08\x10\xdc\xf0\x54\x1e\x11\x7d\x40\x54\x8e\x26\x97\x01\x94\x0a\x93\x98\x49\xb6\x79\x30\x93\xb3\x8c\x3c\x51\xbb\x87\x3a\x8e\x84\xda\x0e\x11\x15\x83\x9c\x8c\x41\x8e\x7c\xc0\xd8\xaf\x5f\x14\xa8\xae\xa1\x92\xf2\xf5\x49\x2a\x60\x38\x17\xd1\x60\xb8\xae\x2b\x31\x58\x3b\xd2\x8c\x72\x00\xf6\xf0\x17\xb9\xd0\xfe\x82\x04\x39\x7c\xf7\x65\xfe\xdd\x97\x86\x24\x9f\xc9\x7e\x46\x6e\x49\x5a\x9a\x82\x9c\x2c\x3f\xbb\x11\x56\x96\x9d\x4d\x62\xae\x1e\x2a\x68\x70\xde\xed\x70\x89\x46\x2a\x9a\x1c\xe5\x24\x1b\x18\xad\xa1\xb6\x85\xa6\x6f\xae\xf9\x0c\x26\x55\xe3\x5e\x2b\xc0\x18\xf8\x95\xf7\xba\x08\x9c\x64\x93\x04\xd1\xe2\xf0\xf5\xeb\x16\x15\xd5\x0a\xb1\x68\x49\x84\x5d\xa3\x6a\xb2\x14\x00\x72\xf9\x67\x3f\xcc\xbe\x7f\x7d\xe6\xce\xb7\x66\x29\xae\x1d\xc5\x54\x5a\x2b\x14\x75\x48\xcb\x27\xe7\xf0\x21\x7e\xe0\xae\x54\xc6\x22\xaa\x33\x25\x6e\x3f\xb3\x64\x61\xd4\x94\x28\x23\x23\x53\x73\x8d\xf4\x94\x7a\xa1\x1d\xf2\x17\x92\x2a\x65\xe4\x2c\x10\x96\xdb\x4f\x77\xe0\xce\xae\x54\x6d\x67\x1d\x9d\x63\x45\x09\x32\x6f\xc0\x91\xb3\x46\xe1\xf9\x4f\x70\xc6\x5c\xbe\x9b\x50\x0b\xae\x77\x58\xcc\x11\xb4\x6c\xd9\x8e\x6b\x04\xe7\x1c\x1e\x2b\xb0\x6e\x56\x59\xea\xe0\x6e\x53\x72\xf5\xab\x8d\xf2\xe2\xe7\x25\x33\x11\xf6\x4b\xd9\xd7\x4f\xc4\x18\xcf\x09\xbb\xff\xed\xf8\x52\xe9\x5b\x52\x73\x03\x01\x8c\x04\x1c\x38\x27\x77\x54\x8d\x8d\xe0\x61\xf6\xbc\xaa\xcd\xbb\xf6\x5d\x67\xe8\x61\x36\xf8\x05\x9a\xc2\x54\x8f\x2c\x09\x93\x4a\x22\x24\x29\xa8\x23\x03\x95\x86\x4f\xa1\xbc\xd8\xe8\xfb\x72\xb3\xe2\x95\xa2\xde\x49\x44\x2a\xdd\xaf\x2a\xb8\xe9\x35\x6e\xc4\x03\x4a\xfa\xc7\xd8\x8f\x68\x2d\xe2\x18\x15\xce\x7b\x00\x88\xf2\x95\xdc\x5d\xc0\x08\x09\x9a\xa0\xa9\x04\x38\x10\xc1\xf7\x91\x27\x1f\xf9\xa7\x03\xc9\x8a\x37\xa0\x24\x62\x0a\x9b\x17\xcd\xa9\x3d\x1a\xa1\xd1\xe5\x10\xd7\x7e\xe2\xa7\xca\x81\xe4\xae\x7c\x78\x2a\x39\x98\x63\x51\xac\x3b\xae\x89\x85\x01\xf7\x07\xd5\xdb\xf1\xfc\x8e\xe7\xea\xfa\xc5\xeb\xf5\x97\xaf\xb1\xbe\xf4\xf5\x0b\x40\x4a\xfc\x84\xf9\x0f\x6b\x2f\xc5\x48\xf8\xf5\x0b\x93\x1b\x87\x85\xb1\x7f\x3f\x7c\x78\x78\x18\x22\x17\x87\x00\x1b\xeb\xd9\x01\xbf\x01\x6e\x03\x40\xcf\x79\xf9\xe7\xff\x81\x8b\xf4\x90\x6e\xb2\x6a\x8f\xd6\x93\xe7\x39\xff\xf8\xda\x34\x28\x6e\xb5\x44\x65\x6a\xaf\x61\x0c\xbc\x03\x61\xb5\x9d\x0a\xc3\xb0\x6a\x6d\x7c\xe8\x38\xda\x05\x66\x41\xdd\xdc\x19\x9a\x34\xe3\xed\x01\xce\xea\xde\x0d\x85\x74\x1b\x25\x3b\xc3\x2b\x2a\xa9\xbb\xc1\x62\xdb\x49\x77\x93\x11\x21\xb4\xdb\x8d\x0a\x50\xbb\xda\xeb\x1a\xec\x46\x56\x78\x05\x4b\x1a\x19\xff\x0b\xf0\xaa\x06\xff\x6d\xc1\xee\xee\x47\xe8\xc3\xe9\x3b\x4b\x91\xe5\x12\xac\x66\x33\xd4\xae\x6b\xa2\x41\xf9\xdf\x0b\xe0\x06\x4b\xd2\xbe\x30\xd4\x1b\x92\xf6\x05\xbd\x83\x99\xa8\xb0\x49\x6a\xf7\x48\xfd\xdd\xbc\xdb\x5a\xea\x4f\xc8\xef\xc6\x40\xc8\xa4\x0f\x21\x9d\x18\x52\x73\xcb\xdf\x9d\xcb\x85\xab\xfe\x1e\x60\x49\x81\x69\x58\x0a\x86\xea\x10\xdb\x09\x78\xf1\x12\xbe\x3d\x34\x76\x5f\x0d\xef\x40\x53\xcd\x62\xf8\x37\x70\x17\xce\x9b\xf1\xe8\xf2\x6a\xba\x43\xf0\x89\x82\x9a\x18\x1d\x5f\xb7\x06\xb4\xdf\xb8\x18\xbe\xcc\xef\x79\xbc\x12\xe8\xce\xc3\x15\xe1\x7a\x47\x00\x6b\x6c\x0d\xbc\x1b\x8c\xfd\xb2\xc6\x84\xb6\x9d\xbb\x1f\xf5\xc6\xc4\xd0\xfe\x94\x2a\x90\x1b\xc8\x50\xca\xa4\xf4\x7f\x94\x76\x85\x72\xe6\x32\xe2\x7c\x07\x2e\xa7\x86\x17\x8d\x54\x02\xc2\xaa\x8c\x14\xc5\xaf\x03\x8d\x23\x2e\xb7\x76\xec\x8b\x45\x44\x89\x54\x22\x84\xab\x04\x86\xaa\xe8\x9b\x0c\xcc\xac\xed\x7a\xf5\x4b\x20\x13\x94\x6f\xa2\xb0\x91\x8f\x0b\x91\x0e\xb9\x36\xc6\x90\x6b\x63\xec\xb4\x4a\xb0\xa4\xb4\xf3\xad\xea\xd6\xbc\x15\x08\x59\xab\x4c\x06\xd9\xc9\x30\x82\x21\xf2\xed\xf5\xe5\xe4\xb5\x2c\xd2\xfb\x2f\xe4\x6f\xf9\x17\xb4\x4e\xe4\x11\x7b\xfc\x1b\xfd\xfd\x99\x3e\x66\x00\xc1\x05\x35\xcc\xe7\x30\x72\xb2\x25\xc7\x4b\x76\x06\x64\x61\x80\x95\x88\x5e\x0e\xef\x5e\x9a\x37\xcb\xfa\x6b\x56\x89\xae\x7f\x7d\x7d\x2c\xd3\x7b\x93\xd7\x32\x1e\x10\xf4\xae\x5b\x37\xb6\x3c\x5f\x63\x44\x29\xbe\x77\x13\xa0\x31\xe5\xc6\x5d\x7a\xff\xf0\x1b\x0b\x0c\x18\xed\xd9\x66\x48\xa1\x86\xf2\x55\x31\xbf\xb7\xe9\x7a\xcd\x5c\xc6\xf5\x65\xc6\x31\x6e\xb7\x09\x39\x7f\xef\xdb\x21\x15\x73\x55\x66\xd6\x4c\x1f\x40\xaa\x35\x04\x9b\x82\xff\x68\x5a\xc9\x13\x96\xd8\x7f\xdc\x3a\xf6\x0f\x50\x83\xf6\xba\xed\xab\x3b\x0a\xc3\xa5\xbb\x92\xca\xb3\xde\xd9\xfb\x70\x71\xe7\x60\x97\x9b\x21\x95\x4e\xda\xfd\xba\xd2\x08\x73\xb7\x2b\x4b\x4f\xd0\xbb\x5f\x5b\x7a\xb2\xbd\x65\x0e\x39\xdd\x5d\xeb\x9a\xca\xdd\x94\x38\xeb\x2f\x94\x8b\x00\xff\xd4\x17\x01\xfc\x1b\x5d\xdd\xeb\x2f\xf3\x9f\xbf\xa4\xaf\xb6\x5e\xc4\x51\x7e\xed\xd8\xee\xfd\x1d\xa2\x7a\xe0\x5d\x52\x17\x93\xad\x21\x90\xe1\xb1\x5f\x42\x9a\x7e\x55\xd6\xb4\xdd\xea\xdd\x2c\x5e\x54\xa7\xad\x72\xe9\xd8\x03\x6c\x55\x92\x59\x87\x3a\x90\x38\x93\xeb\x61\xbb\xd3\xcd\x30\x94\x6c\xff\xfe\x76\x7c\xe3\xa6\x1b\xf5\xd1\xee\x75\x91\xee\x35\xcf\x1b\xc1\xee\x5b\xae\xf8\x98\xcb\xdc\xea\xfd\x7b\x3e\xfe\xc3\xcd\x4e\xa2\x98\x01\xd6\x99\xee\x72\x04\xc5\xaf\x76\x41\xa3\xec\x6f\x08\x75\xdb\x6d\x23\x41\x59\x4d\x1a\x08\x7b\x2f\x8b\xb9\x88\xc8\x62\x80\x30\xb1\xf1\x57\x3b\xe1\x32\x2e\xca\x04\x79\xeb\xf8\x66\x5c\x6f\x43\xd5\x02\xe3\x5b\x53\xcf\xab\x9a\x31\xe6\x77\xc5\xc7\xe1\x69\x63\xa5\x6e\x89\x1e\x03\x9d\xc5\x6e\x6a\x02\x01\x89\xd3\xbd\x00\xa1\x10\x58\x2d\xec\xf4\xfe\x39\x39\x3f\x1e\xff\xd3\x76\x70\x65\xec\x3b\xdc\x2e\xfd\x38\x0a\xd1\x25\x31\xa4\x36\x95\x78\x67\x25\x23\xde\x56\x60\x13\x0a\xfe\x35\xac\xf2\xf9\x4d\xa7\xa1\xa5\xd8\x96\x76\x8a\xfd\x07\xa1\xdb\x76\xe5\x2e\xc0\x0c\xe3\xe2\x76\x92\xbb\xab\x6d\xcd\x6a\xdf\xeb\x65\xd8\xeb\x4c\x4b\x35\xbc\xa4\x0b\x01\x09\x51\xb0\x25\xee\x74\x68\x1a\x43\x9c\xf1\xf9\xfb\x9b\xf7\xa3\x69\xf1\xc3\xfb\xd1\xe9\xd5\xb6\xf3\x65\xb9\x0b\xcb\x12\x8e\xff\xc2\x05\x1c\xb7\x86\x8d\x2a\x17\x55\x44\xd3\x16\x3a\x3c\x4b\xa6\x13\x8e\x4e\xd8\x1a\x2c\xeb\x14\x08\x8a\xf4\x8a\x9d\x60\xb5\x4b\x85\xee\x61\x7b\x5b\x13\x51\x35\x91\xd2\x4f\x65\x6b\xe9\x8e\xf0\xab\x33\xc1\xe7\xd6\xce\xf3\xa1\x52\x64\x3e\x1d\x0f\xd1\x06\x3e\x94\x49\x88\x7b\xca\x23\x30\x4e\xf6\xed\xdf\x37\xe7\xf4\x86\x26\x72\xfb\x73\xd1\x00\xb8\xa5\x54\x55\xc6\x63\x8e\x87\x13\xde\xae\x46\x64\x06\xa8\xef\x54\xbb\x32\x6b\xcb\x51\x19\xd6\x66\x3a\x7d\x4d\xbd\x61\x48\xf5\x64\x39\xe5\x51\x36\x16\xc0\x0f\xa7\xce\xb7\x98\xdb\x75\x23\xab\xd1\x1d\xfe\x11\xa5\xdd\x21\x5e\xa8\xe9\x3f\xf8\x89\x6c\x18\x58\x13\x99\xee\xd9\x43\x8a\x3b\x25\x8a\xf2\x1f\xf0\xbe\x00\xcb\x4d\x7c\x8f\x45\x12\xd4\x2f\x32\x26\x62\xb8\x4a\x44\xe6\x45\xc3\x34\xdd\xd0\xd7\x77\x51\x8c\x41\x87\xc5\x2f\x95\x7f\xc0\xf8\x7a\x5b\x16\x0c\x1b\xca\x2f\xb5\xbf\xcc\x86\x7b\x6f\x37\xbd\x0d\x38\x0e\x27\x08\x75\x43\xdd\x11\xc8\x96\x0b\xa1\x55\x0a\x6d\x0b\x76\x57\x8d\x16\xfb\x93\xee\x06\x81\xeb\xa8\xd7\xd9\x13\xb7\x02\x97\x85\xbd\x32\x89\x6d\x7e\x72\xab\xf6\x53\x0b\xbf\x7b\xca\xf0\x4e\x63\x7a\xb2\x0c\x57\x89\xe0\x29\x73\x5c\x35\x8a\x96\x2c\xd7\x9d\x80\x3f\x59\x3e\xab\x6e\xbb\xa2\xcc\xf7\xec\x9f\xd8\x5e\x75\xc9\xc2\x27\xb2\x3b\x9b\x80\xf7\x67\x79\x6e\x81\xba\x9b\xed\xb9\x37\xf0\xdd\xad\xcf\xbd\xd9\xdf\x36\x9b\x8d\xd7\x99\x2d\x57\xc8\x13\x5d\x33\x18\x70\x45\x87\xdb\xf1\xc2\x61\x42\x7d\x12\x6d\x1c\x10\x3c\x81\x2a\x9c\xad\x3c\x5b\x46\xb0\xd9\x0a\xdd\xd7\xa9\xc1\x7f\xac\xcd\x0d\x96\xb9\xd2\x1f\xe0\xab\x2c\xc4\x3f\xb6\x3c\xbc\x98\x9a\xfe\xd9\xb9\xdf\x0e\x43\xb2\xd1\x29\x51\xb1\x4b\xe6\x08\xba\x62\x87\x3a\x2c\x63\x5f\x99\x25\x72\x68\xcf\x97\xe1\xa8\x11\x36\xa4\x9a\x20\xcb\xd0\xe9\x63\x2d\x1c\xb2\x63\x8a\x63\x91\x86\x27\x49\x71\x2c\xa1\xe8\x91\xe2\xb8\x13\xba\xe6\xc0\x27\xdf\x39\x1b\xfd\xd3\x50\xb1\x7a\x58\x9f\xdd\xd4\x61\xc5\x7e\xc2\x85\xfa\x9f\x20\x61\xa9\xdf\x48\x7e\x19\x09\x4b\xbd\x69\x7e\xae\x84\xa5\xde\x84\x75\x4a\x58\x6a\x84\xba\x8f\xec\x9a\xed\x70\x75\x4b\x67\x6a\x05\xd8\x3b\x9d\xa9\x0d\x62\x97\x74\xa6\xbe\x9b\xfe\x72\x8a\xaa\xc9\x78\x3a\x9d\x4c\x71\x27\x8f\x2e\xb1\xde\x32\x6c\x5f\xca\x7d\xc1\xf2\x6a\x17\xc0\x8b\x8f\x1f\x61\xde\xe0\xef\x71\x1c\x5b\x2b\x38\x5a\x30\xb8\x21\xd5\x77\xa3\xe1\x60\x6e\xad\x93\x07\x27\x44\x77\x0e\x4a\x2d\xbd\x37\x48\x6a\x59\xa0\x9f\xcb\x5a\xd2\xa1\xb3\x8a\x3c\x2c\x24\x9d\x64\xaa\xa4\x7b\x9c\xd7\xa2\x4d\xb8\xc9\xac\xea\x74\xac\x4b\x02\xae\xdc\x05\x96\xbe\xb4\x93\xb8\x2b\x79\x33\xf8\x39\xc3\xb5\x82\x90\x56\x51\x2c\x3b\x98\x3d\x23\x61\xce\xab\x63\xce\x4e\x3a\xd4\x31\xa5\xc2\xb3\x75\x80\xda\x91\x5c\xe7\x15\xb7\xd0\x29\x56\x16\x2d\x22\xb6\x8d\x08\x17\x83\xcc\x77\x29\x97\x76\x1d\xe8\x6f\xc8\xb7\x82\x21\x83\xb7\x5c\x3f\x31\xe1\x32\x7d\xdc\x22\xf4\x56\x48\x00\xf6\x9e\x6d\xb8\x56\x68\x80\xb0\x4c\x64\x1b\xbc\xc0\x52\xb2\x78\x40\x7d\xf1\xe6\x81\xbb\x86\xb1\x6e\xa8\x70\x2a\x17\x04\x2e\x8e\x3c\xe1\x36\x76\x61\x0e\x90\x98\x87\x1d\x36\x1d\xb8\x12\xbb\x71\xe3\x80\x29\x04\x72\xe9\xc6\x1f\x44\xba\xa2\xb2\x8e\x72\xa0\x9c\x7c\x85\x15\x8c\xdc\xbc\xc1\x5e\x53\xe1\x70\x63\x68\x21\x97\x9e\x8e\x35\x8d\x09\xd7\x0e\x8c\xb1\xba\x3d\xd6\x20\x33\xaa\x88\xcb\xee\x9e\xa9\x1f\xda\x0a\x71\x18\x74\x52\x1f\x07\x3f\xa4\xee\x04\x14\x5b\x88\xc1\x86\x95\xa2\x9a\xdb\x13\xae\xe8\x96\x28\xb8\x8e\x63\x12\xc9\x7e\xba\x84\x9d\x4a\xd4\x56\x50\x6e\x37\xa6\xfd\x48\x9e\x27\xd9\xdd\x48\x5e\x22\x8f\xe3\xdb\x08\x0e\x63\xbc\x3a\x71\x6b\x63\xba\x45\x39\x11\x95\x89\x48\x6c\x75\x31\x0b\xa4\x09\x55\x26\xc2\x8d\xb9\xe2\xe9\x5a\xfc\xc0\x9d\x38\x57\xb2\xcc\xf8\x6d\x10\xfd\x39\x13\xf0\x33\x66\x32\x26\xea\x93\xa5\x4a\x66\x1d\x79\x78\x02\xb0\x3d\x39\x2f\xb7\x7d\xcc\x57\x40\xcf\xde\xa6\xaf\x9d\xca\x02\xdc\x4d\x19\x6a\x27\xf2\xf4\x05\xf6\x16\x5b\x45\x23\x6d\xc8\xc0\xd7\xcc\xc7\xde\x94\xa1\x14\x20\x40\x38\xaf\x96\xca\xa3\xa1\xaf\x19\xfa\xba\x03\x3b\xe1\xe8\x5a\x50\x75\x8d\xb5\x2f\x1e\xb8\xab\xb1\x8a\x80\x98\x47\x59\x98\x0e\x50\x7a\x7e\x90\xbe\x29\x32\x9f\x72\xb2\xe7\x52\x2c\xa3\x78\xc3\xdf\x70\xef\xd6\xa6\x0a\xed\x47\xd8\xec\x13\x06\x10\x61\x16\x66\xe6\x72\xc1\x79\xd8\x55\x31\xdc\x3b\x41\x91\x89\x0a\x1d\xf6\x92\x01\xfe\x14\x3c\xfe\x8c\xb6\x5a\xb3\x9f\x10\xf5\xe1\x4c\xe6\x11\xcc\x45\xf1\x01\x22\xc6\x77\x79\x7f\x36\x56\x7a\x97\xe3\x35\x37\x18\x53\x5f\x91\xfa\x2d\x23\x51\x22\xa1\xb8\xaf\x24\xfa\x5a\x89\xde\x48\x10\x65\x95\x28\x85\xb1\x05\x35\x2a\xc4\xb1\x9b\x88\xc7\x7f\x27\xf8\x8d\x8d\xe7\x08\x3c\x35\xd0\x96\xb0\xed\x95\x7d\x19\x7c\xc8\xcd\x30\x14\x02\x6b\x35\xdf\x23\xf4\xde\x23\x60\x5d\xa4\xbd\x01\xb2\x6c\xe8\x88\xb0\xb1\x07\xa7\x1d\x28\x66\xe3\x3a\x6f\x38\x1d\x97\x52\x79\xd7\x70\x71\x41\x19\x49\x15\x86\xfd\xf7\xd4\x4f\x4c\x36\x48\x4d\x9c\xa3\xd3\xc2\x03\x47\x81\x7f\xe6\x63\xcf\x23\xee\x24\x8e\xcd\x7a\xe7\x5c\x37\x3a\xd8\x60\x10\x7f\xf1\x51\x82\x75\x80\x89\x00\xd9\x6a\x11\xbb\xc0\x48\x6a\x3f\x04\x30\x8b\x19\xc3\x87\x5a\x9b\x5d\xc0\xd1\x92\xdd\x92\x29\xd3\x4c\x1b\x86\x0f\xfe\x7f\x55\x8d\xa8\x6c\xd2\xfa\xd4\xe5\xcc\x64\xe1\x14\xc7\x48\x34\xc9\x82\xc1\xc5\x01\x8a\x58\xb0\x1c\x92\x0f\xe0\xab\x30\xde\xc2\x38\x47\xf3\x34\xd3\x3d\xb3\x65\x7b\xd1\xc2\x4b\x85\xa1\x5e\x50\x83\x07\x7a\x45\xed\x3f\x1a\x2d\x0d\x53\xf4\x1d\x67\xfd\x04\xca\x42\x01\xef\x44\x60\x13\x05\xa3\x4d\xe6\xd1\xba\x95\xcd\xc2\x9b\x01\xe1\x11\x6b\x95\x92\xaa\x05\x6e\x27\x48\xe5\xe6\xf4\xcd\xad\xfe\xb1\x4f\x2d\xf5\xd5\xa7\x0e\xfb\x85\x26\xf6\xdc\x68\x1f\xcd\xd0\xf6\x5e\xf2\x6d\xe0\x8d\xbe\xf4\xca\x66\x90\x26\xea\x01\xd6\x6e\xe8\xb8\x4d\xac\x4d\x84\xc6\x8d\x2d\xfe\x25\x5e\x5b\xa7\xff\xfa\x66\xf2\x38\x52\x1a\x73\x74\x80\x23\x64\xf6\x5a\xbb\xba\x13\x1e\x1b\x02\x92\x84\xf7\xee\xad\x1f\xf8\xa4\x0a\x66\xea\xc7\xb9\xec\x0d\x94\x25\x91\x4d\x06\x58\xe6\x2b\xa1\x7e\x61\xc6\x3c\x20\x17\x1b\xba\xdf\xa3\x08\x98\x53\x07\xff\x34\xde\x14\x1b\xf4\x5b\x3b\xc8\xcb\x52\x03\xa1\x9a\x09\xee\x38\x26\x1f\x37\x27\x0d\x7b\xde\x7f\x68\x5a\x00\x40\xc0\x3b\xb8\x70\xac\xd1\x40\x83\x4d\x27\x92\x7b\x22\x85\x6f\x0a\x77\x19\x16\xd8\xca\xb0\xeb\x3d\x9e\x13\x5c\x39\x81\x1b\xde\xa3\x0a\x58\xa0\x15\x7f\xa2\xb2\xe1\xf8\xa1\x4a\x31\xd3\xd6\x7f\x91\xd4\xaf\x00\x7b\x73\x7d\x90\x1e\x91\x17\x3f\xfe\xec\x92\x71\x2b\xc4\x49\xed\xda\x96\x7f\x33\xa0\x99\x0b\x61\x04\x19\xcf\xff\xc0\xc9\x5f\x4c\x52\xbd\x4b\x68\xd1\x20\x67\x65\x4b\xb2\x7a\xd2\x0f\x9c\x19\xf6\x7f\x5b\xde\x82\x7a\x0f\xb7\x24\xbe\xeb\x44\x5c\xc1\x9c\x3a\x07\x8b\x90\x27\x29\xd5\x92\x31\x90\xcc\x55\xba\x79\x27\xb2\xb9\x56\x7b\x68\x2d\xd7\xae\xd6\x29\xb6\x21\xcb\x42\xac\x69\x06\x4b\x85\x52\xf7\x64\xf5\x32\x6a\x8d\x0b\x9b\x7d\x49\x6d\xc9\xd1\x44\x10\x81\x5a\x61\x9b\xaa\x33\x39\x58\x50\xe3\x75\x13\x8c\x03\x67\x8c\xec\xf1\x68\xf6\x71\x5f\xe6\x77\x15\xee\xbb\x1b\x3b\xcb\xc7\x9f\x68\xeb\xa2\xd6\x01\x2a\xab\x9d\xd6\x55\x46\x4d\xda\x3d\x5c\x89\xac\xe7\x25\xf7\xee\x17\x0e\x99\xe1\x54\x9b\x7b\x25\xad\xf2\x5e\x8a\x56\x55\x21\x98\x67\x01\x69\xec\xcb\x88\x6d\x1d\xc0\x4a\x6a\xec\xc1\x60\xbd\xda\xfe\x89\x8a\xdb\x4d\x44\x52\x81\x39\x04\x81\x7a\x45\x2e\x31\x65\xdc\xf1\x80\x77\x24\xd6\x0b\x49\xdd\x0f\x68\xc0\x7c\xb8\x47\x1b\x61\x93\x56\x43\xa4\xa2\x50\x22\xb0\xb4\xc8\xb8\x0b\x3f\x47\x32\xcb\xc5\x00\xf7\xa1\x81\xec\xb4\xbf\x42\x2b\x28\x37\x5c\x23\x5e\xc3\x4c\x78\xdc\x6c\x69\x15\xcd\xed\xfd\xeb\x8e\xa2\x30\x14\x73\xb2\xce\x7a\xd9\x92\x1b\x9b\x8b\x39\x55\xe7\xc7\x6c\x28\xd2\x32\xf7\xdb\x7c\xc2\xea\xb2\x03\x52\x80\x12\x18\xd3\x40\xb7\xb4\x24\xdd\x4b\xb6\xf2\x4e\x90\x30\x5f\x50\x6f\x7b\xe6\xc7\xd3\xf7\xa1\xb8\xb6\xce\xba\xe6\x5a\xea\xfa\x24\xf2\x3e\x25\xbb\x12\x7f\x91\xc9\xfe\xf1\xc4\x26\xc5\xb0\x4f\xcf\xa6\xd5\x86\xb6\x06\xe8\xa8\x73\xd9\xe2\x54\xd2\x32\xa3\xaf\x80\x22\x6e\xe3\x21\x03\x77\xe4\x8f\xdc\x64\x97\x7f\x7c\x92\x4e\x27\x40\x18\x5f\x1a\xe0\x02\xb6\x10\x21\x77\x47\xaf\xd0\xa5\x79\x97\x1b\x47\xca\xd4\x3d\x4b\xdf\x93\x23\x3a\x85\xf1\x86\x8e\x16\x3c\xb3\x8f\x53\xd9\xaa\x73\x1d\x8e\xb1\xeb\xe6\xa1\xd3\x62\x5e\x56\x06\x60\x65\xff\x15\xb2\x17\x99\xec\xf0\x99\xd8\xba\xbf\x54\xe1\xb7\x10\x3c\x87\x15\x50\x94\xd0\x87\x8e\x32\x7e\x47\xdd\xe9\x9b\xe3\x7c\x91\xb8\xae\xca\xe5\x12\xc0\x16\x82\x94\x89\x95\xd5\x20\x79\xd3\x72\xb0\xc0\x24\x2e\x54\xee\xd8\x18\xc5\x9b\xff\xd2\x91\x30\x6d\xb1\x25\xe2\xd4\xeb\x7c\xeb\x87\x57\x6f\xdd\xef\x22\x79\x79\x69\x23\xec\x8e\xdb\xc8\xa9\xaa\x58\x1c\x91\xd0\x79\xfa\xf8\xf2\x4b\xe2\x1e\xde\x84\x43\x36\x2a\xd9\x93\xbb\xa1\x87\xb5\x8e\x6b\xd1\x23\xcd\x42\x8b\x8b\x97\xb8\x09\x55\xc5\xf4\xde\x24\xe9\x3d\x14\x46\x44\x8a\x5b\x06\x2e\x42\xa9\x37\x61\x71\xaf\xc4\x7e\x23\x2a\x90\x2a\x8b\xc9\x23\xa8\xab\x30\xc9\x56\x18\x8b\x2a\xbc\x53\xfa\x96\x34\x3f\xac\xd6\xfa\x21\x84\x8b\x9f\x7c\x34\xc1\xab\xf5\x61\xdf\x78\x91\x22\x52\xb2\x9d\x50\xf9\x2e\xba\x49\xe5\xbb\x23\x6f\xd2\xdb\x9b\x3d\xca\x24\x83\x5b\x4f\xde\x5e\x6a\xe1\x76\xa1\xcf\x26\x16\xa8\x01\x9d\x14\x1d\x26\xef\xb7\x21\xd6\x2a\x1b\x64\x2b\x34\x43\x92\x14\x50\x75\xa2\xbf\x20\xd5\xb5\xf0\xd7\xfd\xc4\xa5\x68\xdd\x8e\xf0\xb2\x1c\xc6\x86\x49\xc2\x26\xbd\xdb\x09\x06\x3e\xf8\x68\x92\x10\xa6\x75\xbf\x23\x5d\xea\x5d\x57\x7a\x52\x72\xd3\x7d\x77\xac\xec\xde\x6c\xb1\x66\x9b\x2e\x3e\x13\x67\x92\x5b\x54\xd8\x9c\xdd\x7a\xf2\xc8\x03\x9a\x8b\xcd\xb1\xd9\xa7\xcf\x01\x83\x4d\x21\xe6\x3c\xdc\x22\xbb\xe9\x18\x94\x87\x6b\x09\xb2\x9d\xa2\xf0\x65\xaa\x82\x01\xb0\x51\xb9\x6c\xa0\x0e\xba\x57\xb6\x42\x33\x4f\x57\x9a\x62\x51\xec\x99\x8e\xb0\xa2\x58\x86\x1f\xe0\xf5\x9f\x74\xd0\x16\x3a\x40\xf1\x0e\x0d\x8b\x79\xc3\xfd\xa3\x8c\xdf\xbd\x8d\xfd\x02\x7e\xbb\x7d\xbc\x85\x86\x87\x18\x4d\xca\x3f\xf8\xab\x3e\xe8\x17\x78\x3c\x15\xf0\x03\x00\x0b\x22\x15\x78\xa1\xc7\x69\xd3\xab\x88\xa5\x78\xe7\xe8\x35\x0e\x05\x5e\x86\xe1\x51\x63\x6a\xd2\xfa\x70\x4e\x03\x6c\x98\x85\x46\xa5\x36\x9c\xea\xe0\x13\xdc\x02\xac\xb8\xce\xd8\xca\x2d\xbb\xc6\x06\x78\x63\x85\x4b\x2a\x1c\xd4\x31\xdd\xb6\xbb\xd1\x05\xd7\xe1\x54\xdd\x93\xa9\x01\xee\xed\x06\xfb\x70\x21\xa6\xc4\x79\x45\x21\x14\x54\xe2\xda\xe6\x28\xae\x50\x8a\x86\x28\xbc\xad\x01\x48\xdd\xd0\x36\x8d\x3c\xd8\x9e\xe4\x6a\xd2\x03\x20\x87\xd3\xab\xe4\xf1\xaf\x40\x78\xa1\xfb\xba\xcd\x33\xac\x08\x0f\xc5\x03\x19\xe9\xdb\x08\x52\x7d\xd4\xc3\x4c\xac\x6d\xe7\xaf\x82\x19\xa3\xe2\xbc\x94\xcd\x45\x71\x82\xe8\x72\xdb\xe0\x45\x91\x48\x5c\xb2\xa2\x03\xc3\x04\xf6\xc8\x57\x7e\x0f\xba\xbc\xda\x1d\x1f\x79\xc4\x8f\xd9\x26\xb3\x6d\x38\xd5\xa6\x97\xad\xe0\xf9\xe0\xa4\x3e\x64\x4d\x65\x17\xf2\x29\xcc\xcd\x1b\xd8\xa7\x1b\xc5\xff\x0f\xae\x17\x15\x9a\x27\x76\x44\xca\x61\x76\x6d\x08\xf3\xb6\xc6\x52\xbd\xec\x89\xa5\xcd\x43\xa4\x67\xa9\x8f\x1b\x48\x23\x69\x70\x56\xeb\x11\x34\x36\xe1\xd6\xa0\xb0\x2a\x28\xaf\x2d\xaa\xc3\xcf\x2a\x41\x1f\x39\x20\xd7\x19\x9a\x97\xe2\x80\x85\x81\x3e\xfb\x8b\x52\xc0\xed\x25\x05\xb8\xbc\x92\x6e\x36\x94\x7b\x0f\x59\x2e\x60\xe7\xff\x5b\xec\xa5\xbc\xca\x92\x7b\xf4\xdf\x67\xf3\xb9\x48\x12\xb2\x9a\xb6\x71\x26\xd7\x7d\xd5\x4d\xd4\xf4\x09\x2a\x7b\xf5\x3d\x6a\x57\x6b\x1f\x57\x19\xda\xdb\x10\x0f\x08\xd7\x18\xaf\x1c\x6e\x27\xfa\x41\xa0\xb4\xf2\xae\x20\x35\x5b\x00\x7a\x48\x38\x26\xc3\x63\xfd\x56\x36\xd3\xc9\x48\x8c\x81\xfc\x24\xd8\x2c\x82\x1f\x30\x11\x3f\x4e\x13\xbb\x39\x23\x86\xa7\x61\x7f\xa3\x2a\x80\xcd\xf2\x09\xe6\x26\x8f\xc7\x18\xc0\x07\xd0\xe6\x12\xb8\x1c\x89\x92\x99\x83\x03\x4d\x58\x8d\x12\x89\xd5\x18\x51\x21\x1b\x6f\x80\xb7\x3e\x5b\xac\xdd\x39\x39\x8e\xe9\xe7\x95\xbb\xa1\xfe\x94\x08\xb1\x33\xbd\x25\x45\x8e\x0f\xf3\x45\x44\xe1\x01\xf8\x23\xb9\x8c\x69\x59\xde\xa1\xee\x25\x8d\x75\x2d\xc4\x62\x5e\x76\x3f\x47\xaf\x9e\x48\x0a\xc2\xd9\xce\xb9\x8b\xb8\x89\x27\xe5\x25\x8f\xf6\x1b\x75\x65\x4e\x44\x9a\x52\x30\x11\x96\x1e\x83\xa7\x1a\x08\xd2\x0c\xa9\x5d\xea\x9e\xd0\xcd\x95\x59\x29\xe5\xb8\x0f\x79\x6d\x6c\x23\xf1\x59\x1a\xe3\x22\x3a\xb2\xae\x7d\xaa\xce\xb7\x7a\xbc\xb7\x0d\xfd\x5f\xdb\xe9\x17\x7d\x5a\xbf\xb6\x13\x23\xd5\x22\x8c\x30\xa1\xbf\xe4\xb8\x70\xc1\x56\xe6\xa0\x3f\xb3\xd1\x9e\x22\xf5\xa4\x32\x06\x65\xd7\x6c\xe0\xfa\x36\xcc\xdd\x03\xd1\xfb\x27\x8a\xe3\xe2\xe1\xa5\xdf\xe3\x1f\xbb\x10\x36\xaf\x83\xb4\x0d\x49\xba\xaf\xfc\x3b\x99\xda\xd4\x91\x00\x3a\x97\x2b\xaf\x75\xc4\xc5\x5d\x9b\x6b\xd7\xd6\xce\xfb\xbb\x85\x86\x0e\x3d\xda\x3b\x36\x66\x37\xd6\x76\xc7\xc6\xec\x5d\xbb\xb0\x1b\xc4\x96\x55\xd9\x7e\x9d\xd3\xcd\xed\x97\xeb\xb8\x9e\x30\xd4\x5c\x2d\xcf\xb5\x2d\xa8\x5f\xc7\xf3\x0a\xad\x32\xd1\x04\x00\xec\x22\x2d\xac\x1a\xb2\x01\x78\x9b\xe5\x6e\xa5\xb2\x70\xd6\xd4\xac\xc3\xfd\xae\xc1\xe2\xf9\x5f\x35\xbf\x3d\x55\x2b\x7d\x63\x03\xd7\x2a\x11\x55\x4a\x9e\xab\x73\x7e\x85\x39\xa8\x2e\xe5\xd4\x7c\x2d\x36\xc6\x89\xd4\xc0\xc0\x13\xf9\xd5\x8e\xdc\x61\x8d\xab\x9e\x33\x39\x2d\xea\xec\x6a\xe3\x65\x89\xa8\x6d\x39\x43\x55\xaf\x6d\x27\xf5\x4e\x87\x32\xaa\x0f\x6e\x9c\xa2\x29\xa9\x0c\x77\xab\x5d\x46\x0b\xb5\xf6\xb4\xdb\x93\x42\xa1\x8f\x40\x23\x38\xb3\x84\xe9\x89\x14\x8b\xda\x4d\x58\xb7\x5f\xb7\x95\xd4\x96\xed\xd4\xba\x11\xb7\x5c\x55\x1c\xf7\xa9\xfa\xad\x58\xbd\x0e\x4f\x2d\x91\x4c\x6f\x84\x11\x4b\x2e\xef\xc7\x22\xd0\x66\xad\x4f\x2f\xa1\x88\x63\xda\x77\xdc\x63\x80\xc6\x10\xca\xef\xda\x30\xaa\x24\x2b\xe7\x01\xa3\x31\x63\x8c\xcb\xe1\xec\x3b\x8e\x0f\xc5\xc0\x32\x77\xe1\xda\xe3\xaf\x66\xec\x37\x88\xc5\xfc\xde\x25\x9b\x16\xe5\x74\x10\x5c\x10\x57\x01\xde\xee\xe1\xa8\x7d\xfc\x0b\x1c\xb7\x01\x9d\xb3\x64\x35\x6c\xa7\x67\x90\x2f\x19\x3f\xc4\x46\x91\x0e\x05\xcb\xc8\x8c\xb9\x01\x39\xa9\x30\x6c\x6c\x15\x25\x42\xc7\x22\xbe\x3f\x1a\x5d\xa8\x3c\xc7\x99\x63\xd4\x2c\x71\x54\xcd\x12\x12\x0f\xb7\x18\xed\x69\xf6\xaa\xe9\x59\x1b\x45\x5e\x6a\x2f\x5a\x62\x99\x8d\x18\xe6\x46\xaf\xae\x04\xa7\xc2\x97\x41\x93\x62\x2f\x0a\xe8\x4f\xf3\x7b\x7b\xb0\xed\xbc\x02\x1f\xde\x82\x6f\x7d\x60\xbc\x67\x33\xef\x64\x70\x97\x5e\x9a\x31\xfb\x1b\xf6\x4e\xbe\x12\x07\x8b\x03\x4c\x74\xd3\x3f\x7d\x86\x0c\x7f\xeb\xa7\x54\x23\x9b\x7f\x7e\xd9\x16\x3e\xfb\x9d\xbb\x76\x73\x08\x07\xf0\xd8\xcb\x02\x18\xf2\x86\xba\xa0\x1b\xc1\x59\x75\x8f\x3f\xa4\xee\x62\x7b\xd8\xff\x75\xfd\xeb\x83\x5f\x1f\x7c\xfe\x92\xe6\xf4\xa5\xfa\x00\x20\x3f\xe3\x98\x67\x58\xbe\xf8\x7c\x3a\xf4\x0d\x9f\x4b\xe2\xa0\xd1\x7d\xa0\xd3\x17\x5e\x4a\x1f\xfa\x4b\x24\xe7\x65\x98\x05\x41\xcf\x6a\x59\xcc\x51\xd5\xd1\x89\x02\x27\xe7\x41\x46\xc1\xfe\xb4\x26\x65\xed\xa2\x41\x21\x70\x2e\xef\x4e\xb5\x04\xdc\x3e\xf6\xe1\xc4\x86\xea\xb6\x75\x78\xe4\xde\x8a\xb9\x80\xc9\xc6\xbe\x54\x09\x76\x2f\x45\xfb\xb1\x9b\xa8\x78\x42\x40\xc8\x69\x51\x20\xa7\x92\x08\x56\xb5\x9f\x66\xde\xa0\xa4\x95\x73\xa4\x97\x91\x6b\x81\xe1\xdf\xb8\x2d\x12\x67\x2d\xb0\x50\x54\xed\xf8\xb8\xc2\xc1\xac\x17\x4f\x8e\xdd\xe4\xfe\x36\x72\x63\xef\x50\xdf\xc5\x2c\xef\x5f\xb8\x21\x12\xc9\x8a\x56\x4c\x1d\xad\xa2\xc4\x78\xab\x1e\x3c\x45\x1d\x4a\x87\x45\x2c\x64\xbc\x10\x29\x03\x16\x34\xc7\x32\x94\x10\x6d\x5b\x28\x7f\x8c\xb3\x1d\xd3\x33\x80\xa5\xb6\xd1\x9b\xa8\xf8\x2c\xda\x17\x42\x43\xb1\xb0\xe1\xa6\x54\xbd\x76\x3f\xda\x4c\xe5\xc5\xf5\x75\xa5\x69\x0c\x8d\xf1\x23\x26\x78\xa9\xce\xb5\x80\x6b\xe2\x8c\x01\x4d\x32\xa5\x05\x18\xdd\xe9\xbb\x00\x43\x83\x41\x0b\xac\xce\x9e\x9b\xc2\x98\xbb\x5e\x6c\x3b\x22\x6f\xf4\xe0\x98\x88\x7b\x3a\x71\x2a\x88\x5a\xac\xbf\x05\xe6\xf5\xb0\xf8\x56\xf0\xd8\x8b\x80\x16\x27\xbb\x7c\xe3\x69\x03\x6f\xde\x46\xba\xaf\x4d\xe3\xaa\xd1\x86\xa0\xc1\x0f\x65\x02\xee\xb6\x4b\xcd\x2b\x09\x87\x2e\xe7\x39\x0e\x21\x1c\xed\xfe\x22\x94\x8d\x09\xf3\xe7\x38\xc6\x31\x08\x9a\x4b\xf5\x15\xb8\xc8\xa0\xf5\xda\xab\xdc\x51\x28\xc1\xd0\x45\x6c\x1c\x40\x51\x79\x00\x63\xcd\x22\xcc\x24\xa6\x7c\x5b\xfe\xd2\x2a\xfd\xe4\xd8\x1a\xbc\xc2\x26\xa3\x1a\xd3\xb4\x14\x30\x72\x81\x73\xdf\x38\x47\xf6\x8d\x7b\xe5\x1f\x88\x03\x60\x4e\x94\x08\x76\x8f\x61\x5e\x13\x6b\x40\xab\x95\xa0\x40\x24\xf6\x2e\x58\x93\xaa\x15\x11\xb9\x3f\x1c\xa5\x41\xe2\xdc\x67\x8f\x7f\x89\xef\x5c\xe0\x3f\xa8\x19\x28\x72\xe7\x7e\xcc\x69\xc7\xe8\x26\x0b\x23\x4e\xeb\x08\xd9\x33\x16\xb8\x7c\x23\x40\x05\x36\x0a\x95\x43\xcd\xe2\x35\x57\xc3\x69\x4a\x09\x34\x79\x63\xf5\x5a\xe7\x80\xec\x1e\xb7\xc2\x0a\xe8\xe0\x74\x93\x30\xe7\xb8\xfb\x31\xb6\xbc\x49\x77\x97\x4f\xb1\xea\x4e\x39\xd6\x22\x69\x83\x9c\x74\x75\xb2\x33\xe1\xa2\x8f\x9b\x9d\x30\x3c\x9f\xb7\x46\xb2\x56\x7c\x52\x8f\x8d\x1e\xf3\x76\x1e\x1b\x73\x0c\xfb\xf1\xda\x68\x82\x76\xb6\x05\x95\x68\xb3\x39\x69\xb6\x61\xd6\x27\x30\xe0\x95\x56\x0b\x1f\x69\x9f\xcc\x70\xa7\x39\xb1\x83\xbd\xab\x34\xa2\xfd\xd8\xb2\x34\x61\x3b\xfa\xa3\xca\xec\xde\xd1\x27\xa5\xc9\xd2\x7e\xa2\x29\xfe\xd1\x83\x02\xe5\x94\x32\xde\xeb\x88\x89\xee\x33\xbd\xf1\xe8\xb7\x9a\xb1\xec\xcf\xe7\x34\xd3\xf2\x9f\x82\x93\xf6\xec\x77\x32\x08\xee\xe2\x77\xea\x46\xe3\x8e\x8e\xa7\x8e\x94\xee\xe0\x75\x2a\x89\xc0\x3d\x7b\x9e\x2a\x94\x3e\x9b\x65\xb5\x34\xae\x4f\xef\xe2\xc9\x59\x61\x77\x0f\xec\x28\x7c\xec\xde\x80\xad\xa6\x4c\xcd\x01\x5b\x6b\x8b\x81\xec\xf9\xf7\xec\x30\xdc\x65\x6e\x0c\x9a\x8b\xa8\x2c\x53\x63\xe2\xdd\x72\x0e\xea\x8c\xd8\x3b\x8d\xc1\x62\xdc\xee\x4d\x5f\x32\x8f\x7d\x2a\xee\x72\x68\xac\x54\xe3\x6b\xab\xdc\x91\xcf\x10\x93\xec\xef\xd6\x63\xe5\xa2\x2a\x18\x38\x86\xbd\x02\x65\x94\x96\x36\x02\x9a\x69\x0b\x16\xe4\x27\x61\x9e\x6b\x8e\x51\xd8\x08\xc8\x28\xc7\x51\x9c\xc1\xdc\xc8\xe7\xd9\x4c\x22\x45\x82\xa8\x14\x9d\x12\x20\x86\xfa\xa4\x8b\x87\x44\x6c\x80\x57\x01\xcc\xbd\x88\x44\x0a\x73\xe9\x10\x35\x14\x15\x89\xac\x01\xcd\x3d\x46\xa1\xb9\x6a\x0e\xa2\x03\xc1\x26\xb5\x15\x12\x0d\x8e\xda\xee\xb7\x92\x96\xbc\xee\x3c\x72\x2b\x9a\x77\x9d\x54\xbe\xb3\xcb\xf8\x73\x0d\xa3\x19\x17\x96\xe9\xe7\xa0\x6a\x61\xba\x33\x3a\x60\xc3\x37\xf3\x84\x4f\x7c\xb1\xe9\x3a\x29\xd1\x51\x08\x64\x9e\xbc\x80\xc6\x0b\x2e\xfb\x40\xf1\xed\xa4\x76\x73\x1d\xec\x6e\xcb\x23\x4b\x64\x66\x9e\xe5\xbe\xa2\xe8\x23\x28\x77\x22\x26\x8f\x52\x3b\x85\x68\xf7\xc7\x30\x43\xd5\x1e\xd6\x01\x34\x64\x55\xe0\x9e\x0a\xf7\xa8\xb2\x1b\x0b\x26\xf4\xc8\x28\x9f\x25\xfc\xb6\x7c\xa9\xcf\x08\xd8\xba\xe5\x62\x5d\x49\x11\x3f\xfe\x0c\xda\xc8\x5c\xc6\xab\xa3\x91\x01\xcd\x2c\x52\x74\x01\x42\x11\x2e\xd0\x64\xc0\x4b\x6d\x53\x89\xe7\x0f\x2a\x80\x9a\xc6\x2b\x43\x51\x71\x24\x58\x56\x0b\xd7\xec\x8f\x98\xe3\xef\x86\x35\x37\xa1\xca\xa9\xdc\xfd\x24\xcc\x47\x3d\xd7\x5a\x97\x1c\x82\xac\xbe\x55\xc2\xcb\xc1\xfa\x4d\x2a\x41\x9f\xd3\xb2\x3c\x56\x9c\xb5\x20\x90\xb5\xf7\x60\xe0\xd6\x11\xde\x19\x12\xcb\x18\x6e\xdb\x75\x3a\x1f\xae\x3c\x79\xb4\x64\xc8\x0d\x67\x35\x25\xc7\x2a\xe8\x89\x0b\xd6\x0c\x0d\x93\x03\x6d\xb7\xf1\x9d\x38\x80\xab\x7a\x87\x0b\xe2\x5e\xb9\xb1\xbf\x1b\x66\x0d\x4b\x6a\x16\x62\x1b\x6f\x9e\x82\x2f\x41\x1d\x21\x5e\x7b\x32\xe4\x13\xf0\x06\xa5\xbc\x4c\x77\x65\x27\xe9\xdf\x25\x2f\x7b\x8c\x28\x89\x28\x51\x96\xe6\x55\x9d\x17\x0a\x44\x4f\xcc\xac\xe9\xee\x01\xbf\xa1\xcc\xb6\x92\x82\x05\x31\x9d\xd9\xec\x9d\xa9\x76\x69\x13\x7c\x2f\x15\x06\x81\x94\xd0\x5b\xd1\x7e\x90\x15\xe3\xd8\xaf\xfd\xe5\xdf\xff\xc3\xd9\xc0\xf9\xe2\xf3\x2f\x7f\x83\xff\xbc\xb5\x59\xb0\x4f\xf3\x4a\x6f\x5c\xff\xed\xd5\xea\xc0\x11\xdf\xd5\xbc\x6f\x43\x0b\x8b\x6e\xe3\x70\xdf\x31\xce\xa7\x48\xe1\x20\xd3\x45\x26\x6c\x25\x59\xf2\xd2\x26\x98\x5b\x45\x29\x49\xd2\x0c\x6a\x41\x14\xc9\x4c\xfd\x20\x8a\x31\xb1\x34\xca\xd2\x95\xb5\x81\xf2\x39\xa7\x72\x52\x96\x01\xda\x96\xa9\xdd\x4f\x23\x5c\x6e\xfb\x43\x6e\x3f\xea\x03\xa4\x6a\x0d\xd9\x11\xa8\x42\x32\x46\xad\x1f\x7e\xd7\x36\x41\x91\xf2\x2c\x28\xdf\x22\x55\x94\x90\x59\x69\x32\xf9\x04\x5b\x96\x2a\xe7\x04\xa9\x39\xab\x58\xac\xfd\x08\xd8\x49\xf9\x3a\x09\x57\x93\x69\x4c\x64\xa3\xb1\xe7\x4e\x05\x23\xd7\x88\x0a\x1e\x72\x1e\x1b\x55\xf9\xf3\xb9\x22\x00\x3b\x2c\xf0\x7e\x19\xae\x1f\x7f\x46\xa1\xaa\xd2\x76\xdc\x90\xd3\x8e\x84\xf4\x19\x37\xe5\xc0\xc9\xe1\x71\x7f\x1d\x99\x92\xe1\xde\x61\x2e\x14\x82\xb2\xab\x66\xe7\x18\xb7\x00\xc2\x49\x12\xca\xa9\x16\xc9\x2a\x7b\xfc\x8b\xa2\x09\x7f\x52\x24\xd9\x70\xcf\x3f\x88\x78\xe8\x2f\x29\x5d\x26\xd2\x89\x8f\xbc\x11\x50\xfb\x7a\xed\x19\x8f\x0c\x51\x8c\xd9\xf6\x43\x01\x96\x4c\x69\x5a\xbb\x4e\x9e\x8f\xa5\x37\x88\x0d\xae\x8d\x44\x0a\x32\x20\x3c\x98\xf2\xd5\x1a\xa1\x80\x61\x2b\xb8\x29\xd5\x8b\xf9\xed\xaf\x29\x42\x81\xad\xe6\x3c\x70\xa3\x42\xb4\x7d\xb4\x6c\x15\x57\x63\x82\x45\x0d\xaf\x44\xfc\x4a\x03\x86\xe4\xb0\x19\x20\xfc\x6e\x79\x9b\x4b\xdc\x39\x6e\x8a\x69\xcc\x20\xa2\x5d\x3f\x10\x9e\xaa\xd4\x81\xa5\x31\xb0\x70\xf8\x15\xd7\x6d\xa3\x98\x16\xaa\x52\x34\xd0\x85\xc2\x12\x5a\x66\xee\x1a\xde\xe3\xb0\x2a\xdc\x25\x28\x5b\x17\xfe\x5a\x10\x67\x6d\x52\xfe\x1d\x28\xe6\x58\x01\x0e\x64\x8d\xf4\x71\x87\xba\x6a\x15\xa5\x50\x97\xa9\x28\xa7\x22\xab\xd2\x56\x03\xa3\xb6\x95\xf2\xe4\xa1\xf0\x5c\x45\xa1\x8f\x24\x01\x3c\x8f\x2a\x63\xe1\x14\x16\x22\xfe\x6c\x47\x86\xe4\x8a\xae\xc5\x24\x8b\x90\xbc\x04\x65\x0d\x4b\x41\x26\xd9\x12\xd6\x81\x48\xf2\xe0\x2c\xca\x53\x73\x96\x02\x24\xa7\x6b\x8d\x78\x38\x45\xaf\xda\xd2\x55\xd7\x1b\xac\x12\x99\xab\xd1\x26\x22\xb2\x06\x32\x0f\x3c\xd7\x8c\xe5\x22\x77\x24\xea\x59\x12\x53\xc4\x85\xcc\xa8\xe3\xbe\x4f\x15\x44\x2c\x03\xca\x96\xab\x42\x81\x26\x64\x9d\x80\x69\x47\xf1\xc5\x95\x88\x2c\x34\xbf\x8f\x02\x4c\xc0\xaf\xab\xa6\x84\x16\x23\xac\xba\xac\xac\xc2\xbe\xa5\xfe\xf2\xf8\xfc\xfd\xc9\x74\x72\x7e\x36\x3e\xbf\x74\xde\x8f\xa6\x27\xa3\xaf\x4e\xc7\x0e\x35\xdb\xb0\x05\x13\xbd\x9d\x5e\x5d\x4c\x66\xce\xf1\x38\x7f\xfe\x18\xdb\xd9\x5c\x4e\xa6\xe7\x93\xee\x48\x66\xb6\x4d\xa1\x1f\x30\xc0\x5a\x36\x48\x5e\x32\xdf\x02\x6b\xfc\xbb\x31\x3c\x30\x39\xb4\xa5\xe4\x35\xd5\xdc\x4f\x74\x59\x79\xef\x16\x6b\xde\x2f\xa2\xc0\x6b\x7f\x6e\x4e\x75\xf8\x63\x77\x79\xb3\xb8\xbd\x7e\x71\xf8\x9b\xfa\x1a\xfb\xe5\x77\xfe\xf5\x35\x56\xab\x21\x85\xe7\x75\xba\x5c\xbd\x56\xfe\xb0\x1b\x58\x52\x77\xfe\xc2\x5a\x5a\xbf\x08\x27\x75\xae\x5f\x60\xe9\xe8\x41\x74\x87\x35\xac\x16\xc9\xf5\x8b\x56\xbe\xfc\x67\x1d\x77\xfb\x74\x9f\xfa\x61\xf6\xfd\xeb\x33\x77\xce\x1f\x0d\x24\x85\x46\x64\xd4\x95\xad\x30\xc8\x15\xd6\xdf\x49\xb0\x80\x6b\x42\x0d\x15\x40\x71\xf2\xa8\x46\x80\xd1\x43\xe2\x0f\x00\x22\x7a\x48\x1c\x55\x9b\x0f\x90\x89\x3e\x78\xae\x5f\xfc\x78\x7d\x5d\x44\x75\x8d\xc8\xae\x4d\x74\xf0\xe1\xa3\x6e\xb7\xa1\x30\x5e\x44\x0f\x22\x9e\xdd\x8b\x20\xe8\x39\xae\x4e\xe8\x70\x7c\x69\x61\x46\x1a\x80\x76\x99\xdd\x2e\x0b\xf4\x49\x67\x0a\x54\xfa\x50\x98\x65\x60\x49\x93\x92\xdc\xfc\x3f\x53\x56\x37\x65\xbb\xec\x2d\x2e\xf1\xa2\xb1\x7b\xb7\xfa\xcf\xc4\x0f\xd6\xa0\x00\xdb\xc5\x49\xf7\x8d\xd5\x19\x89\x9c\x33\x89\xe7\x9a\x30\xf5\x99\x9e\x3e\xa3\x29\xe3\x51\x23\xea\x0d\xab\x9b\xd0\xdc\x06\xb6\x16\xa4\x4e\xbf\x13\xe4\xe9\xa6\xbb\xdf\xee\xfc\x3f\xf3\xbe\xc7\x79\xaf\xdf\xe5\x7c\xd7\xd0\x6d\x71\xd8\xb0\xa0\x4d\xb8\x32\x8a\x5e\x55\x87\x40\x25\x3f\xb1\x06\x4c\xbe\xcb\xdd\x1c\x64\x72\xe0\xc2\xcf\x12\x70\xc9\x2a\xab\xc3\xe5\xa9\x07\x09\x42\x46\x3c\xae\xc5\xe1\x24\xa9\x7c\x77\x79\x79\x81\x57\x8a\xef\x37\xaa\x3c\x3c\x56\x3e\x57\x34\xb6\x52\xa5\x7c\x1a\x20\x5f\xd9\xd1\xa1\xcc\xf4\x1e\x5d\xf2\x09\x30\xd2\xcc\x68\xd8\x36\x58\xa4\x94\xad\x34\x80\xb4\x91\xcc\xed\xbd\x8d\xef\xf6\xe9\x6b\x2c\x52\xb3\x27\x57\x63\x1d\x85\x4f\xe7\x68\xac\x1b\x42\x1f\x3f\xa3\x95\xda\x2d\x1c\x8d\x92\x16\x60\x91\xec\x01\xc9\x46\xb6\x56\xcc\x78\x73\x2e\xd8\x36\xf9\xb5\x26\x1c\xfd\xfc\x8b\xef\xb6\xf3\x2e\x4a\x5c\x45\xe7\xa2\x61\x3e\x6a\xf7\x2b\x16\xb8\x6b\xf3\x26\x4a\x23\x92\xb2\x1f\x3d\xfe\xd4\xc7\xbf\x68\xd0\xf8\x94\xee\xc5\x77\x7b\x74\x2e\xa2\xad\x1a\x06\x57\xf1\x31\x06\x4d\x43\x7c\x2e\x8f\xe2\xbb\x5a\xd7\x89\x27\x6a\x7d\x27\x7b\xf5\x26\x96\x87\xb9\xab\x33\x71\xbb\x91\x3e\x9d\x2b\xf1\x29\x87\xbf\xa3\x27\x71\x8f\xac\xd8\x9b\xaf\xac\x86\x1f\xcf\xeb\x46\xb4\x30\xe5\x69\x9c\x88\x75\x64\x35\xb3\xa5\x9f\x07\xf1\xdd\x8e\xfe\x43\x2b\xda\x2e\xee\xc3\x0e\xc8\xbb\x3a\x0f\xc7\xe1\x3a\xcf\x18\x06\x8e\xbd\x77\xa5\x8b\xde\x79\x70\x13\x59\x5a\x35\xb5\xd1\x71\xea\xe6\xef\x92\xeb\x24\x8d\x62\xae\x05\x9e\x83\x09\x95\x4d\x1b\x75\x4d\x78\x70\xee\x5b\xad\xd2\x64\x09\x97\xcb\xb3\x36\xd6\x1b\xf9\xf3\xf6\xea\xe4\xf8\xe5\xa1\xad\xac\x96\x04\xc1\xab\x0b\x3b\x47\xb4\xad\x13\xc5\x2c\x05\xb6\x81\x30\x3a\xb2\xb9\x11\x00\x69\xbf\x6d\x24\x70\x1d\x55\xad\xcb\x36\x81\x9e\xab\x7c\xf8\xbc\xa6\x98\x1f\x88\xf6\x51\x56\x4a\xb5\xf2\x25\x4f\x56\x12\x6b\x1e\x8e\xc6\x29\x87\xd3\xde\x7c\xb3\x84\xd6\xcc\xc0\x35\x5f\xee\x82\x33\x95\xd5\x69\x5b\x2b\xb2\xdb\x87\x0a\x20\xda\xea\xad\x97\x90\x36\x56\xc1\xad\x19\x5c\x76\x6b\x75\xe2\x96\x21\xd7\x44\x80\x1e\x74\xa8\xe7\x5e\x1d\x9d\xad\xae\x41\x7b\x2d\x77\x86\xe5\xd5\xe6\xd7\xf0\x62\xef\x43\x50\xde\x81\xb2\x31\xcb\xa6\x06\x70\x17\xe2\xea\x73\x6d\xba\x14\x50\xae\x25\xd0\x92\x6a\xd3\xa1\x6c\xb2\xa4\xcb\x1a\xcc\xd1\x98\x4e\x06\xb7\x57\x2f\x43\x79\x46\xa9\x93\x8a\xb0\xd2\xd5\xa3\x4e\x38\x6f\x47\x0b\x9f\x0c\x4f\x43\x91\x71\x5c\x34\x12\xa7\x5b\xa1\x90\xc8\xc8\x37\xbd\xdd\x7b\xa4\x88\x58\xb3\x9f\xcd\x14\x1a\x85\xd7\x3b\x61\x65\x63\xc8\x76\x68\xb5\xc1\xa3\x2b\x5a\x61\x3b\xa2\xdb\x70\xee\x34\xff\x56\xac\x8d\xd3\xdf\x1d\x77\xc7\x99\xbe\xe3\x9e\xb8\x86\xdf\x1b\x6f\x03\xbd\x76\xe8\x6d\x96\xa8\x36\x97\x7c\x00\x27\x4b\x34\x3d\x6a\xb7\x75\xd2\x79\x7f\x56\x89\xe1\x2c\xe2\xee\x27\x96\xa4\x45\x25\x01\x57\xa8\xe8\x4c\xc2\x1e\x24\x97\xa2\x65\x77\xb9\xa5\x88\x6a\xe9\x41\x51\x83\xb9\xad\xab\x44\x11\x7e\x59\x11\xcb\xe5\x7d\x97\x64\x82\xca\x82\x68\x52\xc8\x6c\xa0\x77\xa0\x72\xbf\x84\x75\xa3\xa5\x2e\xe5\xa8\xff\x6a\xb5\x15\xb0\xea\x48\x4b\x14\x3f\xb8\x31\x91\x83\x62\xa0\x5d\x9b\x8c\x85\x0c\x7e\xc2\x33\x3f\x13\x71\x9b\x06\xb9\xe0\x52\xb7\x14\x32\x38\x8f\x3c\xbb\xbe\xda\x15\x08\x16\x0a\xb6\x85\x34\x68\x2a\xa3\xdb\x54\x84\xa2\xd2\x21\x02\x85\x1c\xc0\xb0\x45\x39\x14\x70\x19\x06\x3e\x0c\x58\x59\x52\xfb\x9d\xae\x78\x29\x1c\x25\xc1\x10\x29\x1d\x41\xa8\xcd\x7e\xdd\xf8\xa5\xda\x4a\x52\x23\x6c\x0e\xba\xe3\xd8\x18\x98\xd5\x37\xa0\x14\x73\x33\xfc\x1e\x7c\xa0\x5e\xd7\x25\x07\x8f\x8c\x08\xaa\x85\xdc\x81\x46\x6a\x1d\x81\xfc\xdd\x7e\x3a\xb4\xaa\xde\x05\x1f\xbe\xcb\xbc\x58\x7f\xf9\x9a\xd6\x41\xe7\x09\x29\xa1\xc5\x81\xe7\x30\x3a\xa0\x46\x2b\x3c\x96\x24\xe2\x14\xcd\xc6\x85\x5c\xc1\x0d\x6a\xd6\xfc\xf1\xaf\x9e\xbf\xb0\x65\x64\xa2\x99\x3e\x0a\xb0\x44\x53\x47\x6a\xe4\x84\xa9\x48\x2b\xe6\x09\xc6\x3f\x75\x27\xca\x8c\x9d\x52\xf0\xf4\x82\x30\x42\xa9\xba\x11\xc4\x95\x9d\xb8\x85\x93\xe0\x06\x43\x3a\xa5\xac\xf9\x32\xd1\x04\x9d\x8a\x86\x60\x71\x27\x44\x31\xbd\x38\x52\x56\xa7\xf6\x51\x72\xf0\xa6\x6e\x7a\xab\xad\x44\x00\xa4\x79\x40\xb0\xcd\x93\x7b\x97\x74\xab\xdf\xcd\x26\xe7\xdd\xae\x64\xf2\xee\x43\xac\xa4\xb7\x1a\x10\x60\xcb\x93\x5c\x1e\x52\x27\x3c\x62\x54\xab\xad\x82\x1a\x9e\x04\x54\xe7\x4c\x7c\x4f\x2b\x07\x25\x59\xe3\x60\x14\xae\x4e\x1d\x56\x4a\x98\x0a\xf6\x02\xeb\xf5\xae\x09\x3b\x68\x92\x49\x57\x3e\xba\xa1\x9c\xac\x36\xf6\x29\xa0\xb2\xc0\x58\x67\xb8\x54\x86\x4f\x95\x0d\x6b\x44\x20\x62\x94\x14\x3d\x4c\x38\xb0\x04\x74\xb6\x52\x27\x43\x0e\x5c\xc0\x94\xf5\x0a\x43\x42\x70\x4e\xa8\xb5\x2d\x75\x24\x25\xe1\xfb\x72\xc7\x8d\x53\x87\x61\x7f\x20\x73\x91\x83\xfb\x4a\xc4\xed\x8b\x97\x5f\xc6\x20\x49\x1d\xad\xa9\x1c\xbc\xcd\x2b\x18\x23\x6c\xaa\x26\xaf\xee\x4a\x52\x20\x44\x83\xe9\xab\x9b\x8a\xa4\x68\x50\x37\xcb\x4e\x38\xcd\xbb\x64\x1f\xe0\xc4\xd7\x4e\x18\x34\x78\xc7\x56\xdd\xb0\x01\x43\xe7\x99\xab\x0c\xa6\xd7\xe4\xdd\xc1\x6b\xf7\x74\x7c\xe6\x95\x0d\xba\xa8\x98\x61\xb4\x96\xfb\x09\xcb\x39\x06\xfc\x7a\x1b\xb2\xd0\x5d\xee\xc1\xa6\x45\x25\x37\x23\xdd\x95\x70\x6f\x66\x2d\x29\x4c\x48\x6d\xea\x30\xc5\x52\x90\x70\xd3\xe5\xb6\x09\xd6\x90\xb5\x96\x82\x0a\x4a\x71\xa2\x77\xda\xfc\x58\xe4\x2f\x58\xeb\x02\x1e\x3d\x36\x20\xbf\x29\xd7\x50\x96\xba\x9d\xf7\x5c\x1a\xfb\x82\x30\xc2\x9a\x9b\x7f\xd8\xea\xd6\x50\x06\xb2\xab\x08\x4c\xdc\xb5\x29\x8b\x76\x84\x46\x11\xb6\x7b\x58\xb0\xc5\xf6\xfe\x7b\x5b\xaf\x9a\x3c\xce\xa1\xba\xa1\x90\xff\x9b\x74\xb3\x12\x9d\xcc\x5b\x06\x55\x55\x00\xad\xf6\x2d\x36\xc2\x97\x6e\x61\x9d\x7a\xe7\xe5\x9a\x19\xe6\x0d\xc4\xa5\xab\x57\x97\x26\x79\x65\x0a\x76\x9c\x1e\x49\xc7\x3e\xa7\x06\x3b\xd6\x91\xd2\x1d\x6d\xe1\x22\x51\x9d\xeb\xc2\xad\xdc\x24\x3f\xf8\xab\x55\x69\x5a\x5a\x19\x80\x49\x1e\x64\x84\xef\x14\xfd\x42\xaf\xd5\x9a\x77\x30\xcb\x86\xf3\xeb\xb1\x34\x30\x57\x39\x06\xad\x8e\x82\x71\xe2\x05\xa5\x23\xb1\x4f\xf6\x02\xef\x2e\xf0\xca\x4b\x98\xbb\xd4\xfc\x88\x92\xd2\xa7\x5e\x39\x9c\x69\xb3\x10\xf1\x81\xe3\xbc\x41\xb5\x1f\x3b\xb6\x27\x9b\x30\x75\xbf\x87\xf5\x1a\xac\x06\xd4\x7f\xe9\x4f\xf3\x3b\x15\xd9\x97\xaf\x82\xe1\xfd\x9f\x1a\x9a\xef\x8b\x06\xfa\x13\x21\xb3\x72\x80\x7e\x72\xcb\x92\x63\x5e\xd1\x2e\xc3\xb1\x72\x72\x07\xa8\x8b\x46\x26\xfd\x21\xd6\xa5\x85\x43\x81\x0c\xf7\x98\x05\x17\x1d\x38\x17\xf8\x92\xbe\xd4\x61\x6f\x78\x77\x93\x79\xa8\x89\x62\x37\x54\x3c\x42\x7d\x1c\x95\x9f\x0c\xf2\x0e\x50\xf6\x71\xd9\xe7\x64\x1b\x09\x7c\xe8\x9c\x47\x5c\x4f\x99\xaa\x16\xb7\x24\x5f\xe6\xaf\xa8\x7e\x5d\x5c\xd2\x19\x18\x85\xb7\x98\xc7\xbf\xe9\x1e\xaf\x46\x6b\xee\x46\xec\x78\x14\x7a\x18\x3a\xe9\x3c\xb8\xbc\x65\x88\x02\x98\xe7\xb9\xf3\x5d\x74\x4b\x0a\x37\x3c\x4a\x99\x6b\x2f\x71\x3b\x61\x2d\xc9\xc4\x56\x63\x5a\x02\x95\xc4\x7d\x3f\x17\xdc\x26\x35\x00\x34\xd8\xfb\x52\xd6\xc2\x81\xfb\x45\x1e\x8f\x04\xf0\x40\x08\xce\xe9\x4e\x9d\xaa\x8e\xc6\xc9\xe3\xcf\xe1\x3c\x8e\xc2\xa8\x88\xbf\x71\x24\x2d\xbb\xdb\xf2\x2e\x67\x8f\x26\x94\x3e\x4a\x3a\x02\xe7\x76\x0a\xd9\x90\x14\x78\x83\x71\x9a\x22\xf4\x56\x11\x2c\x92\x9e\xb0\x57\x7c\xd5\x37\xcd\x64\x1c\xa5\xc6\xa6\x26\x0c\x12\xf9\x20\x36\xaf\xd7\x6e\x80\x8d\x1a\x5d\x3f\x4e\x64\x03\x6c\x27\x9a\x53\x1f\x2c\xcf\xec\x8c\x0c\x6b\xdb\x8d\x41\x39\x40\x96\x7c\xb3\x0c\x66\x21\x08\x1a\x91\x22\x5b\xac\xae\x2c\x66\xf6\xad\x8c\xfc\x2a\xc8\x16\xe7\x2e\x13\x32\xb4\x51\x9b\xbd\x02\xee\xe9\x8e\xf1\x41\x58\xa6\xee\x35\xf5\xcd\xba\x0e\xad\x3e\xb1\x72\x67\x65\x07\xae\x8e\x73\x84\x54\x4b\x65\x67\x26\x25\x05\x2e\x75\x1e\x5d\xa2\x87\x47\x21\x4e\x34\xbe\x30\x1f\x60\x0b\x7e\x7d\xc4\x68\xe4\x89\x50\x33\xe4\xfc\x8f\xeb\xec\xf3\xcf\x7f\x4d\x8d\xc4\x32\x31\x20\x99\xe9\xa7\x14\xd9\x41\xd5\xa2\x2e\xe1\xc4\xfe\xf8\xb1\xa1\xde\x7d\x81\xd2\x1c\x93\x9a\x02\x14\x3b\xdf\x65\x32\xa9\x91\x98\x4e\x27\x20\xce\x41\xa2\x70\x4b\x51\x07\xaf\xe0\x0b\x06\xd2\xd6\x61\x5d\xc4\x11\xbc\x9a\x6e\x4a\xc3\xbb\x8d\xa2\x40\xb8\x4d\x55\xfa\xcb\x54\x97\x00\x69\xea\x99\x62\x09\xcf\x1a\x94\xd2\x4e\x91\xda\x13\x09\xe8\xa4\xe1\xc2\xda\x7a\xb8\x3b\x65\xc6\xd2\x06\x1d\xdf\xb7\xb6\x21\xee\x40\x5b\x98\x2d\x6f\x45\x5c\x9d\x7a\xf5\x78\xef\x25\x60\x63\x66\xf8\xf8\xb7\x25\x4c\x74\x65\xba\xcb\x88\x6a\x07\xf2\x66\x74\x72\x3a\x3e\xb6\x10\xf1\x66\x74\x7a\x7a\x72\x6c\x49\x8b\x7c\x33\x1e\x5d\x5e\x4d\xc7\xce\x9b\xd3\xd1\x5b\x5b\xb6\xe5\xf1\xc9\xec\xf2\xe4\xfc\xf2\xe4\x3d\xa7\x5c\x1e\x8d\xa6\xa3\xa3\xcb\xf1\xf4\xf1\x7f\xc2\xd7\x47\xa3\x99\x05\x30\xe5\x09\x3b\x5c\xce\x58\xb9\x97\xe2\x88\x93\x84\x31\xde\xc3\x7a\x6a\x56\xfa\x19\xcb\x12\xc5\x68\x7c\x8d\x28\xaa\x12\x75\x27\x19\xe8\x61\xbb\xf9\x4a\xf4\x77\x22\x9d\xdf\x17\x54\xd5\xa4\x5f\x5c\x89\xbb\x4a\x4b\x56\x4c\x53\x41\xed\x10\x56\x52\x26\x84\x1d\xa0\x5b\x51\x21\xdd\x9d\xc9\x16\x58\xc5\x1a\x94\xa2\xa4\xef\x35\x81\xb0\x26\x19\xc6\x19\x96\xdf\xed\x84\x15\xa6\x6a\xc8\xb1\xce\xa8\x5c\xd0\xe4\xb3\x4b\x70\x0a\x7f\x5e\x46\xb2\x14\x85\x2c\x69\xb3\x05\x43\x74\x3c\x73\x8e\x48\xf9\xe8\x71\xa5\x74\xc4\xd5\x75\x28\xdb\xb1\xaf\x18\x80\xbb\x0d\x17\xc9\xae\x10\x73\xc1\xce\x7c\xee\x3b\x13\x40\x85\x39\x13\x2e\x17\x12\x8b\xb9\x4c\x6c\x8f\x0f\xda\xac\x0d\xb5\x64\x6c\x81\x9f\xaa\x55\xf4\xc6\x46\x0e\xe0\x9a\xc5\x43\x5e\xdc\x7d\x2f\x1f\x13\x59\x69\x01\x75\xc3\xd7\x7d\x48\xe6\xe6\xed\xe5\xfc\x97\x34\xab\x08\x0c\x2b\x98\x26\x52\xd2\x48\xb5\xb7\xc7\x3c\x2d\xe6\xab\xec\x51\x71\xa3\xaa\x14\xf4\x08\xcd\x24\x20\xea\xc2\xa1\xcd\xfb\x25\x90\x1d\x09\x52\xca\xee\x00\x8f\x6f\x59\x4a\x62\x45\x8d\x47\xea\x7a\xf3\x74\x3e\x3b\x74\x5c\x60\xae\xac\x0e\xf2\x90\x5a\x75\xc0\xe4\x9e\x90\xba\x78\xdc\x96\x23\x06\x08\x95\x9e\xb1\x26\x77\x8e\x22\x2c\x2c\x52\xd6\xcd\x3d\x96\x63\xe2\x6a\x2d\x6c\x32\x6e\x9e\xab\x6a\x2d\x0c\xae\xd9\x52\x98\x2a\x02\x64\xc1\x29\x73\x56\xd0\xf3\xcd\x7f\xbe\x09\x5c\x2c\xf2\x29\x0b\xe8\x79\xd6\x26\x53\xa5\x0c\x94\x0a\x80\x3c\x9c\xce\x73\x6d\xfa\x8c\x0d\x39\x67\xd7\x6c\x8f\xbb\x2b\x66\x7b\x7b\x9d\x02\x02\x8b\xbb\x0c\x43\x05\x28\xf6\x9b\xef\xf6\xe8\xf2\x0d\xb0\x93\xd0\xd2\xfd\x00\x1a\x29\x0e\x8c\x12\x7c\xf0\x29\xf1\xbd\x4f\xb9\x8a\xa9\x2c\x87\xb2\x72\x61\x66\x81\x6c\xfc\x71\xd5\x14\xc7\x50\x67\x0b\x30\xcc\x56\x84\x93\xba\x77\x0f\x40\x81\x12\x8b\xc7\xbf\xc1\xa0\x68\x55\xa3\x1e\x6a\x3c\x48\x04\xb8\xb2\xba\xeb\xfa\xf1\x67\xd2\x9a\x55\x96\x0d\x56\x17\x29\x12\x53\x3f\xde\x08\xbb\xdc\xdc\xca\xd8\x1d\x6c\xdd\x84\x86\x05\x4a\x09\x8d\x97\x4d\x96\xb0\x26\x70\x1e\x77\x26\x78\xe5\x71\x9d\x22\xb8\x86\x52\xf9\x19\x0c\x1b\x36\x00\xdb\xea\xe4\x00\x8c\x1f\x48\x79\xd1\x05\xa0\x5f\xc1\xb6\x5f\xb3\xc1\xdd\x35\x7c\x08\x24\xbf\x92\x4c\x03\x25\xbd\xce\x52\x4a\xc7\x20\x0c\xef\xf4\x3d\x06\x2a\xc9\x29\xb4\x4d\x40\xf3\x53\x11\x6d\x13\x56\x59\x57\x87\x93\xad\x28\x24\x61\x4f\x7c\x5e\xfa\x8b\xd8\xdd\x7e\x3c\xf4\xfa\xbc\xff\x78\xfa\x14\x3f\xcd\xb1\x99\xa5\x4f\x3d\xd1\x5a\xfd\x94\x51\xc5\x42\x8a\x4d\xee\x28\xae\x86\xc9\x2b\xaa\x19\x25\x05\x7c\x90\xe8\x34\xea\x9d\xd1\x40\x5b\xdc\xd9\x8c\x39\x0b\xf7\xb6\x29\xde\x8e\x2f\xe1\x12\xf6\xd6\x99\x5d\x8e\xa6\x97\xd6\xbb\xde\xd1\xe3\xbf\x9d\x4d\x9c\xf1\xd9\xc5\xf8\x9f\x47\x53\x0b\xa0\xd3\xc9\x57\xa3\x53\x67\x72\x71\x79\x32\x39\xb7\x56\xc0\x99\x5c\x1c\xc1\xcf\xe3\x99\xc3\x8f\x63\xa9\x9c\x7a\x68\x22\x85\xed\xa4\x9d\x6b\xba\x33\x1d\x45\xdc\x26\xf7\xce\x3c\xc0\x62\x40\x36\x71\x3a\xd1\x61\x40\xc5\x26\x75\xc5\xc0\x1f\xa9\x63\x44\x89\x84\x26\xf3\xbe\x6c\xc5\xc5\x90\x24\x94\xaf\x55\xe7\x0a\x1b\xdc\x70\x19\x34\xf5\x62\x21\xa2\x16\xa4\x04\xb2\x85\xa3\x0a\x48\x26\x5b\x5a\x8d\xac\x6f\x55\xa0\x5c\xa0\x02\x6c\x54\x79\x38\x50\x15\x3e\x88\x14\xf4\xc8\xb9\xb0\xe7\x27\x11\x05\x5c\xcd\x3a\xcf\x78\x53\x81\x3a\x1c\x23\xb0\x44\x8b\x9b\x17\x59\xf3\x92\xde\xe6\xa1\x7a\xc9\xd3\xb4\x43\x31\x88\x24\x24\xcf\xd2\xfe\x44\x0d\xcb\xb8\xce\x1f\x1c\x58\xa3\xd8\x0d\x12\xad\x37\x78\x7a\xbd\x11\x97\xbc\xb1\x37\x34\x56\xed\xc9\x2e\x75\x8f\xef\xde\x47\xb5\x07\x67\x84\x91\x90\xa6\x6b\x3a\x3a\x3f\x3e\x79\x77\x1c\x63\x7c\x39\x7a\x23\xa9\xad\x26\xc9\xbb\x48\xd5\xb3\xae\x1f\xb6\x87\x3c\x05\x7b\xba\x2c\x46\x69\x52\x31\x9d\x35\x4f\xca\x8b\xb6\x15\xce\x61\x56\x9f\x64\xad\x48\x35\xf4\xf9\x78\xd1\xcc\x09\xdb\x99\xd1\xe0\xd7\xa7\xc1\xe4\x31\xbb\xb6\x23\xa3\xc1\xb1\xff\xb6\x10\xc3\x1b\xed\x94\x24\x6c\xb0\xb6\x10\xd7\xbb\xdf\x5c\xe8\x0a\xc5\xfb\x6b\x2b\x53\x60\x67\xcd\x18\xf6\xdf\x6a\xa6\x3a\x98\xb6\x5e\x1b\x5b\x36\xd6\x6e\x9c\x9b\x2d\x5a\x6f\x6c\xdb\x6f\x5b\x0d\xf8\x13\x74\xc5\x32\x58\xf0\xe9\x9b\x62\x19\x7c\x48\x9e\x69\xd0\xd2\xb7\xf7\xac\xc3\xb3\x95\xa1\xe8\x72\x52\x75\x29\x1f\xd1\x76\xba\xf0\x75\x35\xc9\x5b\x58\xe6\x21\xf4\x00\x12\x00\x34\x4a\x56\xa9\xbe\x49\x18\x85\x96\x94\x46\x28\x7e\x42\x60\xba\x93\xa1\x5f\xdd\x38\x36\x37\x7a\x51\x10\xe5\x04\x14\x52\x00\x1c\x8b\x7b\x5b\x21\xad\x6d\x2c\x44\x82\x66\x2b\x91\x5e\x93\xb3\xb3\x6b\xa7\xb3\x02\xa5\x7d\xca\x95\x14\xc8\x4a\x98\x8e\x5e\x05\x46\x14\xe6\x82\x7f\xa3\x42\x80\xd3\x71\xa5\xe2\x82\xb0\xb8\x3a\xb6\x5b\xb6\xb2\xa8\xf7\xb6\xf4\x70\x91\xee\x5d\x30\xd7\x6a\x02\x1d\x75\xaf\x46\x2a\xb7\xc7\xde\x0b\x4d\x17\x80\x36\x88\xcd\x14\x66\x4a\x5d\xa5\x12\xfd\x45\xd5\xc3\x91\xfd\x96\xf8\xcb\xb7\xf8\xdd\x79\xf7\x95\x1c\x8b\x45\xe0\x26\x0d\x9a\x46\x13\xf4\x46\xa2\x8b\x64\x26\xdb\xa9\x43\xf9\x02\xcf\x55\x9f\xbe\x6a\x8e\x3a\xe4\x64\x19\x9b\xed\xb4\x76\xdd\xd2\x25\x29\x77\xcc\xeb\xb1\xf1\x4b\x94\xe0\x84\xe6\xbd\xf3\xbe\xa2\xbf\x70\xcd\x85\xc5\x3a\x74\x72\x01\xe9\xcf\x5b\xdf\x3c\xaa\x63\x50\xd3\x5e\xec\xbb\x67\x12\xb3\xb1\x29\x62\x26\x39\x4f\xca\x8a\x6a\x75\xa1\x27\xe4\x51\xa1\x7b\x4f\x2f\x36\xd5\xd7\x1f\xfa\x05\x73\xf0\x19\x97\x90\x95\x37\x4f\x37\xec\x67\x1b\xdd\x7e\x86\xf0\x9c\xfb\xfd\xd9\x96\xe3\xb3\xee\xdc\x86\xc9\xfb\xe4\xfb\xf2\x59\x36\xe0\xfe\x77\x98\x4e\xd3\x4a\xb6\xbe\xfe\x71\xce\x16\x1b\x46\x7b\xb7\x9f\xed\x4c\x29\x0b\x80\xad\xef\x7c\x85\xcd\x9d\xb4\x1f\xf2\x6d\xea\x5a\x62\x96\x6d\x95\xd7\x17\x5a\xea\x1d\x2a\x44\x6e\x65\x56\x28\x5f\x91\xea\x8b\xbb\x76\x2a\x13\xb9\xdd\x04\xf4\x1a\xe9\xf3\x8d\xaa\x2b\xfd\x55\x57\xd5\x93\x35\x06\x2e\xec\x8d\x1a\xff\xd6\xb3\x35\x04\xae\xb0\xe0\x59\x47\xfc\xec\xa3\xac\xe9\x7a\xfc\x34\x86\x89\x9a\x2e\xc8\x5b\x8a\xe1\x9c\xe4\xdd\xad\x14\x06\x55\xdb\x92\x92\xd4\xf5\x5e\x6e\x5c\x10\x5d\xad\x18\x79\x91\x25\xd1\xdc\x71\xb9\x65\x09\xb4\xca\x65\x4c\xfc\xa4\x44\x9b\x19\xfe\x85\x79\x3e\x85\x45\xaf\x0f\xfe\x27\x70\xfb\xc0\xb8\xd0\x05\x5b\xc4\x6e\x19\x6f\x2d\x29\xfb\x73\xf9\x70\xfe\xeb\xf3\x0d\x1d\xc7\x6d\x9d\xdb\x27\x1e\x2b\x87\xb8\xd6\x37\x0d\x7f\x6d\xf3\x7b\x74\x6f\xb7\x6f\x8c\x52\xc7\xd6\x76\x68\x1b\xfe\xda\xee\xf9\xe8\xd1\x87\xbf\xcb\x18\xb7\x95\xd4\x7d\x46\xd3\x4f\x22\x53\xe1\x7e\xaa\x1a\x41\xbd\xd3\xe6\x41\x46\x5e\x2f\x59\x35\x86\x33\xd3\x6e\x23\x6f\x33\xc0\x2a\xee\x2f\xff\xf1\x25\xa8\x12\xd8\xab\x52\x78\xce\xed\x06\x2b\x8b\x53\xa4\x21\x4c\xbe\x43\xcd\x0c\x5d\x8f\x5e\xd4\x55\x28\x7a\x19\x00\x89\x94\xa5\x48\xef\x23\xcf\x79\xf5\x76\x7c\x39\xb8\x98\xcc\xe0\x3f\x57\x97\x83\xe3\xf1\xe9\xf8\x72\x3c\x10\xe9\xdc\x16\x6e\x77\xf6\xf8\x17\xb4\xcb\x73\x1f\x02\xfb\xcb\xf5\x78\xa3\x24\xa5\x21\x70\x13\xbc\xe5\x66\x98\x64\xb7\x1c\x74\x61\x43\x77\xce\xc9\x8e\xc0\xaa\x7b\x78\x59\x37\xc3\x5b\xfa\xf2\x55\x0c\xaf\x68\xc3\xa6\xec\x87\xdc\xd9\xf1\x95\x4c\x80\x95\x91\x4b\xf7\x2e\xfe\x29\x23\x3f\x6c\x54\xd4\x83\x6a\x41\x9b\xc9\xf4\x5c\x58\x26\xd8\xca\x4d\x07\xde\x39\xc7\x93\xb3\xd1\xc9\x39\x05\xf9\x52\x5d\xff\x8d\x41\x1d\x66\x23\xf9\xd6\xde\x96\x4f\x84\x91\x83\xd7\x76\xc0\x89\x2b\xda\x83\x2d\x50\x80\xbc\x07\x5e\x9e\x9c\xcf\x2e\x47\xa7\xa7\xe3\x63\xe7\xe2\xf4\xea\x2d\x8c\xe0\x68\x72\x76\x36\x3a\x3f\xb6\xe5\x2f\xe1\x6f\xa3\x4b\x4e\x5e\x92\x6f\x30\x88\xd1\xf1\xc4\x92\xbd\x74\xb2\x08\x31\xed\xb9\x50\x5b\xc5\x02\x9d\x1e\xc5\xae\xec\x75\x75\x54\x2c\xd0\xe5\x3e\xd7\x75\x47\x64\xc9\x1e\xb5\xf1\x1b\x5b\xa5\xd2\xcb\x7e\x9c\x97\xec\x71\x24\x24\xae\x41\xc2\x12\xaa\xa9\x81\x2a\x00\xc0\x76\xa3\xf3\xd4\xb9\x4a\xdc\x85\xc0\x76\x2d\x16\x54\x57\x09\xc9\x24\x7e\x3a\xa2\x07\xbb\x40\x3c\xe8\x0c\xf2\xa0\x3b\x4c\x67\x14\xe6\xb9\xec\x7e\xe2\x50\xc7\x29\xf2\x6e\xca\x36\xb3\xf4\x70\xb0\xc1\x78\x68\xd0\xa2\x84\xd7\x83\x8a\xda\xc4\xea\x28\xcf\x13\x70\x3d\xcc\xd2\x74\xbd\x48\xa1\x71\x29\xb2\x1a\x63\x14\x75\x8a\x7a\x9f\xa1\x1c\xe9\x02\x76\x21\x2c\xf8\xc0\x5d\x24\x20\xfb\xbe\x9f\x8b\x55\xea\x0c\xef\x3e\xc3\x2e\x10\x38\xa4\x5b\xd9\x49\x03\x76\xd2\xc3\x3d\x86\x86\x73\x5b\x56\x67\x99\x05\xa9\xbf\x0a\x04\x87\xdd\xb1\x57\xb5\xb8\x52\x6d\x27\x5a\x79\xd8\xa7\x5c\xc9\x13\x8e\xcd\x94\x62\x70\x50\x29\xa9\x36\x3b\x92\xa4\x45\x44\x1b\xf3\x04\x1b\x45\x88\x50\xc6\x72\x51\x46\x48\xa9\xed\x2b\xc7\x80\x25\x4c\x22\xd7\x4e\x23\x66\xd5\x6c\x11\xcb\xc1\x58\x61\xda\xbb\xf1\xe8\xf4\xf2\xdd\xcd\xd1\xbb\xf1\xd1\xd7\x37\x97\xdf\x5c\x8c\x81\x11\x09\x71\xe9\xfa\x05\xd6\x67\xbc\x7e\x81\x6b\xe1\xfa\x45\x18\x85\xe2\xfa\xc5\x35\x4c\x47\xe7\xe9\xaf\x82\xf6\xc4\x2d\xdd\xac\x0d\xd8\x65\xd0\xdd\xa8\x3e\xcf\xab\x18\xa8\x1a\x0b\x5e\xbf\x85\x89\x5d\x44\x05\x95\x88\xf2\xf3\x6c\x7f\xbd\xec\x7a\xac\x3a\x1b\x29\xa4\x42\xc2\x13\x3d\x53\xe8\x2b\xf0\xa7\xaa\x84\xc4\x4b\x98\x75\x6a\xad\x8b\xab\x22\xff\x83\x22\xa9\x5e\xa2\x0e\xa6\xc8\x48\x7a\x70\x82\xa0\x0b\x90\xc9\xcd\xd0\x8b\x75\x23\x92\x1e\xec\x69\x20\xff\x29\x88\xde\x0f\xa9\xca\xe9\xa7\x03\xaf\xf7\x40\x6a\x0d\xcc\x3d\x90\x3a\xba\xb8\x70\x66\xe3\xe9\xfb\x93\xa3\xf1\x0d\x9d\xbe\xe7\x47\xe3\x9d\x69\xad\x05\xba\x1f\x62\xb9\x79\x19\x4a\x69\xa9\x26\xed\x81\x56\x86\xb9\x51\x10\xf7\x4d\x68\x55\x8c\xed\x91\xe6\x2a\xf0\x7d\x93\xff\x14\xab\x43\x51\xff\xb4\x8b\x24\xa7\x73\x6b\x12\x8b\xf4\xec\x83\x94\x9d\x38\x56\x24\x67\x1b\xee\x7c\x75\x75\x72\x7a\x7c\x31\x82\xc5\x82\x00\x07\xce\xf9\xf8\x0f\x37\xc5\xef\x76\x9e\xdf\x0e\x28\xf6\x30\xcd\x6a\xfb\xef\xb0\x42\xb7\x45\x49\xd5\x98\x3a\xcc\x67\x5f\xf8\xa7\xa3\xaf\xc6\xa7\x03\xe7\x62\x3a\x79\x7f\x72\x3c\x9e\xd2\xd8\x2e\x27\x5f\x8f\x77\x17\x72\x65\xc8\x1b\x09\x77\x0f\xf3\x50\x21\x7a\xcf\xa4\xee\x81\xc4\xc9\xf4\x6d\xe1\xc4\xd8\x85\x3c\x84\xb5\xcf\x93\xa2\x4c\xdb\x8e\xdc\x7b\x02\xf2\xe4\x2e\xfe\xfd\xd5\xe4\x72\xb4\x0f\xfa\x0a\xf0\xf6\x40\xe2\x74\x7c\x31\xc9\x4f\xab\xab\xe9\xe9\x53\x6d\xff\xd9\xf8\xe8\x6a\x7a\x72\xf9\xcd\x0d\xf5\xc0\x27\x6c\x17\x23\x38\x7b\x2f\x27\x37\x98\x23\x7e\x33\xbd\x3a\x1d\xcf\x6e\xde\x9c\x9c\xee\x2e\x42\x4b\xa8\x36\x56\x44\x7b\xe0\x5f\x11\xd7\x40\xaf\xc8\xd9\xc5\x68\x0f\x87\x7d\x1d\xf4\x8d\x84\xbd\x17\xe2\x59\xf4\x7f\x35\x05\x79\x36\xe5\xb3\xa6\xf8\xdd\x1e\x46\xd0\x8a\xe2\x09\x06\x72\x05\x5f\xf0\x46\xb9\x18\xcd\x66\x7f\x98\x4c\x8f\x07\x7d\xd6\x76\xe7\xd1\xd8\xf0\xec\x71\x48\xfa\x58\x56\x5f\x7c\x3d\xfe\x66\x6f\xe3\xa8\x05\xfe\x14\xc4\xe3\x96\x30\xa7\x7e\x6f\xea\x70\x05\xe0\xa6\x1e\xcf\x53\x0d\xea\x49\x67\x65\xb3\xf7\x79\x99\x5c\x4d\x8f\xc6\x43\xbc\x61\x5e\x8e\xa6\x6f\xc7\x97\xf4\xe7\xce\x74\xd7\x42\xdd\x07\xb9\x2c\x44\xf7\x77\xc0\x33\xc0\x7d\x1e\xf1\x39\x89\xfb\x39\xe2\x15\x85\x7b\x3b\xe0\x09\xe0\x30\xbf\x8f\xd2\x47\x82\x3e\xdc\xcb\x7d\xc5\x80\xbf\xa9\x42\xdf\xd7\x00\x58\x45\xa1\x9d\x9d\x7f\xdc\x0b\xe9\xb5\x90\xf7\x4b\xf6\x8e\xf7\x57\x2b\x5d\xdb\x90\x95\x9f\x58\xa0\x4b\x0c\x9c\xe9\x64\x0f\xfa\x56\x1d\xcc\x3d\x70\xb0\x04\x96\xd8\xf0\x34\x14\x9b\xa0\xf7\x40\x78\xb7\xfb\xad\x95\xb8\x6c\x3b\x4b\x78\x8e\x7e\xb5\x62\xef\xf9\x8e\xeb\x2e\xd3\xf5\x77\x3d\x72\xcb\xec\x61\xf5\x01\x94\x1b\x24\x6d\x20\xbd\xd0\x37\x65\x3a\xb7\x9a\xcd\x7a\xa8\xfb\x98\xc8\x9d\xa8\xda\x09\xb5\xae\x05\x21\x47\x46\x25\x94\x50\x80\xaf\x64\x75\xe8\x9d\xb9\x56\x8b\x61\x93\xc3\xdf\x03\xff\x28\x8e\x01\x89\x96\x0d\xf2\x76\x25\x99\xe0\x6d\x14\xb4\x3d\x10\x18\x05\x9e\xb1\x5d\x80\xd0\x50\x3c\xd4\xee\x9f\xad\xc8\x2d\x40\xdf\x14\x61\xef\x89\x78\x0c\x07\xe2\xe9\x43\xe8\xea\xd3\x5e\x28\xb7\x80\xde\x07\xe1\xf1\xe2\x09\xa4\x40\x3d\xd4\x3d\x90\x2b\xa3\x67\x07\x85\x48\xe8\x41\x35\xaf\x7a\xd7\x01\x74\xc5\xb3\x8f\x21\x51\x94\xe4\x3e\x0e\x09\x03\xd2\xee\xc7\xc3\xfa\x0b\x75\x71\xc3\x3f\xb5\x11\x13\xff\x3e\x1d\x9d\x3b\xeb\x2f\xf3\x9f\xbf\xe4\xaf\x76\xe5\x79\x7f\x8c\xdb\x72\xdf\x56\x93\xaa\x48\x9a\xa5\x20\x55\x0e\x4b\xd5\xb8\x5c\xba\xe9\x61\xde\x09\x02\x0d\x5b\x58\x9f\x0f\x7b\x4a\x5c\xa7\xf0\x7f\xe1\x7b\x8c\x95\x91\x4f\x73\x49\x3e\x77\xb9\xa2\x56\x4a\xdf\x5e\x87\x00\x1d\xff\xe3\x60\x20\x40\x1c\xa5\xd1\x3c\x0a\xae\x01\xcd\xf5\x8b\x74\xbe\xba\x7e\x31\x50\xbf\x79\xd4\x65\x86\x28\xe5\x9f\xbf\xf8\xfc\xe0\xcb\xdf\xfc\xe6\xe0\x8b\x83\x2f\xfe\x9b\xf1\x18\xc6\x12\x24\xfc\xc0\xaf\x7f\xfd\xf9\x3f\x5c\xbf\xc0\x1f\x80\x90\x3f\xda\xab\x90\x01\xf5\x11\x13\x67\x0c\x5d\x45\x52\x58\x46\x34\xfe\x4e\xc0\x08\xb8\xa5\x9e\x0c\xb9\x20\x08\xeb\xc7\x9f\x60\xa8\xd1\xf3\x8e\xcc\x32\x4b\x5c\xcd\xee\xe8\xf4\x44\xa6\xd6\xf7\xb4\x9d\xd2\xeb\x46\xbf\x3f\xe0\xc3\x05\xfd\xc5\x5d\xc2\xec\x51\x9d\xfc\xaa\x6a\xfd\x6f\x7f\xdb\x8e\x17\x04\x4b\x13\x6c\x2c\xe7\xd0\xfc\xb6\x73\x26\x96\x51\xbc\xb1\x45\xab\xe1\x8f\x5c\x11\xc2\xef\x08\x4f\x05\xc2\xb8\xa0\x85\x86\xc3\x50\x2c\x00\xd8\x5a\xa8\x3e\x1e\x16\x3c\xa7\xc5\xf2\x13\x32\xde\x45\xb7\xcf\xc0\x48\x1f\x09\xc9\xea\x8e\x5c\xd3\xce\xc1\xf5\x57\xdb\x42\xcb\x82\x78\xaa\x63\xd5\xe8\x4d\x2c\xcb\x48\xeb\xb2\xd8\x3f\xab\x19\xe7\x54\x96\x03\xc6\x7f\xad\x71\x2b\xf0\x63\x0e\x3d\x32\x1e\x6f\x04\x3d\x9b\x9d\x3a\x47\x42\x36\x8d\xc6\xd8\x18\x6c\x41\x41\x51\x32\x97\xfe\xea\x4c\x24\x8d\xa1\x32\xf8\xa2\x7f\xe7\x53\xea\x0a\x02\x32\xd0\x53\x7a\x8e\x1d\x5e\x23\x4d\xdc\x97\x63\x2b\x1e\xeb\x9e\x1a\xee\x76\x9c\xee\xd0\x9d\x6c\xc6\x9d\xc8\x6a\x72\xda\x72\x8c\x87\x96\xea\x1c\x0a\x0d\xd5\x45\x5c\x64\xb2\x12\x25\x08\x24\x20\x4d\x06\xe3\x0e\xe7\x14\x23\x77\xe0\x5c\x04\xc2\xc5\xe0\x33\xfe\xd1\xc1\x62\xbd\x7a\xfd\x45\xb7\xdf\xa1\xcc\xa7\x36\x88\x44\xb0\x0a\x8e\xc6\x78\x3e\x50\x71\xa8\x16\x5e\xf5\x05\x6b\x21\x59\x45\x4e\x79\x1c\x88\x1d\x64\x1d\x97\x96\x70\x75\xce\x55\x1e\x45\x07\xe4\x02\xa5\xfa\x21\xba\x1b\x22\x2e\xa0\x88\xf1\x52\xe5\xc0\x52\xa1\x55\xb9\x46\xb0\xb7\x80\x11\x26\x87\x95\x5a\x91\x7c\x5f\x54\xc1\xc8\x37\xac\x72\x8a\x47\x9a\xb7\x23\xc4\x44\x0b\xac\x5b\xc2\xb9\x03\x2f\x9d\xa1\x6e\x6c\x8a\x8f\x78\x11\x46\x99\x45\x29\x57\x83\xb5\xf0\xe4\x98\xa2\x01\x43\x83\x5a\x18\x40\x09\xee\x21\x65\xb0\x94\x9b\xa7\x86\xb2\xcc\xac\xb0\x9e\xff\x92\x5c\x3f\xf9\xc0\x29\x3e\x74\xb0\x1d\xc3\x47\x99\x31\xd4\xaf\x68\xf6\x91\x4a\x3d\x02\x80\xf3\xa8\xb0\x0a\xbb\x81\xdd\x91\xca\xfd\x11\xd6\x46\x0b\xd7\x19\x1b\x52\x9d\xb1\xa1\xae\x33\xb6\x24\x70\xfc\xdb\x11\xfe\xc4\xcd\x23\x2c\x44\x5d\xb8\xf1\xe3\x4f\x4b\x91\x82\xcc\xaf\x82\xcb\xa7\xdb\x02\xb3\x91\x3c\x43\x11\xcf\x42\xee\x0a\xa7\x0e\xad\xe4\x08\xbf\xc2\x91\x9e\x14\x1e\x32\x0e\x33\xbe\x5f\xb7\x1e\x64\x53\x31\xcf\x84\x6c\xa2\x92\x9f\x68\x25\xc2\xab\x68\xc7\x58\xc8\x27\x7f\x33\x68\x39\x0e\x25\x31\x2d\x67\xa1\x1e\xf0\x92\x8e\x78\x27\xf0\x97\x3e\x8f\x9b\xcf\xfc\x53\xfc\xdc\x61\xa1\x9c\x3e\xfe\x0c\x0f\x92\x39\x69\x59\xa3\x0f\x94\x47\x67\x03\xde\x89\xd6\x02\x7f\x0a\x13\xd2\x7b\x2a\x4e\xaa\x04\xba\x15\xf0\x6d\x8a\x47\x3f\x4e\xb7\x53\x1f\x60\xde\x79\x8a\xa5\xd7\x8d\x27\xe5\x32\xd8\xff\x38\xfc\xf0\x4e\xc4\x3e\x96\x52\xac\x43\xd7\x38\x24\xd2\xd1\xdb\x72\x77\x58\x0a\xd3\xa3\x45\x51\xdc\x0c\x5b\xc5\x87\x1f\x38\x79\xe7\x25\xf8\xd2\x56\x03\xf7\x2c\xef\xed\x94\x63\x39\x70\xcc\x7e\x36\x5c\xb3\x17\x2e\x24\x8d\xfd\x8e\x35\xfe\x9a\xfd\xb0\xc3\x66\xa8\xae\xff\x9e\x8b\x7f\xff\xfb\x73\x1f\x5b\xd2\x42\x55\xdf\xf3\xaf\x2b\x75\x5b\x1e\x80\x66\xc1\x2e\x67\x91\xf9\x5c\x14\xe9\x2d\xfc\xd1\x3b\x84\x9c\x01\x62\xe9\x68\xaa\xc8\xad\xcf\xae\x4b\xfe\xa6\xc3\x4c\x18\xa7\x97\x02\x53\x1a\x6b\x1d\xac\x46\x72\xf2\x92\x9f\xd4\x76\xba\xd0\xb0\x89\xdb\x4f\xcf\xa8\x53\xd5\x7b\x37\xe8\xd4\xf0\xf2\x3d\x95\x04\x2d\x5f\x05\xfa\xc2\xb6\x91\x8c\x13\x8d\xf6\x58\xd8\xe1\x70\x93\xe0\xf4\xc7\x01\x7d\x23\xb8\x93\xc6\x9d\x6c\x69\xc0\x05\x5e\x65\x9f\x01\xca\xf5\xb4\x1a\x81\x24\xd8\x8d\xb3\xc0\xdb\x3f\x69\xb1\x32\x03\x72\x00\x5f\xca\x26\x0a\x02\x1b\x78\x16\xba\x21\xf0\xc0\x50\x92\xcb\x7c\x4e\x4f\x60\x29\x09\x1f\xab\xb0\xd9\x6d\x3f\x96\x11\x24\x22\x40\x8d\x1e\x7f\x98\x83\xf0\x5e\xb0\x91\x4f\x0e\x0d\x7b\xb4\x81\x20\xe2\xda\xea\xb4\x5d\x92\xad\x06\x43\x48\x58\x4f\xdf\xc0\x70\x96\xb7\x3e\xa3\x11\x34\x50\xbc\x40\x01\x07\x7f\x98\x73\xf5\xf1\x80\xb7\x15\x69\xb6\x0b\x37\x49\xad\x63\x3a\x85\x1f\x9d\x09\xca\x49\xa2\xa1\x9e\xac\xc7\xff\x37\x80\x05\xeb\x62\x27\xfa\xb8\x49\x82\x9e\x62\x77\x34\xb4\x95\xa8\x52\xde\x79\x97\x42\x9e\x45\x9b\x10\xc0\xbe\x0e\x31\x96\x4b\x84\x89\x09\xf2\x5c\x9c\xc0\x98\x1d\x87\xad\x3b\x96\xa3\x36\xc7\xbc\x76\xfd\x80\xd6\x92\x54\xe8\xe7\x9c\xc0\x64\x2b\xeb\x9e\xa3\x96\x95\x1a\x75\x2e\x51\x7e\x27\x00\x0d\x18\x2e\xb3\x3e\x96\x89\xee\x89\x9d\x98\xc0\x19\x8b\x98\x1b\x65\x94\x72\x8c\x62\x6a\x7c\x8a\xef\x78\x9e\xf9\x93\x6f\x6d\xe8\xd1\x82\x3b\xaf\x33\xde\x75\xa8\xb6\x42\xe3\x2d\x88\xb0\x48\x67\xd7\x89\x2c\x16\xe5\x6c\x01\x2c\xab\xef\xc9\x75\x33\xe7\xa4\x64\x99\xea\x2d\x53\x2d\xd5\x97\x66\x1d\xa2\xae\xb4\x70\x99\x43\x6e\x08\xa9\xd6\x15\x37\x38\x76\xa2\x6a\xaa\x34\xff\xd2\x42\x71\xa9\x52\x5e\x57\xc6\xd7\xd4\xc6\x6b\x45\x54\x74\x17\xec\xb4\xbb\xb4\x2a\x58\xac\x98\x53\xe4\x4c\xe7\x1d\x97\x97\x98\x70\x29\x91\xbd\x2b\x13\x74\xed\x08\xc1\x1d\x30\x0b\xec\x6f\xc3\xc9\x85\x10\x5e\xb9\xd2\x53\xe1\xa3\x39\x62\x15\x73\x23\x5c\x4e\x2c\x74\x92\x0d\xdc\xe2\x97\x03\x99\xa9\x4e\x46\x95\x90\x25\x18\xd7\x52\x90\x3f\x83\xb6\x9d\x62\x1a\x23\x2c\x0f\xea\xb4\x60\x4d\xa1\xae\xb0\x91\xab\x23\xbc\x42\xda\xa9\x40\x04\x30\x01\x3b\x41\xa0\xf1\x60\xe9\x1a\x06\xed\x04\x29\xd3\x46\x23\x0f\x65\x39\xd1\x24\xfb\x94\xaa\x17\x24\x69\xeb\x68\x40\xd6\x14\xca\x5b\x74\xc4\x77\xd8\xfc\x15\xf3\x16\x8d\xbe\xa1\x96\x74\x71\xcd\x1d\xea\xa5\x4c\x52\x45\x0a\xb0\x0e\xc2\xa5\x32\x3d\x66\xc5\x5a\x43\x16\xba\x8f\xff\xee\x62\x93\xa6\xb6\xbd\xac\xf3\xa2\xe5\x59\x9e\x2f\x94\xe8\x6e\x0f\xbb\x98\x4e\xef\x9a\xb5\x54\x57\xab\xa2\xd3\x4e\xd6\xa5\x18\x28\xa9\xb9\xfb\x2a\xd6\xe5\x16\x6a\x30\x37\xa1\xd4\x07\x45\x74\x87\x97\xb0\x70\xa1\x91\x1b\xb5\x8c\x9a\x89\x88\xe0\x45\xaa\x10\x93\x1f\x4f\xaa\xdd\x2d\x57\x24\xea\x84\x9f\xc5\xab\x6a\x84\x26\xab\xd6\x34\x23\xce\x2b\xd3\xa0\x55\x22\x4e\xa2\x42\x95\x9a\x8e\xa7\xa5\x26\x20\x43\xab\x72\x27\xbc\xc5\xaa\x38\xd8\x6d\xa5\x1b\x2e\xa3\x2b\x86\x21\x32\x5b\x27\xb9\xb1\xf7\x45\x27\xf1\xa8\xab\x75\xbb\x15\x01\xde\xc2\x61\xa3\xf6\x36\xca\x97\xda\xe2\xdb\x0d\x88\x0b\x75\x8a\x9b\x51\x59\x0a\x11\x37\x00\x2f\x97\x87\x95\x6c\x95\xbd\x88\xcb\xbf\x52\xe7\xbe\x2c\x0c\x4b\xfd\xe6\x3b\x53\x95\x57\x8f\xe5\xb5\x6d\xf6\x21\xae\x7b\x8a\xcd\xdc\x75\x62\x73\x8b\x21\xa5\xee\x82\x2b\x6d\xa5\xaa\xe5\xc4\xfe\xe8\xd7\xb5\xeb\x74\x71\xc7\xa4\x3b\xb9\x85\x42\x85\x09\x97\x93\x69\x21\x89\xba\x3d\xc8\x7a\x7e\x95\x5a\x84\x5d\x90\xe5\x45\x05\x9b\x11\x95\x2a\x07\x62\x55\x8d\x79\xb5\x70\x60\x07\x8c\xb2\x38\x60\x33\x36\x7b\x09\x40\x3b\x06\x9c\x53\xe9\x97\x85\x43\x92\xdd\xa9\x89\xdd\x0f\x4b\x98\xcc\xd2\xee\xdc\xe0\x0c\x8f\x72\xab\xfb\xf5\x14\x9b\xda\x61\x8d\x01\x5a\x39\x0f\x6e\xec\xa9\x7b\x00\xaf\x9f\x03\xe7\xf2\x1e\xb4\x16\xf4\x16\x91\xf6\x71\x8b\xf2\xe4\xce\x0f\x81\x9e\x65\x44\x5d\xf7\x50\x5b\x01\x41\x61\x23\x6a\xac\xc1\x69\xd6\xc6\x42\x84\xeb\xc7\x9f\x69\x62\x41\x7d\x88\x53\x3a\xa3\x80\x8e\x03\x67\x9c\xa4\xc2\xf4\xfc\xa8\xc2\x08\x8c\xd4\x8f\x9d\xe5\xe3\x4f\x89\xea\x15\xb5\x16\x3f\xd8\x47\xf5\x81\x76\x86\xbe\x6c\x50\xf3\xcb\x98\x7a\xd4\x38\xd9\x0a\x6e\x4e\x56\x0d\xe3\xab\x20\x02\xbd\x86\x1b\x95\xc9\x9b\x47\xf9\xe2\xc1\x1b\xc1\x5f\xae\x60\x3a\x63\x79\x6e\xb7\x5d\x1e\x22\x2e\xa3\xe4\x58\xdd\xf2\x47\xf0\xf2\xdc\xe8\xa1\xda\x02\x27\xb2\x56\x33\x41\xb3\x53\x57\x58\x0b\x98\x47\x6a\x40\x9f\xd8\x22\x44\xc8\x56\x22\x50\xcf\x5a\xc0\xb4\x90\x5e\x68\x09\x13\x41\x70\x54\x3e\x24\x4b\xed\x6b\xf4\x08\xb0\xb9\x5c\xa9\x2f\x91\xcd\xa2\xec\xd0\x62\x74\x96\x53\x73\x7c\x6f\x15\xf9\xe8\xc8\x90\x15\x4a\xc8\xff\xc6\xaa\x6a\x53\x1d\x99\x37\x6e\x90\x92\x2f\x71\x45\x92\x0c\x56\x10\xfb\x54\x83\x02\x6c\xb3\x75\x23\x4d\xb4\xe9\xa7\xb4\x11\x17\x7d\xa0\xc2\x58\x2b\xb2\x39\x21\x09\x1c\xe6\xf0\xb2\xda\x0b\xa1\xe8\xcd\xb3\x2d\xba\xc7\xbf\x25\xb0\xd4\xc8\x8d\x5c\x01\x59\x69\x90\x50\x02\x59\x4b\xe2\x19\x36\xc6\x44\x73\xf2\x6a\xa3\xba\xf4\x49\xd5\x69\x1e\x79\xd2\xdf\x8d\x36\x1a\xe3\xac\x20\x17\x6f\x18\xc1\xbe\x89\x0f\x1c\xe7\x2a\x24\x2b\x7f\xb4\x86\x19\xf3\x41\x4b\x0f\x07\x7c\xb3\x05\x80\x43\x0d\x89\x8b\xae\x3c\xf8\xd4\x82\x82\x5b\x02\x92\x56\x9f\x03\xb5\x2d\x84\x77\xee\x42\x19\xbc\x57\xac\x2f\xcc\x1f\xff\xea\xf9\x0b\x6a\xd4\x1e\xf2\x9e\x93\xbd\x8b\x74\x6b\xb8\xbc\xcd\x15\xa8\x39\x00\xef\xc0\x19\x81\x0e\x19\x82\xf8\xc0\x9b\x48\x82\x8d\x40\x41\x72\xa4\xd9\xc6\x1d\xc8\x06\xb5\x68\x22\x29\x90\x2c\x5b\x0f\xa2\x85\xb3\xd4\x3a\xcb\xb2\x0e\x25\x1f\x71\xcf\x0d\xb5\x0f\xbd\x1a\x7d\xa7\xd5\x44\xc0\x77\xf4\x86\x2e\x68\xd6\x81\xcf\x61\xfb\xfe\x39\x13\x76\x8d\xa9\xec\x11\x8f\x48\x18\xc9\xbd\x8c\x26\xb4\xc7\xbf\x18\x2a\x65\xfd\xb1\x8c\xf0\x8e\xde\x34\x8c\x89\xc4\x23\x9d\x5c\x2f\x93\x42\xd0\x1f\xcc\x79\x18\x6c\x9c\xb5\x9f\x10\x74\xac\x6b\x55\xd0\x48\x71\xfc\x0d\xd7\x78\x1b\x4a\xa3\x98\x8e\xec\x50\xec\x61\xd7\x2e\xd4\x0c\xee\xb2\x00\x10\xc2\xfd\xd6\x1a\x0d\x81\x25\x83\xf0\xa5\x4a\xbd\xa0\xe2\xde\xcd\x4b\xe0\xe0\xbe\xee\x42\x89\x9f\x18\x5d\x65\x4b\x16\x1d\x52\x34\x71\x13\x0f\x80\x2f\x85\x38\x09\xe1\xe3\x26\x91\x3d\x0f\x39\xfe\x10\xe6\x48\x39\x84\x2c\xa3\x68\x69\x2f\x5b\x21\x9f\x62\x20\x98\x02\x6d\x01\x1a\x18\x4b\xa3\x26\x46\x3e\x6a\xad\x93\x75\xe6\xae\xe4\x9d\x37\x52\x17\x0e\x5c\xb2\x29\x1e\xf2\xf6\xfe\x8d\x47\xca\x29\x05\x0b\x92\xd6\xa2\xbc\x73\x38\xb1\xfb\xf8\xf3\x0f\x8e\xeb\x70\x5c\x8c\xad\x77\xe3\x99\xfb\xbd\xf3\xe0\xfa\x29\x37\xb4\x54\x4d\xd1\xf4\xe6\x21\xb9\x91\xad\xd0\xdc\x00\x12\x3e\xcc\xec\x67\xf3\xa5\x2f\x96\xdc\x3d\x82\x7d\x66\xa8\x0e\x7c\xef\x2f\xcd\x2a\xea\x46\x5f\xd1\xc2\xde\x62\x59\x32\x40\xc6\x12\x0e\x9b\x65\xa0\x4a\x6b\xae\x43\x48\x3d\x7b\x67\x42\x81\x16\x7a\x1e\x2e\xc6\x42\xd2\x67\xd5\x35\x3a\x51\xec\x2f\xb3\xa5\xe3\x2e\xc9\xd9\x0f\xc2\x5e\xfa\xbc\x78\x79\x6a\xe9\x9e\x47\x0e\xc0\x0f\xf7\xd8\x26\x8a\xab\x03\x7e\xf1\xf9\x97\xbf\x39\x1b\x38\x5f\xbc\x85\xff\xff\xfc\xad\xcd\xac\x74\xe4\x82\x46\x86\xd7\x03\x1e\x89\x6b\x7a\xc2\x72\x3b\x50\xde\x7b\xb4\xca\xfc\x5c\x7a\xab\xe2\x82\x65\xcc\xcf\x31\xbc\x03\x67\xf8\x05\x9e\xa6\xd8\xbb\x19\xfb\x15\xba\x68\xd5\x23\x77\x07\xfa\x6f\x09\x87\xbd\x15\xb6\x64\x81\x31\x74\xc5\x8d\x56\x16\x74\x18\x7f\x91\x34\x79\x3a\x2a\x9c\x3e\xd1\x68\xef\xb2\xfd\x09\xd8\xe4\xbc\x3a\x16\x77\x6e\x16\xa4\x87\xf9\x6f\xad\xcb\xe7\xd3\xf2\xce\x79\xc5\x9e\x43\x78\xce\x70\xa4\x1d\xea\x27\x6c\x25\x2e\x15\x77\x49\x28\xbc\x42\x67\x09\x5a\x4a\xbd\xe4\x33\x92\x10\x18\x72\x0b\x42\x94\xc4\x46\xe9\xfe\xcd\xc2\x6d\xe0\x90\x56\x25\x03\x0c\x9d\x04\xcf\x10\xe9\x5a\x45\x4f\xce\x86\xde\xb0\x45\xaf\x4a\x59\xa2\x24\xc8\x2b\x74\x35\xc2\x65\x1d\x94\x68\x40\x4f\xf2\x44\xf6\x1f\x47\x32\x48\xdc\x88\x8a\x28\x34\x38\xf8\xdf\x6b\xaa\xcd\x81\x32\x05\x4a\x54\x4a\x88\x12\x43\x6a\xa1\x5c\xc2\xfb\x63\x87\xe0\xc6\x33\xc3\xcf\x2e\x97\xd4\x97\x7f\xff\x0f\x38\x43\x6a\xa2\xac\x06\xeb\xaa\x6b\x5d\x4d\x72\x05\x82\x05\x35\x45\x7c\x4a\x2f\x7c\x73\x34\xe9\x99\x08\x13\xf7\xbb\xf2\xb3\xf5\x60\xa9\x8b\xb7\xa8\xf1\x69\x68\xe5\xb9\x50\x9d\x3e\xd7\x9e\x6d\xb8\x11\x60\x6c\x73\x6b\x70\x3d\xbf\x4a\x09\x7a\xd2\x74\x2d\x87\x39\x26\x11\xda\x94\x8d\xc9\xd9\x57\xd3\xb1\xfd\x35\xdb\x75\x8f\xdf\xb3\xdc\xf0\xf0\xc2\x61\x55\x6e\x50\x0f\xb1\xbf\x46\x77\x10\x79\x89\x14\x71\xc1\xc7\xd8\x4b\x8f\x6c\x81\x85\x65\x1d\x63\xd6\x6d\x73\x77\xa6\x74\x09\xf8\x6c\x65\x00\x21\xd5\x0f\xa3\x78\x70\x2e\x64\xd9\x36\xdb\xe0\x33\xb1\x2e\x74\xdb\xb6\x43\x0a\x1b\x58\x08\x50\x22\xa9\xd0\x59\x00\x44\xce\xdf\x25\xac\xab\xf6\xd0\x31\xff\xce\xa2\x37\xc0\xb3\xa3\x8b\x93\xfc\x72\x9d\x08\x10\xe9\x57\x09\xdf\x3f\xe1\xfa\xed\x87\x97\xfe\x0a\xef\x9f\x32\x6a\x03\x1e\x96\x5f\xa0\xc2\xc8\xc6\x69\x37\xd4\xef\xdb\x4e\xcd\x9c\x24\x76\xfd\xcf\xd1\x9f\xa4\x8a\x2e\x96\x2e\xe6\x80\x02\x48\x48\x41\x1a\xcf\x6b\xc8\x28\x51\x41\xa2\x6f\x1e\xe1\x9c\xca\x7e\x74\xd2\xd2\x4d\xfb\x28\x07\x6c\x39\x30\xcf\x49\xa7\xa6\x6b\x2f\x5c\x87\x42\xb8\xf1\x7e\x13\x65\x1c\xe1\x06\x77\x2b\xba\xcb\x49\xbb\x25\x6e\xec\x20\x50\x77\xa3\xbb\x6a\x6b\x0b\x25\x06\x94\x07\x89\xdb\x43\x86\x54\x39\x3a\x74\x60\xd3\x03\x77\x8d\x66\x2d\xfa\x11\x59\xa0\x14\x57\x6b\xa1\x35\x01\xfc\xd8\xca\x4d\xb8\x0c\xa1\xcd\x49\xf2\x92\xee\xc7\x73\xbe\xc7\x3a\xc7\x18\x38\xe7\x87\x32\xa6\x84\x15\x76\x69\x4a\x35\x9d\x51\x1c\x94\x51\x96\x41\x95\xc1\x29\x17\x56\xad\xa7\xdc\x81\xbb\x11\xaf\x7c\xd0\x50\x95\xc2\x1a\xa5\xf8\x50\xac\x70\x36\x02\x18\x38\xaa\x14\x6a\x63\xb7\x86\x7d\xcc\xa1\x64\xf3\x05\x0c\x5b\x0d\x0d\x85\xed\x7f\xf0\x09\x0d\xf4\x91\x51\x1c\x9b\x67\xb6\x2d\xd9\xef\xbc\xe6\xd8\xb7\x9d\x5a\x4f\x74\x9d\xdd\x95\x6f\x11\x50\x2a\xea\x1e\x4b\x6d\x17\x05\xd1\x1e\xe4\x10\xa0\x2d\xca\x21\x85\x8d\xef\x99\x12\x00\x87\xd8\x1a\xaf\x36\x0c\x63\xa5\x3b\x82\x4b\x43\x03\xc5\xaa\xb1\x81\xaf\xdf\x71\x14\xc9\x22\xc5\xcd\xa7\x80\x21\xff\xdb\x9d\x35\xf0\x7c\x1e\x95\xd3\xe9\x7c\x09\x4d\x04\xfd\xe2\x73\x00\x04\x07\x9f\x25\xce\x83\xa0\x82\xe0\x9e\x5d\xa9\x50\xd8\xf2\xcd\x41\x11\x65\xb6\xab\x30\xbc\xa0\x9c\xa8\xbd\x47\xa1\xdc\xa8\x56\xc8\x0d\x0d\xee\x7b\x9c\xc6\x6a\xc5\x71\xc3\xfa\xd6\x1e\xfe\x56\x6a\xb8\xc6\xb5\x56\x72\xa8\x16\x71\x85\xaf\x1d\xce\x64\xe5\x9d\x31\xe4\x0e\x3b\xc6\x8c\x12\xde\x45\xd1\x84\xd4\xf3\x2c\xd8\xf7\x2d\x26\x6c\x53\x50\x21\x79\xed\x95\xdd\x70\x80\x66\x54\x5a\xf9\xb2\x5c\x77\x45\x99\x28\xbc\xd7\x46\x3c\x9f\xfd\x5e\x54\x3c\xfc\xd5\x28\x8a\x12\x27\xf4\x95\xe3\xff\xbf\x3b\x99\xb1\xb1\x0d\x42\x9a\xf4\x89\x32\xb8\x8d\x11\x92\xd9\xc8\x04\xdd\xfb\xbc\x86\x07\x6f\xb8\xc7\x45\x4e\xc2\xb3\x0c\xb8\x8a\xb5\x89\xfe\x67\x26\x7b\xb0\x67\x5a\xed\xcb\xac\x75\x6b\xf4\xa0\x7a\x1f\x4b\xaa\x71\x2f\x6d\x21\xce\x18\x78\xb2\x6c\x10\x68\xc5\x2e\xd1\xbd\x31\xf4\x8a\xc8\x50\xe8\xfa\x5f\x5f\x14\xc7\x31\xa0\xca\x0e\x5b\x46\x6e\x88\x70\xcd\x75\xf2\x29\xca\x88\xcc\x5b\xb7\x82\x0c\x26\x6d\x6a\x41\x58\xd0\x0b\x50\x9b\xc9\xe1\xa0\x41\x04\x0e\xf9\x38\x64\xbb\x3c\x06\x6d\x34\x1f\x70\x8a\x9c\x72\xbc\x46\x5f\x32\x6c\xe1\x19\xed\x14\x24\x38\x74\xca\xdb\xbc\x87\xa1\xb4\xf0\xc0\x0e\xa5\x53\xdc\x28\x3c\x78\xef\x6e\xba\x47\x8b\x9e\x47\x95\xbe\x8a\xbd\x17\x5f\xdf\x70\x0a\x03\xe7\x07\xb1\x29\x74\x0f\xd4\x16\xd1\x5c\x45\x56\x39\x46\x6d\xa7\x3b\x0e\x5b\xad\x4f\x8a\x85\x72\xea\x7a\xa1\xd6\xfb\xf8\xac\xd8\xba\xd0\x9f\xbf\xfc\xb5\x90\xa9\x0e\x52\xb5\xdc\xd3\xc8\xac\xdb\xb0\x3a\xcc\x3a\x5a\x9e\x68\xe8\x79\x10\xe2\xb6\x52\x84\x83\x11\xfb\xac\x97\xed\x70\x91\x8a\xd7\x8a\xe1\x19\x34\x03\x24\x44\x2a\x02\x5b\x1f\xae\xfd\xb4\xb8\x5d\x95\x37\x3b\xc5\xdd\x0e\xd6\x56\xbd\x4c\x06\xf8\xba\x49\xe2\x2f\x42\xab\x35\x30\x17\x3b\x2e\x3e\x47\xde\x5a\x19\xbe\xdb\x06\xb9\xb7\x34\x6b\x07\x2c\x23\xfc\xf6\x75\xbe\x29\x18\xe6\xd1\x86\x3e\x09\xd3\x2b\xd9\x4a\x4c\xf1\x74\xe8\x40\x43\xed\xd5\x9b\x8e\x8d\xe2\x11\xd7\x9d\x12\x0a\x8e\xcf\xe3\x32\x9e\x92\x3d\x66\x4c\x06\x5a\xcf\x38\x28\x43\x46\xc5\x5b\x29\xa4\xb8\x11\x15\x31\xb7\x6f\xf2\x92\xe2\xf4\x61\x84\x1c\x9a\x62\x8a\xf1\x22\x36\xd2\x52\x0a\x83\xa2\x3e\x66\xb9\x55\xe5\xe8\x0d\x59\x5c\x8b\x1b\x1b\x9e\xc3\x87\x1a\x8c\x0d\x49\xfa\xf8\x93\x23\x83\xce\x30\xa9\xf5\xaa\x20\x67\xca\x20\x39\x7a\x8e\xc3\x70\xa8\xb3\x96\x0c\x05\xb3\x52\x2a\x0e\x39\x40\x01\x3d\x65\x68\xe8\x73\x92\x68\xc9\x0e\x34\x2b\x4d\x58\x49\x80\x82\x12\xf2\x5c\x30\xe5\x63\x74\x63\xcf\x65\xcb\x4d\x34\xb7\x71\x27\x5b\xde\x62\x8c\xdd\x5d\xee\xf4\xb1\x61\x7a\xfc\xdb\x12\x33\xac\xcd\x54\x72\xcb\x36\x9e\x7c\x6d\x81\x31\x42\x2b\x99\x6b\x51\x9c\x27\x17\x97\x27\x93\x73\x5b\x1f\xb6\xc9\xc5\x11\xfc\x3a\xb6\xb4\x5c\xc3\x82\xdd\xa3\xe3\xb3\x93\x73\x1b\x62\xfc\xed\x64\x76\x39\x1d\x1d\x4f\xa6\xd8\xca\x0d\x5e\x18\x9d\x9f\xfc\xf3\xe8\xe8\xe4\xf1\xdf\xce\x1b\x60\x5e\x1d\x9f\x5c\x4e\xa6\x36\xa8\xfc\x6b\x0f\x78\x67\xa3\xf3\xd1\xdb\xb1\x0d\xde\xdb\xf1\xac\x17\x38\x2b\xaf\xf4\xdb\x0d\x1c\xb3\x06\xdb\x4f\xda\x33\x26\x26\x78\x07\xa5\x34\x1d\x2e\x90\x92\x98\x61\xfc\x86\x4f\xb8\x0b\x86\x62\xa5\x92\x92\x81\xa8\x2d\xa8\x7f\x52\xee\xb2\xec\x06\x18\x3b\xb5\xe1\x92\x21\xb6\xa5\xfc\x8d\x2b\x4b\x8a\x34\x9b\xe2\x3b\xa2\x2c\xd6\x3f\xa1\x3c\x42\xfe\xcc\x76\x73\x0c\x2d\xb3\xf9\x83\x1b\xdb\x36\xeb\xc2\x27\xba\x9b\x1c\x6f\x6b\x04\xeb\x61\x4c\x16\x88\xbe\xc0\x22\x8f\x5b\x88\xb4\xc6\x55\x77\x23\xc8\x22\xbf\xe0\x49\x9b\xb3\xb5\x30\xe3\x16\x9f\xeb\xa4\x3d\xf7\xa8\xcb\xd2\xe4\x28\x4e\xa1\x4b\xf9\x78\x1c\xb9\xa1\x82\x68\x75\xa8\x9b\x6d\x4f\x07\x70\xdd\xc2\x84\x22\x8c\x10\x88\xdd\x80\x83\xef\x82\x4a\xd5\x1d\x1d\x8e\x90\x8a\x70\xe1\xb2\x66\xb6\xae\x89\xb8\x28\x05\xb7\x75\x0c\xbb\xb5\x8e\x42\xe7\xd0\xfe\x22\x07\xc3\xe1\x5d\x5c\x92\xad\x79\x5c\x2a\x86\x16\x0e\x9e\x52\x18\x2d\xc5\x26\xb2\x24\xc1\xbe\x80\x71\x14\x52\xd3\x39\xf7\x0e\x2d\x38\xa5\x98\xdc\x55\x20\xec\x91\x69\xf5\x83\xa7\x08\x63\x5b\xc4\x88\xca\xb8\xcc\xf5\x44\xd3\x8a\xb5\x16\x3f\x10\x93\xc8\x03\xe2\xcf\x0b\x11\xc2\xf5\xc3\xbd\x70\x7d\xaf\x18\x71\x6a\x2b\x44\x50\xeb\xa1\x5c\xb9\x0b\x8b\xdc\x43\x37\x3d\x57\x3c\xc0\xc9\xa1\x9e\xe6\x54\xd9\x09\x63\x80\x29\xe2\x14\xc3\x06\x72\x4b\x91\xe6\xa2\x56\xf7\x48\x91\xb5\x56\x45\x48\xb0\x1b\xa3\xae\x8d\x90\xf0\x82\x20\x04\x7c\x1d\x89\x05\xeb\x15\x5a\xa3\xdd\xd6\x82\xd4\x65\x1c\xc6\x8d\xe0\xd3\x8c\xa3\x9b\x92\xde\x12\x39\x71\xd4\x16\x33\xa1\xde\x87\x65\x16\xeb\xa4\x94\x5c\x6e\x2f\xdd\x74\x7e\x6f\x17\xdb\xb8\x19\xe2\xe8\x36\x3f\x36\x83\x42\x98\x06\xca\xee\x79\xe4\x03\xf5\xb6\x5a\x2f\xe8\xa1\x2b\xf5\xcf\xb5\x0f\x44\x7c\x9f\xb2\x64\x22\x07\xb4\xea\x3c\x0d\xfa\x00\x06\x0f\xa7\x14\x30\x34\xbf\x97\xf5\x1d\x64\xd3\x69\xae\xa1\x06\xbf\x53\xe2\xaf\xce\xc0\x09\xdc\xe4\xde\x79\xf5\xfa\xb3\x03\xe7\x32\x76\x7d\x2a\xca\x48\xdf\xa1\x6f\x07\x63\xed\xb1\x30\x4e\x1a\xfb\xab\x15\xde\xc6\x6f\xb3\x54\xf5\xb5\xc6\x34\x8d\xb9\xf0\xd7\xd8\xdf\x14\xdb\x11\x53\x9c\xa9\xf1\x3e\xbf\x4d\x4c\xb3\x9c\x56\x17\xaa\xd4\x1b\xc6\xdd\x2b\x39\x4a\x59\xed\x18\x3c\xf0\x83\xcf\x7e\x4c\x25\xa0\x90\x97\xe4\x14\xcb\x05\x56\xab\xf4\x7d\x5f\x14\xb2\x54\xdc\xa2\x28\x3d\x39\x92\xb9\x50\xb7\x0d\x11\x7b\x9c\x95\x86\x1d\xc4\x65\x44\x5a\xf1\xb5\xa0\x21\x02\x59\x0d\xab\x30\x24\x35\x9a\x8e\x84\x16\xf0\xd1\x67\x83\xba\x66\xb4\x2d\x91\xe1\x55\x4c\x6d\x61\xdc\x04\xb8\x77\x47\x68\x0b\x2c\x11\x63\x49\x57\x94\x29\x3e\x9e\x1d\x0e\xd5\x2a\xe3\xe3\x95\xcf\x38\x81\x61\x55\x1c\xf1\x2e\x7b\x59\xcb\x10\xf9\x40\xa9\x94\xb2\x67\xb0\x05\xef\x94\xfd\x87\xb1\xcc\xf7\x30\xf7\xa4\x44\x49\x82\x47\x1f\xa9\x18\x21\x59\xd0\xf2\x04\xdd\x7f\x85\xb3\x8c\xa8\xee\xad\xd3\xec\x0f\xb8\xa0\x80\x88\xa2\xfe\xa9\xf6\xb0\x2d\xd4\xc3\x96\xfd\x24\xc3\x2b\x72\xad\x53\x45\x9a\x37\xc5\x56\x34\x90\x95\x3f\x6a\xc4\x6a\xe4\xdd\x89\x9b\x2c\x47\x20\xcf\x90\x16\x23\x97\xae\x16\x98\xa9\x14\x2b\x13\x93\xe5\x6e\x69\xa7\x08\x9d\x06\x61\x54\x13\xfa\x88\x8b\x99\xe3\x22\x77\xa6\x92\xaf\x36\x96\x68\x48\x62\x33\x61\x6a\xa0\xfd\xb0\x16\x76\x83\x32\x91\x53\x65\x79\xd5\x8a\x2a\x31\xee\x2d\xce\xed\xc6\xa1\x3a\x95\xa9\x3f\xcf\x02\x0c\x9f\x6d\xd7\xd1\xa5\x2a\x43\x40\x38\x05\x9e\x9c\x17\xdc\xf2\xba\x7c\xbf\xc8\x41\xdb\x08\xa2\x6c\x94\xf9\x7d\x14\x25\x79\x32\x0a\x9e\x27\xb8\x0f\x31\xf2\x09\xff\x3e\x70\xbe\x8a\xf0\xf4\xa2\x40\x01\x37\x16\xb4\x1b\x56\xb8\xc3\xd2\x94\x05\xc7\x2d\x37\xa4\x15\x3a\xf3\x25\x91\x95\xb4\xd1\x52\x63\x4d\xe8\x0c\xc4\xc2\xc7\xbc\xb9\x14\x40\x32\x38\xf8\x48\xdb\x54\x7d\x92\x4d\x96\xd1\x28\x24\xbf\xa2\x28\x11\xd4\x3b\xdc\xe5\xad\x9b\xe4\xa9\xb7\xb2\x0e\x00\xfa\x29\x55\xba\x96\xed\x60\xe2\x31\xb3\x2d\xca\x71\x17\xae\x35\x91\xf2\x7d\x26\x82\x35\x9c\x05\x35\x26\xa6\x46\xd0\x2a\xb9\x87\x83\x47\xd1\xe2\x6d\xa4\x3e\x99\x53\x6c\x16\x40\xed\x75\xc3\x37\x6b\x98\x16\x4a\x98\x84\x69\x1c\xd5\xd6\x84\xd8\xc5\x0a\xc0\xf9\xc2\x4e\x6b\xd0\xae\xa3\xab\x66\x34\xc2\xe1\x64\xe2\x40\x72\x00\xa5\x01\x66\x25\x5b\x20\xcb\x92\xd0\xe5\xeb\x8f\x7c\xcf\xb5\xf5\xd1\x97\xa8\x28\xa1\x4a\x17\x90\xae\xbd\xab\xdb\xe5\x75\x58\x1a\x54\x05\x90\x96\xe5\xfd\x69\xc0\x24\x29\x69\x4a\xa1\x80\xc3\x1d\xa8\xd8\xb8\x72\x87\x44\xf3\x6c\x65\x2d\x82\x71\x91\x17\x46\x21\x8a\x3c\xe7\xfa\x45\x21\xfb\xf3\xfa\x45\xc9\xb8\xa3\x73\xd5\xd0\x49\x23\xe3\xd1\xe9\x55\xfb\x7e\x2e\x24\x97\x1a\xe5\xa4\x44\x18\xc9\x0b\x6e\x15\xe9\x46\x19\x8b\xf2\xd8\x07\x8c\x53\x97\xe3\xb6\xee\x61\x39\x1a\x52\x56\x61\x30\xf2\x98\xb9\xc5\x33\x7f\x63\x24\x51\xe2\x69\xbd\x81\x1b\xa4\x33\x99\x1d\xda\x92\x02\xc7\x7a\x51\x25\x11\xe0\xa7\xec\x8d\xfc\x58\x51\xde\x05\x02\x5d\xa8\xf6\x91\x9f\xe0\xe5\x82\x36\x87\x96\x8c\xc1\x8b\xfa\x19\x2c\x24\x2f\x66\xa1\xaf\x12\xf5\x1b\x18\x6d\x59\x0b\xec\x1c\x81\xcd\xac\x13\xf6\x8b\x59\x8e\xcd\xec\x2c\x43\x5b\xc3\x17\xef\xe1\xda\xe8\x63\xd9\xc1\x22\x95\x3b\xd0\x58\x82\x4a\x14\xf7\x24\x37\xc6\x20\x4e\x0c\x39\x97\x0b\x00\x26\xc5\x5d\x84\x11\x16\xba\x23\xc5\x22\x49\x3d\x7b\x56\xfb\x09\x68\x8d\xfe\xd2\xe7\xec\x43\x7c\xef\xf1\xaf\xf8\x22\x7b\x8e\x78\x01\x64\x9e\x8c\x21\x97\x95\x50\x12\x97\xca\x4b\xd3\x36\x83\xa3\xc5\x76\x98\x12\x59\x58\xe4\x10\x2e\x62\x64\xaa\xbc\x93\xb1\x9a\x78\xce\x94\x2e\x41\xa5\x3b\x8f\xab\x8b\x25\xe8\x6b\x91\xcc\x09\x55\x66\x86\x88\x8f\x8f\xe3\xf1\xc8\x01\x95\x17\x44\x86\x55\x62\xaa\xf1\xa1\x3a\x80\x74\x14\x4b\x33\x51\xf1\xa9\xe2\x05\xa4\x74\x1d\x32\xaf\x4b\x14\xd6\xf7\xf8\x33\xd0\x65\x93\x2b\x34\x68\xa4\x6c\xcd\x73\xda\x46\x15\x5a\xc7\xf0\x49\xfb\x21\x5a\x86\x88\xcc\x78\xcb\x51\xd7\x98\x98\xf4\xe0\x72\x5b\xa1\x94\xcf\x6e\xab\x04\xaf\xc3\x88\xa3\x7b\x1b\xc9\x59\x95\xa9\xde\x79\x42\x30\x67\x3e\xd9\xa8\x8a\x60\xcb\x63\x42\xfe\x12\x0e\x77\x98\x0f\x2f\x7a\x08\x83\xc8\x45\x67\xa1\x94\x3a\x78\xc0\x8b\xa5\x71\x6f\xb5\x4a\x1c\x4e\x43\x06\x35\xc1\xcb\xe6\xb2\x28\xd6\x8a\xe1\xbb\x78\x67\x13\x98\xfb\x24\xf3\x63\xb5\xd8\x11\xc9\x1c\xb4\x03\x22\xb3\x9c\xd1\xab\x2c\x70\x56\xb1\x13\x47\x1c\xba\xce\x97\x22\x94\x97\xa0\x78\x92\x2f\x1a\xde\xf9\xbb\x04\xeb\xce\x52\x3a\x1e\xaa\x29\x0d\xfb\x99\xc0\x60\xac\x8a\x34\xd1\x51\x20\x27\xfa\x08\x03\x15\xea\xc9\xd0\x78\x78\xb4\x69\x70\x43\x5b\xe7\x99\xeb\x6b\xd6\x15\xdb\xcc\xa3\x9b\xf3\xda\xb8\x5c\x3e\x84\xeb\x65\xb2\x0b\x00\x74\xb8\x70\x81\x59\x70\xd9\x0a\xeb\x8e\x60\xec\xaa\xd4\xc0\x68\x96\xe0\x29\x2e\x51\x99\xe2\x91\x80\x6b\xa5\x3d\x8a\x35\xf7\xa4\x07\x5c\x4e\xde\x17\xe8\x47\xae\x23\x51\x6a\x9c\xfa\x7e\x4d\x35\x47\x80\x35\x59\x28\x23\x3b\xc9\x2a\xc4\x47\x73\x82\xea\x1a\xe7\x0d\x8e\x61\x72\x1f\x7f\x0e\x05\xd6\x4f\xc3\xe0\xa3\xc7\xbf\xc0\xce\xe3\x7e\x20\x21\xe6\xed\x58\x65\x1e\xe9\x94\xb6\x8c\x30\xfc\x59\x08\x6b\xd0\xdc\x45\x16\x4b\x47\x3b\x5f\xc3\x8c\xea\xc7\x32\x70\xde\x5a\x67\xe3\x58\xac\x32\x55\x68\x23\x8f\xba\xa9\xbe\xdd\x15\x6f\xe1\x7e\xdb\x17\x6d\xe5\x65\x0b\xd6\x04\x2d\x56\xaa\x51\x15\xc6\x31\x61\x8b\x06\x15\xd4\x4c\xe9\x75\xac\x74\xc8\x1a\x4d\xb6\x35\x1f\xae\x7d\x69\x6b\x08\x29\x31\x8b\xed\x49\x70\xb8\x62\xcf\x06\xb2\x43\xc8\x20\x72\x5c\xe5\xb2\xb4\xc4\x4a\x95\xd3\xb7\xaa\x85\x4c\x1d\x96\x1f\x09\xd8\x44\xf5\x8a\x4c\x6c\x40\x26\xfe\xcb\xe7\x87\x5a\xf6\x9f\x1d\x5a\x4b\xa7\x4a\xea\x70\xff\xad\x10\xa4\x42\x0f\xca\x0a\x68\xf6\xce\x2b\x24\x89\x88\x45\xf1\x92\x2f\x53\x82\x58\x4b\x18\x95\xb7\x77\x8e\xc9\xfb\x4f\xba\x39\x30\x9c\xbe\xeb\xe3\xfb\x3b\x75\x65\xfc\x40\xc1\x52\x4a\x90\x4b\xe0\xb4\xe2\xd7\x44\x0d\xce\x15\x45\xd7\xa8\xbc\x1b\x98\x54\x50\x3f\x54\xd9\x07\x0c\xd6\x7d\x25\xbe\x57\xf5\x0e\xc9\xb7\x1f\x51\x9d\x64\xf4\x80\x64\x41\xca\x67\x2f\x41\x20\xc3\x36\x1c\x25\xca\xd5\x43\x05\xd8\xac\x59\xc6\x84\x5d\x9e\x10\x54\x3f\x9c\x63\x77\xd0\x70\x55\xb9\x5b\x81\x20\xf6\x61\x1b\xf3\x31\x02\x9c\xc7\xad\x8d\x34\xe9\x23\x47\xc6\x0f\x48\x96\x48\x07\x10\x13\x28\x45\x0d\x43\xaf\xf2\xac\xe0\x1f\x72\x2d\x69\xab\x9d\x58\xc5\x17\xd1\x27\x64\x16\x69\xc3\x9a\x4b\xf9\xa5\xb4\xc0\x9d\xe8\x53\x71\xa7\xb4\xf8\x3a\xdd\x01\x4f\x2d\x2b\xb7\xe5\xde\x37\x1d\xff\xfe\x6a\x3c\xbb\xb4\xf9\x6a\x67\x93\xd3\x93\xa3\x93\xcb\xab\x63\x8b\x9f\x76\x3a\x9e\x5d\x4c\xce\x67\xd6\xc4\x5a\xfc\x1d\xe1\x8f\x6c\xef\x4f\x4e\xc7\x33\xbb\xd8\xb0\xbd\x74\x75\x39\xb6\xc5\x3b\x4c\xaf\x2e\x47\x96\x30\x87\x29\xcc\xe9\x90\xaa\xbc\xe4\xe9\x71\xb8\x29\xfd\xf0\x2e\xa2\xb3\x17\xef\x7a\x71\x43\x01\xe8\x51\x5e\x99\xed\xf1\xaf\x70\x0c\x62\x5d\xe9\x0c\x17\x12\x07\x7d\x52\x8b\x30\x73\xe2\xcb\xd9\x13\x98\x7f\xc8\x8f\x89\xc4\x26\xd8\xd0\x6a\x0c\x14\x7a\x02\xdd\x99\x00\x61\x05\x07\x81\x90\xa5\xd2\x93\xdf\xf2\xd1\xbe\x5c\xd9\x3b\x0e\xfc\xef\xff\x75\x2c\x12\xc1\xd9\x2b\xec\xe5\x04\x8d\x43\xe9\x96\xaa\x40\xe7\x7d\xf6\xf8\x97\xf8\xce\x0d\xdd\x22\xc4\x0e\x04\x49\x6b\xf2\x59\x04\x9f\xb9\x71\x87\xfe\xa8\x24\x2f\x16\x0c\x07\x1d\x76\x83\x56\xa4\x05\x6e\xd1\x68\xee\xbb\x4a\x63\x03\x35\xe7\xb7\xfd\x29\x07\xdd\xa5\x19\xe9\x86\x32\x3c\x81\xc1\x80\x0f\xd1\xb1\x2e\xe7\x3c\xfe\x25\xf8\xed\x5e\x46\xf5\x04\x34\x37\x13\x26\xcd\xcd\x35\x41\xc3\x85\xfa\xfa\x9c\x94\xbf\x92\x16\xed\x49\xe0\x55\x6d\xce\x29\x29\x23\xe7\xe2\xa1\xf2\xd3\x6f\xaf\xb3\xcf\x3f\xff\xb5\xcd\x4c\x56\x1d\x1a\x1b\xa6\x5b\x49\x02\xed\x9f\x97\x7f\xd5\x22\x5e\x4b\xa0\xdb\x46\x5f\x13\x9f\x40\xf1\x5a\x54\x8b\x15\x54\xb5\x3e\x66\xd4\x51\x10\xc1\x75\xf9\x0d\xea\xeb\xf1\xa6\xfb\x9c\x7a\xa4\xdf\xc5\x8d\xa1\xdd\x25\x74\xcc\x84\x12\xbe\xee\x03\x51\x21\xdf\x55\xcf\xcd\x9e\xc6\x51\x8d\x08\xaf\xa2\xea\x33\x06\xe9\x7f\xf5\x8d\xde\x67\x73\xd5\xc2\x2c\x95\x85\xd7\x1a\x2f\x98\x78\xf2\xde\xca\xfb\xe5\xdc\xde\xfc\x8c\x69\xb2\x52\x91\xc1\xd5\x79\x2d\x80\x9d\xf2\x52\x95\x97\x76\xe5\xf2\xff\x3e\x36\x59\xa5\x86\x5d\x49\x0d\x27\xa9\x67\xca\x2d\xde\xc9\x94\x72\xbb\x74\xa9\xe2\x9d\x76\x34\x93\x3f\xb8\x98\xc6\x61\xbd\x83\xca\x7b\x71\x2c\xa9\x92\xa5\xbb\xb2\x3c\x42\x1e\xa4\x16\x77\xe2\x02\x81\xec\x7f\xa7\x4c\xe1\x84\x1f\xad\xdc\xaa\xce\x7d\x91\xc4\xc4\xd7\x79\xa1\x71\x6e\x02\x12\xb2\xe3\x57\x21\x41\xa4\x3d\xde\xbf\x91\x63\x79\x99\xb7\x5f\x0c\xeb\x6c\xfb\xef\x17\xc0\x48\xc9\xbc\x72\x4d\x6f\x5b\x3c\x80\x1e\x63\x16\xd6\x1b\xa2\x2d\xe1\xb4\x1a\x91\xac\x0c\x8d\xed\x0b\x69\x36\xb8\x58\x5f\x17\x6c\x51\x20\x6b\xdd\xb8\x79\x01\x96\xc6\xa8\x69\x8d\x33\x8b\x65\x1b\x00\x89\x32\x6c\xba\x8f\xe6\x28\xd9\x6b\x8d\x98\xae\xa6\xa7\x8e\xae\x6b\x68\x89\x1e\x50\xd8\xa8\x51\x85\x91\x07\xcf\xfe\x26\x58\x52\x6d\x08\xe5\x45\x68\x4e\xbe\xba\xd0\x2c\xfd\x80\x39\xeb\x09\xdb\x83\x44\xa2\x83\x27\xfc\x66\x3a\xc2\x42\x00\x7b\x97\xd1\xd6\xc4\xd1\xb7\xa1\x40\x35\x74\xfb\xb9\xac\x94\x19\xe8\x34\xa3\xe5\xcc\x0a\x3c\x00\xde\xbb\xb1\x79\xce\x94\x33\xbe\xf1\xce\x15\x95\xc3\x49\x5f\xcb\xb5\x88\xe7\x07\xfe\xa1\x8e\xf5\x04\xbf\x39\xe2\x90\x89\x2b\x18\x4f\x93\x05\x45\x0e\x2a\xe4\x2b\x54\x5d\x22\x42\x81\xb8\xbc\x4a\x66\x81\xba\xba\x52\xe0\x25\x52\xd5\xb2\x2f\x11\x4b\xd7\xb8\x3a\x72\x9b\xd9\x17\x17\xba\x87\x32\xcf\xa8\x4e\x2d\x76\x0b\xa2\xf5\xca\x90\x0c\xbe\xf1\xd7\x40\x52\x91\x73\xfc\x35\x91\xb4\x03\xef\x30\xa0\x31\x0a\x0c\x8a\x3c\xa3\x82\x66\x99\x26\x0b\xb7\x8a\x04\x1a\xfc\x2a\x92\xf8\x69\x38\xf6\x4b\x61\xcc\xd6\xa3\xcf\x58\xa7\xa7\xde\xad\xfb\xda\x63\x88\x3d\x6c\x31\x51\x16\x37\x18\xc9\x63\x4d\xc6\x93\xed\xa6\x22\x61\x7d\x58\xd3\x69\x20\x85\x51\x34\x60\xe0\x9e\xeb\x79\xb1\x0f\x6b\xbc\x16\xb9\x71\x65\x96\x4c\x7d\x5d\xca\x16\x14\x9d\xd4\x9b\x02\x9e\xde\x7a\x46\x09\x53\x4b\xc7\x02\x13\x57\xaf\x46\x05\x39\xa2\x86\xb4\xc6\xc2\x48\x1a\xf3\x0f\x15\xb8\x26\x8d\xa1\x48\x6b\x83\x7e\xa0\x40\xd9\x7b\x44\x14\x41\x75\x68\xfb\x41\x40\xa5\x81\xbd\xb8\x0b\xf4\xf5\xf9\x29\x77\xa7\xa2\x57\x6e\xcf\xba\xad\x58\x20\xe2\x99\xb6\xa6\xe4\x49\x5e\x0a\x96\xaf\xf0\x5f\xa9\xcf\x65\x16\x95\x7e\xe8\x36\xde\x86\x82\xf3\xf5\xe8\x5c\x3b\xb6\xe6\x71\x54\xe6\xad\x3c\xb7\x5b\x4f\x58\xc3\x4c\xb8\x45\x14\xdb\xf0\xbf\x28\x55\x24\x57\x3a\x0e\xa1\xdb\x04\x58\xa5\x50\x11\x59\xeb\x58\x3a\x0e\xa4\x62\x69\x28\xdb\xa8\x9e\x58\xdb\x2c\x8d\xde\x6e\x01\x71\x6b\xc9\x7a\x3e\x35\x53\xf1\x4d\x8d\x18\xed\x67\x06\xb8\x9c\x6d\xc6\x97\x75\x4c\xdb\x85\x3b\xc6\x50\x4a\xe8\xdd\x1a\xec\xad\xbc\xe9\xcb\x82\x55\xd4\x2d\x96\xcf\xb8\x44\xdb\x41\xc5\x69\xa2\x83\xba\x67\xb3\x77\x1c\xd9\x16\x44\x0f\x1c\x0b\xda\x96\xc3\xcf\x36\x29\x8c\xd2\x66\x07\x7c\x1e\xe5\x09\xc7\x1f\x82\xe3\x70\x95\x96\x83\xb0\x96\x0a\xee\xb0\xe9\x61\xe0\x4c\xa9\x72\xb1\x8c\xba\x14\x71\xdb\x51\x6f\xd2\xc7\x8e\x7c\x55\x39\x8f\xac\x68\xef\x54\x27\xb7\x82\x12\xc0\xa1\x34\xe8\x8b\x77\x8c\x8a\xc3\xf6\x9a\x69\x53\x6d\xd7\xb0\xc6\x8b\x4c\xf3\x89\xb0\xc5\x78\x4c\x65\x24\xd4\x2a\x11\x99\x17\x0d\xd3\x74\x43\xd3\xd0\x18\x45\x3a\x93\xe1\x6e\x71\xc1\xc1\x96\x43\xb0\x61\xc2\x8c\xa1\x16\xc5\xe3\x7d\x14\xac\x29\xca\x5f\x65\xf6\xf8\xad\x2a\x88\xca\x43\x7a\xb6\x0b\x32\xd2\xe8\x0b\xdc\x92\x05\x32\x3f\xed\x2d\x98\xd3\xf6\x5a\x94\x3a\x15\x8f\xdc\xce\xd1\x98\x42\x1c\xea\x6c\xf8\x58\x4c\xf2\xae\xb0\x2d\x0a\x23\xee\x7c\xe8\x31\x2d\xf2\xd0\xce\x37\x42\x11\x53\x35\x13\xb0\x80\xac\xfb\xa9\x97\xc6\xbe\x60\xf3\x8e\x1f\x7a\xfe\xda\xf7\xb0\x99\xa5\x0a\x0a\xa2\xde\x42\xe4\x11\x03\xc4\x69\x66\x0b\x51\x40\x0b\xed\x4a\x28\x4d\x36\x89\x74\xf4\x12\xed\xde\x72\xdb\x5c\xf4\x79\x91\xc8\x4e\xad\xb1\xb5\x06\x59\x1e\xc5\x87\x06\x2e\xa7\xd0\x4c\x46\xba\x85\x94\xce\x1b\xd1\x5d\x3e\x31\x07\xc0\xba\x35\x73\x1a\xa9\x7f\x46\x26\x6d\xaa\x39\xa9\x0c\x5a\x55\xc7\x91\x51\xe9\x8d\x9d\xff\xac\x54\x72\xd3\x61\x58\x09\x2f\x13\xea\x18\x7d\xe0\x38\x23\xac\x43\x4a\xc2\xf4\x5e\xb8\x01\xe6\x7f\x61\x29\x3d\x62\x2a\x06\x38\xae\xb2\x3c\x0f\x86\x1a\x30\x24\x14\x83\x15\x0b\x4c\x01\xb0\x9f\x81\xb5\x43\x02\xde\x22\xd2\xba\x64\xd1\xbc\xa4\xa0\x4b\x41\x65\xca\x0f\x08\x72\x98\x5c\x93\x82\x7b\xc5\x70\x0a\x57\x1e\x30\x20\x43\x0a\x3c\xb3\x26\xe2\xca\xba\xe1\x1a\x99\x02\x3b\xbe\x8e\x29\x25\x16\x90\xc3\x7b\x6f\x2c\x28\x5b\x1e\x75\x7c\x43\x89\x07\xa1\x39\xfe\x42\x1f\x4b\xc9\x88\x44\x8f\xbf\x4b\x7d\xb8\x16\x4e\x48\x3d\xb3\x03\x37\xf4\x35\x7a\x2f\x1c\x09\xcc\x5e\x36\x66\xae\x74\x23\x37\xd0\x2d\xcf\x41\xbb\x49\x25\xcf\x6a\xa7\xf1\x0f\x3f\x88\xcd\xb3\xf3\xa0\xae\x22\xd8\x27\xe5\x05\x9e\x6f\x5d\xb8\x40\x47\xf4\xbe\xd6\x81\x3a\x60\x7b\x0c\xdd\xbe\x29\x72\x78\x5b\xb2\x00\xbb\xf0\x6a\x16\xd8\x39\xa0\x9a\xf5\xee\x49\x36\x50\xdb\xdd\xbd\x88\x04\x84\xd4\x36\x74\x1d\xc4\x6e\x9c\xaf\x89\x79\xc0\xe2\x8f\xc2\x9d\x73\x6a\xd8\xd0\x6c\x68\xdf\x3a\xc8\xc0\x88\x4d\x37\xfb\x27\x36\x9f\xbf\xfc\x04\xc6\x88\x15\x1f\x93\xb0\x68\x70\x0c\xcd\x8d\x13\x6b\x94\x83\x1c\x5e\x5d\xde\xf1\xd6\x49\xfd\xf9\xc8\x2a\xc9\xc5\xad\xd9\xef\x6d\x59\xfc\x8d\x14\x6f\x9d\xbe\xbf\x35\xc5\x79\x1f\xcf\x0e\xe4\xc6\x59\x60\x74\x44\x66\xd9\x58\x2c\x65\x59\x8e\x66\xd2\x92\xa3\xc3\x1a\xa2\x6e\x82\x41\xb5\x3d\x72\x5d\xb9\x4b\x15\xc5\x24\x97\x14\xa6\xe0\xb6\x5c\x2b\x69\x18\x64\x2c\xd0\xab\x1d\x07\x81\x8b\x1d\xcb\x5d\xc9\xa5\x9e\xf4\xb2\x71\x31\xed\xda\x0e\xa0\x16\x75\x5e\xfa\xbc\xb2\x01\xe4\x7a\xf6\xdc\xa4\x9f\xa5\xab\x86\x7a\x78\xf5\x0d\x13\xfd\x06\xc6\xd0\xd3\x3a\x67\xa1\xbc\x02\x73\x3b\x22\xb7\xdb\x8c\xdb\x0f\xa0\xcf\x82\x2f\x14\xda\xd8\xe3\xf8\xda\xb7\xee\xf3\x8c\xcf\x68\xcc\xdb\x67\x70\xca\xbb\xf4\x2e\x4a\x52\x69\x2f\x86\x4f\xc7\x54\x36\x5d\x5e\xec\xe0\xf3\x98\xa3\xe1\xe7\xf6\x3b\xe4\xd6\xe0\x5f\xff\xa8\x2a\xdf\xef\x05\x11\xfd\x01\xb0\x1e\x5c\x0e\x0d\xbe\xa5\x1c\x94\xb4\x9a\xbc\x5e\x13\xae\x87\xad\x07\xb6\x42\xca\xee\xc2\xae\xa1\xf5\x45\x27\x63\x4b\x04\x7d\x09\x87\x91\x72\xda\x67\x64\x92\xf5\xfd\x47\x27\xeb\x41\x6b\xce\xc6\x6f\xf1\x23\x85\x4f\xa7\x8d\xe5\x09\x1a\x60\x5a\xaf\xf4\x18\x82\x6b\x7f\x0f\x37\x19\x66\xf3\x5d\x4d\x4f\x54\xe7\x57\x9d\x2a\x64\xe6\x81\xab\x1e\x10\xb8\x39\xf1\x59\x37\x4b\x61\xb9\xa1\x18\x0e\x82\x8d\x8d\x05\xba\x37\x2c\xbe\xc1\x6a\x1a\xe2\xf2\xcc\x6a\xd6\x4b\x1f\xf7\xda\x81\x73\x82\xc6\x12\xa1\xaf\xeb\x2a\xe7\xa7\xd2\x0d\x42\x42\x23\xfc\x8f\x3f\x21\x01\x4d\xf9\x90\x53\x3c\x63\xad\x62\x01\xcf\x47\xdb\x7b\x2c\x5f\xc7\x86\xfc\x79\xaf\xe4\x0f\xcd\x96\xbd\x99\x6f\x2e\x0f\x3d\xb3\x2d\x79\x9d\x7c\xb1\xc4\xa9\xcf\xc6\x47\x30\xc6\xcb\x6f\x9c\xb7\xd3\xc9\xd5\x85\xad\x64\xdf\xf4\xea\x62\x82\x15\xfb\x66\xe3\xb7\xf0\xf4\xf1\xe8\xd8\x06\x6c\xfa\xfe\xe4\x68\xdc\xaf\x48\x21\xbf\x74\x32\x69\x04\x69\x0b\x8a\x57\x2f\x5b\x02\xe3\x67\x17\xa3\x9e\xe4\x9c\x3a\x63\x7c\xc9\x4a\x0e\x03\xec\x5a\x30\xb1\x03\xac\xe3\xf1\xfb\xf1\xe9\xe4\xc2\x5a\x2e\xf1\x78\x3c\x1b\x4d\xa7\x93\xd3\x53\xc5\xaf\x0e\x30\xbb\x16\x60\x6c\x07\x65\xe3\xbb\x7c\xd3\xc6\xf6\xd9\x3b\x99\xdf\xb5\x95\xc1\x1f\x5f\xa7\xbd\x58\xb6\xea\x07\x25\xb3\x7e\xd1\x54\x65\xa1\x05\xc4\xc6\xb3\x1a\xb4\xc7\x09\x60\x6c\x72\x78\x3f\x8b\x0d\x7b\xa6\xf4\xfb\x66\x09\xf2\xb6\xaa\xa2\xdb\x04\x45\xb1\x3a\x30\x10\xa2\xae\x10\x37\x0b\x79\xa4\x74\x2d\xe9\x50\x53\x22\xb8\x0e\x5c\x4b\x82\x4f\x07\x82\xe0\x3b\xea\x86\x7e\xb3\x6c\x69\x23\xd8\x9d\xa8\x1a\x90\x16\xea\x30\x87\x46\x87\xb3\xbe\xe2\x2a\x83\x09\x3a\xc4\xf0\x50\xc6\x23\xee\x83\xbf\xfa\xcc\x9a\x9e\x84\xaf\xeb\xae\xc0\x6a\x45\xbc\x82\x33\x2a\x0b\xe0\xb8\x3c\xa1\x0a\x23\xb4\x47\x22\x2a\xd1\xf2\x99\x75\xd6\x98\x0c\x5e\xeb\x3b\x51\x51\x5e\xb5\xdb\x10\x43\xed\x32\x89\x7f\x03\xfe\x87\xba\x97\x1f\x3a\x5f\x7c\xfe\xf9\x97\x03\x67\xa9\x1a\x3f\xca\x02\x4a\xa8\x04\x18\xd1\xc0\xb7\x62\xee\x66\x5c\x09\x43\x57\x1f\x5d\x19\xe5\x15\xed\x51\x33\x5d\xc8\x91\xf7\x33\xa6\xe7\x37\x9f\xff\xba\x42\x20\x7e\xa5\x29\xc4\xbe\x64\xaa\x06\x0f\xe8\x07\xf7\x51\xec\xff\xc0\x45\x78\x56\xb2\xfc\x16\x5d\x9d\x74\x65\x0c\x6e\x6b\x66\x5b\x7d\x84\xc8\xec\xc9\x39\xd0\xdd\xd3\xb5\x19\x5d\x12\x65\x7e\x8f\xaf\x19\xa4\xc9\x4e\x98\xba\x56\x0f\xea\x2d\xb1\x4c\x0f\xc7\xc9\xd1\x31\xe1\x81\xee\x45\x96\xd7\xda\xb0\x54\x70\x69\xe6\xd1\xa1\x33\xe2\x7c\x33\x1f\x45\x48\x48\x7d\x8b\x88\x35\x54\xba\x23\xe5\x92\xd8\xab\xd8\x5f\xfb\x81\x90\x39\xbf\xe2\x7b\xd8\x51\x94\x98\xe4\x27\xad\xa5\x89\x3a\xf3\x45\x12\x42\xb5\x77\xc4\x82\x0c\x92\xe7\xaa\x74\x88\xc2\xef\x6b\xab\x23\x6a\x4d\xd4\x76\x8d\x6a\x90\x35\x96\x29\x6a\x18\x3f\x5e\x76\xe2\x78\x46\x5f\x1d\xc1\x37\x1f\x3f\x16\x97\x0c\xff\x3e\x5a\xf9\x34\x0c\xf5\xc4\xd2\x68\x6e\x0a\x3f\x14\x12\x8c\x76\x63\x43\x1d\x3d\xd5\xd5\x62\xa3\x2a\x6f\xa3\x5a\xa1\xca\xca\x18\xbc\xb3\x90\x03\xec\x92\x7c\x6b\xf0\xee\xa9\x7b\x2b\x02\x96\x92\x2a\x55\xbe\x4f\x59\xde\xdc\x01\xa8\x74\xfe\x1f\x8c\x9a\x43\x66\x34\x4b\x3d\xa2\xb6\xda\xbd\x8a\xe8\xaf\x74\xbc\x51\x6d\x22\x6a\x43\x35\x95\xc6\x78\xa2\x72\x62\x6a\x0b\x15\xea\x6e\xa7\x64\x19\xc9\x35\x55\xfb\xde\xce\xa4\xfa\x44\x11\x5d\xe4\xc0\xac\x6b\xef\x76\xaa\x1d\x3f\x6b\xcf\x31\x6b\xbb\x2c\x5a\x4a\x37\x74\xcc\x29\xeb\x4e\x56\xed\xad\xb8\xfb\xfa\xea\xd7\xbe\xa4\xf3\x44\x2a\x0a\x0f\x2b\x71\x56\x4d\xe5\xb4\xca\x74\xd4\xbc\xdd\x88\xd5\xd6\x37\xa6\xa6\x52\xe2\xce\x06\x86\xd3\xae\x8d\x62\x4a\x85\x15\x7b\xb7\x8c\x69\xe1\xb4\xce\x1e\x2c\x0e\xf2\x3a\xbc\x3c\xb9\x38\x74\x4e\xee\xb0\xca\x14\x9d\xcb\x69\xbc\x21\x7b\x5f\x24\xd3\x0f\x5d\x67\xfd\x45\x25\x07\x71\x40\x8f\x53\x75\x57\x65\x6f\x18\xae\xc8\xb0\xdc\x54\x3a\xbc\x9a\x5f\xa8\x07\x7d\x1d\x1e\x61\xce\xf8\xef\x26\x87\xce\x4c\xc5\x2a\xf9\x64\x6d\xa4\xfb\x80\xca\x52\xac\x6f\x5c\x43\x17\xf7\x2f\x06\x5c\xe7\xc0\xb0\x42\xe4\xd1\x06\x43\x9b\xff\xbc\xc2\x9e\x2d\xf7\x6b\xd7\x6e\x3a\x33\x5b\xb8\x63\x67\x39\x6a\x8f\x4c\xec\xb8\xe9\xcc\xdd\xd2\xe5\x10\x9d\xd5\xec\xb2\xee\xc7\x9c\xcd\xae\xa3\xa0\x5a\x4c\x3b\xea\x6d\xbb\x7e\x2d\x5f\xb7\x2a\xcc\x69\x39\x4d\x8b\x9d\x38\x8d\xf9\x69\x66\x3b\xd3\xfa\x94\x23\x7d\xb9\xb6\x86\x2d\x21\x66\x55\x75\x02\xe3\xd7\x02\x71\x80\xdb\xeb\x74\x72\x34\x3a\x1d\xe3\x81\xf5\xf2\xe8\x74\x3c\x9a\xbe\x1c\xe0\x7d\x62\xed\x47\x59\x22\x1f\x63\x55\x10\x73\xcf\xed\x6a\x5d\xc1\xc2\xa6\x68\xa2\xd7\xab\x6e\x65\xdf\x19\x9f\x5f\x4e\xa6\xe7\x13\xc6\x2d\x37\x95\xc6\x9e\x14\xe2\x51\xf0\xaa\x54\x00\x87\x05\x39\xe1\xdc\x8b\xad\x6b\x29\x95\xa1\x35\x37\x54\x24\xf7\x26\xdd\xac\x64\x00\x13\xaa\xaa\x5c\x88\xf3\x25\xc6\x35\x72\xd7\xec\x10\x6e\x42\xb6\xde\x4d\xc5\x51\x79\x54\xd6\x06\xab\xd0\xd5\x20\x00\x5d\x49\x01\x55\x30\xad\xe4\x01\xda\xb5\x2f\x1e\xf2\xa2\x94\x3e\x26\x2b\xb6\xd3\x10\x61\xb5\x2d\x95\x96\xa8\x2c\xa1\x4d\xe5\x25\x0b\xc8\xee\xf3\xf6\x50\x85\xb6\x97\x5d\xf1\x1a\x81\x02\xf5\xed\x82\xdb\x48\x91\x35\x81\xcc\x2c\x49\x92\x15\x63\xf9\xb1\xd9\x00\x23\x5b\xeb\x50\x54\x61\x56\xd7\x95\x5c\xe6\x1d\x14\xa1\x35\xd2\x52\xd8\x83\x58\x88\x4a\xe7\xec\x51\x4f\x1d\xf9\xcd\x7b\x37\xc8\x04\x57\xce\xaa\x76\x95\x7d\x42\x8b\x53\x71\xc0\xf5\x9b\xbe\x44\xb4\x5b\xa1\xd9\x88\xd3\xfa\x54\x36\x2b\xe6\xf5\x9f\xeb\xca\xbd\xc8\x92\x26\x35\xd1\xdf\x9d\xb2\xc4\x0a\x2c\xb2\x15\x43\xea\x1c\xe3\xdd\xc1\x31\xa7\x06\xb3\x17\xbf\x6f\x91\xfc\xbd\x79\x7e\x15\x8d\x4f\xee\xf6\xad\xd0\xbf\x75\x6c\xc6\xbe\x86\xb7\x57\xaf\xef\x4e\xc3\xdb\xce\xef\x3b\xbb\x47\x35\xd7\x25\xeb\x06\xd6\xa1\xe0\x3e\xd9\xb2\x4d\x40\x53\x06\xd9\x51\xb4\xa4\x7a\xd4\x94\xda\x26\x9b\x64\x33\x14\x59\x5a\xa6\x63\x62\x19\x12\xc0\x9a\x38\x21\x2e\xfb\x9c\x65\x31\xb5\xad\x37\xac\x22\x53\x71\x54\x51\x5a\xc6\x83\x14\xef\x6f\xcf\xde\x47\x0f\x79\x51\xb8\x62\x88\x8c\x85\xce\xb3\x28\x49\x65\x9e\x20\x95\x7c\x8b\x6a\x0c\xc9\x4d\xc8\x82\xa0\xd4\x46\xae\x55\xbf\x53\x18\xf3\x60\x95\xda\x65\xd5\x41\xc7\x43\x02\xee\x45\xd0\x86\xc8\xdd\x64\x56\xf3\x20\x82\x90\xf5\xa1\xc8\xc7\x43\xd4\xcb\x80\xbb\x57\x6e\x1e\x79\x47\x55\xc2\x86\x5c\x30\x94\x4a\xab\x72\xab\xbf\x81\x6c\xab\x41\xa7\x7d\xa8\x4a\xf7\xa2\xd4\x94\x3f\x73\xff\x2d\xec\x18\x9f\x11\x4f\x12\x5b\xf5\x33\x45\x6c\xa1\x58\x95\xe6\x01\x45\xec\xbd\xd2\x7f\x01\xa7\xb0\x5a\x89\x2c\x18\x6c\xd6\x65\x05\x2a\x75\xb3\x1f\x2f\x92\xe4\x6d\x94\x22\x51\x29\x31\x3c\xa0\x9a\x0c\xb2\x38\xbf\x32\x2b\x9a\xc9\x26\x96\x6a\x68\xc4\x37\x55\xa1\xab\xcf\x88\x6a\x82\x93\x5b\x30\xa0\x55\x29\xc1\x4a\xa3\x68\x43\x6f\x5b\xc4\x6c\x26\x4a\x6a\x63\xa0\xd1\x94\x04\x30\x1a\xd0\x51\xb5\x26\x50\xdf\x5d\x3f\x90\xeb\xd8\xac\xaa\x5f\xbe\x7d\xb7\xd0\x82\x70\x02\x5e\xd3\xb2\x69\x83\x9e\xcd\x9a\xbb\x33\x4c\xda\x3c\x16\xb6\x0e\x12\x44\x1d\x6b\x15\x5b\x30\x9c\x54\x85\x06\xc0\xd8\xa3\x25\x4c\xb9\xe8\xe4\x1a\xcf\x98\x16\xf8\x49\x86\xa6\xea\x84\xf3\x92\x56\x54\x1f\x08\xdd\x31\xb6\x3b\x24\xa2\xa8\x18\x70\xb6\x18\x46\x8f\x1c\xe9\x02\x4e\xb4\x33\x6d\xc3\xb5\xb2\xbd\xa8\x09\x15\x87\x28\xf7\x47\xd2\x18\x3a\x68\x80\xde\x6d\xee\xfb\x60\xda\x72\xbb\x19\x81\xd5\x6d\xdb\x0c\xc5\xa3\x4e\x5f\xa1\x2b\x37\x67\x10\x3d\xcf\x5d\x83\x69\xa7\x43\x99\xfc\xdc\x32\xd9\x45\x2d\xe6\x4f\x73\x6f\x90\x5c\xa9\x66\xc9\xec\xe7\x1a\xd6\x45\x5f\x31\xf8\x12\x14\x12\x5f\x3e\x4d\xf5\x89\xd9\x07\x7f\x25\x8b\x88\xaa\x04\x71\xf2\xa1\xa6\x51\x53\x05\x9e\x09\x37\xff\xa8\xd4\xfa\x0c\x54\x3d\x9e\x0a\xe1\x6e\x9b\x6f\x01\xe9\xb8\x07\xde\x90\x18\xa1\x12\x6a\x4d\xb9\x90\x39\x01\xfc\x68\x51\x9a\xf0\x46\x41\x68\x0d\xc8\x0a\x8d\xc5\xa4\xb2\xcf\x37\x7e\xbe\xeb\xa3\x67\x10\x1b\x6c\xa1\xef\x11\xbe\x13\xde\x7f\xe9\xe7\x34\x6e\x34\x83\x34\xc9\x08\x5a\x5f\x4f\x54\xdd\xb7\x2c\xa6\xca\x60\x5b\x62\x14\x0d\xda\x6c\xa6\xca\xa3\x12\x06\x9b\xc5\x92\x5b\x8b\x6f\xdf\x35\x55\xf2\x70\xa7\x4e\x29\xb3\xda\xad\xdc\x85\xb3\xe3\xc0\xb6\xf7\xba\x70\xd0\x1a\xa6\xd7\xc2\x32\xcc\xaf\xe3\x16\x44\xb2\x3b\x1d\x69\xc8\x54\x32\x18\x20\x90\xe1\x95\x7e\xa2\x98\x08\xce\xc6\xc3\x46\x71\xaa\x3a\x35\x3f\x8e\xee\x74\x59\x64\x18\x1b\xb3\xc8\x03\xe2\x21\x8a\xa9\x58\x9d\xae\x86\x6f\xbf\xc2\xaa\x34\x3f\x69\x36\xae\xe9\x9d\x19\x70\x8d\x7e\x3d\x09\x4a\x6b\x26\x33\x6d\xb5\xdf\x26\x77\xae\xca\xf3\x07\xc9\x5a\x4b\xdd\x08\xd9\x54\xab\xba\x1b\x78\xc2\x28\x8c\x5d\xad\xab\xef\x51\x63\xc2\x5b\xf7\xbb\x48\x9e\x35\x36\x91\x47\x77\x0d\x16\x70\xcf\x7b\xf7\xb8\xc0\x3b\x85\xcb\x8d\x53\x30\xbe\x62\xeb\x8b\x86\xdf\xef\x9a\xb1\xb2\x5e\x2f\xa4\x71\x63\x8b\x90\xd2\xb7\x95\x20\xd2\x92\x29\x46\xe5\x68\x53\x93\x48\xdb\x92\x6e\x4f\x9f\x3e\xe9\x92\x3c\x2d\xe1\xc0\x09\x8a\xcd\xc1\xa3\x2c\xbd\x0e\xa5\xab\x6f\x64\xc4\x15\x92\x03\xef\x96\x13\xa5\x84\xd9\xa5\x23\xf6\x17\xf7\x29\x2a\x54\xe9\x01\x39\xdb\x61\xff\xe3\x89\x70\x8f\x3d\x19\xe7\x91\xa7\x4c\x43\xf8\xc0\x80\x56\x0d\x7e\xfa\xbf\x2f\x26\xd3\xcb\x5a\xb3\x90\x6d\xeb\xa8\xa1\x80\xac\x5a\xae\x64\x48\x06\xce\x9c\x8e\x50\x5c\x21\xd9\xda\x33\x78\x5a\x16\x66\xd2\xdd\x27\x8b\x9a\x83\x5a\x95\xcd\xc9\x33\x47\x05\x64\x32\xb8\xea\x20\x4c\x58\x2e\xf7\xd8\xdc\x00\x94\x87\x6c\x41\xd7\x23\x1a\x02\x6f\x58\xac\xd7\xe0\x86\x78\x89\xd0\xed\x5f\xf9\xc5\x81\xee\xe6\x63\x29\x3e\x47\xa3\xb5\x6f\x28\xe0\x7e\x16\xe6\x2d\x67\x34\xfb\x33\xd5\x5f\x3e\xef\x02\x8f\x72\x6b\x19\xc5\xc2\x34\x07\x34\x31\x0c\x0d\x5f\xb2\xcd\x4c\x54\xe0\x4f\x66\x36\x9b\x2f\x75\x99\x8f\x6e\x31\xfa\x13\x10\x3d\xfe\x94\x14\x74\xf5\x86\x11\x08\x8f\x7d\x7e\xfc\x77\x83\x4f\xde\xa7\xc4\xa4\xd2\xc3\x76\xb8\xcf\x1a\x54\x7a\xa2\xf3\xfb\x3f\x9d\x96\x8d\x83\xce\x56\x2a\x68\x6b\xc0\x3e\x73\x10\xf3\x19\xa6\x94\x51\xad\x78\xfe\x42\xf9\x0d\xb9\x88\x82\x7c\xdc\xa6\x36\x73\xf4\x15\x8b\x46\xf8\x09\xe4\xdc\x40\x3b\xbf\x7d\x6e\xb3\x02\x08\x74\x04\x5b\xee\x68\x72\x6b\xba\x36\x2f\x73\x68\xdc\xfc\xd8\x3a\x12\x6b\xbf\xc3\x71\x43\x85\x01\x8e\xad\x52\x0b\x24\x6d\x08\x27\xcd\x43\xb2\xd4\x83\x16\x80\xd1\xaa\x59\x4c\x1e\x0b\x5e\xf0\x2d\x62\x32\x5a\xad\x9e\x75\x39\x12\x59\xb2\x6a\xc7\x27\x5b\x8f\x74\x4c\x0f\x65\xf8\x97\x67\x3b\xd0\x2e\x8c\x78\xa8\x48\xc5\x43\xc9\x13\xd6\x72\x7c\xa1\x88\xb3\x96\xca\x57\x72\xca\x56\xe6\x9e\x5f\x86\xcf\x57\x28\x23\x8f\xde\xdc\x9c\x8f\xce\xc6\x52\x35\x1b\xe2\xdd\x6b\xa8\x42\xbc\x86\x2a\x9b\x9f\x5b\xca\x7e\x60\xe3\x81\xfe\x59\x19\x60\x12\xa3\x91\x1a\x3c\x78\xf4\x86\x4e\xfe\x56\xea\x90\x02\x25\x49\xbb\x51\xa1\xfb\xa3\x63\xee\xa6\xb2\xda\x24\x85\x80\x32\xfc\x58\x88\x28\x23\x7f\xfc\x5f\x42\xa3\x1f\x9b\x4e\x6e\x4e\xb8\x7d\xb0\x00\x8a\xed\x9c\x72\x8e\x64\x3b\x18\xea\x64\x4c\xd1\xb4\x70\xb2\x6f\x38\x52\x54\xb6\x86\x51\x9e\x28\xe3\xf2\x80\x6a\x15\x0c\x0e\x0f\xec\x0d\xc5\xfb\xc8\x4e\xeb\xf6\xa0\x83\xfc\xf8\xc5\xd4\x53\xd9\x2f\x86\x35\x54\x3e\x8d\x29\x71\xdb\x2d\x18\x6f\x4b\x29\x87\xba\xa3\x4c\x82\x8d\xee\xf2\xc6\x24\xb2\xd3\xba\xb0\xd5\x74\x28\xc7\x26\xdd\x8a\x7b\x3f\xf4\x1c\xec\xdf\x14\x8b\x07\x2a\x07\x4c\x2d\x1a\xfe\x9c\xf9\x31\x15\x55\x79\x77\x79\x79\x81\x6c\xff\x7e\x33\xe0\xeb\x2c\xe7\xbc\xdf\xa7\xe9\x2a\xb9\xa1\xef\xeb\xdd\x56\x14\x51\x4b\x27\x2a\x70\x10\x84\x31\xb6\x39\x4a\x40\x9e\x72\x03\x60\x6a\xc0\x17\x8a\x14\xaf\x04\x78\xb5\x0a\x05\xc5\x24\xf7\xcb\x29\xa3\xb1\x60\xf4\x10\xdf\xf3\x64\x8c\xc0\x20\x57\x08\xee\xb8\x98\xa8\x71\x70\x63\x1f\x14\x79\xfb\x6b\x0c\x22\xd0\x33\xa4\x83\x93\xe6\x11\x46\x71\x78\xd2\x2f\xa6\x9a\xd4\xab\x56\x80\x52\x88\xfc\xf7\xa2\xc2\x50\xc5\xcf\x4d\xd0\x09\x54\x5c\x84\xd4\x56\xd2\x8a\x06\x7b\x25\x47\x36\x5a\xf9\xc5\x41\xd1\xed\x34\xcc\x84\xf6\xb9\xc1\x5d\x17\x3d\x46\x45\x73\x43\xdb\x60\xaf\x0c\xe2\x8b\x28\x24\xdd\x84\x84\x28\x0f\x2d\xb1\x0c\xb4\x8a\xf1\x1e\xd1\x61\x14\x47\x6f\x34\x86\x82\xd4\xa6\x11\x09\x50\xf5\x80\x7c\x5a\x28\x85\x78\x07\xdd\xb3\x09\x85\x94\xb8\xbb\x83\x95\xd3\x67\x5c\x76\xa4\xb2\x5b\x0d\x51\x1f\x73\x51\x73\xda\x54\x19\x6c\x65\x98\x1c\x44\x14\x91\x38\x52\x3b\xd6\xb3\x69\xb2\x9d\xc6\x2e\x8b\x66\x95\xb4\x56\x37\x54\xb9\x98\x28\x58\x9f\x96\x11\x55\x0a\x78\x9a\xe1\x5a\x0b\xdb\x5f\xc4\x65\x3b\x87\x08\x03\x37\x8f\xe0\x7f\x36\x4e\x15\x16\xfa\x93\x71\xa3\xc4\x84\xa7\x1e\x5d\x2e\xa3\xae\x56\xa0\x26\x0a\x5d\x66\xb3\x38\xdc\x8c\x7e\xe4\x04\x85\xb6\xca\xba\xf5\x97\x96\x06\xf8\x3c\x50\x32\x63\x70\x61\x11\x0e\x95\xed\x51\x92\xf7\xd2\x5d\xb0\x0a\x8a\x7f\xf4\x4c\xb2\xbe\x04\x3d\x82\x62\xb9\x0c\xb7\x55\x10\x2d\x3a\x38\x9d\x67\xfe\x02\x74\x3a\xb8\x6a\x03\xc1\xb1\x90\xe5\x4c\x16\x70\x1e\xc6\xf4\x97\xf4\x60\x75\x70\x3a\x5f\x9a\x61\x65\xa6\x5a\x68\x55\xb8\x26\x96\xd8\xb1\xf2\xdb\xcd\xe8\xea\x74\x5e\x7b\x53\xb7\xbc\x85\x80\x81\xac\xf8\x66\x3d\x3a\xd5\xdb\xb1\x10\x42\x63\x26\x41\xea\xa0\x7f\x37\x35\x0a\xd9\x80\x3e\x20\xbe\x27\x35\x80\xbd\x74\x29\x56\xe2\x90\xcd\xf3\xb4\xcf\x4f\x1a\xb3\x4d\x68\x79\xa9\x0e\x20\x8b\xa1\x58\x86\x74\xa9\x5a\xf1\x97\x43\xb2\x4d\x81\x23\x15\x1a\x8e\xb1\x94\x86\xa6\x50\xf7\xba\x7c\xfc\x39\xf4\x70\x8d\x1b\xdd\x48\x1d\xc3\xad\x68\xb6\xe8\x2b\x60\x28\x59\x6f\x65\x29\x19\x6e\x12\x2e\x61\x5a\xb8\x09\x03\x23\x83\xdd\x8f\xaa\x79\xed\x98\xb2\x87\x70\xcb\xd7\x5a\x75\x81\x02\x4f\x70\xcd\x1f\xd5\xf4\x58\xdb\x3d\xed\x93\x1d\x68\x4b\xa4\x1d\x8f\x36\xff\xd6\xd9\x27\x55\x93\xdd\x03\xeb\xb2\xa0\xec\x34\x8f\x32\x5f\x9d\x87\x7b\x7f\xce\x93\xa6\xa5\x0b\xf7\x73\x27\x35\x0d\x96\xaa\x97\xc5\xc5\xe2\xc4\x98\x0c\x33\xc4\xab\x6e\x63\x12\x59\x40\x28\x42\x49\xa0\xea\x15\x01\xf2\x24\xce\xc4\x2d\x6c\x6e\x6a\x14\xc1\x92\x26\x29\x8b\x1a\xc4\x49\xcd\xeb\x65\x61\x23\x99\x1d\x66\x64\xbe\xf3\x30\x7b\x09\x2a\x9a\x05\xd4\x8b\xf2\x92\x07\x46\xd3\x7d\x55\x8c\x06\xe4\x40\x83\x35\x9e\x00\x50\x6f\xed\xbc\xd7\xbe\x2e\x33\x23\xc3\x5f\xf2\xab\xa6\xbd\xbc\x67\x07\x62\xb8\x13\x9f\x35\x6e\xaa\x91\x18\x6e\x9e\xd7\x1e\x95\x51\x47\x06\xec\xca\x1d\xb8\x22\xdf\xde\x27\x5f\x2a\x04\xf5\xe2\x4c\x85\xa0\x3e\xbc\x89\xad\xc5\x32\xb0\x81\x66\x22\x0e\xa4\xfd\x91\x6f\x8d\x7c\x2b\x8a\x92\x14\x9d\xa1\x2c\x0b\x87\x70\x7b\x9a\xcc\x2e\xe9\xb6\x1b\xc5\x74\xe4\x0f\x87\xe4\x97\x5d\x0e\x19\x38\x9c\xf0\x0b\x34\xa9\xe4\x02\x96\xbf\xa7\x16\xb5\xf7\x22\xe4\x36\x9e\x8d\x8d\x6a\x6b\x4b\x80\xb0\xcc\x44\x2a\xa3\x03\xc3\x9a\x79\x84\x0a\x0b\x59\x64\xf3\x16\xf2\xe4\x0f\x45\x31\x58\xa0\x56\xeb\x10\x25\x82\x89\x89\x4c\xb2\x29\x62\x89\x02\xb8\x20\xe6\x77\x04\xe2\xed\x00\x55\xb4\xc7\x9f\xb1\xb1\xad\xee\x49\xea\x35\x37\xb5\xbd\x34\xa3\xbd\xcd\xbb\x0b\x40\xce\x02\x8f\xab\xb0\xe0\x35\xd7\x05\x09\x65\xbd\x60\x5b\x61\xe3\x9d\x96\x32\x65\xf5\x79\xa8\x4e\x34\x19\x8c\xe9\x27\x5c\x1a\xb2\x1e\xee\x39\xb6\x3a\xfe\xff\x98\xbb\xba\xdd\xb8\x8d\x2c\x7d\xbf\x4f\x41\x2c\x30\x70\x80\x6d\x75\xe2\x60\xae\xec\x8b\x81\x22\xc9\x8a\x16\xb6\x6c\xe8\xc7\x83\x4d\x1c\x78\xd8\x4d\x4a\xa2\xc3\x26\x3b\xac\xa6\xe4\x4e\xe0\xa7\x98\x27\xc8\xe5\x5c\xe4\x05\xe6\x66\x81\xd5\x8b\x6d\x9d\x9f\xfa\xe1\xcf\x29\x92\x6d\x29\x09\x16\x3b\x88\xd5\xac\x53\xa7\xfe\x4f\x9d\xfa\xce\x77\xb6\xee\x44\x69\xdf\xca\x39\x02\x32\xc0\x2e\xe9\x74\xd8\x94\xe0\x68\xd1\xe6\x3e\x25\xdc\x44\x5b\x9f\x59\xe5\x6c\x9e\x7d\x44\xe8\x67\xf4\x80\x00\xf3\x4a\xd2\xeb\xdb\x18\x92\xec\xad\x62\x95\x21\x29\x14\x64\xce\x44\x9f\x01\x0e\xd7\x8a\x10\x1e\xcf\x23\x8c\x30\x59\xc4\x6e\xfc\x83\x3a\x42\x4f\x14\x1c\x44\xca\x71\xc4\x5e\xa6\x29\x78\xd6\x00\xfb\x12\x78\x88\x2f\xab\x5c\x9b\x93\xcf\x26\xa4\xb6\x26\xa9\x71\xde\x08\x03\x76\x99\xd6\x53\x92\x5d\xf9\xb2\x1f\x54\x53\x8a\x2c\x2d\x2b\x30\x9e\xc0\x7a\xcd\xd6\xa2\xf1\x3a\xa5\x8a\xaa\xb7\x8a\xbf\x88\xdb\x1d\x84\xa7\x10\x62\x15\xf8\x00\x01\x44\x0b\xc1\xd9\xda\x8a\x55\x76\xdf\xd5\xcb\xf7\x10\x22\x58\x70\xaa\x6e\xc8\x33\x55\x79\xb9\x9b\x1c\x53\x1a\xe5\xae\x9c\xe1\xde\x81\x9f\xa1\x17\x0f\x26\x18\xb8\xbe\xd8\x38\x73\x35\xd6\x05\xae\x21\x7c\x4b\x7a\x57\xec\xd3\x9d\x2a\x32\x97\xab\xe8\x2e\x2e\xd8\x7f\x6e\x53\x37\xf6\x83\x6b\xff\x26\x0d\xfb\x91\x22\x24\x30\x22\x65\xf9\xf4\x07\xaf\x18\x51\x2b\xdf\xde\xff\x0b\x0f\x7e\xe9\x84\xd0\x3a\x41\x0c\x6e\x0d\x0c\x01\xe4\xf0\xe2\x84\x4c\xc4\xf4\xca\x65\x28\xcf\x26\xd3\xb8\xc5\xba\xf1\x5b\xd8\x80\x6e\x21\xb1\x5d\x45\x3b\x20\xf8\x26\x96\x71\xf1\x33\xdd\x11\xbd\x9b\xed\xda\x71\xbe\xb1\x92\xba\xca\xff\xfb\xdf\x23\x4a\xce\x0d\x97\xbf\xd2\xdc\xfc\x12\x4c\xf0\xe7\xa7\x9c\x14\x00\xc0\x7f\x13\xa7\x69\xa6\x2c\x84\x0d\xc2\xd2\x8a\x27\x1b\x93\xa2\xdc\x3e\xad\xc3\xfe\xf3\x63\xba\x55\x01\x5c\x77\x33\xcc\x2f\x89\x39\x89\x78\x1a\x75\x9f\xc3\x09\xa3\x22\x2e\x70\xd0\x07\x2f\x21\xe6\x48\xbb\x89\x71\x86\x13\x4a\xc7\x5e\x51\x10\xaa\x16\x54\xc8\x78\xcf\xf5\xa9\x43\xf0\x08\x38\x14\x3a\x08\x10\x42\xf0\x24\x12\xbd\x24\xea\x83\x73\x96\x48\x15\x0c\x89\x30\x3d\xe4\x80\x2f\x75\x1e\x89\x33\x94\x60\x67\xbe\x2b\x47\x4a\xd5\x78\x04\x4f\xfa\x37\x38\x85\xd0\xb3\x4c\x78\x28\xcf\x69\x3a\x8f\x42\x13\x80\x30\x66\x55\xab\xaa\xfe\x06\xd1\x0b\x31\x59\x50\x98\x69\x1c\xdd\xa8\x26\x4b\x9f\xb4\xd5\xb4\xdf\x6c\xd3\x8f\xcb\x34\xc9\x8c\xc3\xc5\xcf\x9e\x87\xe2\x62\xa5\x6f\x2c\x90\x77\x5c\x62\x73\xd2\xfb\x1a\x7b\x1a\xe2\x24\xd9\xa3\x7b\xc1\x1e\x6c\x52\x4f\xa8\x6b\xe1\xce\xcc\x57\x14\xf8\xab\x88\x7e\x2f\x54\xfa\xa1\xf4\xfc\x0a\x1d\x69\xfc\x20\x86\x77\x70\x62\x8f\x1c\x4c\x14\x70\xa1\xa7\x48\x1e\xbd\xd2\x5b\x99\x98\xbd\x0f\x7f\xcc\xc0\x8a\xdc\x48\x0c\xd6\x24\x25\x5e\x95\x35\x25\xa7\x5e\xa1\xbc\xe8\x8b\x74\x7e\x3d\x8f\x9e\x7e\xf5\xf5\x5f\x5f\xcd\xa2\xa7\xc7\xfa\xff\xbf\x3a\x16\x53\x55\xc3\x0d\x17\x18\x56\xb0\x1a\x04\x80\x70\xbd\x5f\xac\xe7\xfa\x70\xef\xca\x99\xa2\x89\xe1\x5c\x01\xe8\x06\x32\x50\x3c\x8c\x6a\x0e\x82\x61\x9e\xe4\x1c\x2f\xcb\x74\xad\x8b\x7a\xb5\x80\x70\xb9\x2b\x3e\x44\x24\xeb\xe7\xfe\xdf\xab\x54\xaf\x0a\xab\x4d\x25\x73\xac\xb5\x05\xb7\x41\xc3\xa3\xeb\xf0\x6c\xad\x41\xfc\xee\x45\x05\x5d\x3d\x66\xa9\x9d\xb7\xd7\x12\xb4\x26\x06\x77\x92\x20\xfa\x72\x7f\xdf\x99\xa2\x4c\x18\x47\x99\xc5\x08\x39\x83\xbe\x81\x21\x3a\xb8\x96\xbf\x1c\x64\xc2\x4d\xd6\xc3\x1e\x59\x18\x4e\xe0\x6e\x02\x71\x94\x5a\x0c\x5d\xdd\xad\xc7\xcc\x3a\x8d\xdd\xb3\x14\xee\xa8\x0b\x08\x2f\xd2\x7b\xfc\x4a\xa4\x71\x18\x51\x8b\x4d\x2f\xea\x6a\xa2\x99\x62\xeb\xd0\x3f\xdc\xc5\xfa\xca\x9f\xcc\xa3\x73\x6d\x99\xaf\xbc\xcb\x1a\x48\x32\xb0\x18\x7c\x36\x9a\xa6\xc7\xf9\xfe\xf1\x91\x50\xe2\xf2\x5c\xa0\x0b\xc3\x42\xd2\x23\xac\x2e\x25\xbc\xb5\x5e\x9e\x1f\x9d\x8d\x24\x68\x3b\x38\xb9\xff\xe7\x29\xd0\x96\x5d\x9e\x5f\xee\x9f\x89\xe4\x63\x20\x51\xa2\x2d\x1b\x28\x59\x98\x47\x56\x4e\xa3\xde\xe7\x34\x9c\xa3\xf9\x4a\x04\x2a\xa2\x05\x4b\x4f\x58\xb4\x5b\x80\x2c\x70\xfd\xc4\x12\xb6\xb0\x25\x71\x50\x35\x7a\x27\x04\x52\x26\x40\x45\x21\xdb\x0c\x27\xdc\x63\x22\x22\xb2\x6d\xf4\x31\xbe\x86\x63\x64\x8c\x8a\x09\xc8\xa4\x90\x30\x8f\x32\xa6\x46\x7e\x20\x00\xd4\x99\xcc\xb3\x20\xb3\x4e\x99\x30\xda\xf0\x0b\x85\xd6\x8d\x53\xbb\x86\xcb\xf5\x06\x93\x26\x07\xae\x7a\x4e\xa5\x7a\x43\x9f\x4b\xb1\xdb\x4e\x34\xd9\xcb\x33\xbe\xc7\x3f\x31\xb7\xf2\x27\x23\xd9\x08\xec\x73\xe3\xba\xc4\x83\xdf\x18\x9d\xcf\x6d\x3e\x41\x4f\xe4\x10\x3b\x81\xaf\x15\x41\x53\xd2\xe8\xe0\x00\x6f\xd5\x6f\xd3\x4a\x21\x9c\xb3\x87\xf2\x72\xda\xa5\xda\x55\x52\x2e\x00\x62\x6b\x9c\x9d\xe8\x06\x81\x3d\x20\xb5\xee\x4b\xbc\x13\xd9\x7f\x0d\xcc\x57\xd7\x07\x06\x67\xe5\xbb\x2d\x8c\x97\xd3\x51\xb7\x7f\x10\x6b\x19\x50\x7b\x8d\x8f\x3c\xcd\x7e\xa1\x17\xd0\x37\x27\xfc\x4f\xdd\xd9\x53\xfb\x04\xed\xe8\x28\xe6\x60\x0f\xce\x37\x1b\x7a\x71\x3e\x4c\x15\x59\xc9\x55\xc3\x84\x56\x49\x3a\xf8\x34\x6c\xaa\x73\x49\xac\x7a\x83\x96\x51\x89\xcf\x8c\x2c\xb0\x5a\x82\x27\x7e\x08\xe8\x4d\xda\xa7\x22\x8c\x79\x42\x08\xc1\x65\xb1\x20\x98\x42\x33\x0e\x72\x64\xc7\xd2\xc3\x25\xee\x28\x3d\xcc\x7a\x63\x3b\x39\xa0\x01\x91\x98\x6f\xc8\xd0\x69\x72\x99\xc3\x12\xe8\x03\x8d\x7c\x9e\xb6\x14\xd6\xfb\x01\xed\x89\x06\xdb\xaa\xfb\xb0\x49\x2f\x36\x9c\x74\xea\x73\x1a\xe8\x25\x6a\xfa\x9d\x1b\x68\x10\xc0\xd9\xc4\x26\xb6\x42\xd8\x78\x1e\xe1\xae\x3d\x71\xa9\x87\x45\x86\xf1\x74\x5e\x57\x48\xe4\x44\xc9\x40\x22\x6f\x56\x60\x09\x75\xe6\xf9\x54\x23\x0f\x0b\xf7\xa2\xf5\x68\xb7\x90\xb8\x75\x1e\x0f\xcb\xc7\x5d\x22\x51\x96\xb6\xb9\xd7\xce\xff\x90\x9c\x81\xae\xdf\x56\xf1\x36\xd2\x47\xe8\x6d\x4a\x78\x8d\x95\xfe\x5f\xa2\x5e\x6c\xbd\x1e\xdc\xd6\x39\x38\xcd\xf5\x99\xf3\x3c\xc2\x1b\x60\xd6\xbd\x13\xc9\xe4\x5f\x8c\x8f\x53\xbe\xe5\x82\xc7\xf7\x61\xd9\xf0\x85\xe8\xef\x96\x69\x9a\x48\x0e\x90\x3f\xbb\xda\xd1\x17\xdb\x2f\x0b\xe1\xa6\xea\x74\xef\x4b\xef\x3c\x5e\xa7\xc7\x9a\xb9\x43\x5a\xab\x61\x86\x58\x6c\x09\x03\x96\x5b\x07\x07\x6a\x52\xab\x81\xd4\x6b\x8d\xd5\x93\x8e\xa6\x91\x4d\x08\x43\x71\x1b\xe7\x25\xe4\xae\x68\x42\x99\x5b\x3c\x95\xe4\xc8\x2d\x5b\xea\x3c\x46\xdb\xed\x99\xf2\x87\xb7\xdd\x3b\x63\x1e\xaf\xed\xfa\x07\xb3\x6f\x6d\xd0\xe4\x84\x54\x06\x6a\xed\x67\xaa\x7f\xc4\x3e\x08\xd6\x3e\xbe\xd1\xe9\xc7\x75\xba\x84\xc7\x08\x7a\x29\x01\xa7\x72\xb9\xc4\xf0\xaf\xe4\x19\x5e\x2c\xf9\x49\x64\xea\x4b\x91\xbe\xb9\xa0\x47\x34\x29\x9b\x62\x04\x35\x70\x17\xe0\xdc\x32\x06\x7b\x01\x31\x8a\x1c\x8e\x46\x08\xa8\x28\xae\xae\x6b\xc0\xac\xca\x9d\x49\x72\xc8\xa1\xe9\xcb\xc9\x2c\x0c\xc5\xc8\x28\x6d\x68\x41\x58\x25\x98\x11\x2c\xc9\xe2\x3b\x4e\x87\x6d\x6e\x56\xc4\x24\x72\x16\x05\x08\x95\xe7\x25\x04\xa3\xf9\x20\x0f\x82\xd2\xe1\x15\x88\x20\x66\x01\x73\x6d\x91\x97\x3f\xd5\x29\xf7\x82\x90\x43\x1a\xd7\x89\xc9\x84\x5a\x39\x50\x59\xd8\x1a\x53\x3d\xdc\x5a\xe1\xbb\xc7\x72\x93\xdd\xda\x6e\x68\x7a\xd3\x28\xc9\x42\xa0\x17\xd4\xae\x2c\x35\x87\xe9\x07\x13\xe4\xf4\x30\x74\x35\xa4\x4b\x80\xb0\x06\x77\x84\xcf\x20\xac\x01\x8d\x0b\xce\x8d\x65\x75\x0e\x10\xd7\xf4\x45\x53\xff\xb2\x23\x6f\x0d\xe1\x0d\x75\x3f\x0f\xe1\x15\xf7\x1d\xf2\x10\xb0\xc4\x53\xe0\x3c\xb6\x8e\x51\xb4\x38\xcd\x8a\xc6\x52\xe2\x78\x75\x90\x6d\x11\xdb\xcc\x9d\x63\xea\x69\x11\x08\x93\xf5\x63\x9f\xe7\xc2\x7e\xec\x4e\xd5\x94\x93\x7c\x54\xf3\x44\x52\xe0\x91\x55\x0d\xa4\x43\x68\xb5\x71\x02\x8f\x87\xa9\xa9\xf0\x82\x29\x52\x55\xd6\x95\xf1\x57\x8c\xab\xd1\x3a\x1d\x2a\x18\x7a\xa0\x2e\xb1\xa1\x10\xa3\xeb\xf5\x9c\x24\x13\x2b\x35\xb7\x87\x71\x75\xf6\x86\xd0\x0c\xf5\x70\x48\x22\x45\x0f\xf2\x7f\x8b\xc7\xa8\x55\x9e\xc3\xbe\xdc\xf7\xb2\x68\xe8\x96\xbf\xa8\x1e\x7e\x48\xe0\x13\xfc\x8b\x92\xfc\x5f\xb6\x2a\xd8\x6d\x7a\xcb\xc7\x54\x3c\x5c\x73\x4c\xa0\x2d\x0e\x3b\x51\xe8\x8a\xbb\x45\xcc\x06\xfe\x21\x39\x38\xf0\x9d\x71\x00\xa6\x2a\xd2\xbb\xb4\x9a\x03\xbf\x7b\x65\xe3\xcb\x39\xb2\x23\x53\x58\x96\xed\xf6\x66\xd1\x00\x8a\xca\x3b\xb3\x78\x91\xc2\xae\x64\xd5\x02\x14\x08\xe7\xf1\x09\x69\x46\xd1\xa0\x06\x84\x0c\x41\x2f\x16\xb5\xcb\xe4\x24\x69\x50\xbd\x81\x7e\xfa\x5d\xe8\x43\x1a\x83\xfa\x38\x1c\x8c\x63\xcf\x91\x26\xf6\x54\x17\xb4\x38\xf6\x21\xab\xa9\xd1\x88\x80\xe5\xd2\x2f\x33\xac\x51\xaf\x7b\x75\xf7\xfe\xed\xa5\x7f\xdc\xa5\xa7\x46\xdc\x35\x46\xde\x24\xf6\xdb\x8b\x61\xf4\x65\x62\xf4\x65\xc1\x29\xdd\x3e\x5e\xa7\x5d\xbc\xdb\xbd\x19\xe2\xed\xf7\x39\xba\x26\xf9\x7b\xda\xca\x2e\xda\xa4\xfd\x3b\x8e\x7e\x3a\x8e\xc5\x7f\xb7\xc9\x20\xba\x44\x3a\x3a\x4f\x5a\x4c\x23\x78\xd4\x7b\xd4\x1e\xbb\xb6\xfa\x1e\x30\x1e\x60\x75\xf5\xbc\x52\xec\xd8\xaf\x8d\xcc\x08\xbf\xbf\x87\xb4\x3d\x7d\x94\xcb\xff\xdc\x13\x5b\x6c\x22\x63\xff\x38\x4f\xe9\x3a\x2f\x63\xeb\x61\x06\x90\x84\xc2\xdb\x0d\x1a\x26\x94\xa9\x51\x72\x06\xd4\x0b\x0e\xea\x36\x34\x25\x4c\xeb\x85\x0f\x04\x7e\xf9\x81\x8a\x77\x3b\x3f\x6c\xf5\x0f\x75\x76\x18\x75\xfc\x93\x74\x44\xf5\xed\xcf\x87\xa5\x7f\x97\xad\x5f\xe8\x7e\xfe\x66\xab\x6f\xf5\x90\x4f\x45\xff\x09\xfe\x7d\x00\xc8\x24\xb8\x5b\x66\x72\x6a\x40\xa8\x35\x69\x72\xc3\x0c\x0a\x14\x34\x12\x79\xc1\x2f\xcf\x5e\x0a\x45\x3e\x8b\xc7\xe3\xd2\x10\xde\x3c\x00\x55\x87\xd1\xc4\x0b\x47\x45\x2a\x72\xcc\x5e\xb1\xa1\xe0\x43\x36\x36\x61\x8d\x23\xc7\x5b\xe0\x05\xb2\xa1\x5a\x23\xda\xd4\xcb\xea\x5d\xb2\x6b\x09\x28\x19\x5b\xeb\x72\x6b\x97\xe2\x10\xd9\x14\x28\x1e\x03\x1a\x63\x0f\xd1\x18\xeb\x58\xa9\xbb\xb2\x42\xc7\x7e\x5e\x5e\x67\x83\x7d\x87\x77\x1d\xcc\xc1\x80\xa7\x68\x1b\x77\x81\x3a\x67\xcc\x30\xc3\x19\x2b\x45\x45\xbc\x4d\x72\x13\xcb\x01\x24\x9b\x0c\xd6\x56\xdc\x0c\xed\x8f\xdb\xa1\xfd\x81\x5a\x00\xbf\x8d\x63\x41\x3b\xd1\xf8\xb4\x0f\xde\xde\xd8\x10\x30\x08\xab\x80\x5b\xdd\x4e\x4c\x0f\x5c\xa3\x84\x3e\xd2\x72\x45\xcc\xd2\x60\x49\x38\xbe\x44\x40\x85\x09\xf6\x18\xe8\x4d\x7a\x19\xf2\x89\xbc\xec\x26\x2b\x46\xac\xf1\xdc\x71\x76\x62\x3f\x93\x96\x2f\x28\x50\x7b\xd5\xc8\xbc\x8b\x0f\x3c\xe3\xea\xb5\xf8\x98\x66\xd9\x40\x55\x44\xc9\xf5\x0b\xb2\xa2\x0c\x1f\x07\x3d\xd5\x21\xa9\x56\xb7\x7c\x6f\x95\x6f\x8f\xce\xce\x4f\x5e\x9f\x4a\xc3\x8b\x3f\xdf\xff\xf3\x54\x18\xdf\xb7\xc0\x3f\x18\xfd\xf7\xf9\xeb\x53\xbd\x93\x7d\x80\x1c\x7a\xcc\x67\xe7\xd9\x79\x7b\x86\xda\xcc\x61\x08\x11\x79\x05\x6b\x76\x05\x4f\x1a\x6a\xe6\x16\x24\x67\x93\xc8\x8a\xbd\x1c\x40\x41\xe8\x61\x47\x0e\x08\x48\xad\xf1\x02\xc9\x72\x4d\xa6\x7f\x86\xa9\xa7\x49\x40\xae\x4a\xc1\x9b\xba\x44\x4f\x38\xfd\x4a\xe0\xbf\x34\x44\xb9\x2b\xf5\xf4\x6b\xdd\x42\x3d\x61\xb0\xb5\xb7\xf7\xbf\xe6\xe0\x6c\x6f\x10\xf0\xad\x01\xc1\xad\xab\xae\x4a\xd5\x85\x4c\xfa\x01\xa1\xaa\xf1\x5a\xac\xd5\x04\x7c\x75\x45\x90\x6e\xa4\x0a\x41\x2b\xe8\xfe\xb7\x22\x85\x70\xe2\xb4\xf0\x78\xe0\xe6\xd1\x1b\xff\xdc\x80\x7d\x11\x3a\x24\x36\xef\x45\x61\x1d\x08\x96\x0f\x0f\x48\x33\xf8\x49\xd5\x39\x47\x33\x9a\x3e\x6a\xf0\x27\x77\x08\x84\x55\xe4\xde\xa0\x24\xc8\xfc\x83\x4f\x89\xac\xf8\xf3\x4d\x05\xb1\xe9\x35\x41\xcb\x30\x39\xca\x13\x6d\x13\xee\x99\x4b\xce\x1e\x86\x1d\x3f\x31\x49\x1b\x17\x69\x04\x29\xf8\x36\xd9\xad\x48\xb1\x94\xd3\xdb\x9f\x05\x92\x79\xc9\x52\x7a\x25\x03\x9b\x39\x82\x02\xe1\xec\x61\xe1\xc2\x86\x6a\x59\xee\x4e\xc7\xec\xcd\x1e\x85\x80\x20\x8e\xd8\x57\xde\xf0\xa1\x2e\x6d\x25\x4c\x39\x5a\xf9\x07\xb9\x28\x50\xc9\x06\x15\xfe\x2a\x1e\xf0\x6f\xc1\x1e\x02\xf0\xf1\x0c\xa1\xfe\xd5\x86\x23\x8f\xf8\x49\x47\x11\xed\x9d\x09\x33\x11\x4f\x8f\xb7\x69\xec\x62\xf7\x67\x6c\x9a\xe9\xf3\x7b\x6b\x5f\x64\x53\x0e\xd2\x61\x13\x48\x3a\x3e\xfe\xbe\x7f\x76\x7a\x72\x7a\x4c\x5c\x43\x74\x38\xc3\x4a\x40\x53\xcd\x9a\x41\x10\xe3\x62\x9f\xff\x68\xba\x63\xec\x1d\xb8\x0c\x6f\xb2\xeb\x9b\x7c\x0b\xc3\xbf\xd4\x65\xe2\xeb\x34\x41\x51\xff\xd3\x10\x00\xb0\x09\x3d\xa7\xb4\xd9\x96\x19\xd0\x23\x6c\xa4\x0a\x9b\xce\x3f\x02\x97\x62\x45\x2b\x8a\xaa\x57\x37\x69\x9e\x6b\xf9\x0a\x42\xbf\x81\x5d\x4e\xba\xd9\xbd\x3d\x39\x67\xb2\x24\x82\x40\x22\x2f\x2c\xdc\x02\x62\xdf\x38\x42\x03\xd1\x37\xd2\xf0\x42\x86\x2f\x4f\x6b\xb7\xaf\xd0\xae\x96\xd8\x94\x92\x0a\xe5\x9e\x37\x4b\xea\x29\x7c\xff\xab\x6d\x0d\x59\xca\xb8\xa5\x59\x32\xe8\xad\x03\xc1\x7a\xe1\x1d\xf8\xf4\x49\x0d\xca\xd0\xd5\x92\x53\x23\xb1\x71\xc1\xe1\x89\x30\xd4\x87\xb9\x24\x4b\x8c\x37\xaa\x61\xbc\x91\xde\x92\x40\x66\x0d\x07\x0b\xe3\x86\x9b\xd1\xbf\x5d\x02\x72\x64\x4f\xca\xcb\xe2\x1a\xa0\xcd\x96\xa0\xaa\xb4\x99\x59\x49\x0c\xce\x08\x7a\xee\x8b\xbe\xfe\xea\x2b\xf8\xfd\xaf\x4f\xbf\x9a\x99\x68\xdb\xae\x5c\x78\xbf\x5e\xa4\x69\xc1\xa8\xde\x64\x86\x98\x19\xe2\x30\x5e\xdf\xa0\x67\x18\xc6\x1a\xae\x14\xd1\x41\x5e\xd6\x89\xde\x30\xeb\x22\xa9\xb6\x4f\xf4\x16\x1e\x6f\xe2\x85\xee\xe7\x79\xb4\xaf\x47\xff\xc7\xa2\xbc\xcb\xd3\xe4\xda\x12\x27\x74\xea\x32\x40\x7a\x0a\xee\x4b\xe8\x09\xb0\x21\xd4\xe7\x08\xb5\xdd\x44\x28\x03\xc5\x6b\xcf\x92\xa4\x8b\x51\x64\x34\xc9\xa2\x23\x8c\x83\x86\x61\xe0\x29\x43\x11\xba\x7a\x87\xaf\xd1\x5c\xc3\x23\x32\xe4\x9b\xe2\x81\xb1\x84\x27\x6a\x23\x79\x85\xb6\xb1\xcb\x07\xe9\x98\xb9\x22\x2f\x4b\xa4\x19\x1d\xbc\xef\x32\xb5\x10\x8e\x0f\x0d\xcf\x56\xf6\x38\x11\x4e\x98\x41\xd2\xc0\x5c\x9a\xf0\xc3\xa7\xe3\x03\xb9\xa9\xef\xff\x55\x5d\xc5\x45\xa9\xd8\xe7\x01\x83\x82\x17\x29\x58\x15\xf0\x1f\x8d\x4e\x9e\x47\xe7\xa9\x1f\x6b\xd8\xfe\x1d\x82\x0f\x4d\x56\x95\x72\x99\x51\x16\x7f\xde\xbe\x7b\x75\x74\x6c\xaa\x0a\x2d\x07\x00\x68\x2c\x71\x87\x83\x00\x46\x4b\x25\x6d\xbf\x17\xce\xfb\x47\x59\x40\x36\x45\x5f\xff\x02\xa2\x95\x01\x40\x8a\x4e\xf4\x0e\xc5\x32\x3d\xf2\xda\xd8\x6d\x49\x38\x1d\xfd\x35\x61\x16\x0a\xe6\xe2\x8d\x37\x1b\x6d\x09\x6e\x6c\x05\xab\x18\x23\x51\xc9\x84\x5a\xf6\xf5\xe3\x73\x0b\xc5\xf2\x73\x05\xe3\x66\x02\x71\x7e\x70\x29\xaf\xca\xad\x21\x71\x6d\x8d\x81\x17\xd9\xc8\x7d\xd3\xd1\x55\xf7\xc4\x15\x84\xe2\xf5\xd6\x82\x89\x21\xf5\xe1\x62\xe0\x72\x40\x01\xcc\x16\x3c\x75\xbe\xa1\xcd\xdb\x03\x1f\xfa\x1e\xf9\xd0\xcb\xce\x8f\xac\x0d\x61\x55\xd6\x36\xac\x77\xa9\xc7\xad\xa8\xc5\x90\xf7\xc7\xdc\x30\x7a\x72\x67\xf4\xef\x16\xb0\x09\xb8\xa8\xdf\xfe\x90\x30\xda\x0c\x8a\x3f\xc5\x6e\x90\x8f\x5c\xfe\xfd\x2d\x99\xdb\xf3\x9f\x7c\x43\xba\x62\xc3\x33\x47\x09\x3c\xc9\xa1\xc0\xb3\x95\xe9\xd8\x42\x9d\x8f\xd1\x23\x1d\x9a\x02\x6b\x1b\x40\x8e\x21\x9a\xc2\x35\xc1\x44\xe4\x51\xf4\xa3\x67\x43\x03\xf1\x13\x98\x0c\x85\xed\xee\x58\x4f\xf0\x43\x08\xd7\xe1\xa8\xef\xde\xac\xd7\x33\x36\x34\x4c\xc4\xad\xf7\x59\x60\x9a\x0b\xb3\x9c\x09\xeb\x70\x9e\x13\xbd\x80\x1e\xc5\x75\x96\xfe\x2c\x5d\xa8\xa4\x0d\x36\x53\xd4\x1d\x80\x32\x02\xc6\x4b\x7f\xf8\x9f\xb7\x56\xba\xc7\x1c\xb9\x48\xcd\xf8\x40\x4c\x3f\x52\x2a\x12\xd6\x41\xf5\x26\xc1\x6d\x96\x8c\xf5\x7d\xb1\x82\x50\x3a\x64\x44\xd1\xb3\x39\xd6\x53\x0d\xb6\x8f\x25\xcc\x56\xc7\x82\xe2\x2b\x89\x01\xbd\xeb\x1c\x63\xba\x3b\x1b\x10\x06\xf1\x65\xd0\x19\x2b\xcc\x3b\x06\xeb\xfe\xf6\x69\x74\xde\x4c\x41\x0d\x6f\xdb\x6c\x1e\x05\x0b\x7e\x8d\x5f\x42\x5a\x91\x14\x80\xc3\xfd\x9b\x2f\x6e\xd6\xba\x0e\x78\x41\x47\xed\x74\x31\xfc\xef\x79\x14\xfd\x3d\x75\x39\x0f\x80\xa6\xc0\xec\x9b\xfc\xb9\x45\x68\x21\x3b\x58\x4d\x18\xb1\xa4\xbc\x2b\xcc\x47\x6e\x27\x83\x84\x9f\x98\xef\x26\x49\x30\x85\x41\x9c\xb7\x55\x58\xa4\x98\xa3\x84\xd8\xe8\xe7\xd1\x6b\xb0\xb5\x42\xc7\xd9\x2a\xbb\x06\x3a\x96\x64\x66\x2a\x73\xcc\xa7\x5a\x59\x6a\x0d\x04\xf3\x06\xcf\xa5\x89\x9b\x69\x6a\xe7\x18\xec\x4a\xad\x29\x66\x98\xeb\x0d\xd9\xb0\x5e\x7f\x3c\xb3\xc8\x58\x82\x5d\xa5\xb1\x60\x9b\x8b\x71\xcb\xfc\x68\x0c\x96\xb1\x7c\xa8\xc2\xda\xa5\xda\x56\x86\xcd\xfb\xfe\xd7\x02\x31\x0c\x7a\xe2\x51\x28\x82\x42\xc0\x9b\x2e\xb7\x86\x04\xa9\x8e\x52\xa7\xd1\x18\x0a\x57\xaf\xf5\x45\x7a\x53\x67\x61\x54\x12\xae\x76\x3b\xc1\x62\x03\xb1\xc0\xc0\x5f\xa9\x88\x1e\x14\xb6\x12\x9b\xdf\xf4\x8b\xd2\xf3\x0e\x89\x48\x73\x04\x23\xe2\x79\x20\xb4\xdd\xf8\x76\xf4\x18\x03\x48\xe3\x29\xb8\x3e\xbc\x7f\x7f\x3d\x8f\xce\x60\xd6\xc2\x85\x6c\x05\xf4\x7f\x86\x69\x02\x06\xcd\xa0\x00\x4d\x7e\x28\x5d\x5a\x0f\x4f\x5a\x71\x38\x7c\x53\x51\x98\xe7\xd8\x75\xb7\x88\x96\x34\xf4\x58\x55\x8a\x84\x15\x56\xb7\x38\xc9\x50\xe5\x1c\xec\x83\x4b\xc8\x83\x90\xfe\x6c\x3e\xbe\x89\xb7\x31\x4f\x56\x7c\xe6\x94\x06\x74\xd6\x22\xd0\xdd\xfa\x4d\x4a\x78\x82\xd3\xc6\xeb\x38\x36\xba\xe7\xa0\xb0\x67\xc6\x15\x1c\x4c\xcf\x80\x48\x8e\xd8\x46\x21\xbe\xb7\x49\xdb\x43\x54\x61\x80\x5c\xf2\x3e\x51\x8d\x6f\x14\xb3\xe6\xda\x2c\x28\xf2\x15\x59\xdf\x55\xcb\x67\x11\xe1\x84\x49\x72\x2c\xa6\x55\x45\x5d\x80\x07\x15\xa8\x1c\x9e\x35\x2f\xd4\xcc\x40\x06\x85\x14\x95\x4a\x95\x03\x91\xb2\x8e\x44\x01\x29\x5e\x69\x4d\xe3\x99\xa0\x0a\xe2\xc1\x29\xf7\x25\xfb\xa5\x54\xba\x79\x0f\x79\x6e\xd4\xfb\xc5\xf6\xbd\x81\x43\x88\x40\x2a\x6a\x19\xc6\xe7\xf2\xb3\x67\xc3\x17\x05\x4e\x46\x3d\x65\x74\x4f\x56\xf7\xbf\x29\x24\x41\x93\x2a\x08\x6b\x4b\x80\x6a\x48\x8b\x06\x1a\x83\x07\x27\xac\x91\xa5\xea\x81\xde\xc8\x2a\x67\x4b\x09\xf5\x54\xd9\x06\x88\x56\x2a\x6d\x58\x97\x09\x72\x27\xbf\x38\x81\x2c\xcd\x2e\xe5\x81\xda\x24\xda\x66\x16\x6a\x3d\x86\xec\x1a\xb8\x64\x96\x75\x5a\xad\x4b\x12\x45\x1e\x87\xfd\xb3\x83\x6f\x4f\xde\xbe\x46\xcb\xcd\xe4\x1d\x60\x61\x01\x5d\x0c\x03\xfc\x2d\xb8\x0d\xf1\x24\xe2\x14\x9c\x57\x99\x48\x22\x86\x44\x49\xba\xb1\xc1\xb0\x80\x3c\x1e\x15\xae\xff\x1d\x24\x3f\x42\xaf\x72\xea\xde\xa6\xd8\x59\x3b\x02\x25\xeb\x31\x02\x7e\x77\xf2\x06\xf6\x67\xeb\x08\x37\x46\xe1\x24\xe8\xec\xf7\xaf\x2e\x5f\x5e\x9c\xbc\xd9\x3f\xbb\xf8\xf2\xc5\xeb\xb3\x57\x7b\x87\xfb\x17\xfb\xd1\xc1\xeb\xd3\x8b\xa3\xd3\x8b\xe8\xdb\x93\xc3\xc3\xa3\xd3\x1f\x26\xb9\x63\xbf\x7f\x73\x76\xf2\x76\xff\xe2\x28\x42\x49\x3b\x49\xe8\x23\x90\x56\x13\x65\x5c\xe7\xe5\x42\xcf\x52\x26\xd3\xfa\xc1\x5e\x9e\xbe\x37\x10\x7d\x35\x9f\xcf\x7f\x88\xbe\x37\x7f\x37\x1f\x0a\xb5\x74\xe4\x19\x5b\x79\x50\x5e\xaf\x7a\xb4\x47\x08\x75\x51\x8a\x1a\xa9\xe0\xa6\x94\x80\xbf\x42\x89\x5c\x7a\x79\x87\xcb\x8a\x58\xa6\xbc\x13\x63\x07\x21\xa3\x87\xb6\xae\xe4\xc2\x23\x92\x19\x0d\xa4\x2c\x92\x83\x24\xc5\xef\xf5\x79\x19\xab\x1b\x51\xe9\x16\xd1\xa7\x25\xf1\xbe\x16\x33\x2a\x04\x98\xec\x87\x43\x4b\x11\xbd\x66\xe8\xc0\xae\xf4\xee\x1a\x52\xcc\x31\x9d\xf5\xa0\xd4\xb4\x9a\x57\x7a\x3c\x44\x35\x1d\x3b\xb4\x50\x81\xa5\x69\x4e\xd2\x11\x31\xb1\x64\x4b\x3f\x73\x60\x33\x41\x6a\xc3\x82\xf1\x3f\xef\x97\x6a\x76\x35\xe9\xc5\x53\xd8\xb3\x84\x07\xd0\xc5\x16\x79\x42\xf5\x15\x00\x70\x2e\x62\xd7\xf2\x67\x40\xd4\x54\xc1\x38\x0b\x4d\x5e\xae\xeb\x49\x93\x2d\x3c\xd1\x38\x3c\x46\xae\x0d\x4a\xcb\x29\x46\x61\x4a\x6a\x2b\x5b\x17\x17\x96\x46\x82\xb4\x7d\xeb\x00\xf4\x85\xbf\x08\x6c\xfa\x9c\x07\x55\x2c\x4f\xd9\x4d\x85\xb2\x99\x0a\x6f\x0f\xf0\x22\x16\xde\x21\xb4\x08\xe9\x78\xc3\xf7\x16\xb9\x94\x34\x7d\xb0\x98\x30\x59\xc6\x01\x40\x86\x50\x1e\x14\x99\x23\x55\x4f\x71\x34\xa1\x92\x9d\x18\x1b\x4c\xfe\xc5\x24\x7f\xf4\xc9\x8c\x72\x4c\x14\x91\x9e\xd7\xf6\x8f\x92\xbe\x81\xe8\x1d\x4a\xec\x65\x7e\x35\x01\x3f\xe0\x00\xa3\xbc\x02\xee\x97\x02\x1f\x92\x32\x70\x89\x20\xdf\x9d\xe3\x06\x7d\x57\x18\x36\xf4\x7f\x2c\xaf\xac\x4f\x05\xb5\xdd\x23\xc5\xfe\x61\xae\x75\x4c\x83\x07\x06\x34\x4b\x56\x5e\xa5\x12\xe7\x5c\xa0\x57\x9a\x1d\xc0\xbd\xd2\xec\xaa\x07\xe8\x95\x46\xdb\xbb\x5d\x63\xf4\x1f\xee\x95\xfe\xee\xf0\xba\xa2\xd9\xcb\xa1\xee\x10\x33\x9f\x19\x69\xe2\x14\xbf\x93\xa6\x26\x50\xde\xca\x4f\xd2\x14\xf3\x27\xad\x64\x13\xc0\x27\xad\x63\x26\xdc\x47\x1c\x1b\x00\x9c\xf4\xed\x77\x6b\xf0\x6c\xea\xc6\xe7\x67\x85\x3c\x4c\xf2\xf9\xd7\x97\xfc\xab\x4f\x26\x26\x79\x5b\xc0\x8d\x27\xa6\xe7\xf6\x3a\x17\x9e\xb2\xd1\x0b\x24\x54\x48\x29\x8e\xfb\xcb\xd1\x49\x1d\xe9\x5b\x1b\xe5\x6a\xbb\xba\x42\xc0\x06\x64\x27\x85\x1c\x67\xe8\x6b\xb3\xaf\xbf\xba\x8a\x6a\xeb\x05\xa0\x1e\xba\x9d\x59\x3c\x36\x8b\x16\x99\x4d\x62\x82\x18\xf1\x8e\xa3\xef\xa3\x7c\xeb\xa4\x5a\x63\x7b\xb3\x80\xba\x62\x82\x62\x7a\x2f\xb6\x62\xe5\xfd\x8d\xd3\x6d\x0b\xc0\xc2\x88\x4c\xe7\x3d\xdf\x2e\x04\x11\x55\x8a\x6e\xb8\x75\x9c\x49\x93\x06\xdc\x65\x75\x06\x4f\xe1\xa0\xec\x3a\xbe\x16\x44\x75\x43\x83\xf4\xda\x97\x26\x62\xe7\x5b\xbd\x9a\x27\x88\x35\x26\xa9\xbe\x21\x8f\xae\xc1\xf1\x26\xbb\x8c\x5f\x13\xaa\xc4\x7c\x98\x94\x73\x6c\x74\x95\xf6\xa5\xa3\x95\x64\x4c\xa8\x16\x72\xcd\x4e\xb1\x5b\xec\xdb\x32\x73\x11\x82\x77\x47\x92\x90\xdf\xff\xb6\xa2\xdb\xb2\xe5\x18\xf4\xc9\xf7\xc2\x15\xa0\x39\x68\x78\x16\x4e\x00\x27\x03\x30\x61\x3d\x04\xaa\x2c\x88\x09\xf7\x63\xb6\x69\x4c\xd8\x19\x1c\xbe\x9b\xf7\xca\x25\x31\x83\x4f\x28\xa7\x59\xc0\x04\x65\x6d\xfa\xeb\x5b\x95\xb0\xef\x89\xf5\x61\x1a\xb4\xf7\x0a\x53\xf9\x76\x6b\x0c\xb6\x4f\x32\x9c\x9c\xcb\x6d\xa0\xbc\xb4\xcd\x3b\x01\xc2\x46\x9f\x15\x98\x7b\x58\x0f\xc4\x4d\x5a\x65\x1b\x4a\xbd\xaa\x8f\x51\x83\xd2\x14\xe4\xb6\x92\x9f\xea\xff\xba\xe1\x24\x99\x30\xe7\x08\x55\x67\xb2\x3a\x3a\x90\x66\x58\x85\x5b\x0b\xbb\x32\xc7\xc0\xc1\x8b\xf7\xe7\x17\xfb\xc7\x27\xa7\xc7\xef\x2f\x4e\x5e\x1d\xbd\xbe\xbc\x30\xdb\x93\x38\x84\x84\xb5\xb2\x3a\xb8\x5c\xae\x7d\x47\x42\x50\xfe\x4e\xba\x9e\x5d\x5c\xbe\x79\x4c\x5d\x05\xf9\xbd\xba\xe6\xf1\x22\x95\xce\xc8\x94\x51\xd1\x52\x49\xc0\xe3\x99\xc7\x1f\x41\xc4\xfd\xbf\xf3\x4d\xb6\xf2\x3d\xf3\x01\x61\xf5\x9a\xee\x55\xd2\x3c\x35\xc2\x14\xc6\x07\x08\x73\x15\xb7\x17\xf9\xda\x0b\xbf\x8a\x96\x05\x30\x14\x0c\xdf\xb0\xfa\xcb\xae\x42\x1c\xb2\xbc\x99\x85\x4a\x4a\x8d\xe6\xa2\x42\x6b\x07\x0f\x56\xa1\x98\xb6\x0e\x17\xb1\xca\x96\xf6\x5d\x29\x64\x38\x18\xaf\xfd\xe2\xfe\x57\x05\x80\x56\x51\xa6\xa8\x8a\xb6\x6a\x6a\x29\x5a\x00\x8e\x2c\x5a\x2f\x06\xa3\xc9\x0e\x0c\x6d\x11\x05\x0e\x1b\x3c\xb5\x9a\x8b\x82\x33\xa1\x1b\xc7\x86\x38\x54\x32\xc7\x82\xf8\xbd\xd4\x3f\x63\x12\x4a\xe0\xb5\x42\x72\x40\xa0\x89\x4e\x84\x63\xfd\xa5\xc1\xe6\xb1\x4f\x85\xf8\xf0\x27\x89\xb2\xaf\x29\xfe\x53\x92\x6c\x09\xc1\x26\x3e\xa9\x1b\xa0\x82\xc9\x05\xc2\xda\x0a\xe5\x80\xb3\x59\xde\x53\xe0\xe7\xc0\x56\xc2\x58\x62\xc9\x5d\x09\x3f\xa7\x69\x52\x56\xfd\xa5\x7f\x0a\x65\x7c\x5f\xd2\x8f\xbd\x05\x01\x7f\xca\x74\xd4\xd3\xa8\x65\xdd\x6c\x57\x81\x24\xac\x64\x38\x0c\x4e\xed\x96\x30\xa9\x21\x1d\x69\x62\xa3\x28\xbe\x1c\xb0\x4a\x55\xb6\x40\x32\x51\x70\x88\xbc\xc7\x6e\x7a\x62\x28\x88\x27\xb7\xb7\x2d\xd3\x9a\x28\x0f\x27\x92\x76\xd5\x87\x93\x87\x81\x1a\x3b\x8a\x0b\xd1\x59\x07\xd8\xab\x19\x86\x25\x3a\x58\x3d\x30\x4d\xbf\x80\x51\xbc\x24\x63\x99\x48\x78\x0f\x92\xae\xb7\x41\xd6\x8d\xd1\xe4\x25\xbb\xb3\x95\x8c\xe4\xb5\x98\x40\x15\xd2\xc1\x67\x0c\x9a\xcf\xe3\x65\xfe\x98\x4a\xa6\x02\x62\x31\x1b\xe0\xad\xb0\xa4\xc0\xae\x8c\x10\x80\xb1\x2a\xed\x05\xd9\x5d\x82\x45\xa5\x8e\xb1\x96\x83\x50\x1a\x5d\x6b\xa2\x43\xda\xb8\xc2\x84\xc2\x99\x3c\xc6\x18\x9a\x2b\x14\x0b\x04\x48\x06\x89\x57\xbd\x80\x70\xf1\x1e\x85\xc7\x83\xf2\x82\xbc\x85\x5d\x15\x65\x89\x52\xb8\xac\x74\x17\x53\xea\xc6\x26\xed\xf0\x7c\x0c\xe0\x1f\x0f\xf8\xd4\x60\x3a\x71\x96\x0e\x98\x10\x5a\x86\x75\x34\xe8\x4b\xdd\x80\xc3\x6d\xa0\x4a\xb8\x09\x52\xf7\x7c\x5e\xe5\x7c\x13\x34\x51\xa6\x93\x74\x09\x7b\x14\x03\x0a\xec\xd8\x76\xae\xef\x73\x9a\xfe\x79\x0d\xb7\x9d\x7f\x25\x3e\xcc\x76\xeb\xee\xe9\x73\x30\x9c\xa7\x55\x38\xbd\xc9\x0f\x33\xd4\xa6\xcb\xa7\x37\x78\x97\xe6\xee\x3e\xc0\x0f\x31\xba\x70\x27\xf2\x47\x78\x7c\xed\xd6\x99\xd7\x19\xe5\xf1\x35\x7b\x3d\xbd\x43\xc5\x23\xab\xdd\x84\x9e\x65\xb3\x5c\x32\xb3\x31\x0f\x8f\x6c\x14\x61\x58\xb8\xb4\x94\x07\xcd\x6b\xb9\x5c\x2d\x3e\x73\x07\x0b\x96\x40\x68\x2b\xbf\x77\xa6\x85\x7c\xbe\x51\xd9\x28\x46\x40\xfe\x53\x7d\x27\xa6\xfc\x9a\x03\xc2\xc0\xb3\x6f\xf1\xcd\x10\x8d\xc5\xe5\x02\x46\x22\xc4\xe8\x4b\xbe\xe2\x52\x5a\x2d\x94\x18\x65\x37\x8f\x6e\x20\x91\x0e\xf8\xa3\x25\xd8\x48\xb6\x16\xba\xaa\x2e\x20\x76\xa3\x30\xb9\x1e\x36\x92\x65\xd5\x48\xce\x80\xef\xf3\x08\x97\x4f\x84\x26\xd6\x45\xd8\x95\x94\x85\x7d\x49\xf5\x74\xea\x09\x5d\x44\x9a\x66\xc1\x32\x62\xb8\xfe\xd9\x4b\x61\x15\xd5\x2a\xbe\x16\x2f\x87\xb5\x92\x0c\x17\x40\xf7\x89\x85\x02\x31\xfd\x0d\x06\xba\x80\x27\xc4\x12\x2f\x8c\xe2\x5d\xb8\x0d\x06\x8e\xde\x06\x03\x47\xb7\xb2\xd1\x7a\xff\x5b\x7f\x91\x5f\x28\x21\x09\xa3\x45\x3f\x7d\x8a\xbe\x40\x5c\x2f\x29\xf1\x8c\x18\x52\x32\x0e\x66\x3d\xdf\x40\x40\xd3\xa7\x4f\x52\x4a\xa5\xae\x2c\x13\xe7\xea\xe0\x9f\xa2\x48\x49\xbb\x83\x17\x86\xc9\x67\x9d\x49\x68\x4a\x02\x35\x7b\x1f\x0f\x4b\x0b\x51\x76\x9c\x14\xc6\xcf\xc4\x3c\x1c\x93\xa5\xdf\xc5\x94\x52\x7c\x43\x98\xff\xe3\xb2\xd1\xa3\xc7\xa5\x25\xa5\x93\x7b\xd2\xca\x62\x74\x15\x58\x68\x0c\x4a\x8f\xa3\x5b\xaf\x5f\x8f\xcb\x8e\x50\x51\x3f\x60\x95\x79\x7d\xc5\xa1\x09\x4a\x0b\x37\x88\x7c\x91\x2a\x07\x2a\xff\xd2\x81\xa1\xfb\x84\x08\xaf\xf0\xf0\x29\x81\x7b\x0c\x3b\x4e\x18\xeb\x63\xaa\x62\x1c\x59\xd4\x29\x2f\x56\x73\x98\xa9\x1f\x2f\x61\xed\x03\x49\xe0\x55\xc4\x7f\x61\x1e\x2a\xb9\x87\xfd\x62\x34\xc0\x7e\x31\xb1\x32\xbd\x29\x9b\x06\x05\xa0\x02\x96\x50\x37\x29\xbf\x54\x51\xb3\x9c\x28\xbb\xfb\xf8\xcc\x69\x70\x2d\x7d\xcf\x0b\xd3\xed\xcd\x54\xf6\xc8\xa0\xe3\x05\x13\x2a\x4a\x6c\x4a\xd9\x7c\x1d\x87\x8e\x34\xca\x42\xd5\xfd\xc9\xfc\xfb\x54\x20\xc2\x1d\x0c\x1b\x31\xc1\x58\x3e\xe1\x42\x4f\x6a\x60\x47\xbc\x23\x4f\x1f\x7c\xe0\x79\x57\xbc\xdb\xe0\xff\x51\x4f\x7c\xd3\x4c\xa5\x6d\x10\xf0\xd1\x1d\x64\xf4\x05\x37\xfb\x3b\x28\xf9\xa6\x56\x37\x56\xbd\x77\xff\x89\xa6\x2f\xa6\xad\x31\x11\x25\xb0\x2c\x39\xf7\xab\xcd\x1c\x4e\x71\x9e\x8c\x1e\x56\x36\x51\x22\xd3\xa8\x42\xf6\x25\xc4\xaf\x98\xb1\xe8\xcb\xfa\x0f\xf1\x5e\x69\xda\x4b\xeb\xe0\x72\x80\x37\xa4\xf4\x13\x32\xe9\x76\xad\x37\x37\x9c\x39\xc8\xb2\x33\x85\x87\xcf\xef\x2a\x3b\x72\x2f\x43\xb9\xc0\x95\xe9\xbf\xb8\x80\xf4\x9d\x00\x8c\x57\x36\x30\x0c\x0e\xaa\xde\xbe\xa4\x1c\x22\x09\x80\x28\x28\x1c\xcf\x4b\x91\xde\xe0\x12\x01\x9c\x39\xe7\x98\xba\xaa\x81\xb1\x93\x4f\x01\x48\xe0\x8b\x5d\xe0\xcd\xaa\xbe\xce\xb4\x93\xaa\xc1\x10\x22\xb7\xc6\x12\x83\x74\xa4\x8f\xa6\xac\x8a\x5c\x2c\xfe\x88\x79\x49\x33\xb2\xfe\x2c\x6a\x2d\x5f\x9c\x1d\xb5\x7a\x17\xdd\x45\x75\x5f\x50\xe4\x04\x6c\x8e\x45\xbe\x8d\xee\xca\x4a\x2f\x9e\x1a\x33\x80\x1e\xbc\x88\xbc\xe3\x1e\xb6\xa9\x57\xf1\xc7\x6c\x55\xaf\x1c\x6b\x2a\xb1\x34\x38\xfa\xd7\xc6\xf1\x2d\x93\xbe\x8e\xd0\xc6\x32\xd2\x76\xb5\x30\x0c\xb0\xb6\x9a\xff\xda\x55\x8f\x96\x05\x72\xf0\xf2\x04\xaa\x63\xba\x58\x2d\xc3\x0a\x80\xc5\xd3\x35\x57\x9a\x1f\xfb\x15\xc2\xf7\xc8\x63\x53\x1b\x82\x2f\x40\x1a\xb5\xc2\x48\xdc\xf8\xd1\x61\x3e\x43\xcc\x95\xa3\xc3\xad\xfc\x6a\x22\xbc\x7b\x14\xc4\x0b\xd7\xe9\x01\xb9\x43\x73\x8a\x13\xb4\x1c\x74\x14\x7e\x22\xcf\xb7\x6e\x81\x1c\xbc\xad\x92\xfc\x57\xe9\xaa\x79\xb8\xea\x3f\x0c\x9e\xad\x5e\x21\x3a\x5a\xbd\x42\x62\x45\x7a\x87\xcd\x2f\xf4\x5d\x49\x17\x32\xff\x34\xb6\xdf\x18\x18\x7c\x58\xc4\x00\x48\x1e\xf8\x19\xcd\xab\x3f\x0b\x08\x22\xcd\x7b\xbe\x1f\x02\x97\xf7\x14\xc9\x10\xce\x78\x5d\xc9\xf1\x0b\x3d\x85\x52\xd8\xad\x2b\x09\x75\xd7\x53\x40\xd5\x4b\x48\x01\x33\xb1\x2d\x0a\x73\xe4\xe9\x3f\xaa\x2b\x0c\x94\x90\x1e\xfa\x3b\xd8\x42\x9b\x90\x32\x86\xec\x98\xc4\x5a\x80\xa0\x45\x82\x8e\xc8\x4a\xb4\xc4\xe0\x52\x51\xa9\x21\x7c\xaf\x32\x20\xb6\xa8\x0b\xe6\x14\xd2\x02\xe5\x1e\x18\x52\x68\x67\x45\xb8\x72\x7a\x7e\xc8\xe4\xb9\xd4\x92\x30\x1a\xc0\xd9\x2d\x3a\x1e\xa7\xf9\x4b\x93\xe4\xf8\x0b\x5a\x75\xda\xb0\x79\x09\x57\xfa\x4f\x9f\x5e\x35\x3c\x1b\x33\x1f\xe7\xd5\xf8\x2e\xea\xc5\xb6\xcd\x2c\xfb\x9b\x32\xdf\x99\xac\xe8\x8e\x00\xd5\xfe\x64\xec\xd0\x59\xe4\xbf\xf4\xe3\xce\x76\x5a\x16\xdf\x00\x48\xc3\x14\xd9\x27\x00\x7c\xf0\x5a\x19\x6c\xd7\xcb\xae\x33\xe6\xd5\x2c\x1a\x00\xdd\x89\xad\x9f\x71\xe2\xf3\x24\xed\x34\x78\xd6\x34\x6a\xbb\xcd\x6e\x7d\x00\x28\x85\x81\x16\x4b\x03\x79\x46\x8f\xa4\x66\x8b\xa6\x8d\x17\xf3\xfe\x9a\x3f\xb9\xf8\xea\xf0\x83\x6a\x57\x18\xa9\xde\x27\x0c\x1e\xfb\x46\x3c\xc0\x12\x2f\x1f\x3a\x2c\x8d\x80\x01\x07\x26\xde\xa8\x63\xa6\x5c\x6d\x95\x9d\x5c\x07\xce\x80\x43\x8a\xba\x90\x67\x4d\xa8\xca\xb6\x84\x80\x06\x9b\xd6\x36\x3d\xb7\x77\xb1\x9e\x6b\x50\x59\xf9\xbf\x34\xef\x05\x08\x4d\xf5\x68\x05\xc8\xff\x1a\x30\xe9\x4d\xe5\x66\xbb\x9f\x37\xae\x61\x7d\xb5\x0b\x95\x5b\xba\x86\xaa\xe4\xf0\x4f\x06\x4a\xe8\x89\x70\x55\x17\xe8\x9c\x22\x76\x0d\xd9\xe4\x35\x87\x39\x98\x0f\x68\xd1\xea\x2b\x0d\x2d\x1b\xfd\xc7\x8f\xfe\x62\xea\xcc\x4f\xb9\x85\x3b\x0b\x35\xa0\xd0\xff\xf8\xe1\xff\x03\x00\x00\xff\xff\xc5\x33\x3b\x29\x0e\x01\x03\x00") + +func cfI18nResourcesEsEsAllJsonBytes() ([]byte, error) { + return bindataRead( + _cfI18nResourcesEsEsAllJson, + "cf/i18n/resources/es-es.all.json", + ) +} + +func cfI18nResourcesEsEsAllJson() (*asset, error) { + bytes, err := cfI18nResourcesEsEsAllJsonBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "cf/i18n/resources/es-es.all.json", size: 196878, mode: os.FileMode(420), modTime: time.Unix(1456502789, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _cfI18nResourcesFrFrAllJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xbd\xdb\x72\xe3\x46\x92\x30\x7c\xff\x3f\x05\xfe\xde\xd8\x60\x7b\x42\x54\xdb\x9e\xd9\x8d\x2f\x34\xf1\xc5\x2c\x2d\xb1\xdb\x1a\x53\x87\x21\xa9\x9e\x71\x58\x13\x1a\x88\x28\x4a\x70\x83\x00\x8d\x83\xd4\x6a\x6f\xef\xb3\xec\xdd\xba\xe7\xe2\xbb\x9a\x37\xd0\x8b\xfd\x79\xa8\x02\x0a\x87\x02\x0a\x24\xa5\xf6\xee\xff\xed\xc6\xb8\x29\x12\xc8\xcc\xca\xaa\xca\xca\xca\xe3\x0f\xff\x8f\xe3\xfc\x0c\xff\x73\x9c\x17\xbe\xf7\xe2\xc0\x79\x71\x19\x5e\x86\xf3\xe3\xf3\x83\xcb\xf0\xc5\x1e\x7f\x9f\xc6\x6e\x98\x04\x6e\xea\x47\xa1\x7a\x60\x34\x9b\x5f\x1c\x8e\x1d\x7c\x08\x9e\xf9\xb8\xd7\x04\xe4\xfb\x28\x8b\x9d\x3f\xce\xce\x4e\x9d\x24\x8d\xfd\xf0\xc6\x49\x1e\xc2\xd4\x7d\xef\xf8\x89\xe3\x87\x77\x6e\xe0\x7b\xfb\x8e\x73\x1e\x47\x6b\x11\x6b\x3f\xa5\xb7\x7e\x72\xe0\x38\x8b\xa5\x93\x88\x74\x18\x67\x61\x08\xaf\x0e\x45\x78\xe7\xc7\x51\xb8\x12\x61\x3a\xbc\x73\x63\xdf\xbd\x0e\xc4\xf0\x26\x8e\xb2\xb5\x33\xf8\xf9\xf2\x45\xe8\xae\xc4\xe5\x8b\x83\xcb\x17\x00\x36\x83\x4f\x7b\xf5\xaf\x3e\x0e\x5a\x86\x33\x71\x25\x05\xc2\xf1\x84\x73\x17\xa5\xb1\x70\x16\xb7\xee\xe3\xff\x09\x05\x8f\x20\x1c\x88\x24\x75\xd6\x6e\xe2\x10\xe1\x62\xdf\xd1\x5e\x59\x44\x71\x2c\x16\xa9\x70\xf0\x99\x00\xbe\xcf\xfc\x3b\x37\x84\xbf\xfb\x8f\x23\x5a\x29\x9a\x45\x16\xf3\x38\x2a\x5f\xc1\x38\x9e\x94\xe3\x49\xea\xde\xfc\x4f\xe0\xb8\xed\x38\xb6\xe1\xf8\x6f\x9c\xf9\xad\x48\x04\xe0\x8b\xef\xfc\x85\x70\xd6\x01\x8c\xd3\xb9\x75\xef\x84\xe3\x86\x8e\x9b\x24\xd1\xc2\x77\x53\xe1\x01\xbd\x49\xba\xef\x1c\xc6\x02\x78\x00\xd3\xe2\xe6\x6f\xf8\x21\xd0\x19\xc2\x87\x7b\x3f\x08\xe0\xaf\x05\x4c\x20\xce\x07\xbf\x61\xe4\xdf\x6f\x9c\x43\x91\x48\x74\x5e\x81\x1f\x78\x97\x44\x21\x73\xed\x26\x76\xd3\xcc\x4f\x13\xe2\xdb\x22\x7e\xfc\x44\xaf\x3b\xde\x20\x0b\x35\xb4\xda\xcb\x77\x51\x96\xe0\x1f\xae\xb3\x74\x17\x69\x06\x6f\x00\xcf\x4d\x23\x1f\xad\xd7\xb0\xc6\xdc\x18\x06\xd7\x22\x27\xe0\xa9\xc0\x5f\x48\xc4\x8f\x9f\x56\x6e\x8c\x50\xcd\x32\x03\xa1\xfe\xfc\xf3\x3e\xfc\x73\x0a\x6b\xe9\xe3\x47\xe7\x1e\x06\x22\xd1\x38\x59\x82\xac\x93\xcc\x59\xad\xdc\xd0\x73\xfe\x06\x0f\x1f\xf2\xe7\x8f\x1f\xff\xd6\x42\xc8\x64\xe0\x6a\xa4\x94\x50\xb8\xce\xe3\xa7\xf4\xf1\x93\x46\x9f\x03\xf3\xb7\xc0\x55\x25\xd1\x88\x3a\x1e\x03\xfd\xa7\x91\xe3\xae\x7d\x47\x84\xde\x3a\xf2\x61\x1e\x60\x1d\x9a\xe7\x70\x94\x2d\xb2\xd0\x09\x23\x91\x79\xce\xd2\x0f\xdd\x00\xe6\x66\x74\x7e\x8c\x84\xc0\x9f\xbe\x99\xf7\xd3\x28\x83\x95\x9e\x46\xce\xb5\x70\xb2\x70\x05\x23\x03\xee\x00\x57\xc2\x28\x75\x60\xfd\xc4\xb0\xd2\x83\x07\x47\x7e\x0f\x8f\xa5\xb7\x30\xa4\x62\xf8\x66\x8a\x60\xa1\xc4\x04\x7b\x8d\x72\x24\x70\x7f\xca\x44\x10\xe0\x52\x0e\xb3\x00\x24\x06\x7c\x44\xa0\xee\x8d\xd0\x36\x27\x7e\x83\x3c\x7b\xfc\x4f\x27\x28\x31\x19\xd7\x10\xbe\x8e\x1b\xcf\x3c\x16\x3c\x68\x1c\xe7\x02\xf6\xd0\x00\xf6\x2d\x4c\xc0\x3b\x91\xc2\xb2\x86\xe5\x38\x4c\x9c\xd9\x78\xfa\xf6\xf8\x70\x3c\xc0\x41\xdc\xf9\xe2\x1e\x56\x6b\xb2\x88\xfd\x35\xc2\x4f\x9c\x68\x09\xcb\xd8\xf3\xef\x7c\x2f\x03\xde\xf1\x5e\x80\xef\x5c\xe7\xc6\xbf\x13\xa1\x5a\xd6\x2d\xfc\x97\x47\x98\x93\xa5\x7e\xe0\x27\xe2\x43\x2b\x09\xc4\x12\x77\xb9\xf4\x17\xb7\xc8\x0a\x57\xa7\x05\x3f\x4b\x02\x14\x45\x22\x48\x68\xab\xe5\xbb\xcb\x8b\xc2\xf0\xf1\x53\x07\x23\x46\x49\xe2\xdf\x84\x30\x09\x01\x00\xbc\xf7\xd3\x5b\x10\x51\xb0\xf2\x78\x4e\x81\x49\x31\xac\x57\x94\x6d\x51\x7c\x33\xc4\x87\x06\x0e\xee\x82\xe6\x67\x92\x35\x0c\x81\x9f\xea\x66\x01\x0c\x0c\xc5\xe9\x07\x1a\x49\xfc\xf8\x0f\xc4\x4f\xbb\xa0\x0b\xbf\x48\x2d\xd0\xb7\x0d\x99\xa6\x1e\x21\xbc\x9e\xbb\xf1\x8d\x48\xf3\x6d\x46\xb3\x9e\xd2\x77\x20\xd7\xee\x1d\x02\xd8\x67\x32\x9b\x81\xd2\x3c\x2e\xfc\x6b\x5c\xd0\xb4\xfd\xb2\x3b\x11\xc0\x31\x82\xd0\xdb\x27\x27\xa7\xd4\x44\x21\x70\xa5\x2f\x7d\x26\xba\x84\x24\x0c\xb6\x1c\x40\x75\x43\x3f\xe1\x4d\xd5\x4a\x60\x26\x77\x51\x10\xc1\xc1\xe7\x0c\x5d\x07\xa5\xc9\x70\x98\xbc\xf3\xd7\xc3\x24\x09\x86\x74\x8e\x12\x9c\x01\x40\xa5\x47\x51\x5a\xb5\x3c\x05\xe3\x4b\xb2\xf5\x3a\x16\x09\x6b\x09\x8e\x88\xe3\x28\xee\xb9\xa3\xac\xc8\xc9\x6c\xc8\x21\x1e\x3d\x7e\x0a\xfc\x95\x1f\x02\x9b\x16\x22\x45\x0d\x00\x56\x1e\x7c\xdd\xcc\x19\xf8\x74\xf8\xfa\xea\x74\x74\x32\x76\xdc\x0c\xb6\x13\xaa\x28\xff\x26\xde\xbb\xab\x75\x20\xf6\x41\xbc\x3b\x97\x2f\x2e\x2f\x2f\x5f\x80\x20\x4b\xee\xa3\xd8\xc3\xcf\x97\x2f\x9c\x97\xb0\xb5\xdd\xb5\x70\x7e\xca\xa2\x14\x36\x82\xbf\x44\xd6\x82\x88\x0d\x1d\xf5\xe0\x17\x06\x1e\xd4\xf0\x45\x2b\x40\x27\x2a\xe8\x56\x51\xea\x09\x04\x25\x14\xc2\x15\x0e\xe5\x83\x43\xdb\x6e\x0d\x27\x3f\xa8\x68\xa0\x58\xc0\x41\x02\xc3\x05\xad\x08\x24\x39\x8a\x51\x27\xf1\x69\x83\xea\x8f\xd0\x79\xcf\xfc\x06\x31\x0c\x42\x07\xa5\x10\x4a\x6a\x38\x0c\xe0\xe4\x22\x2c\x5f\x6c\xce\x9d\xd5\x43\x3e\x66\xa4\x13\x97\x98\xe4\xca\x12\x96\x90\xfa\x49\x0a\x2b\x97\x37\xe9\x17\xc6\x83\xb8\x9b\x3d\x2b\x58\xe4\x3a\xe9\x88\x94\x84\x31\x33\x07\x7e\x4a\xf2\xdf\xe0\x7c\x06\x95\x2f\x74\x91\x01\x21\x2e\x21\xe4\x0d\xef\x64\x64\x1d\x6a\x94\x37\x99\x4f\x47\x50\x9a\x7c\x61\x3a\xb5\x35\x9a\x16\xd1\xfa\x61\x98\xc0\x22\x03\x51\x30\x3b\xbb\x98\x1e\x8e\x87\xa3\xf3\x73\x67\x3e\x9a\xbe\x19\xcf\xe9\xe3\x0f\xc3\x48\xfd\x79\x36\x7d\xf3\x57\xf8\x3b\x51\x7f\xcf\xce\x47\x87\x63\xfc\x66\x18\x46\x43\xd8\x31\xa8\xb5\xfc\xd5\x86\x13\x3a\x56\xc0\x71\xc5\x98\xe9\xe3\xe1\xf1\x37\x93\x31\x21\x05\x6c\xfc\x17\xe3\x1c\x13\xb6\xe2\x9b\x0a\xce\xae\x81\xf2\x96\x7c\x19\xad\xfc\x14\x97\x76\x8c\x13\x4f\x47\x89\x9a\x50\xdc\xf9\xfc\x10\xa8\x31\xa0\x12\x2e\x52\x38\x53\x41\xa9\x18\x0e\x73\x18\xa4\xb0\xae\xe3\x68\xb5\x4e\x69\x2d\x5c\x47\xe9\xad\xd5\xcc\xe7\xc8\xd5\x9a\xc7\x65\x80\x87\x25\x2d\x62\x50\x97\x61\x37\x83\x44\xad\xac\x61\xde\xfc\xa4\xa3\xc2\xb4\x87\x78\x5a\xc5\xf8\xe3\xd2\x7d\xfc\xaf\xa8\x44\xa6\x4e\xa4\x27\x48\x81\x03\x9d\x16\x57\x8f\x27\xb2\xf7\x36\xeb\x40\x4a\x2c\x90\x3f\x91\xf3\xb2\x3a\x5e\x38\xdd\x81\x57\x4e\x16\x07\xc8\xa4\xe8\x3a\x75\xe1\x59\xd7\x89\x42\x31\x4c\xfd\x95\xa8\xb3\xd0\x42\x56\x34\x22\x2c\x68\xc7\xf3\xc0\xf5\x50\x0a\x0b\xe7\x62\x3a\x61\x56\x00\x66\x11\xfa\x74\x88\x95\xf8\x04\x8a\x98\xe2\x24\x9e\x18\x59\xe8\x83\x1a\xa7\x34\x3a\xe6\xdd\x7b\xf8\xc1\x42\x26\x48\xaa\xb2\xba\x5c\x18\xae\x37\x16\x9c\xf6\x2b\x04\x11\x57\xe4\x43\x8e\xf7\xd9\x25\xa8\xfd\xaa\x31\xb1\xeb\xc9\x24\x69\x3b\xb7\x3e\xab\x40\x6d\x65\xc9\xda\xfd\x97\x7f\xb9\x8f\xa6\x47\xce\xcb\x64\x2d\x16\xfe\xf2\xc1\x20\x8a\xe0\x92\x01\x3a\x56\x86\xd3\x97\x6c\xcd\x10\x1d\x29\x2c\x0c\x7f\xe9\xf7\x10\x41\x09\x4a\x1f\x98\x2d\xa0\xd0\x1b\x94\x68\xea\x62\xc4\x3a\x4b\x6e\x49\xa2\xd3\x5f\x3f\x0c\xaf\x9d\x6f\x2e\x8e\x27\x47\x20\xc4\xbf\xa3\xaf\x50\x86\x2f\x9c\xc3\xb3\x93\x93\xd1\xe9\x11\xfe\xe1\x39\x47\x67\x27\xa3\xe3\x53\xfc\xbc\x74\xe0\xdb\xe3\xd7\xe3\xd9\xfc\xea\x7c\x34\xff\x96\xe4\xbd\x17\x2d\xde\x89\x78\xe8\xaf\xf0\x36\x76\x74\x76\xf8\xdd\x78\x7a\x75\x7c\x32\x7a\x33\xb6\x3a\x72\x88\x9c\xd3\xb3\x93\x2b\x3e\xd3\xae\xe9\x33\x11\x73\x78\x76\x3a\x9b\x4f\x2f\x0e\xe7\xc7\x67\xa7\x25\xa2\xc6\x3a\x55\x63\x26\xeb\xf0\xdb\xf1\xc9\xf1\xe9\x95\xa2\x6e\x5c\xa7\x8c\x48\xba\x62\xfa\x6c\x0e\x26\x22\xac\x3e\x62\xeb\x31\x35\x52\xd5\x82\xf7\x8c\xee\x6f\x6e\x00\x47\x5b\x21\xda\x61\x09\xa4\x78\x93\xa4\xeb\xff\xd0\x13\xa8\x6f\xa2\x01\x22\x75\x6f\x50\x0d\x76\x53\x3e\x0b\xe0\xf6\x7d\x1f\xfb\x20\x75\x42\x75\xc9\x7e\x7b\x38\x82\xe3\x9b\x6f\x8c\x33\x47\x33\x3c\x39\xca\xf0\x44\x7b\xdd\x0d\x1f\xe0\xb4\xcc\x60\x8d\x6b\xf7\xe5\xc4\x74\x51\x85\xaf\x66\x3e\x1f\x7c\x01\x2d\xc1\x5b\x17\xa8\xf9\xb0\x07\xa0\xb2\x18\x2e\x06\xa8\x66\xe3\x01\x81\x54\xe3\xba\x7c\xfc\x94\xa2\xc4\x4f\x51\xb2\x80\x40\x5b\xbb\x31\x49\x35\xf8\x97\x1e\x03\x9a\x6e\xe0\x36\x0f\xb2\xc7\xc7\xbb\x29\xca\x3e\xd8\x07\x30\x8e\x5c\xf2\xb9\x05\xb5\xde\x40\x0e\x22\x64\xe9\x59\x1e\x20\x9d\x29\x29\x19\x0c\xf4\x8b\x7f\xe0\xb7\x58\x8e\x9a\x79\x2e\x2f\xc9\x43\x16\x04\xfe\x02\x05\xd1\xd2\xbf\xc9\x62\x86\x08\xb4\x83\x54\x80\x03\x1e\xef\xd7\x8e\xcb\x06\x41\xb6\x12\x46\xd7\x3f\x82\x2a\x00\x5f\x0f\x03\xb8\x13\xec\x5f\x86\xda\x8a\xc8\xd6\x70\x71\x00\xa0\xf2\x06\x3e\x5c\xd8\x1b\x2e\xd1\x42\x69\x5a\x1e\x4b\x3f\x60\x49\x09\x07\x3f\xd9\x58\xb7\x24\x7e\xdf\x21\x5c\xf3\x5b\x14\x33\x20\xfb\xe5\x62\xd2\xde\x63\x8c\x6e\x88\x4b\x0e\xed\x8a\xd7\x49\x14\x20\xd7\x61\x2d\xc5\x02\x57\xca\x5d\xf1\x2a\xd3\xd7\xc5\x08\xdc\x55\x57\xf3\xb3\xab\xd7\xc7\x93\xb1\x1c\xeb\x98\xa5\x33\x2e\xfc\x1a\x89\x07\xf4\xc4\xcf\xf4\x5f\xf8\xbf\xcb\x17\x8b\x20\x83\xd5\x16\x5f\x85\x11\x1c\x11\xc0\xba\xe2\x37\xfe\x19\x56\x77\x8a\x5f\xff\xcb\x5e\xe9\xfb\x95\x58\x45\xf1\xc3\xd5\xea\x1a\x7f\xfb\xea\xcb\xaf\x7f\xa7\x7e\xfd\x48\x1f\x3e\x6e\xb1\x05\x3c\x5e\xe3\xee\xea\xf1\x17\x38\xa7\xe8\x4c\xab\xcc\x03\x1c\xf7\xf8\x83\x9b\x15\x36\x19\x5c\xef\x78\xd2\xc1\x20\x53\x1e\x2f\xdb\x9a\x51\x6d\x08\xfc\x1b\x58\x50\x38\x37\x1d\xeb\xc9\xc6\x80\x2c\x79\x6c\xb1\x91\x1d\xb4\x30\xf9\x78\xbb\xcd\xcf\xe2\x9d\x0e\x4d\xae\xb6\x09\x5a\xdb\x05\xdc\xa3\xf1\x24\x5b\x2c\x1e\x7f\xa1\xb7\x15\x6e\x4f\x94\x10\xae\x45\x06\x52\xe2\xef\x78\xfe\xf3\xda\x43\xdd\x80\x57\xde\x52\xc2\x33\xf3\x48\x8a\xe3\xd7\xc7\x87\xdf\x1e\x8f\xa7\xf9\x62\xa3\x53\x19\x90\xd7\x79\xbf\xdd\x62\xb3\x58\x64\x9f\x41\x30\x1d\xc8\x71\x2b\x36\x5d\xfb\xa1\x97\x33\x29\xd7\x0b\xa4\x64\xbd\x3a\x86\x33\x78\x74\x0a\x77\xc0\xff\xff\x8a\x2c\x7b\x06\x6d\x2b\xca\xd6\x22\x5e\xc1\xe6\xc3\x23\x18\x17\xcc\xe5\x8b\x58\xb8\xde\x30\x0a\x83\x07\xb8\x58\x6c\x24\x95\xe8\xab\x35\xda\xef\x3e\xc8\xbd\x1d\x3f\x91\x78\x72\x5a\xd7\x95\x52\xf0\x14\xb7\xd4\xc9\xfd\x7f\x25\x57\x93\xe4\xb2\x66\xdd\x16\x02\xcd\x6a\xb5\xfd\x0a\xc4\xd3\x02\x1d\x95\x85\x14\x57\x83\x3f\x9f\x8c\x4e\xff\x1b\x09\xa9\xdd\xcb\xa8\x6d\xf9\xf4\x3f\x44\xed\xfa\x8c\x02\xae\x8d\xe3\xff\x57\xce\x35\xca\xb9\xad\x79\xb8\x95\xc0\x7b\xaa\x25\x6b\x92\x92\xe7\xb8\x61\x93\xdb\x28\x0b\x3c\xda\xd7\xce\x07\x7f\x4d\x7b\x77\xaf\x30\xda\xea\x5f\xe2\x7d\xdc\x09\xa2\x05\xba\xdf\x7d\x8c\x29\x01\xb4\xfb\xce\x79\x94\xf8\x34\x71\x3e\x70\x1d\x96\x3a\xfe\x75\x27\xc8\xca\x7c\x23\xe2\x3d\xf4\x70\x02\xd3\x63\x3f\x82\x8b\xf3\xc3\x1e\xd9\xab\x7c\xb4\x24\x52\xa0\xc2\x32\x8e\x56\x00\xf2\x1e\x5d\xe4\x80\xed\xd6\xbf\xb9\x15\xe6\x60\x8e\xf2\x54\x47\x7e\x8a\x01\x00\xe8\x06\x66\x07\xa5\x9a\x70\xa0\x78\xaf\x66\x08\xbe\x43\x31\x56\x7e\x08\x27\x1e\xbe\x81\x4b\x3f\x1c\x35\x69\x04\x43\xe2\xd1\x51\x18\xc8\x5a\x0d\x0b\x49\x83\xa7\xe0\x4e\x8f\xaf\xf1\xd7\x4b\x34\x79\xc9\xe0\x03\x0a\xaa\x91\xe3\x43\xaf\xf5\x04\xd7\x98\x7c\x59\x5a\x4c\xd3\xd8\xcf\x0d\x0b\x51\xec\x61\xf8\x4e\x1c\xc1\x1e\x71\xcd\xee\x7e\x9c\x1e\xb4\xd2\xac\xb2\x20\xf5\x71\xf1\xb8\xeb\x75\x6e\xf0\x5c\xb9\xa1\xbf\x04\xba\xcc\x71\x67\xb8\xea\xc2\xbb\xe8\x01\x76\xe1\x1a\x56\x95\x0f\x3b\x37\x29\x99\x50\x88\x96\x3c\x68\x83\x0c\x42\xe4\xc4\x46\x13\xb9\x84\x2e\xcc\x21\x6b\xea\xb0\xe0\x03\xc9\x63\xd1\xbf\x81\x0a\x7b\x9c\xaa\xf5\xc7\x81\x40\x0e\xc6\xad\xe0\x60\xe3\xd8\x7d\xe0\xd1\x6a\x32\x1e\x4f\xaf\x04\x37\x0d\xc7\x13\x5c\x73\x8c\x8b\x70\xe2\x2c\x10\x6d\x36\xa1\x62\xcd\xb0\x70\x6a\x57\x75\x94\x44\xc9\xc5\x07\xae\x33\xe0\xd4\x1a\x57\x2c\xad\xb3\x14\x0d\x3e\x6e\xa6\xfc\x05\x65\xd9\x46\x5b\x3c\x61\xb2\xd1\x70\xe4\x91\xc9\xe8\x0e\x4d\x42\x01\x05\x0c\xfc\x72\x83\xd4\x9a\xa7\x7d\x5b\xc6\x32\x04\x3a\xb0\x35\xde\xd2\xa8\xb6\xe2\x2f\xc3\xa5\xc7\xbf\x71\x61\x53\x9d\x49\xb5\x28\x61\x19\x8c\x0e\x32\xdc\xd1\xb8\xbf\x51\x47\xa3\x37\x93\x9f\x32\x17\x98\x7c\x1d\xbb\x8b\x77\xc8\x15\xfc\x51\x0f\xf5\xba\xf5\x81\x3c\xa9\x5f\xe1\x83\xb1\x00\x96\xc5\xec\x06\x49\xe5\x28\x00\xb1\x94\xa3\x6f\xe9\xd0\xff\x11\xb6\x14\x0f\x4f\x1a\xc9\x59\x84\xfe\x20\xa5\x5e\x21\x33\x41\x83\x8c\xa3\x34\x5a\x44\x01\xab\x8f\xe9\x62\x8d\x07\x5a\xf1\x33\x0c\x33\xf5\x43\x5a\x29\xfc\xc4\x57\x5f\xee\x7f\xfd\xbb\xdf\xed\x7f\xb5\xff\xd5\xff\x2a\x3f\x89\x73\x2f\x95\xd0\xdf\xfe\xf6\xcb\x7f\x95\xfa\xa7\x92\xb0\x7f\xdd\xd5\xd2\x33\x2f\x3b\xc2\xb3\xab\xa5\x37\x91\xe7\x10\xcc\xf4\x35\xce\x24\xbd\x80\x62\x4e\x4d\x64\xc2\x16\xfd\x04\xc5\x14\x90\x8f\x13\x87\x2b\xc3\x41\x94\x81\x7c\x59\x84\x4b\xc4\xcb\xb3\xf9\xf8\x09\xc4\x7c\x16\x48\xbf\x11\x8a\x3c\x9a\xc9\xc2\x41\x24\x47\xb5\xef\x54\x8f\xc4\x62\xc0\xf5\x53\xf1\x49\xa6\xb4\x79\x32\xd5\x44\x9a\x36\xe5\x5b\x0c\xa9\x02\x25\x3c\xba\x27\x63\x2f\x7a\xa3\x5c\x15\x76\xa4\x74\x05\xfe\xd2\x14\x41\x04\x5f\x8d\x38\x24\x8a\xbd\x49\x12\x04\xaa\x86\xc8\x47\xb9\x24\x00\x43\x06\x47\x9a\x0c\x28\xaa\x42\x36\x51\xf7\xc3\xd0\x77\x4e\x2f\x4e\x72\xfd\x79\x86\xde\x85\x77\xce\xd1\xf1\xec\x3b\xfc\xb4\x72\x4e\xc6\x27\x67\xd3\xef\xc9\xe7\x70\x1b\x25\x29\x39\x8e\xbe\x3d\x9b\xcd\xf1\x9b\xb5\xa3\x3c\x25\x89\x03\xaf\x1f\xd2\x2b\xa9\x33\x3f\x3e\x19\x9f\x5d\xd0\x13\x99\xf3\xed\x78\x34\x01\x75\x1c\xb4\x9b\xc3\xef\xae\xe6\xdf\x9f\xb3\xfb\x82\x02\xe0\x86\x24\x7e\xa6\xf0\xe8\xb8\xdb\x01\xf1\x39\x08\x35\x9e\x61\xae\x87\x12\x16\xe6\xc0\x38\x65\xee\x8f\x30\x42\x58\xdb\xe8\xb6\xc0\x49\xc2\xf5\x6f\x00\xe6\x45\x82\xa3\x0a\xc5\x7b\x74\x89\xa0\x23\x0e\xf6\xc0\x3a\x32\x81\x0e\x07\xf4\x20\xb9\xcb\x4a\xf0\x41\x1b\x59\x3e\x7e\x8a\x49\xdd\x08\x4c\xd8\xd0\x35\x62\x82\x4c\xae\x06\xc3\x7b\xa8\xa2\x05\x78\x8d\x7e\x50\xa1\xa2\x26\x28\x28\x0e\x40\x7e\xfc\xf8\xf8\x9f\x45\xb4\xa7\x15\xd4\x08\x43\x29\x2d\xa0\x22\xc4\xbf\xa7\xad\x40\x41\x44\xa4\x0f\x6d\xa0\xe8\x36\x6c\x7e\x1f\xa7\x43\x5d\x76\x41\x9d\xdd\x03\x55\x48\xa0\xbc\x2b\x45\x26\xec\x39\x62\xff\x66\xdf\xb9\x4d\xd3\xf5\xc1\xab\x57\x0f\xc0\xbc\x2b\x9c\x37\x74\x82\xb6\xcc\x9d\x8c\xe8\xac\x29\x99\xf2\x56\x72\x1c\x7a\x28\x9f\x3f\x18\x1e\xd8\x73\x52\x8a\x57\xc3\xf9\x96\x88\x29\xaa\xfb\xaa\x34\xf9\x44\x42\xfb\xe0\xee\x5c\x3f\x20\x81\x04\x07\x0c\x52\x6d\x5e\xca\x05\xcd\x9e\x9f\xac\xa3\xd0\x27\x9f\x95\x94\xce\x56\x6b\x4e\xe2\x84\xb1\xc0\xeb\x1e\xe8\x06\xa0\xfa\x33\x3f\x57\xee\x3b\x38\xea\x33\x90\x5f\x7e\xca\xb7\x00\xe6\x39\x68\x9e\x37\x92\x30\xa3\x76\x16\x12\x76\x84\x88\xc4\xed\x3b\x6f\x81\x0e\xf6\x34\xff\x94\x0d\xfc\xc0\x49\x06\xee\x0d\xea\xf9\x03\x56\xd4\x35\x32\x51\x6d\x05\x04\x43\xc0\xa0\xd8\x6e\xa0\x1c\xc9\x5e\xa2\x13\xd1\x44\x04\xdc\x55\x62\x94\xc3\xc8\x13\x03\x8c\x18\x2e\x59\x77\xf9\x85\x45\x7a\x3d\x71\x64\xa0\xe8\x83\xe6\x2f\x12\x13\xec\x58\xa4\x3e\xee\x1d\x20\x37\x70\x95\xe7\x91\x4e\x63\x6d\x30\x89\x29\x5a\xf1\xc5\x39\xf1\x10\x8e\x2b\xa5\x26\xe5\x83\x51\x3a\x92\x9c\x10\xa0\xcd\x73\x53\xd7\xc4\xe8\x33\x3a\xb4\x75\x78\xfa\xa0\xe5\x42\x48\x64\xe8\x2d\x5f\xcb\x79\x5e\x12\x23\x5f\x07\xc5\x1e\x8b\xc5\x0d\x0e\x2c\xa6\xf0\x7d\xba\x53\xec\x3b\x33\xc1\x21\x96\xb7\x22\x58\x9b\x96\xe5\xa0\xb2\x97\xf2\x0b\x89\x08\x19\x24\x47\xd6\xbf\x85\xbb\x99\x06\xab\x91\x9a\x2f\x72\x19\x44\x82\xd5\x78\x1f\xf8\xc2\x91\x82\x97\xe5\x90\x69\x70\xbf\xf9\xcd\x08\xdd\xd5\xf8\xd6\x81\x23\x99\x46\x2a\x2a\x68\xc5\x2e\xce\x77\xee\xd0\xbe\x7e\x00\x91\x4b\x8f\x92\x91\x0e\xee\xe8\x31\x5e\xe3\x3d\x0a\xdb\x8b\xe2\x04\xa5\x01\x08\xdb\x20\x20\xed\x17\x63\x59\xd6\x0a\x5c\xea\x3c\x50\x78\xd2\x3d\xac\x6d\x3f\x79\xb7\xff\x9b\xdf\xa0\x7a\x74\x14\xe1\xd7\xce\x3d\x9e\x08\xa0\xd6\xfb\xf2\x6d\xb2\xc8\xf1\x8e\xfa\xf9\xe7\x7d\x26\xe9\xe3\xc7\x3f\x38\x2f\x1f\xf0\x36\x60\x0c\x9d\xd2\x06\xe2\x1c\xd0\x1c\xab\x5d\x43\x7a\x1a\x2e\x45\xa9\x81\x25\x34\x36\x1f\x6d\x24\xec\xe6\xe6\x4b\x22\xc5\x00\x65\x29\xdd\x20\xe5\x40\x55\xac\x3a\xcc\x3e\xaa\xe2\xb8\x84\x48\xad\x94\xa4\xb2\x1d\x07\x55\xc8\x81\x1e\x5e\xe5\x69\xb8\x41\xe3\x7d\xfc\x85\x34\xd3\x3c\xa3\x85\x14\x48\xb9\x9a\x13\xf7\x1a\xde\xc3\xeb\x34\xb3\xe4\x2d\xdc\x63\xc4\x87\x21\x99\x9b\x24\x12\x0e\xb2\x57\xf0\x34\x8e\x38\xc0\x92\x08\xb5\x6a\x63\xdc\xd6\x28\x4f\x8a\x40\x83\x2e\xf0\x38\x0a\x98\xd1\x1c\x17\xc7\x6a\xdd\x21\x68\x62\x9e\xf3\x1a\x77\x5a\x6c\x3a\x84\xce\x70\x78\xb4\xb3\xc9\x00\xe7\x69\x0b\x18\x8d\xd7\x22\xa5\x53\xdd\x1b\x30\xe4\x1b\x58\xc4\xa4\xd7\x95\x41\x37\x93\x78\x74\xf4\x6a\x0a\xba\xd0\x5b\xb4\x35\x5d\xbc\x39\x3e\x35\x50\x30\xfa\x23\x2a\x5e\x53\x78\x76\x7e\x3c\x1d\x4f\x9d\x8b\x53\x7a\x7e\x78\x7c\x6a\x1a\x7b\x15\xb0\x33\x1d\x9f\x9f\xcd\x8e\xe7\xa0\x76\xd9\xe3\x98\x8e\x5f\x8f\xa7\xe3\xd3\xf9\xf1\x78\xe2\x1c\x8d\x3b\x51\xbe\x45\x5d\xef\xc8\x04\x9e\x7e\x35\xbc\x3a\x39\x1e\xcd\x0c\xef\x19\xde\x38\x3f\xce\x73\x4a\x0c\x2f\x9e\xd6\xd2\x48\xba\x41\x39\x2f\x73\x2d\x21\x81\xd3\xda\x5d\xfb\xfb\x5a\x88\x96\x69\xef\xd5\x31\xbd\xc4\x1d\x25\xe3\xac\x2a\xd0\x44\x01\xad\x93\x9c\x03\x6b\x84\x07\x16\x83\x3b\xe0\x2c\x1f\x7f\x2c\xff\xfe\x68\xb2\x72\x37\x81\xaf\xbd\xba\x01\x3a\xe7\x25\xfe\x8e\x16\x3a\x12\xb7\xfc\xf3\x5b\xfe\xf3\xe3\x47\x7b\xee\x36\x41\x96\x60\x68\x97\x96\x1e\xd2\xe0\xdb\x91\xdc\x8f\x3d\x25\x74\xdd\xec\x39\x37\x2d\x73\xf8\x69\x72\x7c\x38\xc2\x20\xb3\x99\xe1\xe5\xc5\x02\x93\x0e\x28\x34\xb2\xc8\xec\x81\x85\x96\xfa\x8b\x2c\x80\xf5\x76\x1d\x47\xef\x84\x29\x15\x61\xa4\xec\xe5\xef\x55\x8e\x1c\xaa\x5a\x0b\x38\x97\xd8\xde\x29\xc1\xe0\xe7\x4e\xf4\x79\x6e\x1d\x5e\xdb\xaa\x54\xa8\x1f\xa3\xe5\x52\x60\xc2\x65\x17\x3d\x1c\x67\x58\xe4\xdc\x71\x36\x1e\xbc\x1d\xeb\xa9\x78\x49\x41\xe1\xe3\x2f\xb1\x49\x7d\x1b\x2d\xd0\xae\x84\xf6\x2c\x99\x5c\x0a\xaf\x2f\x32\x34\x48\x3b\x94\xde\x98\xd0\x35\x10\x26\x4a\x85\x55\x7e\x34\x26\x64\x12\x28\x69\x1a\x06\x32\xe8\x75\xd6\x97\x12\x38\x35\x33\x32\x02\x63\x30\xd8\x7b\xfc\x8b\x0f\x42\xed\x76\x57\x41\xd1\x41\xac\xcc\xcb\xac\x10\x8b\xb4\x96\xe0\xd8\x50\x9a\x49\x4a\xab\x84\x92\x0d\x29\x49\xfd\xb4\x83\x56\x03\xa9\x1e\xa8\x39\x94\xd0\xa3\xe9\xfa\xa4\x11\x9b\x8e\xcc\x11\x5e\xa9\xb5\x7c\x22\x98\x67\xa3\x5a\xdf\x86\x13\xdd\x13\xb1\x4a\xee\x43\xcb\xe8\x7a\xdd\x89\x51\xc8\x37\xbc\x01\x5e\xc5\x30\xf8\x3b\x2c\x87\xe3\x19\x11\xd2\xca\xa1\x77\x81\x29\xf0\x32\x08\x16\x44\x5b\x4d\xc1\x04\x9a\xa3\xf8\x06\xbf\x3b\x8b\x6f\xe4\x77\xaf\x38\x3c\x19\xbf\x9c\xe1\x07\x95\x4a\x49\x73\x78\x91\xf3\x77\x7f\xdf\xa4\xb0\x12\xfd\xf2\xfa\x50\xa1\xa1\x96\x48\x58\xa2\x86\x95\xfa\x41\x29\x29\xaa\x42\x5a\x30\x10\x8d\xd4\x55\x96\x41\x99\xcc\x66\x26\x05\x3e\x0c\xa9\x9c\xfc\xa9\x6e\x28\x72\x6d\x5c\x0b\x64\xa3\x52\xdf\x3c\xbe\x29\x86\x6c\xc3\x3e\x7c\xad\x54\xa7\x57\x2e\x42\xda\x77\x9c\xa9\x20\x31\x82\x00\x2a\x60\x95\xf6\xd6\x01\x1e\x27\xc3\x13\x18\x76\x09\xe3\xe1\x5b\x72\x9a\xab\x8f\x32\xf1\x92\x35\x72\x13\xeb\x27\x03\xb7\x69\x58\xea\xda\xac\xd6\xa9\x60\x79\x99\x90\xa6\xa7\x6b\xc0\xe4\x39\xd2\x94\xc2\xc3\xd7\xaf\x60\xdd\x33\xcc\x90\x2d\xbe\x30\x4a\xf8\x15\x6d\x82\xc6\x1c\x5a\x6b\x7c\xee\xd2\x27\x99\x24\x75\xcf\x98\x32\x9c\x9d\xaa\x52\x8e\xdf\x69\x6a\xb9\xe9\x02\xd4\x3c\xa1\x38\x65\xa5\x89\xa2\x84\x05\x9e\x80\x41\xae\x84\xf3\x2a\x1a\xc0\x24\x7e\x0f\x7a\xf8\x82\x9c\x10\x69\x8c\x77\x23\x49\x0c\xce\x94\xe9\x2d\x9a\x14\x98\xd7\x50\xbb\xf9\xf8\x89\x7a\x5c\x9f\x55\x3f\xbc\x83\x83\xad\x65\x85\x00\x01\xdf\x46\xf7\xe2\x0e\xdd\x90\x78\xa5\x92\xfe\x90\xa5\x1f\xc3\xcc\x2c\x33\xbe\xae\x01\x30\x4c\xf0\x26\x9c\x8e\xbf\x5a\xe3\x0d\x00\xce\xae\x12\xad\xf8\x13\x5d\x1b\xf1\x8f\x3a\xc5\x4c\x5b\xcf\x55\x54\x5d\x1d\xc5\xd2\xa8\xce\x77\x03\x63\xdf\x6a\x61\x05\x70\xfa\xba\x0f\xec\xe7\x26\x77\x68\xd3\xfd\xa8\x06\x62\xcf\x59\x93\x7d\x7e\x50\x3c\xbe\x28\x1e\xe7\x95\x84\xa2\x45\x04\x22\x6e\x59\x9b\xfb\xce\x1c\x45\xd2\x32\xf2\x13\x19\xeb\xe0\x09\xa4\x09\xde\xbd\xc6\x84\x04\x74\x60\x80\x64\x47\x97\x67\x30\x90\xcc\x65\x51\xa6\x91\xea\xaa\x23\xca\x48\x2d\x33\xbf\xc5\x5d\x3a\x0a\xb4\xb4\x66\xf2\x3c\x49\xad\xc1\x25\xab\x3a\x1b\x06\x5c\xd2\x54\xfc\x3c\xb6\x1c\xde\x01\xe1\x68\xb2\xdc\xcc\x39\xb6\x21\x2f\x1d\x50\x84\x23\xf0\xc5\x59\x9a\x31\x73\x98\x89\x16\xe4\xcd\x2f\xea\x92\x37\xd9\x1d\xdd\xb4\x1d\xcc\x09\xb4\x1b\xd2\xcd\x19\xa2\x16\x19\xb4\x56\x24\x83\x0e\xfc\x04\xcc\xd6\xa1\x76\xb0\x7b\xa7\xc4\xef\x84\xe3\x0d\xc4\xf7\xe1\x79\x74\xef\xcc\x66\xdf\xca\x79\x93\x54\x89\xd6\x4c\xef\x51\x86\x96\xc9\x04\xf7\xaf\x8a\x8a\x41\x08\x9c\xde\x36\x68\x4d\xe3\x1e\x05\x49\x04\xfb\x34\x10\x98\xaf\x10\xe6\x05\x12\x48\xfd\x30\x4d\xe1\x0c\xb3\x9f\xfd\x15\xa0\x73\x33\x18\x25\xbb\x1c\x79\x76\x64\xe1\x03\xe3\xa4\xb0\xda\xb4\xca\x40\x22\x5e\x0b\x99\x26\x2e\x30\x26\x05\x86\xa9\xfe\x96\xb5\x40\x5a\xc6\xfb\xb6\x10\x3f\x5a\x72\x78\x89\xbb\xee\x1d\xfb\x4a\xb5\xac\x76\xe6\x83\x81\x30\x50\xf0\x4c\xcc\xed\x56\x1b\xe1\x65\xd2\x60\x7c\xf6\x05\x49\xcf\xf6\x12\x94\x5c\x93\x21\x7a\x22\xd4\xa5\xa7\xac\xd6\xe1\x51\x21\x1d\xaa\x66\x5c\x65\xdd\xaf\xe4\x8e\x6a\x39\x99\x4c\xca\xa3\xee\x9f\x32\x0a\xdd\x9a\xfe\x8b\x23\xbd\x8f\xe2\x77\x14\xf7\xf3\xce\x5f\xaf\x0b\xc5\x99\x22\xa9\x10\x6f\x6f\x52\xd4\x41\xa9\x3f\x00\x2c\x4a\x1f\xe0\x36\x03\x50\xd0\x07\x82\x91\x69\xce\xef\xe9\x9c\x2a\xaa\xb7\x68\x1a\x33\x82\xf0\x6f\xc2\x88\x4a\x96\xf4\x18\x8c\x14\x08\x9c\x81\x04\x1a\x07\xaa\xc9\xbc\xb5\xf9\xa1\x0d\x18\xab\xb9\xc0\x28\xfb\x07\x95\xf8\x3a\x58\x13\x89\x70\x94\x52\xd6\x3f\xae\x06\x82\xe4\xbb\x30\x2c\xd0\x4b\x16\x09\x87\x80\x04\xd1\x0d\x05\x47\x74\x5c\x86\xc8\xd6\xaf\xbd\x4b\x41\x1f\x7c\xc0\xb3\x29\x85\x6e\x47\xb9\x6f\xfe\x47\x0c\x5e\x70\x4d\xae\x21\x7d\x2f\xdc\x0a\x37\xc0\x90\x95\x5b\xb1\x78\xc7\x53\xc4\x96\xb3\x01\x7a\xdd\xb9\x96\x42\x18\x85\x62\x60\x32\xea\xcc\x1f\xf8\x8e\x5a\x10\xc7\xf6\xd3\xc7\x4f\x37\xea\x6a\xad\xb3\xb6\x64\x4f\x53\x38\x32\x85\xc3\x82\xde\xbc\xba\x8f\x0f\x63\x7f\x6f\x20\xea\x18\x7f\x53\xba\x12\x95\x02\x1a\x58\x5c\x1b\xd7\xeb\xc4\x64\xa7\x1b\xe9\x91\x58\x07\x86\xf7\xb9\xc0\x89\xcb\xde\x7f\x79\xcd\x35\x1f\x42\x23\x2e\x4b\x42\x32\x8d\xdf\x90\x17\x5c\x9b\xe3\x45\xa1\xe2\x33\x81\x5f\xf7\x04\x45\xb7\xe1\x5b\xb4\xb2\x5a\x8f\x9a\x02\xb9\xc8\xe3\xe2\xe4\x26\x94\xd0\xd4\x81\xc3\x0b\xab\xfd\xf4\x29\x93\x83\x85\x51\x98\x04\x34\x47\x58\x0c\x9f\x8a\xb2\x54\x31\xea\xf9\xaa\xed\x68\xf9\x34\xda\x18\x6b\x89\xdf\xfd\x70\xc3\xf1\xf0\x16\xc3\xbf\x4d\x07\x1c\x45\xe0\xca\x02\x34\x20\x3a\xda\x40\xb1\xe0\x0d\xe8\xfa\x3e\x85\x7f\xd9\x62\x81\x43\x71\x6a\x35\x68\x0a\xb3\x05\x97\x80\x39\x8b\x6f\xe0\xdb\x16\x8b\x04\x11\x90\x6b\xed\x3c\xf0\x02\x0f\x59\x25\xf4\x21\xd7\x10\x1a\x2c\x13\x1a\x76\xb3\x9d\xc1\x62\x74\x0c\xa7\x75\x70\x9a\x55\x86\xbf\x26\xeb\x47\x6e\x97\x29\x91\xbb\x53\x46\x94\x68\xeb\xe6\x43\xc5\x46\x53\xa6\xb5\x62\xa5\xa9\x11\xfd\x94\x0c\xfc\xb5\xf1\x69\x4b\x5e\x54\x2c\xac\x00\x41\x7d\x73\x45\xdf\x30\x7f\xf2\x79\x48\xe4\x0c\x14\xbc\x61\xda\x3e\x10\x6d\x39\x7b\x32\x1b\xf3\x5e\x99\x37\x8d\x56\xda\x26\x72\x88\x69\xa2\x46\x91\x81\x55\x15\xf2\x8c\x66\x5e\x1b\x56\x69\x67\x04\xbc\xfb\x27\xfc\x20\x75\x1b\x9d\x45\x1b\x1a\x3b\xcb\xdc\xa8\x9c\x1d\x15\x74\x15\x16\x6c\x69\xc0\x84\xab\xd8\x6a\x4d\xd7\x0c\x18\x86\x17\xdd\x87\x41\xe4\x7a\xec\xee\x7f\xe0\x78\x53\x8a\xfd\x20\x5f\x6e\x28\x52\x0c\x1f\xc3\xb8\x1e\xf3\x58\xe6\xb0\x00\xd9\xba\x89\xda\xea\xe3\xa7\x80\xaa\x6b\xc0\x92\x25\xd7\x39\xb9\x59\x94\x7e\x25\x1d\xef\xf0\x20\x59\x65\xf4\xa8\xa1\x63\x89\x0f\xf0\x98\xce\x8e\x12\xe5\x2b\x1f\xab\x19\x0a\x4d\xa7\x3c\x96\x5a\xcb\x51\x51\x85\xad\x6d\x0a\x4a\x64\x33\x34\x79\x92\x5b\x80\x34\x12\x28\x23\x29\x28\xb8\x19\x6e\xc9\x64\x46\x3a\x87\x0f\x3c\x5f\x7f\xc3\xeb\xb8\xba\x34\xff\xad\xaa\x0e\xff\x4d\x05\x9a\x2c\x63\xa1\xe2\x9b\x73\x55\xec\x6f\x75\xaa\xd4\x5b\x5a\x9d\x48\x57\x96\x95\x74\x0e\x31\x69\x6a\x21\x03\x2f\x5c\x6f\x05\x8a\x4a\x02\x0c\x80\x9b\x32\x96\x60\x41\x23\x21\x5c\xf6\xc3\x77\x7c\xe5\xa7\x5a\xa0\x5c\xc8\xcb\xb8\x60\x4b\xc1\x15\xcd\x63\xd3\x0c\x02\x0d\x63\x2b\x22\x60\x64\x19\xca\x3c\x92\xa2\x63\x78\x8d\x45\x28\xcf\x41\xec\xe1\x05\x58\x0e\x93\xe2\x0d\x38\xbe\x42\x1b\x2c\xca\xd8\x44\x66\xef\xc0\x95\x22\x69\x8a\xb6\x52\xd5\xc2\x8c\xab\x2e\x43\x1b\x6d\x8a\x5a\xac\xe0\x83\x03\x74\xee\x61\xa9\x04\x92\xd9\x2e\x41\x6f\x2e\x7d\x56\x9c\x74\xc9\x8f\x4b\x0e\x04\x15\xb9\xf2\xc2\x4a\xad\xa2\x4e\x3a\x30\x26\xcd\x2c\x59\x72\xac\xb2\xb4\xa3\x71\xb5\x6a\x00\xf1\x42\x83\xf1\x99\xef\xd7\x78\x77\xc7\x82\xb0\x1c\xf1\x86\xb7\xac\x6b\x17\x6e\x38\x3e\x29\xc7\xb1\x18\xba\x1a\x3b\xf6\x55\x59\x60\xaa\x83\xf7\x37\xbd\xae\xdb\x65\xf6\xe5\x97\xbf\x5d\x28\xb7\x32\xfd\x25\xb0\xfc\x0a\x7f\x8f\x6c\x54\xdf\x45\xf2\x3b\x90\xdc\xea\xab\x44\x7e\x45\x12\x8f\xbf\xfc\x9b\x2c\x9d\x94\x53\x83\x86\xec\x2a\x39\xe6\x4b\x6a\x85\x27\x74\x39\x75\xe3\xd8\xbf\x93\x17\x53\x1a\xb8\x74\x13\x4c\x85\x2a\x26\x25\x03\x71\x8a\x2a\x53\x78\xe7\xd6\x26\x95\xa3\xbc\xeb\x15\xee\x1a\x38\x41\x25\x3d\xc9\x63\x5e\xe3\x45\xb1\x2a\x2c\x58\x22\x4a\x3c\xd1\x28\x13\x45\x05\x2c\x90\xd9\xcd\xd4\x9a\xd7\x41\x14\xcb\x33\x93\x36\x30\xda\xd8\x7d\x4f\x46\x41\x72\x06\x14\xc7\x0a\x45\x18\x45\x84\x05\xad\x16\x91\x67\x52\xde\x27\x6c\x6b\xa4\x45\x8e\x8c\x47\xd3\x1c\x83\x0e\x07\x2e\x6d\xff\x75\x1c\x2d\x1e\x3f\xc1\xed\x89\x0e\x36\x37\xc7\xc1\x86\x2b\xce\xcd\x41\x04\x86\xb2\x55\xcd\xa3\xf8\xe6\x78\x32\x39\x3e\x7d\x83\x45\x62\x46\x6f\xc6\x53\x03\x71\xd3\xf1\xec\xfc\xec\x74\x36\xc2\x12\x6a\x47\x63\x67\x32\x72\x5e\x8f\x0e\xe7\x17\x53\x0a\x3b\x30\x41\x56\x55\x79\x4c\x91\x0b\xf4\x1b\x82\xd3\x0b\xe5\x98\x80\xf9\x98\x19\x52\x55\xc3\x3a\xef\x9d\x13\x29\x42\x1a\xb5\x26\x8b\x9b\xa6\x11\x2d\xda\x56\x55\x94\x67\x35\x54\x40\x56\x93\xc5\x6a\x5d\x68\x86\x55\x11\x05\x7a\x76\xd5\x86\xe4\x6a\x01\xa2\x86\xc0\x82\x7c\xea\x29\x15\x8d\x0d\xb9\x45\xa4\x41\xc9\x2c\x61\xb2\x15\xee\x62\xcc\x2a\x30\xe1\x33\x8d\xd9\x2d\x07\x2d\xf4\x1b\x76\xa5\x98\x34\xad\x31\xb2\x12\xf6\x8a\x33\x6b\x03\xd7\x16\x8d\x20\xd9\xd1\x5c\x56\xda\x3a\x24\x81\xb0\x2f\xf0\x75\x74\x75\xf7\x26\x1c\xa7\xee\x5a\xa4\xf7\x42\xd0\xe5\xa0\xac\x58\xd0\x11\x52\x36\x26\x4b\xa1\x47\x16\x61\xd3\xb8\x70\x1a\x5d\x3f\xa1\x18\x12\x54\x37\xea\x70\x41\xfe\x36\x99\x98\x5d\x9f\xb5\x9f\x76\x72\x57\xee\x03\x0c\x18\xa3\x67\xa5\xe9\x93\x7d\x20\xf5\xa0\x0c\x4c\x94\x0b\x38\x14\xf9\xfa\xa1\x3e\x3f\x26\x75\x6a\xdf\xa9\x84\xdd\xa2\x34\x16\xc2\xfb\x83\x61\xbc\x9f\x9d\x2e\xe7\xe5\xc3\xab\xd0\x10\xba\xa6\x88\xab\x53\x61\x8d\xb7\x7f\x2c\x8b\xa5\x2d\xa0\x9d\x62\xbb\x7b\xb8\x27\x96\x6e\x16\x28\x56\x2b\xf9\x6b\x17\x15\x35\x91\xab\xb4\xcf\x5d\x1b\x83\xe3\x38\xfd\x5d\x86\x44\x3f\x7e\x02\x02\xd2\x06\x09\xdc\x33\x7e\xaa\xdf\xb0\x73\xa9\xfb\x74\x23\x6d\x94\xaf\x1b\x0f\x8a\xd7\x9a\x71\x89\xed\x24\x84\xca\x72\xd9\x69\xcc\xe8\xa4\xeb\xb9\xc2\xaa\xec\x8c\x54\x66\x76\xee\x92\x8d\x36\xc6\x99\x56\x1e\x3e\x33\xef\x2c\x2c\x3a\x8a\x71\xba\xfc\xd3\xa9\xb1\x18\x68\x39\xd6\xae\xfa\x72\x33\xd6\xcc\x0f\xbc\x35\xde\xc6\xe0\xf1\xfc\x0f\xc5\xeb\x52\x8a\x8a\xf9\xa6\x40\xef\xab\xd8\xcc\x38\x5b\x28\x46\x55\xe1\x95\x52\x59\x4c\x27\x68\x1b\x41\x96\x7e\x62\x7b\x8a\x6c\xfc\xc6\xdf\x3c\xa4\x68\x40\x84\xd9\x44\x91\xa7\xdc\xfe\x6e\xa8\x6a\x46\xa8\x32\x07\x19\x16\x57\x00\x65\x74\x05\x77\xee\x2c\x66\xb3\x59\xe0\xbf\x13\xce\xc9\x9e\x73\xf2\xcd\x9e\xf3\x86\x4a\x52\xbc\xf9\xc6\xac\x92\x48\x24\xe4\x36\x8c\xe0\x12\x88\x05\x5c\x31\xaf\x9a\xb3\x6d\x8b\xaa\x0e\x79\x16\xb3\xd4\xc0\x10\x33\x47\xc7\xae\x04\x25\xb6\x15\xf9\x7a\x88\x3b\x02\xdc\xe8\x66\x7c\x13\x19\x46\x98\x57\xee\xf6\xbc\x21\x07\x87\x0d\x29\x3d\x0f\x73\x2d\xf8\x17\x58\x54\x78\x49\x1e\xff\x65\x74\x72\x3e\x19\x73\xbe\x33\x56\x75\xaf\xbc\x70\x0e\x77\x71\xb8\x03\x4f\xf1\xb3\xcc\x14\x5c\x3d\xac\xf9\x4b\x95\xa6\xf8\x0a\x3f\xbc\xea\x75\xdc\xe6\xf4\x61\x5c\x89\xec\x3f\x90\x24\xb7\x0e\x97\xca\xc6\x9f\x0c\xe0\x4c\x2f\x62\x11\x28\x2e\xb4\xdd\xc5\x91\xb5\xef\xfc\x00\x83\x37\xe5\xcc\x77\xbd\xbd\xce\x2b\x9c\x75\x51\x08\x8f\xca\xd2\x54\x1d\x30\xb1\xba\xfa\xc5\x6c\x3c\xa5\xbf\xce\x47\xb3\xd9\x9f\xcf\xa6\x47\x38\x39\x5d\x18\xf0\x45\x44\x71\x31\x3f\x9e\x1c\xcf\x46\xf3\xf1\xc5\xd4\x39\x39\x9b\x5f\x1d\x61\x26\xf4\x6c\x46\x65\x8b\xda\x71\x53\x21\x2d\x4e\xa3\x56\x12\x95\xab\xc6\xd6\x4b\x22\xfd\x30\x5c\xd6\xd3\xa2\x8b\x7a\xb8\xe7\xa3\x29\x7c\x9e\x8f\xa7\xb3\xab\xd1\xec\x0a\x73\xe9\xff\xaa\xad\xaf\xd9\x41\xbd\x7e\x57\x19\xad\x5e\x70\x78\xf5\x80\x36\x42\x2e\xe5\x1a\x3b\x1a\xca\xd5\x03\x70\x75\x0b\x48\x0b\x2e\xe8\x80\x15\x1c\xb6\x82\x82\x95\x8a\x28\xe7\x93\x0a\x13\x11\xb8\xa2\x2c\xd1\x71\xe8\xfc\x19\xe0\x45\xf7\x89\x73\x1e\xdd\x8b\x78\x76\x0b\x7b\x97\xf2\xee\xbc\x28\xc3\x86\x46\x54\x4a\xda\xdb\x73\xb8\x00\x37\x57\x91\xc2\x62\x00\x3f\x63\x7d\x6c\x06\x7b\x89\x80\x2f\x25\x68\xf8\xf7\xa3\xac\xf8\xa0\xc1\x96\x31\x90\xce\x04\x53\xc8\x10\x3a\x97\xd6\x30\x40\x1f\xb4\x01\x37\xa5\x1a\xd8\xac\x1d\xd9\x2b\x4b\x29\x72\xb2\x5b\xd3\x6c\x7c\x78\x31\x3d\x9e\x7f\x7f\xf5\x66\x7a\x76\x71\xde\xb1\x8e\xdb\x00\xd1\xfb\x58\xe1\x88\xe0\x75\x6d\x6e\x59\x17\xae\x85\x14\x2c\xce\xcf\x52\xc6\x86\xa8\x0e\x62\x10\x96\x95\xd0\xb1\xac\x90\x68\xd8\x47\x76\x94\x76\x14\xc3\xd3\x60\x4f\xc7\x0a\xb0\x05\xd1\xb2\x33\xd7\xd6\xf3\x6b\x00\x54\x61\x69\x07\x45\xea\xac\x37\x69\x2e\xed\xaf\x53\x4c\x10\x6f\x73\x12\x5e\x4a\xd4\x81\x50\xa3\x1a\x12\xb2\x7a\x84\x49\x68\xe9\xaf\xaf\x1e\x50\x26\x95\x84\x84\xf6\x7f\xff\xa4\xff\xd0\x07\x86\x24\x64\x19\x45\x00\x83\x7f\xd7\xd3\xfc\x5e\xc1\x0f\x1d\xbc\x2e\x8f\x11\xd6\xa8\x2c\x02\xde\xb1\x40\xb9\x02\x1a\x72\xc2\x4d\x1e\xc2\x05\x75\x47\xc0\xac\x0f\x59\xdb\xe2\x0a\x6b\x74\x1f\x9f\x5e\xcc\xb9\x60\xc6\x10\x90\xc3\x5a\x7b\x09\x7a\x98\x70\xfe\xdd\x59\xba\x41\x82\xff\x22\xed\xaf\xd2\xe8\x15\xca\xd8\x2f\xe8\xb9\x45\x14\x80\x82\x54\x7a\x8e\x7f\xa0\x32\x57\x00\x61\x72\x76\x38\x9a\x8c\xe1\xb7\xc3\xc9\x78\x34\xfd\x62\xb3\x43\x59\xd6\x48\x83\xa3\x61\xa8\x4a\x47\xe9\xf5\xdb\xd7\xce\x2b\x45\x19\xdb\xea\xf1\x41\x2a\x77\x48\xd6\xfa\xfc\x9d\xfd\x87\x55\x60\x2c\xa5\xd3\x86\xab\x28\xce\x0e\xa8\xb8\xda\xce\x2b\xe5\x5d\x58\xe1\xa3\x15\x44\x42\x62\xb2\x19\x54\xbe\xe4\x8b\x22\xf4\xb4\x4e\x1d\xca\x99\x45\x7b\x36\x70\x93\xb3\x4b\xfe\x7d\x38\xf4\xe0\x4e\x03\x9f\x2c\x07\x51\xc0\xae\x95\x93\x97\x75\xe4\x3a\xb0\xd8\x0c\xc0\x8b\x56\xd8\x74\x03\x45\x25\x2f\x45\x3b\xda\x6a\xaf\x75\xae\x60\x7e\x0f\x2f\x9d\xf0\xd2\x36\xeb\x88\x7d\xfe\x7f\xba\x38\x9b\x8f\xa8\x24\xcc\x1c\x3e\x4c\xae\x8a\xc2\x30\x7e\x21\x5c\x8b\x2f\x63\xae\x40\x33\x93\xd5\x61\x2a\x92\x9d\x77\x0d\xeb\xac\x6b\xd7\xcf\xc5\xf5\x90\x02\xb6\x2d\xa7\xab\x4a\x17\x22\x3f\x9e\x8e\xaf\x88\xbe\x31\x53\xa6\xbe\x53\x88\xeb\xa4\xe5\x24\xa9\x93\xa1\x83\x34\x1b\x8e\xb1\xb8\xe1\x83\xb0\x90\xa9\x8d\x8a\xa2\x9d\xa4\xd5\xc1\xae\x1e\x58\xcd\x37\x09\xdb\xda\xff\xb5\x48\xdf\x4e\xb8\x55\x5d\xb3\x0c\x97\xbe\xda\xdf\x21\xf4\x8a\xbc\xaf\x40\xb7\x11\xf7\xbf\xa6\x09\xd8\x8a\xf1\xe1\x93\x30\x3c\xb4\x67\xb4\xcd\x42\x6f\x57\x2d\x55\xc5\x58\xd4\xad\xae\xa6\x17\xc0\x55\x2a\x1e\x6b\x37\x85\x1d\xaa\x66\xb9\xae\xe7\xd5\x74\xfc\x66\x22\xb5\x38\x3b\xb9\x68\x57\xf6\xd6\xa0\x80\x72\x99\xab\xd1\x9b\x99\xa5\xa4\x52\xc8\x74\x24\x76\x1a\x29\x61\x1a\xcf\x8f\xff\x74\x31\x9e\xa3\xc8\xea\x33\x36\x8a\x39\x18\xa6\xd1\x3b\x11\x3a\x93\xd1\x37\xe3\x89\x73\x3e\x3d\x7b\x7b\x7c\x34\x9e\x82\x08\xff\x6e\x6c\x79\xf0\x34\x01\x3b\x06\x60\xa0\xa5\xbc\x3e\xbb\x98\x9e\x1e\xc3\xbd\x1a\xae\xd9\x7f\x1c\xcf\x7b\xb2\x7e\xc8\x59\xf0\x39\xd3\xbf\x99\x02\x51\xd3\xfa\xc5\x9f\xca\x34\xc1\x3e\x95\xb6\x8d\x45\x04\x97\xb8\x7e\x7c\x57\x98\x0e\x81\xde\x39\xae\x96\xbc\x0b\x48\x9b\xb1\xa0\x19\x6f\x9f\x01\xbe\x13\x0f\xf5\x25\xa5\xbe\xf8\x6e\xfc\x7d\x9b\x9d\xc0\x79\xc6\x5e\x23\x7d\xc9\xfe\xd5\x16\xcd\x7e\xca\xa2\xfe\x1b\x30\x69\xab\x8a\xd9\x36\xe5\xd6\x6b\x06\xcb\x16\x62\x57\x0f\xde\x35\xfc\x07\x3f\xca\xf9\x2b\xc3\x2f\x81\xc7\x79\xeb\x03\xee\x3f\x5e\x61\x92\x11\xed\x94\x57\xe9\x6a\xfd\x4a\x79\x33\xaf\x78\x06\xc9\xc0\xb4\x8d\x0a\x9a\xdc\xba\xb1\xf0\x94\x12\xdc\xaa\x37\xdb\xc1\xa3\x93\x91\xf5\x03\xd9\xa1\x10\x45\xed\x4f\xfc\xd5\x90\x74\x4a\x5b\x19\x43\xa0\xc6\x0d\xb0\x08\xca\x90\x7f\xb1\x14\x1c\x24\x6a\xca\x7a\x6d\xa3\x76\xad\xd7\x65\x7c\x06\x4d\xbb\x99\xae\x26\xdd\x3a\xd7\xc2\x9f\x47\xd1\xa6\x30\xc7\xda\x89\x61\x37\x28\x7a\xb7\xf5\x00\xb0\x26\x61\xa8\xca\x03\x57\xd5\x0a\x5d\x93\x58\x3b\x87\xd3\xf1\x11\xd6\x68\x1a\x4d\x88\x25\x81\x33\xfb\x7e\x36\x39\x7b\x73\x75\x34\x85\xe5\x7c\x85\x36\xf8\x82\x69\x8a\x49\xf4\xb5\x14\x1e\xe7\x6e\x22\xdb\x87\x83\xa8\x44\xd1\x46\x25\x7b\x61\x63\x70\xad\xb3\x42\xda\x51\x9a\x63\xa2\xd7\x59\xd0\xa2\x36\x57\x91\x27\x1a\xa5\x85\xe5\x48\xa8\x33\x1f\x51\xb1\x57\x90\xb1\x57\x20\xdf\x63\xec\x97\x2f\x4a\x54\x37\x50\x49\x35\x5e\x48\xfe\x01\xa1\x4c\x83\x16\xc0\x53\x0b\x5e\xdd\x92\x66\x94\x78\x20\xad\xbe\x2a\x8e\xa7\xaf\xe8\xc8\x82\xef\xbe\x2e\xbe\xfb\x5a\x2f\xa7\x2f\x3b\xfb\xb9\x95\x73\x41\x3f\xb2\xc8\x98\xbc\x1d\x61\xd5\x53\xa2\x4d\xa0\x37\x43\x05\x55\xdf\xbb\x1e\x62\x5f\x61\x9e\x1c\x15\x0f\xb0\xa7\x35\x6d\xdc\x14\x5a\x6e\x2a\x2a\x66\x30\xa9\xfb\x0b\x3a\x01\xc6\xc0\xaf\xa2\xb1\x52\xe0\x24\x0f\x49\x10\xdd\x1c\xbc\x7a\xd5\x71\x97\x31\x42\x2c\x3b\x27\x60\xd7\xa8\xda\x5d\x25\x80\x5c\x3a\xdc\x0f\xb3\xf7\xaf\x4e\xdc\xc5\xc6\x2c\xc5\xb5\xa3\x98\x4a\x6b\x85\x42\xb7\x69\xf9\x14\x1c\x3e\xc0\x3f\xb8\x41\xa3\xb6\x88\x9a\xbc\x13\x9b\xcf\x2c\x39\x2d\x72\x4a\x94\xdf\x82\xa9\xb9\x44\x7a\x2a\x6d\x4d\x0f\xf8\x0b\x49\x95\xf2\x9b\x94\x08\x2b\x5c\x32\x5b\x70\x67\x5b\xaa\x36\x73\xb8\x2c\xb0\xe6\x10\x19\xff\xe0\x38\xba\x43\xe1\xf9\x17\x38\x7e\xe6\xdf\x9e\x51\x17\xca\x6f\xb1\xf6\x30\x5c\x76\x64\xef\xc7\x11\x9c\xe8\x78\xe0\xc0\xba\x59\x67\xa9\x83\xbb\x4d\xc9\xd5\x6f\x1e\x54\x00\x53\x51\xe1\x19\x61\x0f\x64\xdf\x5c\x11\x63\xdf\x4c\xd8\xfd\x6f\xc6\x73\xa5\x59\x4a\x1d\x15\x04\x30\x12\xb0\xef\x1c\x2f\xa9\xda\x27\xc1\xf3\x93\xa2\x5e\xfc\x9d\xef\x3a\x43\x0f\xfb\x37\x9c\xa3\x85\x5d\x35\x5f\x94\x30\xa9\x2a\x4e\x92\x82\xe2\xb5\xa7\xaa\xac\x50\x42\x04\x6c\xb4\x21\x26\xde\x12\x38\xf5\x4e\x22\x52\x19\x5a\xa2\x62\x39\x5e\xe1\x46\xdc\xa7\x9a\x2e\x18\xf6\x16\xdd\x89\x38\x46\xd5\xfa\x16\x00\xa2\x7c\x25\xb7\x3d\x30\x42\x82\x26\x68\x2a\x51\x19\x44\xf0\x6d\xe4\xc9\x47\xfe\xb2\x2f\x59\xf1\x1a\xd4\x61\xcc\x36\xf6\xa2\x05\x35\x08\x25\x34\x79\x9d\xde\x3b\xac\x5e\xa5\xdc\xde\xee\xda\x87\xa7\x92\xfd\x05\x16\x4f\x5c\x72\xed\x44\x4c\x6b\xda\xaf\x9b\x51\x16\x4b\x9e\xab\xcb\x17\xaf\xee\xbe\x7e\x85\x8d\x13\x2e\x5f\x00\x52\xe2\x27\xcc\x7f\xd8\x68\x3d\x41\xc2\x2f\x5f\xe8\xdc\x38\x28\x8d\xfd\xfd\xf0\xfe\xfe\x7e\x88\x5c\x1c\x02\x6c\x11\x62\x24\x36\x76\xa7\x6d\x01\xe8\x39\x83\x9f\xfe\x37\x2e\xd2\x03\x32\x79\xa8\x3d\xda\x4c\x9e\xe7\xfc\xdb\x2b\xdd\x82\xbf\xd1\x12\x95\x25\x1b\x34\xeb\xfb\x12\x84\x55\x97\xda\x25\xdf\x2a\xec\xe8\xfc\x92\x05\xa6\x46\xfb\x38\x7a\xaa\xad\x30\xb6\x5a\xc0\x09\x8a\x0d\x09\x25\x2d\xbd\x07\xf2\xd2\x7b\x63\x7b\x7c\xd2\xc4\xdd\x86\xc9\x12\xce\xfa\xd6\x0d\x85\x74\x7c\x27\x5b\xc3\x2b\xeb\xcb\xdb\xc1\x62\x9b\x9e\xbd\x29\x93\x10\x9a\xed\x99\x25\xa8\xb6\x76\xe4\x16\x7b\xa6\x11\x5e\xc9\xc2\x4b\xee\xbd\x12\xbc\xba\x4b\x6f\x53\xb0\xdb\x7b\x0a\xfb\x70\xda\x72\x65\xb6\x9b\x47\xed\x77\x46\x87\x2d\xb4\x07\x3d\xc6\xdb\x89\x3d\x29\x0c\xa2\xc1\x7a\xd9\x8f\x88\x16\xeb\x64\x6f\x6a\xba\x8c\x93\xbd\x69\x6b\x36\x4d\xf6\xa7\xcb\x68\x78\xec\x4d\x91\x85\x2d\xb1\xb4\xe1\x1b\xf7\x7b\xb3\x01\xa7\xdf\x90\xf0\xdd\xda\xe4\x1f\x4e\xca\x0b\x81\x09\x19\x23\x21\x4e\x37\x25\xee\xb5\x07\xff\x59\x04\xc6\xde\x03\xd5\x97\x1b\xac\x41\x7d\x26\xa7\xe1\xf5\x3e\xeb\xb7\x64\x3b\xb2\x46\x5a\x36\x13\xf5\xc1\x25\x0f\x12\xcd\x34\x35\x54\xba\xc4\x56\x67\x4a\xd9\x78\x62\x3f\x94\x46\xc3\x89\xc5\x90\xd8\x4b\x3e\x5c\xc2\xc5\x22\x8b\xe1\xdf\xc0\xbd\x71\x5e\x8f\x47\xf3\x8b\xa9\x55\x84\x63\xe3\xfb\x48\xc6\xeb\xb3\xd3\xb6\x4c\xb6\xea\xfb\x89\xd6\xcd\xde\x12\x65\xa2\x75\x9c\xef\x46\xb2\x69\x08\x67\xc3\xbb\xd6\x51\x9c\x6c\xe7\xd9\x98\xb7\x4d\xaf\xf7\x60\xad\x7c\xbd\x07\x67\xb5\x37\xec\x18\x2b\xc2\x3b\x7b\xd8\x77\x76\x81\xa6\x02\xeb\xdd\x27\xd6\x60\xf9\x69\x3b\x72\x37\x9d\x88\x4d\x67\x40\x7f\x6f\xb3\x60\x30\xbc\xe2\x24\xda\x45\x45\xa9\x91\x85\xfd\x19\xa5\x7a\x4a\xff\x4f\xb9\xd4\x28\xd6\xe7\x11\x27\x28\x72\xf1\x57\xbc\x13\xa7\x12\x10\x16\x9b\xa6\xb4\xbb\x3c\x1d\x28\xe2\xe2\xb0\x47\xbe\xb8\x89\x28\x3b\x5a\x84\x70\xeb\xc5\x40\xcd\xfc\xd2\x0d\xcb\xc1\x64\x09\xf8\x35\x90\x09\xf7\x44\xa2\xb0\x95\x8f\x37\x22\x1d\x72\xcd\xad\x21\xd7\xdc\xb2\x5c\x5e\xb5\xf7\xac\x96\x30\xf6\xdf\x70\x7e\x38\x3c\x3b\x39\x19\x9d\x1e\x75\xc9\xef\xd2\xc3\x5d\x2e\x09\x59\x0a\x54\x06\xbf\xcb\xc8\xb4\x21\xb2\xfb\xd5\xfc\xec\x95\x6c\x55\xf0\xef\xe4\x24\xfd\x77\xb4\xbf\x15\x91\xf4\xfc\x1b\x7d\xfe\x22\xd7\x06\x00\xc1\x79\x1c\xad\xd6\x32\x47\x8c\xfc\x42\xf1\x4a\xe5\x4b\x07\x58\x42\x71\x30\x5c\x0e\x74\xdb\x49\xb3\x21\xa1\x42\xd7\x7f\xbc\x3a\x92\x95\x41\x92\x57\x32\x4e\x1f\x54\xfd\x6b\x37\x36\x3c\xdf\x60\x26\x2c\xbf\x77\x15\xa0\xb9\xf0\xca\x5d\x79\xff\xfa\x3b\x03\x0c\x18\xed\xc9\xc3\x90\x52\x00\xe4\xab\x62\x71\x6b\xba\x5e\xb4\x73\x19\x97\xa5\x9e\x5f\xb0\xd9\xde\xe5\x1c\xfe\x1f\x86\x2e\xda\x6e\x94\x23\x21\xcb\xcf\x76\xd5\xab\x8b\xbd\x23\x7f\xd5\xbd\x54\x09\x1f\x4f\x7f\xb5\x88\xae\x2f\x90\x00\x02\x58\x99\xc7\x8c\xa4\xa2\x08\x30\x2e\xdd\x8d\x52\xc1\x37\xd6\x10\x76\x0d\x0a\xae\x62\x9b\xf2\xc3\x5a\xac\xd3\xb3\x76\x42\x7d\xe5\xae\xe5\xf5\x30\x97\x3f\xbb\x08\x2e\x2a\xc0\xae\x1e\x30\x3a\x72\x17\x17\xf2\x56\x98\xdb\x5d\xca\x7b\x82\xde\xfe\x62\xde\x93\xed\x1d\x73\xc8\xd5\x78\xf2\x0b\x88\xf2\x54\x27\xce\xdd\x57\xf9\x15\x06\x3e\xe6\x97\x51\xfc\x8c\x61\x3b\x77\x5f\x17\x3f\x7f\x4d\x5f\x59\xec\x19\x33\x36\x75\x75\xbb\xfb\x4a\xbf\xa9\xe2\x9f\x08\x1a\xff\xcd\x9f\xf8\x5a\x7e\xf5\x75\xf7\x9e\x89\x8a\x8b\xf0\x46\x1b\x67\x9b\x68\x51\x78\x97\xae\x06\xc9\xc6\x10\xc8\x47\xd0\x2f\x79\x3e\x7f\x95\x3b\x38\x6d\xf6\x6e\x16\xdf\xd4\xa7\xa8\x76\xdb\xee\x98\x6a\x03\x94\xda\x55\xb9\x0f\x2d\xaa\x33\x87\x53\xdc\xad\xd7\xb9\x99\xa4\xeb\xb4\xb7\x00\xa5\xad\xbc\x8e\x6d\xa3\xd9\x32\x37\xe2\x31\x37\xcc\xdc\xe8\x55\x6e\xf4\xd6\x9c\xb5\xd7\x94\xb1\xd7\xf0\xbc\x96\xb4\x67\xdc\xb2\x5d\x44\x90\x90\xc9\x05\xd0\xe9\xf8\xcf\x57\x96\x07\x8c\x7c\x55\x1d\x31\xa7\x67\x17\x6f\xc7\xa3\x8b\x2b\xbb\x23\x87\x5f\x6e\xb2\xea\x17\x74\x94\xbf\xb2\xa2\x46\x03\x88\x74\xd4\x8d\xfd\x3a\x95\xf5\x5f\xad\x68\x56\x66\x79\x24\xd1\x2c\x11\x4c\x2f\x21\xfe\xc9\x64\x8c\x6f\xda\xa1\x33\xda\x36\x11\x7f\xcf\xbd\x5c\x01\x59\xdb\xc3\x39\x75\x3d\x77\x77\x19\xae\xc1\xca\xa8\xd3\xcb\x5f\xf5\xa2\xb6\x2d\xd8\x91\xe7\xb4\xfe\x8b\x1d\xd5\x9a\xdd\x8b\x68\xb4\x48\x1a\x2b\xbd\x2a\x0d\x19\xcc\x3c\x3b\xb3\x06\xee\xde\xa1\xea\xce\xf7\x83\x7e\xcb\xa8\xdb\x3a\x17\xcb\xf2\xe3\xf0\xb4\xb6\xef\x37\xdc\xf5\x98\xa5\x25\x6c\x55\x49\xf5\xb8\xd5\xcd\x8d\x1e\x8e\xd3\x5e\xb0\xe3\xd4\x52\x53\x95\x4f\x53\x5a\x4e\x7e\x14\xe5\xc2\xeb\x18\x6e\x7f\x7f\xb1\xc3\x57\x86\x50\x24\xd3\x21\x80\x76\x0a\x64\xfa\xa2\x08\xef\xfc\x38\x0a\xd1\x97\x3c\xbc\x73\x63\x6a\x4d\xc8\x6e\x8c\x8d\x66\x24\xa1\x34\x29\xcd\x9d\x5a\xdc\xfb\x5b\x5a\x17\x77\x5a\x36\x19\x6c\xe1\x6f\x6d\x82\xfa\xa7\x8b\x7a\x84\x5b\x97\xcd\x73\x9b\x2c\xc1\xad\x12\x3f\x4d\xd2\xb0\x13\xa7\x41\xe2\x59\x61\xd3\xdc\x30\x9b\x1d\xf5\xb6\xce\x0e\xa3\x9f\x63\x23\x07\x87\xad\x67\xc3\xec\xd4\xd8\xcc\x9b\xa1\xbd\x55\x8f\xdb\xb4\x19\x62\x42\x63\xb4\x1f\x5d\x52\x1b\x9e\xd5\x90\x12\x1e\x53\xd7\x60\xd2\xa1\x6e\xa3\x75\xc6\xa7\x6f\xaf\xde\x8e\xa6\xe5\x3f\xde\x8e\x26\x17\xdd\x6b\x90\x21\x15\x0a\xd3\x09\xbd\x0b\x30\x1c\x78\x1f\x6f\x49\xea\xcf\x6e\x92\x1a\x2d\x71\xb2\x2e\xfd\xbf\x73\x51\x7a\x0b\x72\x9a\xec\x72\x15\x20\x9d\x94\xe0\xf5\x88\x0a\x3c\xe7\x1e\x17\x54\x6d\xa6\x67\x1c\xf4\x67\x41\x44\x0e\xa0\xea\x7a\x29\xc1\xe9\xa4\x83\x35\x79\x7c\x87\xb4\xf9\x16\xe4\xdd\xb0\xba\x85\xbc\x7d\xa2\x80\x05\x07\x6c\xd1\x45\x2b\x05\x1a\x6b\x55\x12\xba\xca\x57\xa6\x4e\x7f\x3a\xb6\xba\xef\x8d\x7e\xaa\xba\xe1\x2c\xe8\xd6\x21\x69\x1e\x1d\xfc\x48\x70\xec\x74\xa1\x02\x52\x7d\x19\xf1\xfb\x3d\x16\x93\x06\xa8\x69\x39\x8d\x2b\x00\xbb\x09\x93\xd9\xec\xcf\xb4\x12\x6c\xd1\xed\x60\x25\xa0\xb3\x78\x28\x0b\xbc\xf4\x4e\xde\xed\x78\xbb\x73\xca\x0b\x95\xbb\x0b\x91\xa6\x61\x5b\xc0\xd4\x97\xb5\x5c\x83\x36\x6b\xb9\xb2\x8e\xfb\x2c\xde\xe2\xd5\x0d\x55\x03\xe5\x13\xe5\x8c\x01\xe1\xd9\xfb\x55\xeb\xaf\x5a\xbb\x55\xf9\xd5\xdc\xaa\x65\x3f\x15\xda\x3b\xd6\x93\xb2\x21\x63\x34\xa7\x2b\x69\xae\xba\xc6\x3e\xa4\x26\x2a\x5c\x90\x46\x36\x8c\xc3\x3f\x26\xce\x0f\x58\x83\xe2\x4a\x56\x4c\x3f\xf8\x2b\x1e\x65\x07\x68\x4a\xa5\xff\xe0\x5f\x64\xbd\xc6\x8e\x41\x64\x61\x1d\x52\xb2\x12\x51\x54\xfc\x80\x86\x16\x58\xd5\xe2\xbd\xe0\x5a\x7b\xf4\x8b\x0c\x2f\x1d\xae\x13\x91\x79\xd1\x30\x4d\x1f\xe8\xeb\x65\x14\x63\x66\x47\xf9\x4b\xe5\x5e\xd7\xbe\xee\xe2\xad\xe6\x2f\xc6\xb1\xd2\xf0\xae\xf2\x6c\x23\x18\x7a\x69\xac\x42\x0e\x56\x96\x6e\xbf\x92\x05\x31\xd5\x78\x1f\xff\x91\x8a\x03\xfc\x48\x9f\x3e\xd7\x88\xbb\x66\x77\xd8\x52\xc3\xb8\xfb\x65\x76\xb4\x7b\xb6\xd7\x4c\xfd\x15\xab\x6b\x2c\x70\x1e\x74\x22\xd0\x2a\xed\xcc\x4f\xfc\x38\x59\x95\x8e\x27\x9d\xbb\x2f\xdd\xb8\xb4\x49\xf7\x01\xb1\x29\x58\xfb\x2b\x7b\x9f\x0b\x7b\x92\x46\xd6\x85\xb4\xe8\x59\xab\xc9\xe1\x46\x6d\x4d\xfe\xbe\x0e\x14\x4d\x2f\x5a\x25\xb2\x65\x61\xaf\x0a\x5a\xa6\xe8\x4a\xe3\xed\xa7\x11\xbe\x7d\xa9\xac\x8d\x26\x5d\xe1\xdc\x41\x65\xa7\x76\x50\xbd\x6a\xff\x48\x50\xbb\x29\xee\xd4\x0c\x6c\xe3\xf2\x4e\x39\xb8\x8e\x02\x4f\xb6\x54\x75\x94\x72\xb2\x23\x66\x07\x85\x9b\xda\x41\xf5\xb3\xd0\xe4\xed\x6c\x55\x54\x01\x87\x4d\xd8\xdc\x29\x6a\xaf\x92\x3c\xe5\x88\x8c\x2e\xa4\x4f\xe4\xc3\xd6\x01\xef\xce\x8b\xdd\x01\x75\x3b\x3f\x76\x6f\xe0\xdb\x7b\xb2\x7b\xb3\xbf\x6b\x36\x5b\xad\x2e\x9d\xc4\xb4\x59\x5a\x6c\x30\x6f\x65\xd2\xa8\x80\xd8\xdc\xa8\xc1\x80\x6a\xd7\x9a\x4e\xf3\x86\xf9\xfd\x71\x15\x80\x35\xfe\x2d\x6f\xe6\x35\x50\x5b\xdf\xcd\x01\xe2\x56\x17\xd8\xce\xf7\x3b\xc5\xdc\xda\x33\x95\xed\xfa\x41\x26\xbf\x72\xf8\x9e\xaa\xac\x45\x22\xa7\x56\x5a\xcb\xe1\x1a\x69\xef\xe0\xab\x2c\xc4\x0f\x5d\x1a\x4c\x0d\x6f\x53\x42\xd3\x5a\x96\x91\xd9\x90\x02\x9b\x81\xf7\x2f\x9e\xf5\xc3\x30\x24\xff\x9a\x92\xbf\xdb\xe4\xf7\x63\x68\xde\x30\x8f\x2b\xee\x9f\xff\x6f\x18\x84\x55\xa5\x2d\x1a\x47\xe1\x46\xde\xb6\x20\x40\xf7\x50\x6c\xa6\xe3\x29\x0a\x16\x35\x83\xde\x59\xc1\xa2\x1c\x7c\x4b\x65\x01\x5c\x2f\x18\x24\x64\x2c\x3d\xeb\xd8\x56\x2c\xaa\x60\x6b\x48\xf3\x59\xe7\xb3\x5a\xc3\xb8\x61\xd9\xa2\x32\xce\x2d\xcb\x16\xb5\x00\xdb\xb0\x6c\x51\x05\x62\x8f\xb2\x45\xfd\x48\xdd\xbc\x4a\x91\x1d\xfd\xed\xb9\x24\xb0\x83\x47\x7f\x19\xaa\xf9\x1e\x36\xd7\x1a\xb1\x90\x4c\xcf\x22\x90\x5a\x2d\x91\x4d\xd2\xe8\x0a\x06\x57\xf3\xde\x76\xc8\xa7\x1d\x0d\xc8\x66\x6e\xfe\x07\x14\x11\xe9\x37\x92\x5f\x47\x11\x91\xde\x34\x3f\x57\x11\x91\xde\x84\x59\x15\x11\x69\x85\xba\x8b\x8a\x17\x9b\xe1\xb2\x2b\x31\xd2\x09\xb0\x77\x89\x91\x2e\x88\x36\x25\x46\xfa\x1a\x94\xe6\x53\x94\x50\xe3\xe9\xf4\x6c\x8a\x3b\x79\x34\xc7\x56\x70\xb0\x7d\xa9\x1e\x05\xb6\x6f\x38\x07\x5e\x7c\xfc\x08\xf3\x06\x9f\xc7\x71\x6c\xec\x25\x03\x20\xf0\x28\xc8\x41\x4e\xce\xa6\x33\xd9\x29\x8e\xe1\xc2\x8e\x38\xba\x70\xa4\xba\xe1\xfc\x11\xcf\xbc\xd1\xa4\xc0\xe0\xe8\x28\x9a\xa9\x75\x43\x6a\x44\x41\xac\xc1\x2a\x61\x4e\x11\xbd\x1c\x2d\x1d\x14\x75\xf9\x3e\x23\x51\x67\xa0\xf4\x78\xb5\x8e\x92\xc4\x47\x09\x42\xed\x1b\x52\xec\xf4\xf0\xf8\x9f\x98\xee\x06\x3f\x70\x57\x72\x4c\xc5\x29\xa0\x7b\xf0\x3f\x16\xae\x5a\x2b\xae\xb5\xfb\xe0\x62\xfe\x95\x99\xd8\x6d\x09\x3d\xf1\x93\x1a\x61\xde\xb3\x12\xe6\xbc\x3c\xe2\x3a\x24\x07\x79\x32\xa0\xf0\x4c\x8d\xf9\xb7\x24\xf7\xa5\x6c\x5e\xae\xb7\x4f\x2a\xa1\x35\x0f\x08\x57\x85\x2c\x51\x91\x54\xda\x57\xed\xe5\xdf\x50\xe0\x08\x26\x5c\x5d\x73\xd7\x97\x84\xfb\x8a\x2c\xfd\x98\xbb\x8b\x30\x00\x53\xb4\x77\x79\xd1\x24\xd9\x1a\x2e\xa0\x2b\x81\xbd\x9d\x9a\xda\xb4\xfd\x9e\xfb\x48\x7a\xe2\x4e\x7c\xc0\xe6\x73\xd7\x20\x9e\xf4\x97\x80\x0f\x18\x8f\x53\xe2\x83\x48\xe9\x7b\xe9\x12\x6a\x99\x3e\x1c\x2d\x65\x8f\xad\xdc\xf8\x9d\x48\x81\xa1\x8b\x1c\x0a\x97\x58\xc1\xc2\xe0\xae\xb4\x99\xc3\x61\xda\xd6\x1f\xb1\x3c\xae\xf8\xf1\xd3\x5a\xc4\xd8\x79\x52\x52\x99\x83\xa5\x49\x0d\xf1\x39\xf8\x92\x3b\x40\x31\x62\xea\xc7\x1a\x2f\x6e\x1f\x3f\x39\x09\xce\xac\xec\xcd\xb3\x80\x47\xcd\x01\x47\xda\x20\xa8\x1f\xae\x1f\x62\xd9\x14\x4e\xbe\xc2\x6c\xac\x5a\xd3\xa0\xdd\x8e\x4a\x43\x27\x47\x93\x2f\x4c\x6a\x6f\x55\x43\xdf\x77\x64\xff\x5d\x44\x14\xd2\x9a\x48\x85\xe0\x3a\x02\x75\x00\xed\x08\xb4\x49\xd8\xa4\xe0\x44\x54\x26\x33\x31\xb5\xfd\xa9\xec\x8a\xf5\xe3\xa7\x05\x37\xed\x0d\x06\xfc\x26\x7e\x8d\x45\x80\xa2\xcc\x0f\x02\x0c\x45\xc5\x55\xae\xfd\x06\x1b\xbd\xf4\x73\xe2\xaf\x40\xda\xb8\xe1\xe3\x27\xf4\x90\x99\xda\x03\x35\x51\x8e\x67\x07\xfb\x09\x8b\x06\x85\x47\x6c\x2a\x81\x6f\x7a\x0f\x80\xfb\x4e\x2e\x23\x3f\x29\x43\xe6\x16\x85\x3a\x60\x2b\x0a\x73\xab\xcf\xb5\x9f\xb2\x14\x42\xf6\xbe\x62\x2e\xf7\x26\x0e\x27\x9b\x00\x79\x86\xb6\x4b\xc8\x65\x1d\x7e\x33\x8d\xb7\x6e\x78\x43\xf5\x46\xef\x7c\x71\x4f\x49\xa6\xb9\x2c\x5b\x44\x59\x98\xee\xe1\x7a\x7b\x27\x43\x39\xc8\x83\xc5\x45\xa1\x56\x62\x15\xc5\x0f\xfc\x0d\x6d\xd7\xd6\x7e\x96\x8c\x26\xc6\x6e\x48\xee\x12\xdb\x99\xd3\x26\x84\x93\x7c\x75\x8d\xfd\xcc\x73\xf9\x99\xec\x71\xa7\x4f\x74\x94\x15\x0d\xdd\x81\x02\xec\xa9\x84\x03\x2a\x7e\x84\x2d\x01\x0b\x24\xc2\x7e\xe8\xb4\x5f\xed\x5a\x62\xca\xf1\xea\xfb\x8f\xa9\xaf\x1d\x1a\x1d\x23\x51\x5d\xbc\xf5\x9d\xa6\xc8\x68\x3a\x0d\x5a\xc9\xa1\xe2\x05\x4a\x85\xed\x46\xbc\xa2\xa3\x8e\x5e\x20\x1c\xc1\x40\x6f\x8e\xdd\x82\x09\xf5\x7a\x85\xc6\xdc\xd7\x8c\x31\x71\xfb\xf9\xac\x84\xcc\xdc\x5d\xfe\x10\xa3\x10\x11\x7c\xde\xd6\xd2\x0c\x7f\x2a\x70\xfe\xe1\x7f\x44\xbb\x9b\x3f\x6e\x02\x8d\xa5\xbc\x9c\xd7\x5c\xcb\x8b\xea\x80\x81\xb4\x20\xb9\x4a\x9d\xd6\xfc\xb7\xd8\x17\x8f\x2a\x88\xc1\x5a\x48\x9c\xc3\x49\xe9\x81\xc3\xc0\x3f\xf1\xb1\xed\xbc\x43\x15\xc9\x5c\x58\x2e\x0b\x6e\xa8\x17\x3c\x60\x5a\x75\xf9\x51\x82\xb5\x8f\xa9\xd9\xd9\xfa\x26\x76\x81\x3e\xea\x00\x0f\x30\xcb\xe5\xc6\x0e\x72\xb5\xfb\x06\x0e\xa5\xec\x9a\x5c\x2d\x7a\xcd\x31\xf8\xc3\xff\x27\x4f\x25\x01\x1b\x18\x31\x71\x73\xf4\x34\x8b\x38\xb6\xf2\x68\x6b\x23\x84\x23\x0c\x59\x96\xbf\x36\xa0\x8b\xe4\x52\x1e\xc2\x81\x7f\x13\x0a\x16\x04\x1c\x6a\x52\xe6\xc0\x5b\xd4\x47\xf2\x3e\xdb\xd8\x0d\x1e\xfb\x95\x71\xc3\x34\xb7\x99\x13\xe7\x38\xfc\xe2\xec\x09\xe1\xbe\xea\x66\xb2\x55\x7c\x3b\xea\x3d\xe6\x14\x20\x0a\x50\xa4\xc3\x96\xed\xc5\x32\xe3\x6a\x90\x25\x0b\xbf\x15\x81\x49\xd8\x8c\xb0\xda\x1c\x2f\x2d\x45\x4c\x3b\x2c\x3c\xe0\x0d\xb0\x4e\xa3\x55\x2f\x50\xd8\x88\x5f\x7e\xc6\xe6\xfb\x3e\xe7\xed\x4b\x8f\xe8\xb5\xc0\x1d\x22\xdd\xa4\x58\x65\x0f\x4e\x01\x27\x74\xc9\x76\x71\xf8\x5a\x61\x78\xe5\x82\xfa\x07\xe3\x77\xa6\x9c\xa3\x85\x00\x2a\x60\xe5\x93\x5d\xe0\xb1\xbb\xa3\x07\x22\x43\xb3\x96\xa4\x89\x7a\x80\xa5\x24\x1d\xf3\x89\xb9\xf9\x7b\x31\xee\x2a\x0d\xdc\xa4\x91\x91\x0f\x7d\x6a\xff\x09\x07\x46\x9c\x28\x69\xae\x30\x60\x59\x3f\x14\x8a\x39\x9c\xc3\xd7\x70\x24\x39\x34\x48\x1a\xfc\x12\x9b\xc6\xc3\x49\xb0\xc2\xa5\xb2\x3d\x3e\x77\xe9\xd3\x76\xc2\x42\xd2\xbc\x6e\x13\xa5\x82\xe5\x24\xa5\xf4\x9d\xd6\x1d\xbd\x6b\xb5\x55\xa7\x15\x27\xae\x34\x5d\xc8\x6c\x39\x0d\x03\xbc\xce\xd2\x47\x56\x1c\x07\x52\xf4\x00\xb5\x81\xe7\xa4\xb0\xab\x73\x57\x39\xc9\x63\xc3\x5b\xaa\x3e\x62\x4e\x3b\xfc\x81\x75\x08\xf8\x71\x7d\x6e\xfd\xf0\x2e\x7a\xd7\xb6\x4e\x80\x80\x6f\xe1\xf6\x74\x87\x16\x2c\x6c\x12\x9c\xdc\x12\x29\x7c\xeb\x59\x66\x58\xff\x1c\x76\x20\x6c\xff\x54\x95\x7b\xf4\x57\x70\xf0\x52\x57\xc5\x12\xad\xf8\x13\x35\x6e\xc4\x3f\xea\x14\x33\x6d\x1b\xac\xa5\xea\x1a\x29\x16\x48\x75\xd6\x1b\x98\x4b\x52\x0d\xce\x5e\xbc\x66\x89\x24\x71\x1f\x48\x39\x42\xad\x32\x51\x7b\x21\x6e\x05\x01\xa2\x3d\xf3\xb5\x75\x04\x8f\x2f\x8a\xc7\x79\x3d\x61\xb3\x52\x41\x80\x8c\xa3\xc0\x63\x03\x0e\x32\x54\x17\xf7\x9a\xae\x7e\xf0\xda\x1a\xce\x1d\x2f\x46\x51\x2f\x19\xcc\xa2\x45\x23\x95\x17\x28\x1c\xbb\x46\x6a\x79\x02\xdc\x16\xc5\x58\xae\x59\x58\x19\x71\x16\x62\xf9\x79\x18\x1c\x95\x6e\x91\x85\xe6\x3d\x01\x43\x02\xf9\x00\x0a\x1c\xae\x1a\xf8\x32\x02\x65\xc5\xa8\x0d\xa8\xd1\x82\xf8\x97\x2d\x8c\x45\xbc\xef\x1c\x0a\xac\xdb\xef\xa1\xb6\x45\x17\x76\x91\xa9\x7e\x99\x78\x6f\xf7\x43\x1f\x47\x90\xf8\xd4\x0c\x19\x59\xd2\x42\xed\x1a\x23\x0f\x90\x62\x58\x97\xac\x82\x26\xb7\xee\x57\x0e\x59\x2d\x71\x09\xea\x22\xce\x0f\x5d\xd8\x40\x2d\x95\x2f\x0f\xdd\x60\x91\xe1\x44\x01\x7d\x85\xaa\xe9\xca\xc6\xcc\x0c\x19\xd8\x8b\x3f\xa0\x16\x8d\x00\x51\x85\xf4\x8a\x09\x6f\xa3\x93\x1a\x02\x20\x08\x54\x73\x0a\x49\x2b\xb3\xfb\xf6\x78\x8b\x62\xd5\xd3\xd4\x7d\x87\x26\xdf\xfb\x5b\xb4\xaa\xb6\xa8\x5a\x44\x2d\xe9\x89\x08\x95\xfb\x2a\x8b\x24\xa7\x45\xa2\x40\x2b\xc1\xef\x61\x51\xa6\xd8\x1a\x00\xae\x00\xaa\xf7\x00\x32\x5d\xad\x29\x18\x54\x2a\x56\xeb\xa4\x45\x91\x8a\xc2\x50\x2c\xc8\xa4\xed\x65\xab\x35\xb5\xfe\x16\x0b\x3a\xfd\xb1\xdc\x04\xa9\xc1\xbb\xed\x10\x6c\x8e\x2d\x60\x52\x1e\x3f\xa1\x96\xe0\xe1\xa5\x0f\xaf\x33\x3f\xc2\xf0\x43\xec\xa2\x0d\x97\xf5\x05\xd5\x35\x92\xad\xb3\x9f\xbb\x53\xb0\x31\x80\xa1\xe0\x60\xea\xfa\x24\x12\x3f\x1f\xeb\x60\x45\xf0\x02\x57\xec\x03\x09\x1e\xfa\x8f\xbf\xc4\x64\x40\x02\x6d\x2c\x29\x33\xf5\x57\xc7\xcb\xf5\x03\x6d\x27\x20\x0b\x20\x2e\x63\xd0\xb4\x24\x0f\x67\xf4\x15\x50\xc6\xdd\x98\x65\xdc\xa7\xfc\x71\x4e\x7f\xf1\x8f\x4f\xd2\xbf\x1a\x08\xf3\x95\xfe\x28\x89\xf3\x04\x9d\x10\x35\xe6\xe9\x84\x4a\xf6\xe9\x4f\x2c\xe8\xda\x5e\xa1\xf9\x59\x9b\x5b\x1f\xd2\x41\x8f\x56\x08\x34\x78\xea\xad\xfd\xab\xe6\xad\xcb\x70\x1c\xc7\x51\x7c\xe0\x74\x98\xf8\xcb\xf6\x88\x80\xad\x69\xed\x50\x51\xee\x6a\x70\x3b\x08\x5d\xc0\xba\x28\x8b\xfb\x03\x47\x79\x05\x22\x5b\xba\x16\x38\x87\x44\x59\x8b\xa0\xaf\xc0\xed\xa0\xcb\x43\xc7\x1e\x79\x87\xf0\x3c\x92\x77\x48\x07\x3b\x8c\xe0\x2a\xf6\x00\xf6\x22\x8d\xe2\x87\xff\xd7\x8a\x3e\x38\x23\x25\x34\x22\x52\x19\x27\x25\x81\xf0\xea\x1d\x88\x97\x42\xc5\xed\xa2\x6d\x89\x93\xeb\xe6\xf5\xc2\x39\x1e\xca\x40\xc8\x11\xfd\x28\x4a\x26\x76\xb8\xc9\xc1\x25\xfc\x8e\xae\x08\x76\xb8\x60\x2f\xe2\xd2\xf3\x48\x3f\xc9\x65\xc8\x00\x77\xa4\x6a\xa0\x68\xba\x9d\x69\x1b\xa4\xf6\x72\x41\x86\x52\xfc\xf2\x76\x8c\x76\x84\xc9\x96\x95\x08\xf8\x22\x44\x63\x7b\x14\x83\xb8\x9e\xd0\xb7\xa4\x2d\x62\x33\x9e\x77\x21\xdc\x32\xe5\xa3\x09\x9a\x04\x0e\xfa\xa6\x1b\x96\x91\x92\x21\x88\x6a\x96\xd3\x85\xad\xd8\x04\xe7\xf0\x03\x0f\xce\xa4\x13\x2b\x2b\x52\x84\xa7\x30\x19\xc4\x48\x19\x6e\x02\x41\x3f\xf4\x9e\x29\xd3\xce\x44\x59\xa0\x64\x82\x3e\x0b\x06\x42\x67\x26\x30\x3a\x41\x7c\xc2\xb8\xca\x7d\x51\x6d\x86\x6f\x47\x6f\x49\xf0\xe5\x32\x1e\x56\xc1\x07\x5d\x56\x9a\x5d\x90\x0d\x00\xaa\xab\xaa\x49\xf8\x76\x93\x07\x9c\xf4\xe1\x52\xf2\x41\xe8\xae\x03\x3b\xab\x2d\x68\x6c\xf8\x6a\xd2\xe4\x7a\xb0\x47\xcb\xae\x61\x5b\x3b\x7c\x05\xe7\x0a\x3e\x25\x38\x23\xa8\x0f\x98\x35\x44\x85\x55\x9e\xb9\x5c\x39\x9f\xad\x50\xf6\xa7\x02\x9d\x7b\x71\x85\xcf\xfb\x4e\x19\x90\x99\x80\x70\x90\xaa\xa0\x09\xd4\x68\x39\x32\x01\x55\xac\x6c\x8d\xa6\x21\x3b\x12\x40\xa4\x0a\xb4\xc6\xe6\x07\x00\x82\x8a\x62\x37\xb7\x17\xc3\x73\xa0\x44\x81\x6a\x0d\x0a\x54\x2c\xcd\x9d\x1d\x44\x45\x6b\x90\xc8\x85\x19\xbf\xe5\x16\xa2\x13\x33\x80\xc5\x17\xfb\xa5\xc3\xc8\x64\xb2\xef\xc0\x7f\x1f\xa3\x19\xed\x83\xbf\xb6\x46\x0d\xa3\x8b\x71\xc4\x1a\x1f\xf0\x75\x03\x1e\x15\xa8\x92\x0f\xd1\xa4\x21\xe5\xcc\xed\x33\x0a\x05\x5d\x46\xeb\xe2\xd5\x9a\xd5\x37\x9c\x5a\x00\x8e\x10\x13\xe3\xb5\x2e\x47\xe9\xc9\xf3\x8b\xb6\x32\x1a\x0d\x4a\x9b\x39\xb7\xc1\x6b\xc6\x1d\x07\xce\x44\xdc\x0d\xa0\x87\x18\x85\x66\x85\x38\xb8\x15\xa7\xea\xba\x0c\x44\x79\xce\xf5\x83\x83\x26\x18\xc0\x95\x38\x2f\x29\xec\x84\x9a\x92\x99\xdc\xe0\x75\x72\xd1\x40\x81\xba\x1b\xdf\x91\x99\x3a\xd0\xe1\xf1\x14\x4e\xb9\xb2\x3f\x55\xfe\xd4\xc6\xa2\x10\xc1\x6d\x3f\xe6\x4b\x76\x22\x32\x36\xd7\x1a\xdd\xe0\x6a\x18\xa1\xb8\x27\xa7\x42\x27\x79\x16\x8e\x03\x05\x13\x40\xc0\x60\xd8\x5a\x4f\x73\x46\x97\xdd\x16\x9f\x8f\x42\x22\xe4\x3b\x2e\x6c\x36\x37\x2d\x3c\x36\x7c\x9f\xb5\xf0\xd9\x14\x01\x54\x1c\xcc\xea\xb4\xe5\xca\x15\x63\xa3\xa7\x94\x30\xa4\x37\xcd\x2e\xdb\x6a\x8c\x16\x46\x68\x3a\x6d\x25\xeb\x0a\x34\x3f\x8a\x94\x2c\xf1\xf8\x0a\x06\x0a\x2d\xd5\x68\xba\xbd\x3f\x55\xac\x1c\x6c\xd9\x89\x11\x95\xc2\x54\xca\x91\xdc\x39\x6f\x89\xa2\xcb\xbd\x55\x4c\x5a\x83\x17\xab\x0b\x47\x8b\x37\xbe\xa0\x9e\xef\x36\x1d\xa0\xb0\xf3\x09\xaf\x1a\xea\xaa\xc8\x87\x7a\x2f\x41\xa1\x56\x9d\x37\xc0\x60\x54\x29\x2d\x94\xff\x7e\x4b\x31\xc1\xc5\x79\xf3\xd6\xe2\x85\xfb\x93\x05\xc7\x2d\x5c\x36\xaf\x05\x9c\x15\xeb\x2c\xb9\xc5\x28\x85\x6c\x01\x33\x94\x90\xa5\xb5\x8d\xec\x0f\x48\x61\xa1\xf0\x7a\xa5\xcb\x64\xa3\x93\x93\xf5\xc6\x81\x08\xef\x22\x9f\x64\x49\x6e\x9b\x44\xd4\xc0\x38\xf7\x1a\x98\xe0\x77\x8d\x06\xc4\x4e\x37\x3b\x75\xd9\xd4\x01\x10\x6b\xcd\x84\x68\x96\xc0\xb6\x35\x6c\xda\x93\xcb\x74\x4f\xfe\x25\xd8\x70\x82\x7f\x60\x7d\xac\x38\x4d\xcc\x06\x0f\x66\x0d\x68\x23\x37\x30\x3d\x68\x50\x15\x89\xce\x84\x04\x7f\xf2\xb4\x38\x95\x3d\xcd\xf6\xf7\xa1\x6c\x03\x91\x4f\xc6\xee\x5a\xe1\xb4\x1c\x08\xde\xf9\xae\x7d\xb6\x82\xbb\x0b\xf2\x8c\xd3\xcf\x6b\xf7\x81\x34\x07\x54\xe9\xec\x47\x40\x91\x96\xab\x35\xbb\xb1\x97\xe8\x88\x8b\x73\xcf\x44\x4d\x41\x54\x8d\x40\x61\xd0\x19\x46\x8f\xd0\x09\xd0\x41\x39\xd6\xfc\xe9\xe7\xd6\x2e\xe6\x99\x8a\x04\x6d\xe2\xcb\x46\xd4\xc4\x9f\xea\xf6\x40\xd3\x8e\xba\x30\x27\x20\xf4\x29\xf0\x0a\x8b\x5c\xc3\x53\x2d\xf4\xc8\x25\x3e\x68\xd9\x14\xca\x30\x83\x26\x53\x0c\xbe\x7d\xfc\x25\x45\xf3\x57\xe1\x1b\x12\x15\x93\x4c\x17\xe9\xbb\x35\xe2\x75\x0f\xae\x4a\xdf\x73\x58\xe4\x3a\x78\x50\x28\xb8\xf0\xe2\x37\xea\x8f\x53\xfb\x31\x65\xcd\x6a\x61\x33\xb4\x76\x5a\xa4\x3a\x86\xd1\x36\xf4\x49\x8e\x0e\x97\x76\x6d\x5a\x36\xe2\x7f\x96\x2b\x68\x55\x1c\xd2\x5c\x6a\x66\xfe\x16\x2c\xde\x0d\xed\xe2\xa9\xc8\xe3\x14\x06\x78\xe9\x4f\xf8\x61\x3b\xf6\x36\xc2\xda\x82\x36\x3e\xd4\xe1\xa5\x6f\x65\x5e\xaa\x3d\xb3\x5c\xd3\xcb\x96\x18\x41\x8f\x30\xad\xbd\xad\x45\x42\x07\x0d\x65\xcd\x17\x81\xaa\x6f\xae\xe8\x9b\x1c\x57\x96\xe3\xb2\x99\x9c\x46\x0d\xb9\x09\x78\x65\xc2\x34\x2c\x5d\x74\x57\xd5\x69\x49\xe7\x21\x1f\x07\xc8\x1a\xeb\xa5\x64\xa3\x68\x57\x08\xad\xa1\xb1\x23\x57\x26\x3d\x01\x80\xed\x16\x7f\xa3\xa2\x5e\x40\xdd\x62\x1b\x18\x29\x2d\x1d\x58\x0d\x2b\x73\xb7\xab\xb2\xac\x5b\x34\x59\x07\x7b\xee\x95\xfe\xeb\x42\x18\xc2\xaf\x6b\xb4\xec\xee\x34\xdd\x70\x55\xa1\x52\x56\x50\xf5\x9d\x78\xd0\x4e\xb3\x16\x56\x1e\xcb\xaf\xb6\xe7\x93\xcb\xba\x5d\x23\x93\x0a\x72\xe4\xc1\xd7\xce\xd3\x0a\x51\x5b\x32\x88\x7a\x5f\x99\x0e\xfb\x2d\xcf\x75\xd0\x0b\x53\xf7\x86\xe5\x5a\x09\xee\x36\xbb\x8f\x16\x49\xe3\xd1\xb6\x4b\xd5\x84\x11\x78\xda\xa2\xd4\x31\x3d\xa5\x82\xd2\xb8\x0b\x9a\x36\xf3\x36\xbb\xb6\x79\xaf\x75\x6e\xd3\xed\xd6\x1a\x87\xda\xaa\x46\xb8\x46\x61\xf1\x0c\x82\x2b\xcb\xb1\x2f\xf1\x7a\xca\xf7\xf7\x72\x28\xef\xaf\x47\x86\x11\xdb\x72\x4f\x76\xcf\x89\xae\x0c\xa9\x0a\xc3\x84\x59\xa5\xdd\x39\xf7\x22\x16\x70\x0d\xfe\x51\x86\x5e\xc8\x40\x5c\x8c\xa4\x73\x6f\xdc\x96\x80\x33\x8c\x80\x88\xc2\x10\x6e\xb6\x14\xdd\xe5\x95\x94\x06\xb4\x9c\x3c\x7e\x42\x85\x07\x21\xa7\xf8\xd0\xbe\x33\xc5\x7f\x30\x84\xec\x83\xd1\x45\x52\xd0\xb5\x57\xac\x23\x3f\x0c\x7c\x32\x91\xb0\xb9\x0a\xcd\xf3\x7b\xe4\x61\xc3\x78\xb9\x75\x94\x88\x3c\x56\xf3\xed\xe1\xe8\xbc\x48\xa2\xd6\x2a\x81\x39\xaa\x12\x18\x89\x90\x6b\x8c\x89\x2d\x59\x39\xfa\x1d\xd1\xf2\xb6\x7d\xde\x1e\x53\x7e\xa2\x07\x92\x77\x79\x9b\x25\x48\x15\x3f\xee\x78\x3e\xbb\x8a\x56\x6e\xba\xb8\x35\xfb\x37\x57\x8d\x38\x28\xd8\x0f\x00\x62\x42\x11\x5a\x51\xcc\x58\x93\x34\x5a\xe9\xb9\x13\x0f\xec\x64\x7d\x29\xf6\x6f\xf6\x31\x21\x32\xff\xe9\x0b\x64\xff\x1b\x3f\xa5\xe4\x73\xfe\x79\xd0\x15\x72\xfc\xa3\x7b\xe7\x16\x10\xf6\xe1\xb1\x41\x09\x0c\x39\x75\x5d\xd0\xb2\xe0\xac\xbb\xc5\x1f\xe0\x28\xd9\x1c\xf6\x3f\xdd\xfd\x76\xff\xb7\xfb\x5f\x0e\x68\x86\x07\xea\x0f\x00\xf9\x05\x87\x9c\x03\x83\xf0\xf9\x14\x83\x13\xf2\x17\x13\x07\x1d\x0d\x7b\x79\x1a\xc9\x40\x7a\xf9\x07\x48\xce\x20\xcc\x82\xa0\x67\x9f\x72\xe6\xa8\xea\xc6\x4d\xf1\xa3\x8b\x20\xf3\x84\x5a\xa1\xb2\x74\xe0\x5e\x29\x66\xb0\xe8\x2c\x8e\xb9\x39\xfe\x1a\xbd\x67\xfe\xca\x58\x1d\x72\x1c\x0e\xd3\xc7\xbf\xa3\x57\x63\x0d\x48\x60\x0f\xba\xe4\xee\x20\x07\x24\xa1\x8b\x95\x2f\x16\xa3\x16\xd8\x62\xf9\x7b\x52\x3a\x9a\x22\x0a\x55\xd6\x0b\xda\xa5\x4a\x41\x85\x86\x45\xc3\x45\x60\x66\xa6\x00\x08\x2e\x11\x33\x33\xbc\xeb\x26\xb7\xd7\x91\x1b\x7b\x07\xf9\x95\xcf\x00\x67\x8e\x9b\xd5\xcd\x70\x71\x53\x7c\xa7\xf6\x42\x33\x64\x0a\xbb\x94\xce\x19\x58\xf9\x1c\x5a\x44\x67\xbc\x89\x52\x8e\xa4\x24\xab\x79\x88\x01\xae\x6e\xae\x13\xe0\x34\x25\x0c\xc2\xc8\x05\x1d\x1f\x1f\x09\x3b\xc5\x9a\xeb\x25\x26\xf4\x94\x8b\xd9\xed\x4d\x9c\xe5\x29\x91\xfd\x1c\x8a\x39\x82\xd6\x70\x97\x12\x74\xa5\x13\x76\x00\x6c\xe3\x4e\x09\x1e\xb3\xa5\x03\x1a\xd9\x0f\x2c\xa0\x49\x87\x45\x07\x34\x6b\x07\x55\x89\xd0\xcd\x7d\x54\x35\xc4\xad\x3e\xaa\x12\xd2\x1e\x6e\xaa\x1a\x96\x0e\x73\x75\x99\x6f\xd6\x9e\xaa\x1a\x1a\x73\x1d\xfe\x32\x86\xea\xbd\xa9\x0b\xbc\x7e\xa1\xe9\xb3\x30\xf3\xcb\x4a\x17\x82\x16\x4f\x5b\x09\xb0\xdd\x16\xd5\xef\x33\x14\x1d\xce\xd9\xa5\x9c\x03\x0a\x07\xb7\x7f\xc3\x47\x83\xfe\x1c\x07\x6c\x06\x41\x7b\x99\xe0\x32\x1b\x65\x68\xb8\x5a\x79\x95\xfb\x0d\x7a\x6d\xc2\x30\xe3\xd0\x11\x77\xb9\x04\x75\xcf\x74\x15\xa2\xb3\x23\xc5\x18\x7b\x34\xfd\xf3\x97\x9d\x6b\xab\xc5\x21\x5e\xe2\x99\xa6\xae\xb6\x43\xa4\x80\x00\x6e\xcf\xef\xc8\xf6\xfc\x2f\xfd\x7d\xb1\x0f\xbc\x8a\x12\xc1\xbe\x40\x4c\x38\x63\x2d\x69\xbd\x16\x14\x6d\xc5\xee\x11\x53\xe4\x40\x41\x89\x16\x16\x20\x81\x23\x32\x81\x8a\x26\xe0\xc1\xcb\x82\x78\x2f\xb0\xe4\x83\xb3\xc0\x34\xae\x04\x78\xe4\xa3\x5e\x95\x44\xac\xa5\x11\x4a\xd2\x7d\xe1\xd0\xad\x38\x0e\x4d\x01\x04\x6a\x64\x6d\xb9\x9c\xe5\x29\xd5\x80\x76\x81\x34\x7b\x19\xcb\x20\xbb\x1d\x8d\x12\xe6\x02\x37\x3d\x06\xe0\xb7\x81\x85\x03\x8b\xd7\x32\xac\x2c\xe0\x46\xeb\xc0\x13\xdb\x20\x03\x45\x70\xcf\x30\x03\xc2\xf2\x7c\x7e\x26\x7d\xfc\xbf\x22\x4f\x53\xce\x85\xcd\x3c\x4d\xa5\x51\x6d\xef\x6b\xca\xa9\xd9\xda\xfc\x54\x21\xcc\xe4\x58\xda\x82\x61\x9f\xc1\x82\x58\x5d\x43\xd2\x86\xf8\x59\x0d\x87\x39\x3f\xb6\x30\xb4\xd5\xf6\xc6\x2e\xed\x68\x39\x81\x5b\x7a\xd2\x2a\x2b\x6a\x47\xbe\xb4\x9c\xba\xdc\xb3\x35\xc5\x0f\xfd\x56\x41\xd3\xbb\x96\xd8\xe8\x8e\xb4\x11\xae\xfc\xcd\x76\x4c\xbb\xf3\x96\x55\x26\xe0\xa9\xfc\x65\x1a\xe5\x36\xfe\x32\x3b\x62\xb7\x75\x97\x59\x92\xba\x85\xaf\xac\x42\xf0\xce\xbd\x65\x35\x5a\x9f\xcd\xcc\x5b\x19\xd9\xaf\xc6\x27\x55\x70\xc4\xec\xc1\xd8\x52\x3c\x99\xdc\x15\xdb\x4c\x9f\x82\xc7\x96\xe3\x72\x66\x40\xf1\x3d\x3b\x3c\xb7\x3a\xdd\x34\xda\xcb\xb8\x0c\x13\xa5\x23\xde\x6e\x42\x9a\x0c\xec\x5b\x8e\xa5\xc5\xec\xbe\x29\xb1\xc9\x22\xf6\xa9\x6e\xcf\x81\xb6\x96\xb5\xaf\x8d\xb2\x49\x7b\xc6\x31\xbf\xdb\x8c\x95\xeb\xec\x60\xd8\x1d\x36\xe4\x97\x61\x6d\xb9\x3d\x52\x4f\x0e\x31\x5b\xb4\x12\xae\xb5\x48\x37\xcb\xc5\xe2\xf1\x97\xa4\x88\x70\x2b\xcd\x69\x61\x6a\x34\xde\x14\xca\xe4\x50\xed\x44\xb5\xbf\x35\x35\x2c\xaf\x2c\x13\xb1\x5f\x40\x45\x8f\xf7\x21\x91\xee\x6d\x05\xf0\x8c\x0c\x64\xa6\xa2\x33\xa5\x61\xc0\xb3\xc6\xa8\xf2\x1e\xc3\xca\x99\xac\x8f\xaa\xff\x08\xaa\x34\x6b\xf6\xdc\x76\x62\x8a\x8e\x34\xc8\xbf\x68\xd1\x63\x92\xf3\xc7\x75\x20\xed\xd8\xb0\x8f\x0f\xc7\xb5\x97\xaf\xb5\xdd\xf8\xf0\xcd\x7a\x7a\x6d\x3b\x36\x8a\x28\x2d\x72\x49\xd0\x9a\xc2\x05\x3c\x28\xdf\x80\x34\x7a\xee\xe8\x60\x33\x5e\x43\x3e\x09\xd1\xf4\x53\x36\xf0\x03\x36\x0c\xf8\x6c\x18\x28\xb2\x0f\x64\xc2\x16\xbd\xe4\xa7\x59\x9b\xb5\x55\x23\x1b\x1d\x15\x18\xbe\xe9\x2c\x85\x9b\x66\x54\x61\x83\x8d\x1d\xdc\x5f\xea\xd6\xbd\x2b\xad\xa3\xd0\x23\x2f\x42\x96\xf0\xdb\xf2\xa5\xce\x61\x7d\xd0\x44\x98\x2f\x03\x41\xd1\x39\x16\x96\xc6\x26\x68\x85\x6b\xa2\x2e\x71\xc2\x01\x2c\x17\x5f\xfa\xaa\x1c\xb9\x12\x45\x8a\x2c\xc0\x68\xd1\x44\xfd\xa2\xc0\x0b\x93\x99\x87\x86\x2c\x23\x7e\x71\x30\x58\xbd\x0d\x97\xf2\xcf\x58\x92\xc1\x0d\x1b\x2e\x5f\xb5\x03\xde\xfe\x30\xcd\x07\xae\x39\x4e\x25\xed\x54\x0e\xa2\x86\x57\x65\x31\x19\x71\x6f\x70\xe2\x56\x47\x8c\xd3\x07\x82\x8b\x8b\xca\xc1\xf0\x8d\xb8\x96\x9a\x88\xd3\x06\xdd\x75\x97\x6f\x19\x34\x88\x8e\xdc\xc0\x27\x8b\xda\xb5\x28\x52\xc4\x0c\xa3\xc8\x6b\xe0\x44\x97\x55\x60\x2b\x4e\xe0\x32\xdf\xe2\x6e\xba\x5b\xae\xec\xf8\x6a\xdb\xc0\x98\x86\xc5\xd9\xc5\xa1\xa7\xe1\x8e\xdb\xb8\x51\x3e\x1b\x87\xf0\x58\x90\x39\xc8\xec\xf2\xfd\xe7\x64\x60\x3f\xae\x2c\x7f\x37\x3f\x5e\x14\x80\x9e\x78\x59\xa7\xdd\x1a\x7b\xae\x1d\x77\x92\x81\xc5\x5a\x9d\xd9\xec\x5b\x5d\x67\xcb\xfd\x07\x06\x02\xbe\x09\x22\xe0\xb1\xa6\x3b\xe0\xfb\x65\xbc\x46\x84\xef\x64\x1d\x42\xf6\xcc\x7f\xfd\x2f\xff\x7a\xb2\xe7\x7c\xf5\xe5\xd7\xbf\xc3\x7f\xde\x98\x2c\xed\x93\xbc\x90\xa0\xac\x2f\x58\xb2\xa9\xd7\x80\x98\x70\xc3\x82\x7b\x70\xb8\x17\x2f\xe7\xb6\xa4\x70\xbc\xe5\x25\x41\x4c\x49\xf0\x5a\x65\x9a\x04\x96\x17\x9c\xc5\x94\xfa\xc1\x6f\xa7\xb6\x79\x0b\x47\x91\x2c\x99\x10\x44\x31\x66\x08\x83\xfc\x5b\x67\xa6\xc4\xfb\x53\xc1\x5e\x01\x2e\x8a\x45\xc5\x2d\xf0\xba\x2d\x63\x32\x02\x73\x06\xa0\xc4\xc2\x0d\x06\xc9\xa3\x49\x1d\x07\x55\xae\x51\x3b\xba\xbc\x64\x50\xb9\x08\x98\xc7\x35\x8c\x8c\x73\x1a\x29\xa7\x89\x72\xa0\x52\x21\x10\x99\x70\x28\xd3\x86\x56\xd1\x9d\x50\xae\x11\xd2\x9f\xe0\xfa\x73\xe7\x53\x35\x28\xcc\xbb\x4a\xb8\x76\x50\x6b\x8e\xe2\xa9\x60\xc7\xcc\x07\xa2\xd5\x53\x39\x63\x20\x65\xeb\xc9\x89\x30\x41\x31\xdc\xd5\x38\x7f\x27\xf7\xc9\x60\x3a\x91\x1a\x15\x23\x06\x32\x60\xc8\x8f\x9f\x30\x4c\x88\x1e\xa8\xc3\x6a\x1d\x34\x77\xe8\x93\x49\x34\xee\x12\x59\x87\x60\xcd\x9a\xa0\xe4\xb4\xf7\xf8\x69\xe5\xc2\x35\xae\x9e\x25\xe6\x02\x45\xbf\x24\x2d\x79\x62\x26\x7a\x16\xef\x44\x3c\xf4\x57\x94\x00\x15\xe5\xb9\xb0\xbc\xcb\x50\xd7\x7b\xe5\x69\x8f\x0c\x51\x2e\x9a\x36\xdb\x31\x01\xe1\xc7\xe9\x56\x20\x35\xaf\xf2\xa6\xd3\xd4\xb8\x57\x61\xb4\x92\x70\xf9\x2d\xd3\x0e\x8c\x16\x19\x86\x4f\xf1\x48\xb3\x38\xe8\x8c\xdb\x18\x71\xdf\x4d\x8a\xef\x91\xf5\xb7\x4a\x30\x3a\xe3\x38\xd8\x4f\xc0\x5c\xd0\xaa\xae\x9b\x86\xae\x0a\x6e\x94\x46\x2a\xff\xa5\xf7\x8c\xec\xc7\xf7\x92\x83\x76\xb0\x89\x73\x60\x7a\x9d\x2b\x29\x3a\x6e\x8a\xa9\xef\x70\x12\xb8\x7e\x20\x3c\x55\x88\x05\x4b\x9e\x60\x4d\xfe\x0b\x2e\x0c\x48\x61\x40\x54\x6b\x6a\x2f\x2f\x31\x97\xd0\x72\xa4\x52\x24\x1c\x97\x86\x7b\x0c\xc5\xf8\x0d\x68\xe7\xc4\x6b\xd3\x61\x32\xc6\xa6\xe4\x92\xb9\x29\x33\xf6\x8e\x2b\x9b\x54\x33\xee\xab\xe4\x94\xb3\xf8\xd7\x71\x44\x1b\x89\x4b\xf1\x96\xeb\xfc\xfd\x5e\xaf\xe9\x16\x0e\x30\xd1\x8c\x76\x41\x5e\xa3\x1a\xdf\x41\x7f\xba\x1f\x4b\x71\xaa\xcf\x3b\x87\x05\x9a\x82\xfc\x14\xef\xf2\xd2\x5e\xb2\x12\xcd\x00\xf6\x3a\x16\x3a\x4d\xb2\x15\x80\x10\x49\x11\xff\x46\x59\x8c\x28\x5b\x5d\xcf\x35\xc6\x8e\x4c\x90\xcf\x30\x02\x79\x4f\x4b\xe3\xc7\x7f\x04\xa2\xa3\x1a\x99\xc6\x31\x38\x24\xea\x61\x73\x98\xd5\xb8\x7a\xfc\x04\x78\xf3\x48\xc7\x0c\xeb\xc9\x2c\x31\xd3\x30\x04\xf9\x1e\x98\xc6\x98\xad\xd6\xa5\xfa\x5f\xc8\x5d\x01\xeb\x05\xa5\x26\x17\xb7\x32\x0c\xe3\xad\xef\xc9\xa2\x12\xf5\x82\x5d\x51\x86\x35\x81\x32\x34\x3b\x17\x75\x7e\x9b\x4a\x53\x35\x13\x35\x3e\x7d\x7b\x3c\x3d\x3b\x3d\x19\x9f\xce\x9d\xb7\xa3\xe9\xf1\xe8\x9b\xc9\x98\x9b\x16\x99\xa2\xb9\xb8\xa3\x11\x75\x19\x50\x2f\xc0\x1f\x03\x09\xe8\x74\x4c\xa0\xec\x91\xcd\x4c\xdb\xcd\x0c\xfc\xc0\x04\x3e\xef\x76\x61\xda\x25\x7f\x19\xe3\x03\xd8\xf4\xa0\x0b\x82\x53\x6b\x10\x91\xe4\x2d\x21\xbc\x6b\xec\x57\x71\x13\x05\x5e\xf7\x73\x0b\xea\xa1\x11\xbb\xab\xab\x9b\xeb\xcb\x17\x07\xbf\x6b\xee\x8f\x51\x7d\xe7\x3f\x5e\x61\x99\x23\xd2\xc1\x5e\xa5\xab\xf5\xab\xbc\xb5\x31\x2c\xe2\xa5\x7f\x63\x6c\x8b\x51\x86\x93\x3a\x97\x2f\xb0\xda\xfb\x5e\xb4\xc4\xf2\x69\x37\xc9\xe5\x8b\x6e\xc6\xb4\x00\x75\xaf\x3d\xab\x81\xd3\x73\x3d\x07\x2e\xdf\xd9\x7a\xe0\x04\x47\x0d\x5c\xec\xc1\x3e\xf5\x41\xd3\x04\x81\x8c\x83\xef\x9e\xf3\x89\x1f\x66\xef\x5f\x9d\xb8\x0b\xfe\x53\x43\x54\xea\x41\x4a\x5d\x64\x4b\x33\x8c\xc5\x4f\x7d\x32\x05\x27\xd4\x11\x25\x86\x8d\x4d\x05\x2b\xb4\x26\x30\x7f\x06\x10\xd1\x7d\xe2\xa8\x7a\x91\x80\x4c\xf4\xc1\x73\xf9\xe2\xe7\xcb\xcb\x32\xaa\x4b\x44\x76\xa9\xa3\x83\x3f\x3e\xe6\xfd\x72\x14\xc6\xf3\xe8\x5e\xc4\xb3\x5b\x11\x04\x3d\xc7\x65\x85\x0e\xc7\x97\x96\x66\xa5\x05\xa8\xcd\x0c\x5b\xad\xd2\x7c\xaa\x9c\x8e\x31\x45\x21\x27\x47\x17\xab\xd2\x66\xb2\x26\xb5\xca\xce\x8a\x99\x88\xce\x06\xd3\x2e\xa6\xab\xf7\xd8\x76\x32\x61\x65\xa8\x56\x33\xb6\xcd\xd6\xe2\xd2\x43\x39\x7a\xef\x3a\xff\x98\xf8\x01\x5a\x5b\xcd\xa2\xd4\x7e\x5f\x59\x23\x91\xd3\x26\xf1\x5c\x12\xa6\x3e\x1b\xaa\xcf\x68\xaa\x78\xd4\x88\x7a\xc3\xb2\x93\x9b\x9b\xc0\xce\x0f\x11\xa7\xe7\x29\xd2\xb2\x3f\xbb\x51\x1b\x8f\x90\x1e\x7b\xd3\x1a\x4b\xcf\x19\xdf\x6e\x3c\xdb\x4f\x79\xaf\xa3\x72\x13\xd8\xc5\xf1\xe9\xd8\x9c\x9f\x7c\x9f\xc9\x5b\x50\xb1\x49\x24\xb7\x4f\xcb\xe4\x06\x55\x79\x04\xf5\xe8\xc4\x18\xbc\x3a\x52\xee\x95\xdc\x56\x92\x83\xad\xda\x9b\x65\x12\x03\xf9\x19\xb0\x9a\x23\x81\x35\x29\x86\x4c\xe2\xb7\xf3\xf9\x39\xde\x70\xde\x3f\xa8\xbe\x09\x58\xff\x5f\x11\xd8\x4d\x12\x56\x74\x43\xe3\x0d\x81\x90\xd0\x54\xfd\xe0\x9c\x1c\x8f\x9a\x0a\xb4\xd2\xb1\xb9\x5f\x75\xb4\x2b\x9f\x6a\x99\x92\x1d\xb9\x54\x6b\xd4\x3d\xa7\x3b\xb5\x69\x44\x7d\xbc\xa9\x06\xe2\x7b\x7b\x52\x25\x1d\xc0\x2d\xd9\x32\x98\x8d\x85\x1d\x58\x61\xbc\x9e\xee\x5e\x2c\x16\x5b\xbb\xa5\x50\x62\xeb\xe7\x48\x1d\xb5\x3a\x51\xdb\x31\x95\x9d\xa8\x9a\x8d\xaa\xdb\x7f\x3a\xb2\xf7\x9d\x92\xe3\x74\x13\xa7\xa9\x46\xe5\x53\xfa\x4c\x8b\xc5\xb2\x91\xbf\x94\x7d\xa5\xc5\x3a\xa3\x9e\x47\x61\xde\x44\x28\xf7\x99\x76\xf9\x4b\x69\xb4\xcf\xe5\x2e\x1d\xf5\xf1\x00\x3d\x81\xab\xb4\x3a\xd8\x6d\x3d\xa5\x1b\x8e\xf7\x89\xbd\xa4\x4f\xc9\x84\x2d\x9d\xa4\xbb\x63\xc8\x6e\xdd\x7f\x0d\x3c\x79\x5e\xff\x68\xaf\x9d\xf1\xb9\x98\xd3\xcf\x35\x3a\xda\xc2\x2d\x6a\x44\x69\xe3\x15\xed\x40\x6c\xe7\x11\x1d\x87\x77\x45\x72\x37\xf0\xe9\xad\x2b\xa3\x0f\x9c\x7b\x37\x91\x35\x7e\xd3\x96\xae\x29\xf9\xbb\xde\x40\xe6\x8b\x87\x6c\x3c\x2f\xc1\x0a\x07\x2e\x19\x84\x39\xa7\x5d\x66\x5a\x19\x2d\xdc\x64\x72\x97\x4b\xb4\x31\x92\x1e\x39\xf4\xe6\xe2\xf8\x68\x70\x60\x2a\xd1\x26\x2b\xbb\x83\x36\x91\x54\x77\x60\xdb\xa2\x51\x59\x02\x45\x36\x3e\x42\xb9\x09\xa2\x6b\x37\xc0\x6e\x33\xb8\x98\x8c\x26\x55\xa2\x9a\x0e\x7c\xee\x5e\x41\xba\xb2\x25\x7d\x2e\x56\xdf\x0b\xf3\xe6\x19\xd2\xf5\x23\x93\x8f\xdb\xf0\x2d\x54\x11\x84\xa2\xa2\x9d\x1f\x08\x6b\xbe\xb8\x54\x8c\x38\x5f\x44\xca\xd6\x5f\x94\xb4\x6b\x1f\x6d\x8e\x5d\x8e\xd6\xa2\x0b\x6f\x1b\x01\xa5\x51\x77\xb6\xdb\xad\x90\x90\xca\x6a\xcc\x9d\x5d\x02\x2c\x79\x80\xf0\xba\x3a\x03\x54\x48\x68\xad\x01\xdd\x81\xd6\xb2\xde\x73\x15\x63\x43\x64\xee\xbe\x45\x47\x82\xae\x69\x68\x2d\x8b\xd1\xdd\x99\x80\xa9\xf4\x1a\x73\xa9\x78\xab\x6d\x44\x63\x62\x97\x5d\xd5\x80\xc1\x86\xca\xe6\x1c\x2b\x9b\x0a\xe3\x9d\x94\x1a\xd2\xad\x2c\x8a\x8e\x4b\x1a\x8d\xe1\x33\xd6\x14\x79\xdd\x31\x34\x9b\x51\x20\xc3\x5f\x76\x48\x47\x47\x4c\x8d\x24\x28\xef\x12\x44\x92\xa7\x10\x16\x66\x97\x96\x4e\x4b\x56\xf4\xf6\xd1\x84\x4e\x09\x8a\x15\x72\x36\xd2\x6c\x89\x5d\x19\x65\x6c\xd1\x0b\x93\xda\x60\x7f\x1a\x6e\xbc\x10\x8c\xb8\x7b\xad\x83\x2e\x0a\xac\x96\xc0\x92\xfb\x64\x6b\x51\x00\x78\x6f\xd9\x6c\xc3\xc6\x5a\xdf\xcf\xea\xdd\x43\x6b\x2d\x6d\xbd\x63\xeb\xb4\x71\x1e\xf8\x06\x07\x64\x99\x34\x95\x4f\x5e\x25\xca\x9a\xa2\x5d\x8a\x39\x8d\xb4\xed\x85\x9c\x22\xb0\xa3\x47\x4b\x07\x15\x5d\x3d\x59\xca\xb8\xaa\xaa\x65\x71\x68\xd8\x24\x8e\xb4\xcf\x55\x9b\xa6\x69\xc2\xb3\x05\xc9\x4f\x48\xa5\x1d\x61\x4d\x99\x60\xdb\x13\xd7\x98\x60\x66\x49\x58\x14\xdf\xbb\x31\xd1\x86\xd2\xa5\x87\x52\x4c\x0f\x48\xcf\x20\x69\x1a\x28\x9c\xda\x55\xe1\x1b\xae\x1d\x4d\x91\xa1\x8b\xc8\x33\xab\xe0\xb6\x40\xb0\xce\xb6\x29\xe0\xa3\x26\x4e\xa3\x6b\x0c\x65\x62\xed\xad\x52\xa2\x1b\x61\xd9\x91\xae\x5b\x36\x93\x6c\xb5\xa2\xf6\x56\x1b\x50\x40\x31\x3e\x0b\x77\xed\xa7\x19\xbe\xb0\xac\x17\x45\xb7\xa3\x47\x75\x92\xa5\x36\xfc\x1c\x44\xc9\x01\x4f\x30\xf9\xaf\x41\xd3\x3f\x77\xd3\x5b\xeb\x85\x55\x62\x11\x37\x02\xa2\x92\xdd\xa5\x10\xc9\xbc\x64\x77\x1e\xe2\x54\x46\x65\x41\x34\x35\x84\xc1\x09\xd8\xc1\xd4\x69\xb7\x11\x1b\xd4\xf8\x2e\xf3\xe9\xee\xeb\x57\xb4\x7c\x36\x99\xbd\x1a\x11\xcc\x13\x09\xd2\x14\xd1\x57\xa6\x04\x9d\x20\x58\x82\x8b\x73\x85\x5b\xb7\x43\x1b\x29\x03\x2a\xd4\xe3\x89\xa6\x44\xe1\x3c\x4e\x53\x06\x57\xda\x5c\xce\x15\x79\x72\x19\xa9\x88\x38\xe6\x19\x06\xc9\x6d\xca\xb0\x4a\x90\x5b\xb1\x7c\x8a\x05\x55\x0e\x7b\xb3\xa3\x93\x2b\x9e\x71\xfb\x36\xc1\xfd\xc3\x10\xa5\x1e\x97\xb8\x81\x90\xa1\x22\x37\xd8\xb5\x09\x51\x4c\xcf\x0f\x95\x91\xcd\x7e\xf0\x0a\x82\x32\xe6\x6b\xfd\x0d\x08\x60\xfb\xe8\x40\xae\x24\xb7\x2e\xe9\x90\x7f\x9c\x9d\x9d\xda\xdf\x50\xa3\x50\xb5\x01\xc7\xf7\x5a\x71\x60\x37\xa4\x42\x1a\x53\x53\x4a\x62\x9c\xf5\xf4\x66\x80\x8a\x5c\x21\x39\xee\x50\xbc\x47\xd4\xdd\xe2\x54\xe1\xb6\x6a\xc6\xd4\x86\x39\xdb\xb0\x27\x13\x93\xb1\x06\x36\xf7\xe4\xf1\xc0\x0d\xdd\xe0\x21\x01\x5d\xf5\x21\x4c\xdd\xf7\xb4\xa3\x3a\x59\xad\xf0\xc8\xa2\x7d\x5b\xa0\x22\xf5\x36\x2f\xce\xd7\x8a\x53\xc4\x28\xa1\xfa\xdb\xd9\x06\x32\xe4\xbf\x9f\x91\x0d\x43\x7d\xa5\x2d\x12\xa3\x7d\x70\x3a\xa9\xa9\x36\xf5\x3f\xa6\x93\x61\xb0\xe5\x9e\x6c\xc2\xb0\x3b\x90\x85\x90\xc3\x6d\x2a\x62\xbb\x7d\x90\xa1\x1a\xe4\xa7\x6c\x8d\xf2\x4a\xf5\x4a\x73\xa9\x46\xf0\xa8\x85\x66\x1b\x29\x18\x52\x55\xb7\x51\x6e\xa0\x1b\x06\x62\x51\xdd\x1a\x9a\xa9\xd2\x4e\x2b\x54\xc4\xa8\xbb\x7b\x7f\xe4\xa5\x3b\xbb\xd5\xc0\x15\x2e\x9a\x84\x6d\x11\x4a\xee\xf7\xc6\xdb\x6b\xf2\x2d\x08\xe8\x31\xfd\x4b\x20\xe4\x96\x14\x83\xa2\x78\x48\x1f\xdb\x7d\x9a\x69\xa7\x8d\xaa\x1e\xc2\xb0\xba\x50\x87\xee\x6a\x47\x26\xc8\xcc\x59\xdc\xba\xa1\xb4\xce\xc2\x5f\xd8\x0f\x73\x67\x56\x48\x29\xc6\x48\x83\xb4\x5f\x23\x32\x69\x86\xbd\xe9\x4a\x92\x59\xad\x8f\x1c\x5b\xae\xaa\x91\xa2\x55\x5a\x27\x5b\x89\x1f\x2c\xe7\x19\xdc\xe5\xb5\x75\x36\xd9\xed\xb0\xe0\x00\x86\x2e\xac\x39\x03\xca\x7a\xa3\xa7\xb1\x2f\x88\x84\x24\x85\x49\xda\xe8\x46\x56\x05\xb2\xad\x54\x4e\xdc\x3b\x5d\x12\x6e\x09\x8d\x42\xba\x77\x69\x61\xa7\x50\x1a\xd9\x88\x73\x77\x8b\x3b\x27\x93\x53\x11\xaf\x28\x4f\xe5\x2a\x7d\x58\x8b\x7e\x36\xec\x2a\x75\x04\x81\x12\xf6\xdc\x9b\x30\x82\xf5\xbc\xc0\x52\xda\x98\xb1\x78\xc3\xe5\x8f\x3a\xad\x99\xec\xb1\xa9\x5c\x7e\xad\xba\x8a\x56\x8f\xca\xaa\xfb\xa6\x9a\x25\x69\xd5\x62\xb4\x4a\xd4\x4e\xa4\x56\x9d\xb4\x5d\xcd\x2b\xf6\xfc\xa4\x7b\x4a\xb4\xb9\xf7\x8d\xdb\x80\xa6\x45\xd1\x65\xb1\x81\x07\xee\x83\xbf\x5e\x57\x26\xb1\xc7\xb5\x62\x65\x2e\x44\xd8\x86\xb4\xd1\x82\x87\x99\x69\x5c\x2a\x83\x8a\x8a\x53\x69\x75\x37\xe1\x68\xb3\xf8\x86\x32\xf9\x38\xa6\xe0\x3c\x4a\xa8\xd6\xe8\x00\x26\x39\xd5\xff\x44\xd9\xec\x63\x32\x92\x8b\x7d\x48\x53\x71\x23\xe2\x7d\xc7\x79\x8d\x17\xa7\x28\x56\xfa\x32\xec\xa4\x60\xbd\x47\xbd\xea\xfe\xb6\x58\xaa\x68\xd5\x62\xb9\x0c\x6f\xff\x66\x74\xda\x0f\x04\xf3\xa0\x99\x7e\x54\xcf\x94\xf9\x0b\x03\xc1\x38\x5d\x78\x45\x77\x70\x35\x00\x60\x93\x46\xf0\xca\x85\x31\x57\x07\x00\x77\x18\x2a\xf1\x8a\xd7\x5d\xa0\xff\x9c\x76\x2c\x71\xd7\xc7\x10\xc1\x0c\x78\xfc\xf8\x89\xf2\x1a\x31\xa7\x2c\xe1\xa8\x35\x1e\x9b\xd8\x73\xe0\x50\x8b\x5b\x06\x66\x9e\x94\x2e\xa5\xa2\x55\x5b\x38\x70\x4e\x23\x2e\xe0\x4e\x65\xd2\x3b\xd2\xa4\x73\x88\x6e\xb6\xa0\x6a\xd4\x2b\x87\x7a\x39\xe7\x51\x78\xb6\x0b\xe9\x80\xce\x5f\x0f\xa3\x81\x9d\x7b\x97\x77\x14\xa1\x06\x76\x2c\x40\xd6\x5d\xd3\x3d\x03\x1e\xa5\xbc\xcf\x01\xee\x36\x0c\x9f\x48\x4c\x75\xed\x73\xc2\x3c\x50\xd8\x70\x11\xaa\x4d\x0f\x7f\x07\x2e\x6a\x0b\x98\x75\x19\xa6\x4a\xaf\x5b\xfa\xa1\x54\xf6\xa9\xb1\x3b\xa1\xbd\x8d\x51\x2f\x28\xe3\x6d\x1d\x82\xdd\xae\xef\xdc\xcd\x9c\xc6\x9d\x50\x1e\x37\xa9\x28\x9c\x5a\x2d\x64\xcf\x67\xe0\x12\x86\x0c\x8b\xd0\x5b\x47\xb0\x37\xfa\x9d\x98\xef\xd7\x6c\x46\xd1\xa7\x85\xa3\x32\xd9\x18\x88\x71\x4f\xef\xc4\xc3\xab\x3b\x37\xc8\xf0\xbe\xed\xc7\xc9\x65\x28\xaf\xf4\x0b\x6a\x11\xe8\xe9\x2d\xe4\x9d\x50\xb8\x31\xa8\x22\xc8\xa4\xef\x57\xc1\x2c\x04\x19\x24\x52\x60\x94\x29\x5c\x47\x4f\x7a\xc6\x09\xf0\xb2\xf2\xfe\x12\xb9\x49\x92\x90\xa3\x61\x12\xf6\x08\x92\x03\xac\xc3\x64\x58\xe1\xc8\x9d\x8b\xd8\x61\xcb\xdc\x89\x30\x6b\x6a\x46\xcf\x19\xd5\x1c\x42\x51\xa7\xce\x9a\x39\x49\x89\x3b\xdd\xa3\x4a\xf2\x61\x25\x8d\xe3\xea\xc0\x9c\x9f\x3e\x39\xda\x44\xa8\x39\x71\xfe\xf7\x65\xf6\xe5\x97\xbf\x15\x0e\xcd\xcd\x1e\x89\x4c\x3f\xa5\x10\x25\x2a\x11\x37\x07\x45\xe0\xe3\x47\x93\xc4\x2b\x20\x7b\x18\x2c\xcb\x75\xfb\x61\x63\x44\x0b\x8c\x4d\xe6\xe0\x65\x01\x17\x9b\x95\xca\xec\x2d\xb8\xaf\x23\x06\xce\xef\xb1\xb0\x83\xe7\xe9\x4c\x55\x81\x4e\x8c\x1e\x48\xe1\xf8\x26\xb2\x0d\x66\x26\x31\xa5\x8d\xf7\x3c\x8e\xd6\x20\x28\x1f\x2a\xe3\xbe\x8e\xa2\x40\xb8\xc6\xd6\x21\xf5\x17\x8d\xc3\x52\x74\x13\x48\xb8\xba\x87\xa1\x39\xe8\xaa\x9b\x2e\xb5\x49\x40\x63\xc0\x2e\x99\x3b\xa1\x2f\x5f\xf2\xa0\x9f\x3c\xfe\x9f\x10\xfb\x9c\x6c\x4c\x5f\x98\xad\xae\x45\x5c\x5f\x1d\xea\xf1\xce\x55\x62\x4b\x36\x0a\xfb\xeb\x58\xc8\xd5\x80\xbb\x51\xff\xbd\x01\x63\xe3\x88\x5e\x8f\x8e\x27\xe3\x23\x93\xc0\x3c\xfc\x76\x7c\x68\x60\xc5\xeb\xf1\x68\x7e\x31\x1d\x3b\xaf\x27\xa3\x37\xa6\xd4\xe3\xe3\xd3\xa3\xe3\xc3\xd1\x7c\x7c\x31\xa5\xf4\xe3\xd7\x67\xa7\x87\xf3\x63\xa3\x25\xef\x35\xa5\xdf\x3b\x5c\x4d\x5d\x39\x19\xe3\x88\x73\xef\x31\xc6\xc8\x7c\xae\xe6\xd9\xf4\xe5\xaa\xe8\x68\xba\x97\x29\xe4\x65\xff\x22\x45\xe0\xe9\xd1\x45\xa6\x23\x59\xd2\xb4\x14\xe9\xe2\xb6\xa4\x0b\x27\x56\x01\x4e\x05\x5d\xe2\x3d\xfc\xb6\xc8\x2d\xd5\xdc\xb7\xa4\xa2\xfb\x4a\xed\xbc\x55\xe7\xad\x12\xc4\xfe\xee\x2d\xa9\x91\x4e\xf3\x64\x13\x02\xc4\x1d\xa6\xb5\xdb\xdd\x56\x8c\x04\x3c\x7e\x02\x8d\x85\x63\x36\x13\xab\x3b\x4a\x95\x0a\x98\xdd\x21\xe7\x09\xa0\xd2\x42\x8b\x86\x7d\xc8\x53\xf8\x38\x8f\x64\x15\x1a\x59\xd2\x6a\x2b\x5e\x95\x12\x03\x2a\xcb\x4a\x45\xd1\xf3\x9a\xb3\x24\xc0\x76\x7c\xdb\xf2\xb8\x14\x4e\xb2\x11\x93\xc9\xf0\x11\x73\x8d\xdf\x62\xc5\x6d\x40\x0a\x57\x09\x2e\xca\xc9\x00\x2b\x8b\xa5\xd7\x8b\x9a\xad\xc8\x90\x10\x7a\x63\xa6\x60\x80\x86\xe5\x46\xb1\x01\x4f\xbd\xe0\xf4\xfe\xec\xfa\x52\xb3\x43\x6e\x3f\x3e\x5d\xa4\x58\x85\xa1\x18\x07\x20\x83\x85\x74\xe1\x62\x11\x6f\x22\x89\x02\xd1\xcf\xd7\x2f\x07\xf3\x23\x99\xdd\xb2\x47\xcf\x95\xaa\x2b\xd2\xea\x7b\xd1\x0a\xad\x94\x42\x5d\x09\x9c\xca\x54\x52\x56\xcb\x0a\x68\x4b\xca\x94\xd2\xbb\x87\xbd\x40\x64\xad\x18\x74\x48\x89\xc6\xee\x65\x16\xa7\x58\x85\xd4\x42\xa9\xfe\xbd\xe3\x6b\xe5\x5f\x94\xfb\x8a\x86\x60\x8c\x81\xef\x38\xda\x80\x56\xe9\x0b\x6d\x75\xd2\xe9\xb4\x59\xb9\x40\x0b\xf0\x5c\xae\x89\x0d\xe5\x56\x93\x95\xa9\x4a\x4d\xb5\xd0\x48\x09\xc5\x80\x51\xe6\x8d\x61\xb4\x04\x7f\x7c\x1d\xb8\x58\x77\x58\x56\xe6\xf4\x4c\x4a\xd7\x6b\x95\xcb\x55\x7b\x33\x8f\x13\x6d\x29\x85\x63\x44\xcb\xb9\x6d\x1b\x60\xb5\xc4\x68\xf2\x72\x2a\xc0\x89\xe1\x6d\x8c\x0d\xc1\x9c\x0a\xb6\x2f\xa0\x3f\x3f\xc0\xf6\x69\x2b\xf7\x1d\xd9\x40\x64\x3e\x9d\x4f\x35\x98\x7c\xca\x04\x4e\x65\x41\xa3\xb5\x0b\xcc\x07\x72\xf1\xc7\x75\x5b\xdc\xcb\x6b\x69\x3c\x83\xeb\x31\x5a\x23\x68\x5d\x12\x22\x5e\x92\xbf\x77\x60\x78\x31\xa6\x7a\x7e\x90\x09\x84\x84\xa9\xb8\x46\xc2\x3a\x58\xa1\x41\x80\x7c\x7d\x15\x8c\xcd\x83\x8a\xb0\x69\xd7\xb5\x0c\x02\xc3\xa6\x74\x68\xc8\xa0\xcc\x6a\x19\x43\xd2\xeb\x9a\xce\xe0\x3c\x6e\xa2\xf2\xd2\xe3\xb2\x63\xeb\x38\xa2\x2a\x51\x18\xfa\xae\x01\x36\x55\xb5\x22\x18\x71\x35\x0e\xfb\x65\x28\x6b\x91\xf1\x82\xae\x80\x32\x4d\x78\x41\x0e\xc2\xe8\x31\xbc\x66\x22\x12\x64\xb3\xfe\x76\x2b\x5e\x59\x54\x8a\xb3\x15\x29\x66\x65\x47\xfc\x5d\xf9\x37\x32\xd5\x64\xa3\x11\x15\xaf\xf7\x1b\x4f\x9f\x9a\xc9\x0a\x5b\xaf\x72\xc9\x8c\x06\x98\xcd\x82\x6f\x49\xde\x74\x35\x44\x5e\x45\x1d\xe8\x28\xe2\xa6\x2c\x03\x4b\x86\x3c\x1a\xb0\x0f\x62\xde\x68\xd1\x60\x1a\xb2\x70\x67\x5b\xe2\xcd\x78\x3e\x3f\x3e\x7d\xe3\xcc\xe6\xa3\xe9\xdc\x78\x63\x3c\x3e\x3d\x9e\x1f\x8f\x5a\x2e\x79\x6f\x26\x67\xdf\x8c\x26\xce\xd9\x39\x3e\x63\xac\x25\x25\x7f\x76\xf8\xe9\xf1\xcc\x78\x88\xbd\xc1\x96\x58\x85\xfb\x30\x6f\xbd\x49\xb1\xe0\xc9\xad\xb3\x08\x30\x75\xd7\x24\x29\xcf\xd0\x46\xc2\x7d\xfc\x4a\x4d\x38\x9b\xc3\xba\xf2\xda\x01\x12\x28\x21\x30\x93\x85\x52\xb4\xee\x6a\x62\xbb\x1e\xae\x89\xb6\x0e\x52\x8a\x30\x3a\xd7\xc9\x76\x62\xed\x68\xaa\x96\x36\x34\x12\xc8\xd1\x96\xd8\x9e\x4c\x45\x4d\x91\xdf\x15\xd6\xdc\x3b\x91\x82\xfe\xb8\x10\xe6\xac\xbf\x33\x3d\x8c\x31\xcf\x26\xcd\x01\xf1\x99\x4d\x30\xf0\x33\x80\x5c\xdc\x3e\x7e\x02\x70\x5d\xd4\xac\xd7\xc9\xd3\x34\x7a\x3a\x2b\x45\xca\x95\xec\x8b\xcf\xda\xd9\x49\x8d\x54\xb3\x23\xec\xef\x1b\xd3\x35\xca\x54\x37\xdb\x0c\xe8\xf5\x56\x5c\xd2\x44\xd0\xd2\x9d\xba\x3f\x07\x95\xc5\xa0\x77\x33\xea\x1e\x3c\x12\x5a\x56\x68\x5e\x2e\xd6\xf9\xf9\xc9\x9b\x82\x95\x47\x5a\x50\x50\x55\xac\x1b\x1c\x2c\x3f\x7f\xb6\x96\x61\x39\xd3\xc8\x1c\xf3\x14\xdc\xb2\x5c\xa5\xba\x29\xe7\x73\xb1\xa8\x6b\x47\x70\xec\xdc\xe7\x5a\x51\xd2\xb3\xfc\xd9\xb8\xd3\xce\x1b\xd3\x91\xd5\x12\x23\x71\x56\x09\x6a\xef\x7b\x64\xb5\x13\xc4\x01\xe5\xdb\x65\xfc\x9f\x99\x23\xcb\x9f\x20\x87\xbf\x46\xf9\xee\xda\x6d\x75\x0e\x44\x3c\x59\x0b\xae\xfa\xa8\xba\x9a\x0e\x55\x67\xca\xb2\x4d\x4f\xf7\x64\xf5\xec\x41\x64\x9c\x4b\xbb\xa6\x3e\x6a\xe0\x9f\xa1\xb7\x60\x75\x67\x7d\xfe\xce\x82\x1a\x33\x92\xe7\x1a\x39\x7b\x41\x93\xe7\x1f\xa4\xa9\x02\x8d\xe5\x51\x68\x5f\x3c\xa6\xeb\xc0\xe2\x7b\x77\x52\xb4\x14\xc6\x3c\x91\xc4\x4f\xa3\xd8\x07\x3c\xa4\x58\x5b\x69\x90\xe5\x84\x90\x5c\x71\x2f\xa5\x85\x24\xdd\x7a\x7a\x89\x9c\x9c\x94\x07\xc7\x14\x75\xd0\x4a\x45\x2d\x2d\xa5\x1d\x77\x63\x47\x36\x92\x49\x3b\x39\x0e\x3c\x43\xcf\xb7\xcd\x4f\x01\x02\xd7\xa7\x90\x51\x99\x3a\xf9\xfa\xe6\xf8\x4b\x5e\x9b\x1a\x19\x8e\xfd\x72\x6e\xf0\xda\x6c\xb5\xa8\x65\x7f\x80\x2d\x28\x92\x10\x76\x40\x44\xa3\x7e\x61\xa9\xf7\xb5\x12\xbc\x39\xf6\x5e\x68\x6c\x00\x9a\x20\xb6\x53\x98\x29\x55\x99\xda\x93\x94\x15\x19\xd5\xa8\x8e\xbf\x7c\x83\xdf\x9d\xf6\x5a\xdc\xf1\xe3\x2f\x37\x54\x87\xaa\x4d\x77\x69\x43\xd2\x4a\x7b\x99\xda\x64\x33\x1d\x4b\x5b\xf5\x1a\x4d\x1b\xea\x4e\xea\xb8\x92\x95\xaf\x36\x93\x09\xa5\x8a\x55\x49\x73\x9f\xd2\x1e\xf2\xa1\x42\x13\x4e\x75\xd1\xb1\xf4\x1b\xfa\x84\xab\x31\x2c\x17\xbc\x94\x4b\x2b\xff\x7b\x63\x75\xbc\x71\x34\x6a\x3d\xe4\x0d\x4f\x75\x52\xb0\x0f\x4c\x93\x8e\xa7\xd3\xf2\x1c\xec\xa8\xeb\x1e\xbf\x2a\x3e\xed\x35\xd7\xf3\xfb\xd5\x33\xf0\x19\x57\x91\x89\x3f\x4f\x3d\xf6\xe7\x1a\xe2\x2e\xc7\xf1\xdc\x8b\xfa\x59\x17\xe8\xaf\x68\x2b\xff\x3a\x76\xec\x73\x6d\xcd\xa7\xda\x7f\x79\x82\x5f\xb2\xcd\xb5\x93\x52\xfc\x92\xc6\x0e\xe1\xc6\x93\xb7\xdf\x0d\x53\x01\x61\x29\xb1\xcd\x65\x53\x49\x80\x44\xbb\x16\x6f\xa7\x1a\x27\x7a\x55\x69\xed\x92\x64\x53\xa0\x76\x7b\x53\x4f\x22\x9d\x6d\xb2\x44\xa9\xb0\x58\x3a\xbb\xb8\xf2\x6f\x34\xe8\xe7\x1d\xa0\xed\x18\xea\x0e\xbd\x27\xeb\xe6\x5e\x1e\x66\x87\x1f\xf0\xd9\x7b\xba\xd7\xf8\xf2\xdc\x6c\xf8\x5c\xe3\x6d\x68\x61\xff\x34\xc6\x92\x5a\x4b\xfb\xed\xa4\x78\x41\xf7\xd6\x76\x93\x9c\xb2\x2d\xc9\x49\x9a\x9a\xe9\xb7\xae\x11\x4b\xb9\x9d\x97\x52\x6b\x5e\x24\x55\x5c\x1d\x0b\xa2\x53\xa6\x63\xfa\x30\xa5\x54\xcd\xf0\x13\x66\x54\x95\x36\x43\xae\x50\x3c\x85\xeb\x8b\x84\x01\xc6\x95\x95\xf0\x9b\x77\x47\x9d\x98\xdd\xbb\xbb\x38\x9f\xfa\x19\x99\x90\x10\x0b\xda\x84\xc2\x73\x0c\x9b\x83\x97\x1b\x96\x74\x79\xb8\x65\xf7\x4a\xc3\x3a\xb7\x1a\x70\x39\x82\xb9\x63\x9d\xd7\x06\x5c\xa6\xa1\x6d\xfd\x6f\x3e\xe4\x2d\xa4\x7c\xdf\xc1\x6d\x24\xd1\xa9\x77\x09\x15\x50\xa1\x36\x94\x8b\x20\xf3\xe8\x30\xe7\xda\x4c\x9c\xa3\x78\x1d\x79\x0f\x7b\xd8\xc7\x62\xf0\x6f\x03\xd0\x56\xb0\xc3\xb0\xf0\x9c\xeb\x07\xec\xa8\x40\x21\x9f\xb0\x32\xf0\x75\x2c\xcb\x41\x2f\xe6\x05\x59\x7a\x99\x2e\x89\x94\x95\x48\x6f\x23\xcf\x79\xf9\x66\x3c\xdf\x3b\x3f\x9b\xc1\x7f\x2e\xe6\x7b\x47\xe3\xc9\x78\x3e\xde\x13\xe9\xc2\x14\x12\x79\xf2\xf8\x09\xdf\x93\x9d\x5d\xcc\x6f\x37\x23\x8e\x92\x94\xc6\xc0\x7d\x45\x57\x0f\xc3\x24\xbb\xe6\x38\x14\x13\xbe\x53\x2c\x8e\x31\xb8\x7d\xfc\x47\x5a\x69\x2e\xba\x8a\xc2\x21\x66\x07\x0e\x65\x1c\x8b\x29\xf0\x32\xc7\xa9\x0c\xa0\x5c\xfb\xe1\xa5\x4c\x8f\x96\x71\x66\xb7\x2e\x7e\x94\x61\x36\x26\x5a\x9a\x41\x75\xa0\xcd\x64\xf2\xf6\x22\x5a\x61\xe7\x4b\x5a\x4f\x18\xc9\xe7\x1c\x9d\x9d\x8c\x8e\x4f\x29\xba\x9a\x9a\xa6\x3c\x68\xd4\x61\x26\x9a\x6f\xec\x3a\xfc\x44\x18\x39\xd2\x70\x0b\x9c\xb8\xb0\xb9\xe2\xb9\x06\x79\x07\xbc\x3c\x3e\x9d\xcd\x47\x93\xc9\xf8\xc8\x39\x9f\x5c\xbc\x81\x11\x1c\x9e\x9d\x9c\x8c\x4e\x8f\x4c\x39\x6b\xf2\x67\x6e\x98\x89\xaf\x0c\xe1\x1d\x05\x04\xbe\x35\x60\xb9\x09\x31\x2f\xbe\x54\x5b\xc8\x14\x22\x49\x8f\xc6\x7a\x8d\x81\xae\x72\xa1\xc7\x72\xc7\xe7\x95\x74\x64\x99\x2b\x25\x02\x5a\xbb\x5a\xd3\xcb\x31\x77\x35\x29\x0a\x5b\x79\x42\x2b\xa5\x43\x52\x2b\x6f\xe1\x64\xa4\x01\xfb\xaa\x2e\x52\xe7\x22\x71\x6f\x04\x76\xaa\x32\x20\x9c\x71\x02\x3d\xca\x29\x7e\x83\x1f\xb6\x81\xba\xdf\x0b\x2c\x66\x94\xd8\x02\x76\x46\x61\x51\xfb\xc0\x4f\x1c\xaa\xab\x49\x2e\x5e\xd9\x20\x9c\x1e\x0e\x1e\x80\x45\x8b\x20\x82\x05\xd9\x97\x94\x0b\x0d\x3e\xcc\x27\x8a\xf7\x28\xd3\xda\xee\x92\xd4\x4e\x14\x22\x8a\x8f\xea\x45\xff\x61\x5e\x87\x12\x7b\xd6\x04\xee\x4d\x02\x82\xf0\xfd\x42\xac\x53\x67\xb8\xfc\x02\x7b\xe1\xe0\x38\xae\x65\xf0\x27\x6c\xa8\xfb\x5b\x8c\xd8\xe7\xbe\xd8\xce\x2a\x0b\x52\x1f\x25\x1f\x85\x58\xb2\x1b\xb9\xbc\x5a\x4d\xa7\x5d\xd3\x58\x27\xa4\x0e\x7b\xb2\x35\x01\xdf\xf3\x6a\x2d\xde\x5e\x26\x6e\xb6\x24\xda\x30\xe4\x5d\x64\x77\x14\x33\x87\xfd\x17\x38\x99\x15\xc9\xfc\x29\x43\xbf\x7e\xb5\x92\x50\xbd\xfd\x36\x17\x33\x4c\x7c\xee\xc6\x53\x8a\xde\x64\x27\x72\x16\xd6\x37\x93\xc9\x8b\x5d\x63\xed\xb7\xe3\xd1\x64\xfe\xed\x15\x26\xbb\x7e\x77\x35\xff\xfe\x7c\x0c\xec\x4a\x88\x97\x97\x2f\xb0\xe8\xea\xe5\x0b\x5c\x26\x97\x2f\xc2\x28\x14\x97\x2f\x2e\x61\xd2\x7a\xad\x0c\x6c\x6a\xdc\x15\x07\x45\x59\xbe\x2e\x55\x9c\xa0\xeb\xbf\x0c\xa1\x2a\xf0\x67\x55\xfc\x76\x43\x3b\x8d\x8a\x55\xa9\x0e\xad\x9e\x0b\x7b\x44\x95\x25\xca\x50\x92\x1e\x0b\xd7\x44\x02\x29\xac\xf0\x44\xcf\x9a\x43\x35\xf8\x53\x55\xaa\x04\x03\xe9\xa8\xc5\x3a\x46\x8e\x16\x1f\x28\x7c\x6d\x80\x2a\x9e\x22\x23\xe9\xc9\x81\xa9\xaa\x25\xd2\x8e\x01\x97\xac\xa8\x20\xd9\x7a\x08\x4f\x45\xf8\x6e\xc8\x55\x7e\xcf\x3c\xf0\x7e\x47\xe4\x36\xc0\xdd\x01\xb9\xa3\xf3\x73\x67\x36\x9e\xbe\x3d\x3e\x1c\x5f\xd1\x89\x7e\x7a\x38\xde\x09\xbd\x08\x58\x01\xbc\x92\x18\x76\x44\x30\x37\x82\x44\xc1\x2f\x15\xb0\x5d\xd0\x7b\x7a\x76\x72\x85\x34\x8b\x54\x42\xdd\x3d\xb5\x75\x99\xba\x0d\xe1\xe3\x3f\x5d\x1c\x8f\xa7\x73\x9d\x70\x84\x79\x75\x74\x3c\x7a\x73\x0a\x37\x88\xe3\x43\x98\xd0\xf9\xf8\xcd\xf4\x78\xbe\xfb\xa1\xec\x74\xc9\x34\x8c\xe4\x69\x57\x4e\x41\xeb\x36\x64\x96\x49\xda\x15\x45\xdb\x32\x6f\x7b\xaa\xbe\xb9\x38\x9e\x1c\x9d\x8f\x60\x8d\x22\x6d\x7b\xce\xe9\xf8\xcf\x57\xe5\xef\x76\x36\xdb\x04\xf1\xf0\x0c\x26\x7b\x7a\x41\x65\x30\x00\xdb\xd9\xc5\xdb\xf1\xe8\xe2\xaa\xf1\xe7\x5d\x2c\x03\x25\x33\xb6\x58\xc5\x9b\xa2\xa4\xd2\x61\x16\x13\xdd\x17\xfe\x64\xf4\xcd\x78\xb2\xe7\x9c\x4f\xcf\xde\x1e\x1f\x8d\xa7\x34\xb6\xf9\xd9\x77\xe3\xdd\x48\xc6\xc9\x31\x40\x9f\xc0\x42\x78\x7d\x76\x31\x3d\x3d\x9e\xcd\xc6\x17\x53\xdc\xa3\x7f\x1c\xcf\x77\x33\x23\x35\xf2\x9f\x8a\xe8\x1d\xd0\x7a\x36\x7d\x53\x3a\x79\xb6\xa5\x13\xe1\xed\xf6\xc8\xa9\x52\xb8\x03\x66\x3e\x09\x91\x52\xba\xfc\xe9\xe2\x6c\x3e\xda\xd9\x09\x0e\x70\x15\xc8\x1d\x50\x39\x1d\x9f\x9f\x15\x67\xde\xc5\x74\xf2\x54\x02\x62\x36\x3e\xbc\x80\x73\xfa\xfb\xab\x37\xd3\xb3\x8b\x73\xc2\x76\x3e\x02\x55\x61\x7e\x76\x85\xe5\x04\xae\xa6\x17\x93\xf1\xec\xea\xf5\xf1\x64\x37\xba\x19\x61\xc1\xb3\x95\xb0\x8e\x71\x6e\x41\x29\x39\x39\x3e\x05\x14\x87\xdf\x82\x74\xbe\x9a\x8e\xdf\x20\x46\xaa\x65\xb0\x03\x46\x96\xc7\xb7\x97\xaf\xd1\xd9\xf9\x68\x47\xea\x66\x65\x48\x7b\x6a\xcd\x8e\x19\xc5\x4e\xc6\xc0\x87\xc5\x37\x53\x90\xac\x53\x3e\x16\xcb\xdf\xed\x64\x20\x87\x20\xaf\xe6\x38\x05\x12\xf6\xac\x38\x12\x6b\x3f\x3d\xc5\xb0\x2e\xe0\x0b\xde\x99\xe7\xa3\xd9\xec\xcf\x67\xd3\xa3\xbd\x3e\x2b\xbf\xff\xd8\x4e\xae\x2e\xe6\xc7\x93\xe3\x19\xd5\xc4\xda\x73\x4e\xce\xe6\x57\x47\xe3\x2b\x44\x3e\x66\xcc\x3b\x1c\x64\x7e\xd0\xab\x2f\xbe\x1b\x7f\xbf\x93\x91\xd5\xf4\xd5\xc3\xc9\x4e\x75\xd7\xba\xa6\x02\xbb\x47\x5f\x81\x3b\xbd\xbb\xd5\x46\x23\x52\x5e\x84\x70\xa2\x5e\x3d\x85\x6a\xde\x38\xbc\x27\x9f\x23\x14\x7b\x3b\x9e\x26\x58\xe0\x87\xe3\x21\xea\xe1\xf3\xd1\xf4\xcd\x78\x4e\x1f\x77\x74\x9d\xbe\x62\xe8\xf4\xf1\xf0\xf8\x9b\xc9\x6e\x28\x66\x09\xbc\x5b\x7d\x41\x0a\xdd\xdd\xaa\x0c\x05\xa5\xbb\x53\x19\x0a\x42\x77\xa6\x33\x10\xc4\x61\x71\x51\xa6\x3f\x09\xfa\x70\xeb\xab\x93\xae\xe9\x14\xa4\xe3\x5f\x84\xe0\x6a\x87\x87\x1d\x02\x62\xd5\x87\xa4\x4c\xf1\xe7\x8e\xe9\xd7\xaf\x7b\x4f\x42\xfe\x16\x57\xeb\x06\x72\xb7\xbf\x5d\x17\xe7\x2b\xe9\xaa\xd3\xb3\x1d\xe9\x74\xb5\x83\xb4\x00\xbf\x03\x86\x56\xa8\x26\x66\x3c\x39\xf1\x63\x1d\xcd\x0e\x06\x61\x77\xf9\x6e\x25\x34\x0b\xb7\x9a\x7c\x4c\xad\x27\x1b\xee\x0e\x56\x25\x55\xac\x42\x5f\xbe\x9e\x2b\xbf\xfd\xfa\x04\x68\x57\x48\xe2\x9e\x74\xde\x5f\x55\xe9\xdd\x78\x92\x1b\x09\x16\xc5\xf7\x22\x6f\x54\xb9\x8b\xb9\xde\x96\x5a\xaf\x06\xa4\x27\x05\x79\x39\x13\xc9\x4e\x2a\x14\x86\x47\xc2\x5a\x16\x64\xdf\x09\x53\x65\x81\x73\x43\x1f\x2a\xac\xbe\xa7\x0a\x87\x89\x94\xea\xe0\xe4\xd8\x77\xc0\xe4\xdb\x08\x2b\xec\x86\x2a\xce\x63\x37\xab\x44\xc6\xa6\xf0\xc2\xd8\xe1\x8a\x88\x02\x4f\xdb\x7f\x40\x74\x28\xee\x1b\x37\xe4\x16\xa4\xbb\xe1\xc2\x17\xf9\x8c\x04\x8d\x2b\x3d\xbb\x13\x6e\xd6\xfc\xc8\x8e\x46\x89\xc1\x5c\xbc\xe6\x70\x88\xea\xaf\x27\x1a\x62\x29\xae\xcb\x30\xc6\xd2\x33\xbb\x18\x64\x7c\xf3\xc4\x32\xca\x38\xb2\x5d\xcb\x29\x19\x10\xbd\x57\x0a\xb2\xdf\xab\x57\x10\xd8\xd1\xe0\x72\x74\x81\x0c\xe7\xd7\x62\xec\x29\xa1\xa6\xa9\x90\xc0\x2e\x86\x49\x31\xb6\xbb\x3e\xfa\x8a\xe8\xd9\xed\xcf\xbd\xbb\xaf\xf2\x8b\x20\x7c\xcc\x6d\xd1\xf8\x79\x32\x3a\x75\xee\xbe\x2e\x7e\xfe\x9a\xbf\xda\xc5\x94\xa8\x3b\xee\xdd\x57\xba\xa1\x1a\xff\x44\x14\xf8\x6f\xfe\xc4\xd7\xf2\xab\xaf\x37\x9e\x0f\x53\x65\xb9\x3a\x85\xc6\xda\x72\x05\x44\x55\x7a\x76\xe5\xa6\x07\x45\x83\x19\x34\x18\x62\x31\x4d\x6c\x55\x73\x99\xc2\xff\x87\x6f\xdd\xc0\xf7\xe4\xd3\x5c\x3f\xd3\xc5\x70\xc3\x83\xcb\xf0\x87\xcb\x10\xa0\xe3\x7f\x1c\x0c\xea\x88\xa3\x34\x5a\x44\xc1\x25\xa0\xb9\x7c\x91\x2e\xd6\x97\x2f\xf6\xd4\x6f\x1e\xb5\xc4\x22\x7a\xf9\xe7\xaf\xbe\xdc\xff\xfa\x77\xbf\xdb\xff\x6a\xff\xab\xff\xa5\x3d\x86\x71\x21\x09\x3f\xf0\xdb\xdf\x7e\xf9\xaf\x97\x2f\xf0\x07\x20\xe4\xaf\xe6\xca\x82\x40\x3d\xd3\x96\x8f\xdd\x39\xc8\xa3\x66\x0c\x23\x1a\xcb\x80\x49\xaf\x08\x56\x23\x10\x77\x38\x52\xea\xed\x60\x35\xb2\x1d\x0c\xcb\x30\x45\x5c\x9a\xf2\x70\x72\x2c\x8b\x52\xf4\x34\x52\xd3\xeb\x5a\x37\x56\x60\xc2\x39\x7d\xe2\x8e\x8a\xe6\x20\x60\xf9\x6a\x9e\x0d\xa6\xb5\xea\xad\x02\x30\xa3\x06\xd9\xd3\x9f\x5e\x14\x58\x27\x62\x15\xc5\x0f\xe6\x28\xdb\x55\xe4\xcb\x8e\x79\x85\x90\xeb\x00\xa9\x42\x9e\x5c\x10\x37\xe1\x30\x14\x37\x00\xef\x4e\xa8\xe6\x3f\x06\x54\x13\x4d\x86\x62\x04\x13\xad\x2b\x8c\x51\xf4\x62\x91\xf7\xb4\xa0\xbc\x54\x00\xea\x84\x8f\x9f\x10\xea\xd2\x48\x0a\xad\x2a\x2e\x2a\xdc\xd4\x34\xd0\x40\xc4\x54\xc5\x31\xd2\x8b\x61\xb1\x3a\x65\x92\x9e\x30\x96\x98\x52\x18\xa7\xb2\x80\x37\xfe\x6b\x0c\x47\x9a\x52\xa5\x6d\x0d\x7c\xf1\x42\x2b\xf0\xd9\x6c\xe2\x1c\xa2\xfc\x5b\x72\xbb\x26\x6a\x64\x43\xe1\x4f\x73\x7f\x7d\x22\x92\xd6\x18\x28\x7c\x91\xb3\x0e\x09\x8e\x86\x9d\xc2\xc4\xcc\xe0\x5a\x49\xe2\xa6\x3e\x9b\xb0\x58\xeb\xcb\xb3\x09\xa3\x2d\x1a\x2f\xfe\x91\xda\x2a\x36\xa4\x5c\x6a\xf8\xcc\x12\x9b\xd1\x50\x91\xd3\x9b\x4c\x56\x87\x05\x99\x74\x07\x6f\x71\xb0\xf6\x70\x41\xc1\x93\xfb\xce\x79\x20\xdc\x44\xa8\x1f\x1d\xd7\xd1\x16\x5f\x74\xfd\x23\x4a\x47\xea\x2b\x4b\x04\xab\x18\x7a\x00\x9c\x82\x36\x44\xb5\x2a\xeb\x2f\x98\x64\xc5\x61\x89\x1c\x6d\x1c\x4b\x98\xc3\xd0\x17\x45\x61\x23\x15\x52\x09\x64\xee\x3b\xaf\xe9\xd7\x24\x11\x1f\x70\x1f\x21\x8a\x94\xb1\xc9\xb7\xa3\x8c\x82\x30\x7f\xca\xe0\x01\xad\x66\xb2\xca\xb6\xe5\xed\xa7\xa4\x36\x52\x2e\x42\x4c\x3c\x68\x82\x65\x0e\x95\xe4\x41\x16\xbd\x5b\x31\x75\x07\x2b\xfe\x70\x06\xca\xc0\x19\x2a\xc9\x49\x8f\x78\x11\x68\x17\x18\x87\x4a\xf5\x9c\x0d\xec\x38\x52\x1d\x5c\x0b\x4e\x50\xf8\x67\x15\xf4\xef\x29\x64\xb9\xa9\xa1\x75\x38\xe0\x7a\xd1\x32\xa0\xb4\x83\x76\x3f\x79\xc7\xd9\x60\x74\xc6\x1d\xc1\x9f\x32\x45\xad\x5f\x81\xfb\x3f\x71\xa6\x1b\x06\x71\x26\x18\xdd\x5b\x5a\x8f\x76\x80\xb7\xa4\x73\x97\xa4\x75\x51\xc3\x65\x00\x87\x54\x06\x70\x48\xe1\xab\x6b\x37\x76\x57\x04\x8e\x7f\x3b\xc4\x9f\xb8\xb7\x8c\x81\xac\x73\x7c\xe3\xf1\x17\x8c\xf6\xad\x83\xab\xd2\x58\x07\xda\x4a\x5f\x7e\xee\x2c\xa2\x2c\xe4\x0e\x96\xea\x28\x4b\x0e\xf1\x2b\x1c\xea\x71\xe9\x21\xed\x88\x63\xc3\x40\xe7\xf1\x76\x1a\x61\x87\x1d\x0a\xd5\x95\xa0\x6b\x64\xd7\x91\x4e\x84\xec\xcc\x53\x7a\x4f\x6b\xe3\x53\x1c\x8a\x4c\x46\xd7\x79\x98\x0f\x75\x45\xa7\xbe\x13\xf8\x2b\x9f\x47\xcc\x6a\xc0\x04\xff\xb6\x58\x25\xf4\x1c\x27\xe2\x36\x6b\x08\xd5\xb1\x99\xc0\x5b\x51\x5b\xe2\x4e\x69\x32\x7a\x4f\xc3\xb1\x89\x40\x1d\x7c\x55\x15\xd9\x8e\xd7\xdd\xd4\x07\x58\x2a\x21\xbd\x75\x43\xfd\x49\xb9\x08\x76\x3f\x0e\x3f\xc4\x02\x69\x18\xff\x2e\x64\x77\xa7\x2a\xca\xd6\x61\x91\xce\xde\x95\xef\x95\xcb\x65\x7a\xba\x22\x9c\xdb\xe1\xab\x98\xfb\x7d\xa7\xe8\xe1\x06\x5f\x9a\xca\x5b\x9f\xe4\xf9\x2e\x05\x96\x7d\xe7\xc4\x5d\x83\x5c\x50\xed\xdb\xba\x8e\xa4\xa6\xcd\xb0\xc5\x4e\x68\x58\xfb\x3d\x17\xfe\xee\x77\xe7\x4e\xf6\xa3\x81\xac\xbe\xa7\x9f\x35\x79\x1b\x9e\x7e\x7a\x95\x3a\xe7\x26\xf3\x3d\x02\xf9\x06\x3e\xf4\xce\x0f\x60\x80\x58\x0f\x9e\xea\xed\xe7\xc7\xd6\x9c\xbf\xb1\x98\x0b\xed\xe0\xc2\x43\xb5\xda\xb1\xb2\x3a\xf0\x26\xc0\xad\xb4\x15\x15\x75\xa9\x79\x7f\xa9\xe1\x1b\x37\xf1\x9f\x51\x77\xbb\xb7\x6e\x60\xd5\x6b\xf7\x2d\x67\x8b\x54\x6f\x07\x0d\xc0\x9d\x56\xe8\x26\xa2\x71\xe6\xd1\x8a\x0c\xdb\x1c\xdb\x11\x50\x26\xed\x1e\x7d\x23\xb8\xe1\xcd\x52\x76\x24\xe1\x9a\xca\xb2\x5b\x08\x65\xf0\x1a\x4d\x45\x0c\xf6\x03\x5a\xe2\x6e\xb0\xf6\xe3\x87\x5a\x36\xed\x1e\xfe\x46\xbd\x50\xe4\x8f\x4b\xd5\xd8\x44\x55\xba\x97\xc9\xf3\x52\x47\x34\x5b\x86\x0c\x03\x48\x04\xf6\x96\xa7\x1f\xb8\xa9\x3a\xd7\xe2\xd8\x93\xc5\xa9\x52\xcc\x74\xe4\xee\x09\xb4\x7b\x92\xad\xc6\x92\xc0\x2a\x12\x44\x7e\xc8\x4f\x32\xca\x0f\x45\x0d\x10\x1a\x2f\x2c\x36\xea\xab\x9a\x48\x20\x84\x19\x2b\xe5\x89\x80\x2e\xe4\x58\x45\xe7\x3d\x35\x55\xc5\x66\x91\x89\x69\xcc\x13\x17\x4e\xa9\x33\x98\x79\xa6\xd1\x20\xf0\x05\xdc\x2f\x1e\x7f\x81\x55\x1e\xad\x81\x6c\xfe\xbe\x19\x1c\x36\x5d\x44\x43\x8b\xaa\xd0\x5f\x74\x43\xe5\x69\x6e\xb9\x37\xc2\xea\xc3\x32\xa5\x31\x96\x1b\xc5\x91\x04\x86\x02\xfc\x72\x2e\x17\xd8\xdb\xa8\x8b\x0a\xec\x11\x4b\x0b\x4f\x5e\x3e\x64\xb6\x98\xa9\xcf\x83\x89\x0c\x95\x64\x56\xba\x5c\x80\x0e\x0d\x77\x5d\x9f\x4a\xbe\xf7\xa4\x83\x58\xc3\xe9\xb1\x98\x81\xa7\x55\x46\x8d\x62\xea\xc1\x8c\xef\x78\x9e\xfe\x93\x6f\x6c\xe3\xd3\x81\xbb\xe8\x20\x60\x39\x68\x1e\x72\x63\x13\x81\xae\x71\x62\x1d\xdc\x9e\xac\x2d\xd5\xbe\xed\x00\x2f\x8b\x56\xca\x65\xb5\xe0\x8c\x78\x59\x84\x40\x26\xf8\xaa\x2f\xf5\x7a\x5c\x3d\x29\x92\x58\xca\xab\x0d\xee\xd0\x55\xe7\x47\x48\xa5\x94\x3a\xe7\xbe\x52\x5c\xb2\xd7\x24\x34\xd6\x94\xec\xc4\x57\xf6\x92\xec\x62\x1b\x6a\xd7\x93\xc2\x03\xd2\xb0\x1d\x3b\x79\x91\x57\x48\x71\xa9\xbc\x42\x2f\x66\xe4\x05\x50\x06\xe8\xb2\x2d\xcd\x45\x17\x5a\xae\xdd\xf1\xd2\x95\x2e\x17\x1f\x5b\xad\xae\x63\xee\xd4\xcd\x59\xad\x4e\xf2\x00\x6a\xe6\x6a\x4f\x16\x4d\x20\xc3\x0d\x90\xc8\x82\x11\xcb\x7f\xc8\x9f\x41\x91\x4f\x31\x87\xd6\x89\x33\xea\xcb\x62\x4c\xe3\x37\xb1\x92\x8b\x7a\xbc\x24\xaf\x33\x99\xfe\x13\xb2\xb4\x20\xfc\xc7\x5f\x56\xba\x01\x3d\xc1\xd6\xc8\x9f\xe0\x9c\x80\x23\x2b\xc6\xf4\x57\x22\x4d\x5a\x66\x8a\xe7\x07\xe2\xfd\x3a\x80\x0b\x80\xcb\xbe\xed\x9f\x32\x1f\x93\x68\xd1\xb2\x82\x2b\x06\x75\xa5\x6a\x27\x13\x53\x11\x83\x9c\x5f\xd4\xff\x9d\xc4\x8f\x14\x9b\x16\x52\xa8\x34\xde\x40\xe5\xac\x82\x92\x41\x59\xab\x59\xa5\x74\xb3\x26\x46\xdd\x1f\x81\x39\xf0\x8c\x05\x4d\x5a\xd1\x5a\x6d\x35\x45\xcb\x1d\xee\x7a\x52\x18\xea\x4b\xae\xee\xfa\xb4\xdc\xfd\x79\x31\x11\x4a\xbf\xef\xb9\xe2\xcb\x25\x43\x6a\x34\xb4\xa1\xce\x0f\x9c\x68\xb9\x14\xd4\x00\x59\x11\xa1\x95\xf9\xb2\x9a\x4a\xe2\xf0\x12\x75\x36\xfd\xc0\x93\x3d\xf0\x6b\x25\xbb\xac\x68\x62\x89\xa1\x7a\x28\xca\x0a\x4c\xb6\xc4\xa8\x7a\x4d\x04\x80\x21\x68\xd5\x9b\x6c\x0f\xe5\x9c\x96\x0c\xed\xe0\x1b\x92\x30\xd0\x9b\x3f\x59\x62\xd6\x9a\xec\x68\x42\xd9\x72\x65\xb0\x9d\xb3\xa5\xa3\x4e\xa7\x14\xce\xcb\xf1\xbb\xb5\x83\xc2\x96\x00\xad\xc6\x3e\x4a\xb1\x26\xe7\x78\x0b\x01\xa5\x2a\xe3\xb6\x28\x1b\x2a\x8a\xb7\xa0\xa8\x96\x73\x96\xac\x96\x0d\xda\xab\xbf\x52\xa7\xd0\x2c\x0c\x65\x5f\xa9\x5c\x4a\x6e\x40\x9b\x56\xf7\x59\x1d\x8e\x5a\xa3\xf6\xe6\x07\x55\xa7\x0a\x96\xd6\x3e\xbb\x34\x74\xad\x77\x83\x81\xa6\xee\x0d\x97\xb1\x4b\x55\xef\x9a\xa7\x1b\x15\xa9\x87\x7e\xca\xa4\xe7\x9d\xcf\xec\x47\x50\xaa\x28\x9a\x70\x09\x26\x6b\x2a\xd7\xf9\xfd\x3b\x29\xfc\x19\x5a\xf5\x50\x1b\xcc\x45\x05\x50\x5b\xac\x56\xd5\x3e\x2d\x50\xcb\x5a\x9e\xd6\xfb\xae\xb1\x70\xa7\x19\x0f\x2e\x01\xe9\x7d\x86\x93\x9c\x9d\xcd\x89\xd9\x51\x3d\x91\xbd\xed\x8b\xbe\x0b\xb2\x9f\x23\xec\x76\x73\xa7\x87\x09\x36\xeb\x74\xd0\x1b\x8f\x4b\xed\xde\x8d\x3d\x75\xaf\x61\x96\xec\x3b\xf3\x5b\x50\xb7\xd0\x95\x46\x6a\xd3\x35\xa2\x80\x8b\x2b\x50\xb4\x8a\xa8\x85\x28\xaa\x59\x20\x3e\x8c\x65\x45\xe0\xc6\xb9\xd0\x38\x4c\xe5\x68\x5c\xf6\x61\x71\x7b\x2d\xb2\x62\x00\x7e\x38\x92\xa9\x75\xe8\xbe\x73\x08\x0b\x5f\xf3\x91\x91\x3a\xc4\xe6\x51\x79\x6b\xd6\x8a\x84\x2c\x23\xdf\xd8\xc5\x1f\x06\xf7\x8e\x76\x54\x7e\x87\xa2\x8e\xbd\x31\xf5\xce\x72\xb2\xb5\x07\xf0\x4d\xd3\xf7\x56\xc4\xb0\x85\x7c\xe0\x3d\x55\xf0\x69\x0a\x44\xe4\xed\x22\x56\xeb\xc7\xbf\xc3\x78\xa4\x36\x82\x05\x67\xc8\x74\xfb\xa3\xb9\xe3\xd1\x24\xe2\x2a\x65\x8e\x31\x8c\xe1\x10\xad\x07\x8b\x94\x54\x31\xbd\x7d\x7d\x07\xbc\xc8\x58\x1c\xe8\x08\x66\xa1\x19\xa6\x11\xe4\x0d\xcc\x31\x32\x21\x4e\x4c\x31\x36\x63\xd0\xda\x70\x0e\x70\xa8\x21\xa8\x8a\x09\x59\x95\x4d\x4e\x5b\x04\x49\x95\x78\xb2\xd4\xbc\x8a\x15\x9d\xef\x7d\x6a\x79\x67\x86\x14\x63\xe0\x02\x08\x47\x11\x7a\xeb\xc8\x47\xa7\x8f\x2c\xf4\x43\xde\x4b\x76\x0c\xb7\x55\x67\x3a\x8d\x44\xe6\xc1\x03\x40\xb7\xa3\xc3\xa3\x92\x3e\xa8\xa4\xab\x16\xb5\xca\xb1\xca\x93\xaf\xf9\x77\x4d\xb4\x45\xef\xa8\x0a\xdd\x9a\xcc\x72\x48\x01\x47\x88\x0c\xea\x5d\x54\xca\x7e\x50\x93\x1c\x11\xb8\xb8\x16\xb7\x42\xb9\x4e\x75\x90\x8a\xc8\xb2\x76\x5e\x05\xdc\x48\xe8\x09\xb6\x01\xc6\x26\xcf\xeb\x07\xd5\xba\x54\xea\x73\x0b\xac\xdc\x46\xc4\x46\x95\x1e\x93\xe8\x20\x0f\x23\xd8\x51\xf1\xbe\xe3\x5c\x84\xe4\x1a\x89\xee\x60\x91\xf8\x70\xdb\x08\xf7\xf8\x06\x0f\x00\x87\x39\x24\xae\x65\x74\xef\x53\x2b\x1b\xee\x93\x4a\xb7\x93\x02\xa8\x69\x25\x8c\x41\xf1\x5d\xa4\x19\x39\xc5\x09\xaa\x4f\xf1\x07\x44\x9c\x04\x5f\x8b\x35\xcd\x8b\x04\x95\xc9\x26\x2e\xd1\x97\x19\x08\x91\x7d\x67\x86\x05\x8b\x12\xdf\x11\x81\xbc\xc0\xc1\xa2\x8b\x5d\x5c\xbd\x7b\xdc\xf7\x5a\x96\x24\xd2\x87\x92\xf7\x69\xad\xe0\x34\xc9\x1e\xc9\x5e\xdc\x96\xc3\x3c\x30\xa1\x1e\x01\x99\xeb\xb1\xc0\xda\xc3\xd7\x74\x23\x35\xf9\x52\xe0\x6c\x95\xcc\x68\x52\xd9\xf2\x10\x03\x97\x0c\xa6\xba\xd0\x00\x61\x84\x9d\xb5\x51\xbf\x95\x61\xd2\xb5\xde\x98\x87\xaf\x5b\x46\x41\x12\x94\xce\xba\x41\x52\x0a\xe9\x84\xc9\x0f\x83\x07\xe7\xce\xe7\x3e\xe5\x58\x3e\xae\xa4\x16\xe3\x88\x5b\xac\x15\x26\x94\x5a\xb1\x2a\xd9\x79\x1d\xe0\x64\xa4\x61\x2c\xb3\x00\x10\xc2\x15\xde\x14\xfd\x56\x2b\xb4\x86\x0d\xd6\x95\xe6\x63\x83\xd0\x4f\xb4\x9e\xd9\x15\x4b\x95\xe7\x63\x30\x1d\x6c\xdd\x3d\x18\x7e\x29\xaa\x44\xf8\xb8\x29\x64\xaf\x57\x0e\x09\x8d\x0a\x2a\x4c\x27\x76\x53\x61\x38\x24\x44\xef\xa6\xad\xed\x70\x52\x27\xa4\x37\x17\x40\xe1\xd2\xc1\x46\xf1\x2a\x34\x44\x45\xcd\x97\x76\x44\x94\x51\xd3\xdb\xae\x52\x59\x27\xee\x5a\xde\xd0\x23\x75\xc5\xc1\x15\x99\xe2\xd9\x6f\xee\x5e\x4b\x8e\xbc\x58\x0f\x69\x8f\xdd\x05\xfe\x03\x2b\x6e\x81\xcb\xd5\xa2\x41\xed\x89\xfb\xde\xb9\x77\xfd\x94\xfb\xfa\xaa\x56\x8d\xf9\x0a\x27\x91\x91\xad\xd1\xae\x03\x12\x3e\xcc\xcc\x07\xf6\x1c\x0e\xe2\x44\x73\xde\xac\xdc\xf7\xfe\x8a\x74\x1b\xae\xb2\x5d\x6d\xb3\x5c\x6c\x22\x9d\x61\x7b\xa8\x86\x48\x44\xd6\x14\x17\xea\x85\x54\xdd\xb7\x26\xd7\x2d\xeb\xe5\x18\x77\xd8\x98\x09\x61\x43\xac\xbf\xca\x56\x8e\xbb\xa2\xc8\x08\x10\xf4\xd2\x4f\xc8\x4b\x35\x9f\x9c\x22\xcc\x02\x7e\xb8\x75\xef\x54\xf5\xcd\xaf\xbe\xfc\xfa\x77\x27\x7b\xce\x57\x6f\xe0\x7f\x5f\xbe\x31\x19\xcb\xfe\x84\x27\x26\xdd\x30\xe4\x30\x2a\xd1\x07\x51\x98\x56\x04\x57\x69\x91\x92\x82\xc7\xf2\x09\x96\x53\xa9\x80\x67\x15\xff\x73\x0c\x72\xdf\x19\x7e\x85\xe7\x34\x1c\x58\x18\x8a\x8c\x50\xb2\x90\xfd\x33\x9e\xc4\x61\x3a\xb4\x9e\x8d\x11\x39\x8d\xa0\xdd\xd3\xfa\x41\xa8\x3f\xe5\xd8\xe1\xbc\x45\x7a\xe1\x44\x33\xef\xf8\x67\xe7\x99\xf3\xf2\x48\x2c\xdd\x2c\x48\x0f\x8a\xdf\x3e\xfb\x8a\xea\xc1\xc8\x97\xd2\xfd\x8a\xd0\xf0\x22\x02\xda\x04\x28\xbb\x4d\xcf\x9a\x2c\xb4\x8a\xe9\x24\x39\x5e\xa2\x0f\x49\xc0\x7e\xf6\x92\x2f\x48\x8c\x60\x70\x33\x08\x5d\x92\x2d\x95\x7b\x3f\xcb\xc1\x3d\x87\x74\x2f\x19\xc2\x09\x1a\x8c\x27\x94\xfb\x3b\x01\x3e\x3d\xd0\x1b\xa6\x68\xe1\xa3\x0c\x86\x28\x0a\x76\xbe\x14\x0a\xbd\x00\xfc\xe8\x00\x45\xad\x37\x70\xe1\x2c\x41\xb5\x88\x4c\xc0\x22\x5e\x4a\xfb\x60\xbd\xec\x23\xc7\x6f\xc0\xf0\x07\x35\x75\x4b\x29\x4a\xbf\xe7\x3b\x36\xdd\xee\xc9\xb7\xae\x0b\xbc\xc5\xe3\x3f\x90\x69\x2a\x9e\x54\x15\x8e\xac\x15\x8d\x34\x70\x52\x8b\x76\x90\x2b\xf2\xeb\x7f\xf9\x57\x9c\x57\x35\xbd\xa6\x95\xd5\x10\xe0\x50\x5a\x1f\x35\x30\x06\xfc\x14\x80\x2b\xe3\x21\xda\x63\x7b\xe5\xef\x4e\xe5\xe1\x66\xb8\xfe\x0d\x5c\x2f\x44\x83\x17\x28\x57\xc8\x4b\x9d\x2b\x0a\x8d\xdc\x84\x1c\x00\x4a\x1f\x42\xb3\x17\x08\xa6\xaf\x96\x35\x73\x87\x56\x0a\x74\x90\xe0\xe4\x19\x66\x00\x33\x67\x4d\x77\xab\xb3\x93\x96\x97\x4c\xb7\x49\x7c\xeb\xc0\xf0\x1a\x28\x54\xe6\xd0\x3d\xf3\x3b\x74\xb1\x81\xdd\x7d\x83\xb6\x91\xb8\xe4\xa9\xed\xa5\x93\x76\xc0\xc2\x12\xac\x31\xeb\xc9\x85\x53\x58\xba\x5e\xb0\xf1\x65\x84\x86\x8c\x7e\x35\x93\x4f\xc5\xbd\x73\x2e\x6b\x22\x1a\x47\xce\x19\x69\xab\x88\x6d\x28\xf0\xb4\x71\xae\x00\x5a\xd8\xc6\xc3\x22\xb7\xcd\x00\x20\x72\xfe\x39\x61\xa5\xd8\x00\x83\xab\x87\xc2\x43\xa4\xba\x1a\x3d\x09\x00\x68\x74\x7e\x5c\xdc\xda\x13\x01\xe7\xc2\x45\xc2\x37\x5b\xb8\x87\xfb\xe1\xdc\x5f\xe3\xcd\x56\xc6\xcc\xc0\xc3\xf2\x0b\x54\x47\xd9\xd8\xee\x86\xf9\xfb\xa6\x73\x98\xa9\x09\xb5\x3b\xbe\x37\x40\xbc\xd2\x7e\x04\x28\xe9\x7e\x04\x5a\x73\x0d\x6f\x56\xc1\x4b\x0a\x19\xd9\xe5\x63\xa7\x0c\xd3\x74\xb4\x62\x21\x54\x36\x10\xa5\x70\x7d\x82\x1b\xa2\xf3\x3d\x40\xa5\x78\x42\x38\x92\x48\xab\x97\xf6\x52\xdc\xbd\x70\x33\x96\x77\xa9\x65\xbd\xc5\x4d\x71\xbb\x8b\x73\x07\x3d\x45\xad\xa0\xe1\xd2\x01\x51\x11\xa6\x7a\x37\xa7\xfc\x11\x59\x30\x18\x57\x64\xa9\x01\x09\xfc\xd8\xce\x32\x49\xb8\xe0\xcb\x37\x1d\x7b\x6f\xd1\x9d\xe5\x09\x0a\xce\x01\x81\xcc\x81\x3a\x71\xd1\xed\x09\x94\xfd\x22\xea\x80\x7b\xdc\x64\xe6\xa6\x3d\xca\x41\xd7\x18\x3f\x00\xf7\x2a\xbc\xbf\xc3\x11\x11\xfb\xd7\x99\x8e\xa4\xe3\x35\x2a\x41\xac\x8f\x74\x27\x73\x23\xd9\x77\x0e\x83\x52\xd4\xa3\xa0\xfc\xef\x3a\x51\x6e\xc6\xf4\x97\x87\xf4\xdc\x93\xd5\x6f\xae\xd6\xbe\x41\x56\xa8\x38\x37\xac\x53\x5f\x96\x09\x3b\x11\x09\x0a\x3c\x0d\x45\x3e\xd2\x67\xff\xc3\x1d\x76\xe9\x73\x47\x55\x69\x48\xa0\x20\x3d\x36\xdb\xf5\x3b\x09\x22\x59\xcb\xbb\x4b\xf8\x56\x4c\x75\x2c\x86\x0d\x11\x56\x00\xb4\x88\x2b\xb2\x90\xeb\x8d\xe6\xef\x4e\x49\xcf\x91\x6f\x89\x73\x2f\xa8\x64\xbe\x67\x3a\x7f\x24\xf9\xab\xc8\xd3\xb2\x80\x06\xae\xf3\xf8\x09\x35\x44\x18\x55\x14\x93\x06\x6e\x44\xa4\x9c\xb2\xdd\x03\x51\x86\x0a\x49\xbb\x11\x22\xb9\x08\x92\xdc\x1e\x81\x27\xc2\x5a\xb6\xa3\x6d\x85\xff\xf8\x09\xa0\x4a\xc7\x86\x74\x0d\xea\xb3\x52\x82\x63\xc2\xcd\x45\xdf\x73\x4d\x82\x2a\x6b\xd7\x58\xd9\x2e\x1d\x34\xef\x49\x22\x1d\x30\x8f\x9f\x64\x89\x6f\x0b\x46\x9b\xa7\x14\x13\xef\x29\x6a\x92\xbc\xf5\xca\xcc\xb7\x87\x76\x4e\x5a\xe1\xb2\x7a\x7d\xed\xc0\x2e\xbd\xd7\xbe\x0c\xaa\x29\xea\x2e\x8d\x48\x0b\x53\xc2\x5b\xc1\xef\xa5\x85\x53\x6e\x57\x0d\x6d\xf9\xbc\xae\x83\x2b\x60\xb5\x0e\x12\xfb\x7d\x98\xc6\xf8\x9a\xfb\xbc\x14\x48\x7b\x0c\x08\x4e\x9b\xd2\x50\x6a\x23\xa9\x03\x6f\x23\x73\xc7\xd4\x31\x4d\x62\xf7\x44\x99\x97\x45\xeb\x42\xb6\x24\xcf\x6e\xf6\xdb\x97\xb5\x95\x84\x2d\x51\xa3\x44\xac\x19\x6c\xb9\x25\x7b\xb7\x74\x2a\xda\x62\xe7\x8d\xd7\x3b\x85\x6c\x1e\x54\xd5\x49\xbc\xec\xe1\xd2\x75\x30\xa8\x60\x0a\x11\xde\x39\x77\x6e\xec\xbb\x14\x12\x43\xa6\x9f\x6b\x41\x46\x83\xd6\x23\x56\xe4\x2f\x61\x54\x4f\x78\xe7\xc7\xe8\xcf\x63\x4f\xaf\x1e\x26\x51\xc8\x1d\x79\xbc\xb6\xf1\x51\x92\x54\x0d\x98\xe8\x20\xa5\xb9\xcd\x78\x89\x0a\xe5\x50\x36\xa2\x4e\x70\xdc\x94\x1d\x7a\xeb\x26\x5d\x0c\x30\x43\xb1\x0a\x22\x35\x13\xdd\x02\xb8\xdc\x57\xb4\x7b\x8d\xe5\x1d\x84\xf5\x28\x84\xce\x55\xa6\xf0\xbc\x13\x0f\xa5\x0e\x99\xb9\xfd\xad\xd0\x1d\x55\xc2\x52\xf7\x69\x29\x28\x16\xa9\xde\x12\xb3\xb1\x60\x87\x11\x81\x0d\xc9\xc5\xcb\xdf\x09\x99\x22\x21\x35\xb3\x27\x1c\x4c\x13\xd2\x5c\x66\x3c\xc5\x48\x8b\x58\x41\x1b\x51\x86\x41\x81\x4d\x8b\xa0\x65\x1f\x16\x0d\x47\x3b\x97\x99\xa2\xa9\x4b\xd1\xda\xcd\x21\xbb\xb3\x33\xb5\x9f\x5e\xd3\xad\xce\x74\x10\x66\x3a\xb8\x3a\x55\x14\x19\xd8\xea\x26\x09\x1a\x66\xdb\xa7\x42\xc2\x72\xe9\xaa\xd8\xba\xc9\x19\x68\xf7\xe4\x4a\x88\xdd\x52\x43\x46\xb2\x3d\xc1\x51\x52\x89\x5c\xeb\x73\x9a\x14\xf1\x75\xba\x50\xde\xf0\x30\xa9\xd0\xd1\x7d\x9e\x50\x20\x7a\x11\x12\xb0\x7b\xd6\xe8\x91\x00\x32\x30\x9e\x22\xcd\xfb\xb0\x88\xc2\x16\x54\xa0\xd7\x13\xcc\x9e\x22\x80\x68\x2c\x45\x38\x15\x54\xaa\x68\x9b\x36\x89\x94\x3a\x01\x07\x2a\xf9\x61\x61\x1a\x38\x7c\x4d\x06\xbd\xf2\x96\x85\xe7\xf0\x21\xa3\x05\x14\x0f\x46\x8a\x8f\xc2\x7b\xd2\x45\x59\x7a\x54\xc1\x71\xe7\xa6\x88\xba\x7c\xc9\x98\x2a\xb3\x6e\x99\x8a\x03\xf6\xa3\xa3\x83\x06\x8d\x4e\x4e\x12\xad\xd8\x6f\x63\x8c\xf8\x59\xb9\x31\xa6\xf7\x1f\x48\x2f\x7a\x91\xb5\xc5\x8e\xad\x75\x2c\xa8\xf0\x8a\x97\x39\x29\xb9\x91\x0d\xb8\xb3\xd5\x35\x06\x85\x2d\x0b\xcb\xbf\x75\xfe\x7b\x33\xc4\xb3\xef\x7a\x29\x3e\x67\xe7\xd8\xdf\xc2\xd4\x80\xcf\xf0\xce\xf4\x8d\x33\x3a\x3a\x39\x3e\x35\x2d\x2d\xfc\xed\x78\x36\x9f\x52\x51\x4d\xec\xdd\x37\x19\xc0\x3b\xa3\x53\x2c\xb3\x89\xdd\x34\x5a\xc0\x5e\x1c\x1d\xcf\xcf\xa6\x26\xc0\xf8\x6b\x5f\x90\x27\xa3\xd3\xd1\x9b\xb1\x09\xe4\x74\x3c\x3b\x87\xf1\x8f\xb0\xac\x71\x0f\xa8\x26\x86\xe9\x6f\xcf\x0c\x6f\x1b\xe3\xd0\xcf\xba\x33\x0f\xce\xf0\xea\x46\xf9\x31\x5c\xfd\x24\xd1\x23\xdc\x35\x2b\x86\x0d\x86\xa2\x0c\x49\xa5\x1a\x60\x4b\x80\xfb\x59\xb5\x55\xb7\x1b\x60\x0f\xd3\x07\x2e\x32\x62\x5a\xbb\x93\x96\x7e\xdb\x5c\x3d\x04\xc5\xcd\x8f\x8f\xff\x69\x8b\xb5\x5c\xdb\x84\x32\xfa\xf8\x6f\xb6\xdf\x52\xda\x62\x7f\x52\x54\x29\x13\x2a\x64\x52\x6a\x18\x58\x80\xdd\x8c\x42\x63\x40\xb0\x25\x35\x26\xd1\x05\x4f\x9b\x5c\x75\xa5\xa9\x36\xf8\xec\xce\xba\x73\x79\x74\x30\x06\x20\x1c\x5c\x28\xf2\xfa\x3c\x1e\x47\x10\xa8\x00\xcf\x3c\x22\xcb\x14\x7d\x9c\x5d\xd3\xd9\xcc\x51\x4a\xd5\xca\x39\x6e\x56\x0d\xab\xaa\x14\x14\xd2\x1c\xfd\x3d\xe9\xcb\xf3\x55\x9f\x81\x4c\x2d\x19\xab\x07\xc5\x2a\x1c\x13\x8e\x87\x4a\x44\x26\x85\xbd\xf1\xae\x97\xc7\x36\x1d\xda\xee\x32\xa5\xfa\x42\xa5\xf0\xce\x75\x20\xcc\x31\x4e\xe5\x61\x55\x03\xb0\x6a\x11\x9a\x41\x45\x4b\x60\x59\x81\x8a\x04\x06\x79\x1b\x23\x33\x81\x2a\x60\x97\x59\x4b\x38\x77\x7d\xaf\x1c\xb6\x68\xaa\x06\xc0\xce\x2b\xed\x36\xea\x3e\xb8\x68\x05\x36\xc1\x4d\x64\x06\x03\xb0\x20\xa6\x06\xf6\x54\x69\x09\x56\x01\x47\x2d\xa2\xbb\xb8\xb0\xa5\xe4\x7c\xcc\xb5\x22\x52\x28\x4d\xe1\x61\xf8\x27\x00\xe6\xd2\x04\xe5\x4c\x09\xbd\xb3\x34\x61\xe4\xbb\x03\x2a\x4a\x74\x77\x28\x14\xd5\x42\x6b\x6b\x35\xc5\x6c\x3e\x3e\x4d\xc1\xff\x95\x8d\xaf\xa2\x97\x9b\x87\xd8\xe2\x61\x3f\xd1\x3c\xeb\xed\x00\x30\x62\x42\x4b\x72\x50\xf2\x79\xe5\xa6\x8b\x5b\x63\xf4\x67\x82\xae\xfb\xa4\xf0\xdd\x53\x98\xb3\xaa\xab\x27\x6b\x5e\x99\xd0\x82\xb4\x29\xf7\x44\xee\xa3\x63\x9d\xab\x62\x67\xeb\x75\x21\x9a\x28\x03\x1b\x0b\xa0\x7d\xf0\xd9\x77\xa5\x24\x03\x1f\xe5\x69\xa2\x49\x8a\x4e\x81\x76\xd8\x29\xc2\x82\x6a\x98\x6a\xb9\x8c\x19\x12\x41\xd1\xde\x88\x3b\x93\x09\xa8\xe6\xf7\xdb\xc7\x59\x1a\xa3\x1a\xde\x66\x94\x37\x12\xda\x8e\xbd\x23\x0a\xb8\x01\x61\x57\x9b\x68\x82\xdc\xbb\x99\xb6\x01\x96\x88\xb1\xe0\x29\xee\x65\x9f\xe2\x9f\xa8\x74\x17\x1f\x65\x2c\x59\x05\x86\xb7\x70\x78\xb3\x34\x21\xcb\x78\xe8\x40\x69\x66\xb2\xb9\xb2\x45\x20\x3f\x4d\x68\x4c\x05\x16\x25\x3a\x77\xe9\x87\xb2\xf8\x8a\x44\x87\x81\x6d\x4e\x61\xaf\x96\x8a\x0a\xaa\x4c\x26\x2d\xe1\x9c\xc2\x97\xca\x6a\x9b\xda\x1d\x26\x4f\xbd\x39\x26\x9b\x7c\xe4\x25\x75\x4d\x85\x10\x1b\xfd\xe4\x2d\x64\x15\xcf\x6a\x3e\xf7\xa2\x89\x73\x9b\xad\x45\xd1\xd2\x08\xa2\x1a\x27\xde\x97\x04\xb4\x66\x87\x51\x43\x9c\x19\xae\x58\x0e\x42\xdb\x84\x2c\x2e\xc6\x9e\x3c\xfe\xc2\x52\xad\x5c\x1a\xad\xe0\x20\xec\xa1\x15\x07\xa6\x99\xe9\x3e\x68\xc4\xd0\x72\x76\x3b\x86\x37\x8c\x18\x4a\xba\xf7\xf5\x03\x16\x15\x00\x8d\xc8\x5f\x64\x01\xa8\x51\x16\xb9\xe8\x55\x18\x89\xcc\xbe\xa8\xf8\x89\x14\x50\x2e\xc1\x62\x22\x87\xf2\x09\x16\xb7\x51\x94\x14\xe9\x04\x41\x10\x61\xad\x73\x0a\x4d\xc1\xcf\xfb\xce\x37\x11\x4a\x7e\x72\x10\xbb\x54\x9a\x09\x4e\x09\xdc\x36\x69\xca\xd2\xe0\x5a\x1e\x26\x79\xee\x42\x82\xa1\x6b\x52\x6f\x32\xd6\xad\xbc\x05\xfd\x8a\x4b\xd1\x48\x94\x99\x86\x92\xc2\x4a\x68\x5e\x33\x0c\x2d\xc1\x59\x4d\xb5\xd3\x9b\x4e\x5f\x91\xbd\x2f\x35\x0a\x87\xcd\x0d\x5a\xb0\x0b\x5a\x19\x9f\xc6\x2a\x01\x67\xf5\xf8\xf7\x82\x1c\xa3\x9f\x59\x32\x83\x4d\x36\x8e\x7b\xe3\x1a\xf3\xe4\xa6\x42\x59\x60\x3e\x0c\xc9\x20\xd3\x0a\x50\x65\x6b\x70\xa0\x1e\x5a\x30\xb5\x94\x15\x7d\xbe\xf5\xfa\x9f\xbd\xee\xc0\x5a\x29\xcf\xbc\xb2\x46\x53\x9e\x37\x56\x79\x40\x1c\xbe\xe8\x75\x43\xe6\x24\x50\xa7\x3d\x1c\x52\xaf\x52\xdc\x0a\xc6\xd7\x4b\x1b\x2f\x70\x8f\x62\xa6\xa9\x01\xb0\xa9\x0e\x32\x48\xb2\x2c\x68\x51\xbe\x19\x15\x65\xc4\xe4\x25\x93\x1b\xaf\xb1\x66\x69\xa3\x7a\x41\x54\x2b\x2f\x37\xdd\xac\xfb\x53\x81\x21\x4c\xd2\xce\x40\x21\x61\x1b\xd3\x81\x12\x59\x5a\x1a\xd8\xa0\x69\xb4\x8c\x9f\x17\x55\x39\x88\x26\xcf\xb9\x7c\x51\x4a\xd9\xbb\x7c\x51\xb1\x7d\xe4\x09\x47\xe8\x8f\x90\x01\xbf\xf4\xaa\x69\x4b\x5f\x84\x2d\x15\x3b\xd6\x6b\x81\xce\x88\x3a\xd2\xb2\xbd\xe4\xf7\x28\x8e\x94\x60\xc8\xa3\x81\x81\x0b\xe6\x7d\x2b\xc7\x05\x9a\x7b\x82\x02\x49\x1e\x32\xd7\x7e\xe8\x62\x66\x41\x9e\xec\x86\x87\xf3\x03\x1e\xaa\x67\xb3\x03\x53\x2a\xd7\x44\xab\xd4\x24\x50\x5c\x00\xc5\x21\xed\x61\x0c\xea\xe7\xc3\xa5\x48\xa0\x42\x14\xa8\x9f\x49\xd3\x2c\x12\x6a\x28\xb1\x62\xcc\x4f\x3d\xaf\x54\x06\x57\xfa\x82\x9e\x79\x96\x85\xbe\xca\xc8\x36\x9a\x5d\x5c\x8a\xbe\xf3\xbb\xea\x86\x2b\x1b\x97\xe3\x5e\x83\x9e\xe3\x77\xf0\xb4\xfa\xda\x1d\x7c\xf1\x16\x6e\x65\x3e\x56\xdc\x2b\xd3\xd8\x4d\xe1\xc0\x96\xb8\x3b\xc6\xe0\x94\x90\x75\x52\x1c\x63\xb0\x1e\x86\xd6\xc9\x85\x00\x67\x89\x7b\x13\x46\x70\x19\x5b\x90\x7a\x91\xa4\x9e\x39\x51\x79\xb4\xc4\x29\xd5\xab\xa8\xe8\x6f\xa3\xa2\x28\xd8\x04\x20\xa3\xf7\x50\xb8\x32\xc0\x56\x72\xf0\x77\xd7\x09\xc8\xa0\xb7\x94\xa1\x79\xb8\x15\x2a\xf7\x9f\xca\x75\xc7\xcd\x93\xe1\xf3\x1b\x91\x4c\xf1\x53\x17\xfb\x88\x0f\x8f\xa3\xf1\xc8\xb9\x76\x17\x20\x3e\x8c\x8e\x33\x35\xae\x80\xc9\xe0\x6b\x6f\x5e\x2a\x88\xc2\xf0\x2b\x17\x8d\x40\x14\xf7\x9f\x81\x76\xe5\x50\x11\x5d\x78\x3f\x6e\x1b\x33\x12\x26\x67\xd0\x82\x28\x35\xd7\x96\x10\x91\x17\x6f\x38\x44\x16\xf3\x56\xee\x5d\x6e\x0e\x94\xf2\x71\x6d\x14\xe7\x4d\x18\x61\x32\x01\x92\x7b\x27\x16\x7d\xd2\x4f\xa4\x97\x28\xaf\xaf\x64\xba\xa1\xc7\x11\x48\x1c\xcc\xbb\x5e\xc1\xe1\x0f\x33\xe6\x45\xf7\x61\x10\xb9\xe8\x7b\x93\x72\x09\x15\x00\xb1\xd2\x2e\xb5\x46\x99\x44\xc0\x48\xa6\x04\x91\x2c\xe9\x03\x4b\x24\x5b\x63\xda\x53\x22\xf7\x52\x55\x22\x01\x91\x20\x6c\x17\xb7\xa0\x42\xe4\x15\x38\xca\xe9\x9c\x84\xdc\x28\x95\xe2\x88\xc3\x91\xe9\x72\x44\xb9\xb0\xa0\xa9\xa2\xd7\xd7\x0d\x0e\x9c\x7f\x4e\xb0\x12\x2b\x25\x59\xa1\x2a\x63\x26\x1b\x61\x64\x49\x6e\x2b\xcb\x9d\x83\x04\xc7\x61\x40\xb3\x08\x03\x43\x78\x22\x8c\xc4\x50\x91\xc9\xc6\x8a\x93\x79\xa4\x6b\x51\x24\x96\x6b\x47\x70\xcd\x48\xb6\xa2\x03\xe3\xc2\x1b\x5c\xc3\x19\x05\x1b\x62\x74\xa3\x54\xce\x68\x82\xe0\x29\xae\xd3\x98\xe2\x79\x81\x2b\xc9\x24\xc4\x10\x7b\xec\xf3\x1a\x68\xa2\x26\x0f\x66\x50\x1c\xd7\x72\x60\x0f\xc9\xab\xa6\xaa\x4c\x2a\x53\x7c\x90\x61\xc5\x2e\xac\xde\x80\xc5\xa1\x70\xbe\x30\x55\x1c\x27\xd7\x5f\x81\x7a\x09\x33\x0d\x2a\x20\x2e\xb4\x24\x71\x1f\xc4\x07\xb3\xf8\x23\x25\xd3\x94\x8f\x93\x6b\x88\xa6\xca\x0b\xe7\x59\x2c\xbd\xd3\xf9\x65\xb3\x1c\x06\x62\x2e\x9e\x80\xaf\x8a\x4a\x40\x77\xfd\x5d\x5b\xac\xa5\x2b\x6e\x3f\xa4\xb5\x57\x0d\x38\x93\x5b\x6c\x43\x21\x5b\x56\x61\x20\x0e\xb6\x2b\x50\xa1\xae\x94\xda\xc4\x2a\x89\xac\xed\x63\x32\x30\x84\x77\xd1\x83\xe0\xbc\xbc\x5c\x3e\xac\x11\x78\x16\xca\xc6\x4d\x28\x52\x2a\xf6\x26\xd5\xe0\xc0\x4f\x64\x7d\x16\x3d\x2a\x36\xd1\x6a\x06\xe8\xed\xae\x90\x18\x37\x34\x1b\x66\x78\x44\x58\x87\x82\x11\x3a\x2f\x71\x5b\xe2\xd0\xf0\x5f\x3e\x84\xd4\x42\xfc\xe2\xc0\x58\x67\xb4\x7d\x44\x3a\x45\xa0\x90\xe0\x31\xf0\x92\x36\x2d\x8e\x0a\xc9\xce\x97\xfa\x17\xd8\xb8\xa5\x99\x54\x2e\x25\x7f\x84\x2e\x7e\x5f\xf9\x87\xe8\xbb\x5e\xbe\x37\x57\xb9\xf2\x95\x23\x82\x4a\x6b\x55\x61\xd9\xb8\xe1\x98\x1e\x9c\x73\x0a\x69\x51\xe9\x17\xb0\x38\x40\xa5\x51\x55\x00\x30\xb8\xf4\xa5\x78\xaf\x2a\xfc\x91\x5b\x3d\xa2\xb2\xc3\xe8\xce\x80\x1b\x27\x1f\xea\x04\x81\x2e\x9e\x70\x48\x29\x8f\x0c\x51\x66\x4e\x37\x45\xec\x40\x1c\x07\xc9\x08\x2e\x9a\x50\xbe\xb3\xa9\x85\xc4\xbe\x09\x2a\x2b\x00\x8c\x4f\x7c\x8e\x04\x20\xaa\x40\x4f\x56\x1e\x7b\x7c\x85\x3a\x52\x31\x47\x74\xc7\x0c\x4a\x1b\x15\x8c\x63\xca\x14\xb5\x62\x07\xdf\x2f\x9f\x93\x21\xf2\x4a\xdb\xc0\x8a\x27\xe6\x44\x65\x45\xd9\x5e\x1d\x1b\x97\xa3\xc5\x85\x71\x3a\xfe\xd3\xc5\x78\x36\x37\xf9\x3f\x8f\xc6\x27\xa3\xd3\xa3\xb1\xf1\xd0\x96\x8e\x7f\x63\xaa\x23\xf6\xe0\x87\x9f\xcd\xef\x9f\x4d\xc6\x33\xb3\x78\xa0\x9f\xcd\x5b\x7b\x7a\x76\x31\x1f\xf7\x8b\xba\x98\xc2\x5e\x1f\x52\x31\x8f\x22\xfb\x09\x37\x9b\x1f\x2e\x23\x3a\x8f\xf1\x9a\x18\xb7\x54\x46\x1e\xb1\xf1\x1a\x6b\x38\xa1\xb1\x17\xaf\x5f\x22\x43\x19\x48\x86\x21\x6e\xa9\x45\x72\x95\x02\xfa\xdf\x3b\x31\x27\x1b\x34\x94\x45\x34\x8e\x4a\xb8\x78\xbb\xf1\x04\x7a\x1c\x81\xb8\x35\x1c\x13\x42\xd6\x13\x4f\xfe\xc0\x1a\xc0\x6a\x6d\x2e\xca\xff\x36\x02\x7a\xa4\x95\xe8\x2e\x76\x7d\x5a\xbb\x89\x3c\xde\x63\xbd\x86\x24\xc2\x16\x01\xd5\xe8\xfb\x83\xa3\x03\xb6\xa0\x4b\x9a\x9c\x4f\x22\xf8\x9b\xdb\x5b\xe4\x7f\x2a\xc1\x8a\xd5\xb4\x41\xf5\x7d\x40\xcb\xd3\x0d\xee\xcd\x68\xe1\xbb\x4a\x83\x03\xfd\xe7\x0f\x9b\x0d\xa0\x1d\x2b\xb0\x3d\xbf\x50\x91\x42\xba\xe2\x34\x7d\xc2\x8e\x09\x15\x7f\x30\x2d\xc5\x7e\xc3\x7b\x12\xe2\xff\xd0\x4a\x9a\xb4\x56\x37\x84\xcd\x96\xca\xd2\x73\x02\xb5\xb2\x5c\x9f\x05\x5e\xdd\x78\x0d\x8b\x1e\x53\xbf\xc4\x7d\xed\xa7\x3f\x5c\x66\x5f\x7e\xf9\x5b\x93\xd1\xad\x71\x70\xd2\xbe\xdd\x45\x95\x2c\x59\x14\x88\x76\xd2\x28\x23\xdb\x40\x9c\xa3\xa8\x6b\xe3\xd2\x9a\xd4\xb4\xa6\x48\xe7\xb2\x86\xc8\x6c\x3a\x0c\xa2\xcc\xc3\xc6\x44\xa1\x17\x3f\xf4\x9a\x53\xc2\xd3\x12\xd9\x5c\xc1\x26\x87\x5f\xc2\xd7\x31\xdf\xe5\x91\xa8\x98\xe7\xba\x53\x66\x57\x03\xa9\x07\x4a\xd7\x50\xf5\x1b\xc5\x42\xf8\x77\x64\xa0\x2f\xfa\x86\x2d\xf2\xf6\x5f\xb2\xf2\x96\xc9\x52\x6f\x6c\x13\x16\x8b\xc7\xff\xca\xcc\x0d\x3c\xa6\x18\xeb\x9a\x00\x5e\x60\xa0\xbc\x69\x15\x15\x44\xb9\x30\xbe\x8f\x5d\x56\xa9\xbf\x55\xd2\xc0\x3b\xea\x2a\x72\x8d\x17\x35\xa5\xc9\xae\x5c\x2a\x74\x26\x8d\x3c\xac\xaf\x57\xf2\x11\x8c\x56\xfb\xd4\x8f\xd9\x97\xaf\xf5\xe9\x4c\x50\xf4\x62\xc3\x2a\x3c\x46\x96\x2e\x3b\xf1\x97\xee\xe3\x7f\x45\x64\x19\x91\xf4\xcb\x4b\x37\x51\xe2\x89\xa2\x6b\x54\x99\xd8\x84\x23\x39\x58\x71\x66\x87\x6d\x63\xde\xc3\x06\xcc\x2a\x6a\x77\x7d\x36\xae\x35\x57\x00\xfb\x95\xb1\x50\xb2\xad\x5a\x81\xda\x14\x31\xa0\xad\x09\xa3\xe1\xba\x03\x95\x2c\x4b\x8c\x3d\xfe\x68\x26\xb8\xfa\x9a\x0d\xbe\x7f\x70\x8c\x32\x03\xe0\xb1\x76\x57\x5d\xcc\xf1\x66\xb1\x2c\x6d\x2f\xd1\x86\x2d\x77\x55\x7d\x12\xf9\x1d\x6f\x70\x31\x9d\xc8\xa2\xe8\xdd\x21\x0d\x0a\x29\xb5\x68\xd0\x72\xa3\xd9\x43\x05\x2b\xab\x03\x2f\x66\x65\x93\x61\xd1\xbf\x0e\x64\x24\x56\x3d\x25\xba\x1d\x75\x58\x0a\x08\xb7\x18\xa7\x31\x0c\xbc\x0b\x0f\x6a\xa0\x9b\x4f\x67\xe9\xf2\xd6\x6b\x52\xab\x29\x0b\x64\xff\x76\x63\xfd\x5c\xa9\x26\x05\xe3\x35\x2b\xaa\xc6\x69\xbe\x92\x4b\x12\xcf\x0b\xfc\xa0\x34\x40\x3a\x41\x0e\x39\x88\xe2\x02\xc6\xd4\x66\x5e\x81\x81\xc5\x58\x10\x88\xf7\xac\x91\x95\x25\x0a\xeb\x8b\xa9\x44\x6a\x93\x43\xb2\x42\x77\x7e\xd3\xab\x90\xae\x87\x66\x35\x8d\xa1\x9d\xa7\x71\xa9\xfd\x26\x33\x92\xea\x96\x62\x6f\x1d\x5a\xc0\x0c\x49\x63\x26\x7f\x0d\xa4\x95\xd9\xc9\x5f\x13\x65\x1b\x33\x34\x93\x2b\xa5\x20\x88\xae\xb8\xfa\x1a\xa9\xd2\x65\xe0\x5c\x99\x48\x9d\x77\x65\x3a\x3f\x2b\xf7\x7e\x4d\x4c\xda\x96\x11\x19\xab\xfb\xd4\x12\x75\x57\xfb\x11\xb1\x87\x1d\xb6\xce\xf2\x66\xac\xd0\x51\x0b\x4a\x7b\xa2\x4d\x57\x26\xb4\x0f\xab\x36\x1b\x58\x0b\x16\xee\x7d\x5e\x94\x92\x30\x42\x0f\xb1\xbb\x37\x49\xe7\xc6\x4a\x12\x1d\xf0\x2d\xd5\xa3\x02\x49\x2f\x45\xa5\x82\xa4\xab\x9c\x7e\x81\xa6\x4f\xed\xfc\x02\x4d\x5b\xfb\x16\x6d\x08\xad\x09\x80\x0a\x5a\xbb\xa6\xa1\x11\x6a\xa3\x58\x28\x90\x2d\xbd\x0c\x74\x90\x16\xad\x2c\x08\xa6\xb4\xdd\x97\x77\x43\x7e\xd3\x7e\xca\xdd\x7a\x48\x8e\x04\x0e\x40\xca\xf2\xe6\xfa\xe6\x2d\x2a\xc2\x32\x51\xcf\xbc\x65\x25\xaf\x8a\x62\xa2\x6c\x0b\xf8\x46\xfd\x5d\x65\x5d\xe5\x87\x5e\x7c\x68\xae\x27\x6a\xc0\x98\xf3\xa5\x01\x63\xfb\x58\x6a\x73\x5a\x9d\xf7\xad\x27\xb3\x25\xf7\xa7\x32\x9b\x5b\x4c\x49\x59\xfe\x48\x2e\x59\x8e\xa8\xcf\x9c\x34\x8a\xad\x12\x36\xeb\x41\x59\x8e\xa8\x66\xc9\xa8\x9a\xc0\x9e\x58\xbb\x6d\x64\x83\x91\xb8\x7c\xf4\x15\xeb\xcb\xb3\xeb\xb3\x8a\x8b\x0a\x24\x9a\xec\x34\xa8\x05\x13\xb5\x2f\x9b\x58\xb8\x2d\xaf\x44\x69\x60\x15\x2a\x0a\x6e\x69\x5f\x76\xf2\x6a\x43\x8e\xac\x23\x8b\xa8\xc4\xf2\xc5\xde\x0c\x0a\xfd\x02\x2a\xe6\x7c\x36\xfb\x96\x43\xf4\x82\xe8\x9e\xa3\x5a\xdb\xcf\xd0\x63\x2e\x87\x8d\x31\xe4\xf8\x2a\x79\x98\x32\xec\xc2\x91\xa8\xe8\x8b\xee\xc3\xb5\x91\x02\xee\x80\xe9\x61\xc4\x4f\xa5\x44\xae\x0c\x16\xa5\x7e\x0e\xad\xba\x43\x13\x6d\x58\xa4\xad\xa0\xac\xac\x52\x70\xf4\x0f\xea\xd8\x56\x3d\x65\xa6\xb9\x8d\xc5\x18\xc0\x32\x2d\xcd\x80\xd1\xfd\x24\xe3\xb6\xd6\x89\xc8\xbc\x68\x98\xa6\x0f\xc4\xff\xd6\xc8\xd7\x23\xb6\x14\x51\xc1\xab\xfc\x59\x1d\x82\x09\x15\xa6\x10\x75\xaa\x32\x2a\x97\xa7\x87\x3a\xa3\x52\x93\x9e\xf1\xa6\x5e\xae\x04\xf0\x4c\xd7\x01\xdb\x1d\xca\xd9\x7e\x1d\x7c\x56\xa5\x7b\x7b\xb1\x39\xa6\xf8\x8c\x26\x97\x02\x16\x32\x5c\x9a\x0d\x11\x96\x67\x65\x4e\x56\xbd\x76\x7b\x19\x57\xa7\x7a\xd7\xef\xac\x4c\x63\x5f\xb0\x21\x0a\x43\xdb\xef\x7c\x2f\x73\x83\x3c\x9a\x89\x3a\xe2\x90\xc7\x0e\xd0\xa7\x99\x29\x42\x62\xfc\x1e\x2f\x56\xdc\xa0\x5c\x2b\xca\xe6\x69\xe1\x47\x0a\xb8\x08\x64\x0c\x9c\x60\x90\x66\xfb\x58\x4e\x98\x47\x35\xae\x03\x97\x93\x7f\xce\x46\x79\x2f\xa4\x3c\xfd\x25\x6f\xb2\xc9\x01\x6a\x5d\x54\x0a\xf2\xc7\xcb\x08\x3d\xc1\x9d\x92\x24\x5c\x55\x98\x5e\x42\xea\xea\xa0\x67\xa4\x92\x7b\x06\xc3\x2c\x0d\x12\xea\xff\xbc\xef\x38\x23\xac\x86\x49\xb2\xf6\x56\xb8\x01\xe0\xa2\x4a\x71\xc4\x56\x0c\xdc\x5c\x67\x45\x3a\x0f\x35\x07\x48\xf2\x98\x3b\x73\x90\x6b\xf3\x90\x06\x32\x5b\x4a\xcd\xc3\x4d\x10\x5d\xc3\xa4\xca\x28\x9a\x7a\x5a\x2a\x9b\xc6\xf7\x9d\x39\xdd\x88\x39\x00\x3a\xe1\x30\xb9\x05\x76\x3d\x8a\x39\xc5\x3d\x9f\x31\x8c\xda\x74\xd1\x74\x2e\x6b\x83\x94\xc1\xa1\x4c\x95\x3e\xcf\x96\x2a\x7b\x1d\x9c\x03\x91\xd1\xc4\xb9\x0a\x9f\xc8\x79\xff\xa4\x7c\x2a\x89\xae\x36\x46\xc9\x4a\x47\xe5\x3a\x7c\xbb\xe0\x84\xd4\x13\x2d\xb8\x91\xdf\xed\x9f\x8c\x23\x85\xd6\xca\xac\x68\xe1\x84\xe6\xb1\xd9\x21\x17\x86\xef\xc4\xc3\xaf\x82\x13\x64\x41\xaa\x96\xc2\x52\x3e\xa6\x67\x64\x0b\x9e\x98\x36\x0c\xa1\x23\xf6\x69\xb7\x4a\xa9\x7b\x79\xdb\x1e\x91\x0f\xee\x86\x01\xd8\x2a\x37\x67\x80\x79\xfc\xaa\xa3\xee\x53\x2e\x07\xea\x94\xdb\x2d\x23\xdc\xa2\xa5\x6e\x8f\xe1\xe7\x41\xfd\xda\xc9\x9c\xe8\x47\x33\xfe\x28\xdc\x05\xe7\xcd\x0d\xf5\x3e\xf6\x5d\x03\x2d\xc5\xea\xeb\xf9\x6d\xfa\xf9\x5d\x39\xb4\x51\x6f\xbf\xc5\x30\xf6\xe2\x09\xcc\x9c\x73\x8b\xde\x06\xac\xf2\xe7\xad\x9a\x34\xb5\xa0\x63\xa4\x4d\xd9\xd8\x1b\x57\x18\x28\x06\x29\xf4\x34\xeb\x1d\x15\x0f\x68\xa5\x79\xe3\xaa\x01\xdb\xd0\x6c\x55\x10\xa0\x44\x76\x9c\x05\x5a\xb7\x62\x96\x9e\xe5\xfa\x93\xd5\xe0\xad\x5c\xa0\x74\xd3\x9f\xc0\x6d\xf8\x97\x9b\xa0\xd6\xb2\xb8\xb9\x71\x67\x11\xa7\xa5\x87\x61\xb6\x8e\x81\x0c\x14\xf9\xfa\xc7\x11\xe0\xf2\xc7\x5a\x59\x72\xf1\x27\x3d\xac\x6f\x3a\xe3\x8b\x75\xae\x95\xf8\x56\x6b\xbd\x08\x29\x13\x89\x74\xba\x6a\xeb\x7b\x13\x1b\x5c\xc3\x60\xe0\xd5\xd7\x3c\x86\xd7\x30\xa4\x5e\x66\xc4\xe6\x81\xd4\x00\x6e\x45\xe8\x66\xdb\xb4\xef\x20\x58\xb4\x94\x6b\x24\xf4\xde\xbc\x6d\xe3\xec\x5e\x5e\x9b\xed\xed\x67\x1b\x68\x65\xc7\x6f\x32\x56\xe5\x08\xfb\x36\x4a\x52\x69\xf4\x86\xbf\x8e\xa8\x88\xb8\xbc\x56\xc2\xdf\x63\x0a\x27\xa6\x3b\x68\xbf\xa8\xdb\x6e\xf0\xaf\x7e\x56\x55\xe3\x77\x82\x88\x3e\x00\xac\x7b\x97\xc3\xa7\xaf\x29\x67\x27\xad\xd7\x01\x68\x88\x5b\x04\xe2\x36\x43\xca\xee\x51\xdb\x84\x82\x8a\x57\xd5\x26\x77\xa0\x82\x49\xcb\xe8\xed\x33\x3e\x39\x01\xfd\xc7\x28\x0b\x3c\xe7\xfc\x8d\xdf\xe0\x9f\x18\x68\xae\x1a\x09\xf6\x87\x69\x62\x90\xf9\x15\xdc\x74\x18\xbc\x73\x31\x3d\x56\xbd\x50\xf3\xdc\x2a\x3d\x93\x5e\x75\x4c\xc0\xcd\x8a\xcf\xa2\x75\x14\x83\xb3\x17\x18\x5c\x69\x4c\x27\x86\x07\x65\xc2\x25\xc7\x2d\xa1\x29\x46\xb5\x4a\xdd\x77\x6a\x69\xf8\xe5\xb6\x09\xc1\x40\x47\x04\xfb\x0f\xf7\xa7\x71\xcf\xe1\xa9\x6b\x34\x5f\xd2\x91\x69\x7a\x91\x45\xec\x58\x93\x3c\x6f\x95\xe4\xa1\x29\x31\x36\xb2\x7d\x53\x1c\xba\x96\x82\xd3\x64\x3a\x9d\x8d\x0f\x61\xac\xf3\xef\x9d\x37\xd3\xb3\x8b\x73\x13\x3a\xfc\x8d\x4a\x02\xca\xc7\xc7\x46\x68\xd3\xb7\xc7\x87\xe3\x5e\x05\x11\x2f\x1c\xf5\x56\x2b\xcc\x7e\xf9\x01\xb3\xf3\x51\x4f\x32\xb0\xdc\xe1\x98\x5f\x6b\x05\xd9\xa3\x26\xa3\x05\xb8\xa3\xf1\xdb\xf1\xe4\xec\xdc\x58\x91\x51\xfe\x7e\xde\x07\x66\xcf\x1a\x8f\xdd\x10\x4d\xac\x1f\xcb\x5f\x9b\xdf\x9c\x7d\x2b\x33\xe2\x36\x72\x3d\x5c\xc8\x80\x1d\x69\x99\x46\x68\xb4\x47\xb7\x74\x39\xcc\x40\x6a\x3c\xab\x91\xfd\x44\x76\xd7\x0e\x06\x98\x53\x4b\x79\x7d\xbf\x2e\x43\xfb\x4c\x5d\x11\xac\x25\x8e\xa6\xe6\x1b\x4a\x29\xce\xca\x85\x8a\x81\x16\x75\x11\xb9\xba\x91\x47\x8d\x6d\x42\x54\x63\x11\xe3\x26\x80\x16\x49\x52\x16\x64\xc1\x77\xd4\x42\xfc\x6a\xd5\xd1\x23\xef\x8d\x2d\x5d\x0d\x10\x0d\xc4\x61\x22\x52\x1e\x15\xfc\x12\x6e\x71\x64\xde\x70\xb0\xf9\x20\x55\x3a\x4b\xde\xf9\xeb\x2f\x4c\xf3\x33\x7b\xfc\x84\xef\xfb\x28\xfd\x3f\x68\x2e\xc3\x97\x51\x86\x8b\x3d\x7b\x80\x6f\x13\xd8\x25\x63\x2c\x67\xa5\xca\xb9\xfb\x37\x61\x14\x8b\xf8\x0b\xf3\xe9\x20\x89\xe2\xcd\xb1\x2d\x4d\x95\x18\x9c\x6d\x49\xa3\x9e\x92\xc4\xdb\x3d\xfe\x87\x7a\x6d\x1f\x38\x5f\x7d\xf9\xe5\xd7\x7b\xce\x4a\x35\x3c\x94\xb5\xab\x50\x85\xd0\x02\xae\xaf\xc5\xc2\xcd\xb8\x3e\x49\x5e\x2f\x75\xad\x95\x97\x34\x07\x15\xd9\x90\x23\xaf\x7e\x4c\xcf\xef\xbe\xfc\x6d\x8d\x40\xfc\x2a\xa7\x10\x3b\x7a\xa9\xe2\x48\xa0\x74\xdc\x46\xb1\xff\x81\xab\x23\xad\x65\xb1\x33\xba\x91\xe5\x55\x4a\xf8\x86\x61\x12\xca\xd4\xe3\x5e\xd9\x32\xe1\xe3\x1e\xb7\x20\xf7\xf2\xfb\xa3\xa4\x88\xbf\x1d\x08\x7e\xbe\x4c\x13\x3c\x43\x6a\x51\x38\x78\xfc\x7b\x4a\x65\xa2\x12\xcd\x2b\x0d\xe2\x4c\xb6\xf1\x92\x4d\xb4\xa4\x94\xe6\xa2\x27\xa6\x6b\x7e\x3b\x87\x0e\x9c\x11\x27\xf2\x61\xcf\x4d\x11\x52\x1b\x21\x62\x8c\x17\x11\x5f\xa8\x8a\xf7\x3a\xf6\xef\xfc\x40\xc8\x64\x6b\xf1\x1e\xf6\x1a\xe5\x78\xf9\x49\x57\xc5\x28\x4b\xae\xc0\x7f\xf3\xa6\x60\x68\xd5\x8b\xc5\x32\x4b\xd0\x04\xaa\x6a\x4a\xc9\x16\xad\x1f\x64\x39\x97\x44\x92\x04\x6a\x1e\x7e\x16\x31\xd6\x98\x72\x75\xdd\x0b\x2b\x90\x52\x5e\x69\x57\x0d\xa9\x16\xf6\xe0\x45\x2a\x8e\x67\xf4\xd5\x21\x7c\xf3\xf1\x63\x79\x3d\xf1\xef\xa3\xb5\x3f\xc6\x2f\xd5\x13\x2b\xad\xe3\x27\xfc\x50\xca\xe2\xda\x82\x4b\x4d\xc4\x94\x97\x52\x07\x41\x4e\x33\x45\x46\xa6\xe0\x2d\x88\x1c\x7a\x73\x72\x14\xc2\xbb\x13\xf7\x5a\x04\x2c\x5a\x55\xf1\x82\xda\x89\x62\xac\x25\xa3\x9c\x84\xd4\xe9\xf5\x36\xb7\x04\xcb\x2b\xbb\x16\xca\xd3\x8c\xc5\xa6\x10\xb1\xa2\xfa\x9b\x3c\xfc\xaa\x31\x0b\xb8\x85\x44\x53\x60\x55\x43\x42\x70\x17\x11\xea\xb6\xa8\x84\x1c\x09\x3c\x55\xcd\xbf\xbd\xe0\x4e\x25\x50\xb4\xa8\x00\x5d\xaa\xd8\x3f\xe8\x4e\x52\x98\x75\x67\xf1\x75\x5d\x3d\x8f\xad\xb2\xf3\xba\x0b\x0c\x36\x91\xd2\x78\xaf\xb6\x2e\x5a\xdd\xa7\x23\x4a\xaf\x99\x53\x80\x0f\x6a\x81\x65\x3d\x78\xd4\xf0\x72\x2b\x52\x53\xf3\x99\x86\x6a\x95\x5b\x9b\x28\x26\x75\xbf\x5b\x13\xea\x86\xd2\x96\xbd\x98\x6e\x54\x7c\x2b\x09\x99\xe5\x21\x5e\x86\xf3\xe3\xf3\x03\xe7\x78\x89\x85\xbf\xe8\x78\x4e\xe3\x07\x32\x22\x46\x32\xa3\xd3\x75\xee\xbe\xaa\xa5\x75\xee\xd1\xe3\xd4\x9f\x53\x19\x2d\x86\x6b\xb2\x64\xb7\x94\x3d\xaf\x25\x6c\xea\x43\xbe\x0c\x47\xb3\xf9\xc5\x21\x26\xdf\xe7\x15\x0b\xb8\xa2\x0b\xa5\x9a\x71\xd6\x67\x73\x83\x1c\xaf\xa8\x7e\xf4\xd5\x1e\xbf\x9a\xb7\xdb\x54\x96\x0e\xcd\xda\x3d\x5c\x77\x2d\xc9\x9c\x57\x5d\xdb\xf5\xac\x46\x8b\xfd\xd6\xac\x85\x51\x5a\x8b\x4d\x63\x20\x66\x8f\x6d\xa7\x6f\x18\x9b\x33\x73\xd6\xb0\xd1\xec\x4f\xb6\x7e\x66\x33\xf5\x92\x51\xe1\x56\xcc\x36\xde\xcb\xd2\x6a\x3a\x1c\xbb\x8b\xda\x82\xac\x8e\x8a\x66\xa2\x2d\xa9\x71\xf9\xe5\xbc\x3b\x06\x0b\xa9\x50\x35\x3d\x30\xf0\x2e\x00\x9d\x08\xb6\xd9\xe4\xec\x70\x34\x19\xe3\x31\x35\x38\x9c\x8c\x47\xd3\xc1\x1e\x5e\x36\xee\x7c\x72\x34\xd1\x63\xac\x1b\x62\x5e\xbf\x51\xcf\x93\xc4\xaa\x82\x96\x25\x12\x09\x88\x5e\xce\x63\xdf\x99\xf9\x0a\xb4\x2b\x2b\xf1\x71\xc7\xfc\x9c\x02\x03\x0c\xcc\x4d\x7d\xfc\x44\x35\xaf\x4b\xce\x5f\xf3\xda\x4a\x65\xa8\xd0\x15\x95\x2b\xbe\x4a\x1f\xd6\x32\x24\x0b\x15\x59\xae\x9e\x3a\xc0\x30\x4e\x6e\x24\x1d\x46\xa1\x30\xf6\x8f\x22\x7f\x15\xc7\x3b\x11\x18\xd4\xbd\xf2\x92\x73\x54\xc0\x16\xee\xa2\x37\x7c\x23\x05\x55\x5d\x81\xcd\x14\x58\x23\x85\x80\xf9\xce\x17\xf7\x45\xf5\x50\x1f\x53\x45\xbb\x96\x05\x4a\xc7\xc2\xb9\xee\x7a\xe4\x93\x77\x28\x47\x14\x0d\x1d\x68\x83\x6d\x2b\x11\x5a\x42\x7c\x5b\xb4\xb2\x2a\x35\xb5\xec\x47\x43\xb5\x7f\x65\x6e\x2f\x91\x4d\xad\x8c\x84\xc8\xba\x4d\x7a\x9a\x2a\x45\x46\x8f\xe5\x9f\x6d\x86\x9e\x23\xbd\xae\x50\xd6\x90\xa4\x5a\x83\xd3\x4a\x45\x69\x8f\x62\xbd\xb0\x3c\x5b\x92\xba\x03\xc9\x6f\xde\xba\x41\x26\xb8\x96\x59\xbd\xef\xeb\x93\xd9\xb4\x8e\xca\x25\x94\xda\xd2\x3c\x2b\x94\xcb\x9a\x79\xf9\x36\xab\x8c\xa2\xa3\x01\xed\x67\xb0\x8d\xf1\x64\x34\x56\xe5\x91\x15\x67\x1a\xe2\xe3\x6d\x3c\x85\x95\xe5\xd2\x88\xa1\x29\x10\xad\x2d\xf6\xdd\xc2\xeb\xab\x46\xb4\x13\xdf\x74\x65\x0c\x3b\x75\x4f\x2b\x42\x9f\xdc\x37\x5d\x19\xc4\x53\x39\xa7\xfb\x8f\x72\xa7\x8e\xe9\x2d\x47\xd9\xc3\x33\x6d\x18\xe8\x2d\x6a\xd0\x2e\x99\x4b\xb0\x66\x08\xb7\xb5\xe6\x20\x94\xd6\x14\xbe\x73\x37\x46\xdf\x1d\x05\x1e\xa9\x5e\xd8\x08\x04\x63\x4c\x50\x98\x58\x66\xf6\x21\x7e\xd6\xf1\x09\x6f\xd5\x27\x2e\x8b\xde\x6d\xbc\x9b\x25\x95\xc8\x4f\x45\x64\x15\x05\x8b\xbe\xdd\x6e\xe6\xdb\xe8\xbe\xa8\xde\x57\x8e\xf5\x31\x29\x0f\xea\x94\x34\xf5\x07\xe4\x30\xb8\x36\x7c\x41\x50\x69\xb0\xd7\xa9\x41\xea\x25\x72\x55\xfc\x8d\x79\xb1\xf5\xd1\x24\x91\xa0\x5b\x11\x74\x22\x86\x33\xc5\x37\x96\x9a\x21\x28\x5a\xcd\x2f\x1e\x90\x0c\x34\x7c\xe9\x16\x11\x87\xb8\x7c\xc5\x90\xab\xc6\x52\x79\x5d\xee\x8d\xb8\x07\x2f\xab\x82\x76\xb8\x96\xd7\x02\xfb\x1c\xa1\x90\x95\x3f\x73\x8f\x32\xf8\x29\xce\x88\x4d\x89\xa9\x88\x5d\x41\x2f\x5d\x98\xb4\x2a\x64\x39\x53\x28\xe0\xf0\x65\xfe\x09\xb5\x4f\xac\x4a\x93\x97\x8e\x16\x45\x89\x5e\xd4\x52\xf3\x6a\xb3\x09\x13\x89\x0b\xac\xf4\x7c\xa9\xd4\xf4\x1e\xd5\x79\xa7\x96\x7d\x85\xf9\x12\xad\x9c\xba\x67\xcd\x54\xf7\x8e\xd8\xa8\x6a\xb0\xf5\x1e\x60\x52\x3f\xea\x3a\xd0\xa0\x21\x2b\xc1\xda\xb2\x68\xcf\xb7\xc1\xa7\xd9\xa9\x1a\xca\xb8\xd1\xc5\x80\x6b\x07\xb4\x20\xa6\x9a\x57\x9e\x48\x5d\x3f\x90\x0b\xff\xff\x63\xee\xeb\x96\xe3\x36\x92\x74\xef\xcf\x53\xe0\x6c\xac\x83\x9a\xd8\x26\xc7\x76\xcc\x95\x7c\xb1\xc1\xa1\x28\x0d\x37\x44\x52\x23\x36\x3d\xeb\xb1\x1d\x1a\x34\x1b\x24\x31\x6e\x02\x3d\x28\x80\x14\xe5\xf0\x03\xec\x5b\xec\xa5\xb5\x17\x7b\xb5\x4f\xb0\x7a\xb1\xad\xfc\xa9\x3f\xa0\xb2\x80\x6e\x52\xb2\xe2\xc4\xd9\xb1\xd8\xa8\xac\x44\xa1\x2a\x2b\x2b\x2b\xf3\xfb\x7c\x0a\x86\x7e\x30\x60\x8a\x56\xc0\x23\x82\xd2\x10\x32\x19\xe5\xdb\x8f\x3d\x3c\xd1\x4f\xa1\x66\x40\x45\xc9\xa1\xd8\xea\x53\x58\x54\xcc\x84\xf8\xa6\xb8\x40\x8a\x2d\xed\x72\x16\xb7\xb0\x6b\x4d\xe9\xe5\xc3\x7b\x6d\xb6\x69\x95\xab\xf0\xba\x16\xc1\x7e\x0a\x99\xba\x0a\xfb\x1c\xc4\x9b\x1e\x30\xd1\xa6\x17\xc2\x07\x5d\x43\x74\x6c\xfb\x5e\x87\xe1\xae\x54\x97\x94\xe7\xbd\xfd\x2b\x26\x73\x2e\xbd\x2e\x1e\x63\xa6\x2c\x27\xf7\xf6\x08\xab\x96\xbb\x9a\xb2\x5e\xc1\x0a\xdb\x8a\x22\x3c\xe7\x53\x79\xd7\xa7\x39\x27\xd1\x7b\xd8\x22\x30\x9b\x00\x60\x2b\x91\x3e\xb3\x4c\x00\x1e\xb0\x61\x4d\xd3\xe3\x9c\x2e\xa7\x38\x52\xe1\x90\xd9\xca\xa4\xa2\x0d\x0f\x18\x9f\x0b\x6e\xc9\xd9\x4f\xe5\x9a\xd1\x6a\x0d\x7c\x00\xde\x2e\xb7\x75\x0a\xfb\xe9\x88\xee\xb6\xe1\x2d\xf0\x1a\xd5\xde\x3e\x31\x12\xd4\x60\x6b\x1a\x40\xd8\x24\xb4\xb9\xae\xb5\x4b\x00\x76\x0a\x71\xf6\xf2\xc4\x4d\xb1\x55\x23\xf7\x9e\x0d\xea\x61\x76\xae\x3f\xfc\x8f\x88\x1d\x8d\xbd\x05\x34\x72\x7c\x70\x81\x60\x87\x09\xa0\xec\x65\xc0\x79\xac\x77\x0b\xc0\xe1\xa8\x96\xc5\xf2\xff\x6f\x16\xf0\x4c\xe5\xa6\x53\x64\x48\x6e\x97\x7d\x54\xc8\xe8\xa5\x37\x89\x36\xc5\x8e\xf6\xd4\x93\x42\xb9\x7f\x0e\x3b\x11\xb3\x20\x88\xd7\x7c\x7b\x12\xdc\x43\x8e\x8c\x6d\x41\x7f\x7b\x16\x5d\xea\xd3\x28\x70\x85\x05\x38\x75\xec\xa4\x51\xe3\xb7\x91\xc2\xdf\xc8\x8d\x41\xb4\x59\xcc\x47\x88\x6e\x3c\xc2\x53\x6b\x09\x18\x86\xc6\x9f\x30\x61\x84\x98\x34\x80\x54\xdf\xe0\x93\xd3\xe3\x90\x6d\xc0\x80\xd6\xc0\x98\xca\xdb\xcb\x5d\xdd\x20\x50\xa2\x25\x65\x90\x4c\xdc\x19\xb3\x61\x30\xbf\x1c\xb1\xe9\x99\x7a\x22\xc0\xa6\xb6\xe6\x80\x3d\x79\x0a\x53\x5b\x9a\x55\x77\x0d\x6b\x78\x35\x3e\xbc\x47\xb8\x6a\x43\xe4\xe0\xd8\xf8\xe0\x41\x46\xbb\x8e\xf1\x38\x40\x45\x44\x83\x24\x37\x76\x4b\x12\x03\xd8\x78\x06\x22\xb3\xf6\x69\xcf\x44\xaf\x40\xa8\xa5\x28\xd2\xaf\xf7\x79\x1e\x7e\x38\x58\xf3\xd1\x72\x79\x7b\x11\x18\xd1\x1e\x8c\x17\xcd\x3f\xdb\xb0\x64\x9e\x45\xea\xed\x1f\x28\xe0\xf5\x09\xfe\x87\x8a\xef\x46\xf7\xbd\xb6\x78\xe3\xb9\xa0\xe2\xb6\xc2\x67\x9a\x69\xca\xab\x6b\x38\xd4\x37\x7a\x2f\x80\x7b\x59\x6d\x1d\x60\xa3\xb8\xce\x9b\x25\xe4\x8d\x98\xe8\x17\x3c\x30\xc3\xd9\x05\xff\xfa\xe7\x57\xa7\xaf\xe7\xd1\xc8\x57\x22\xc0\x85\x3c\x72\x06\x6e\x44\xdb\x90\x55\x5e\xc2\x29\xa3\x85\xa8\x5a\xc1\x7f\x93\x08\x7d\xe1\x9d\xec\x35\x6b\xbf\xa6\xba\x34\x95\x70\x26\x8f\x13\xd3\xf7\x15\x15\x81\x82\xe2\x30\x3a\x4c\xef\xb1\x97\xed\x77\x7a\x10\x8a\x8e\x3e\xd9\xb2\x70\x0f\x15\xb0\xa8\x9b\x99\x99\xc9\xef\x92\x81\x73\x1c\x81\xc4\x6a\x6c\x60\x2a\x3b\x1a\x25\xfb\x4d\x60\x04\x21\xac\xee\xb1\xff\x83\x9d\xbb\xa9\x9b\xc2\xf7\xdd\x25\xfb\x09\xb7\x53\xe1\x50\x05\x23\x63\x55\xef\x75\x81\xe6\x0b\x09\x49\xe0\xfa\xc9\x3b\x21\x24\xf4\x2f\x96\x74\x65\x4a\xff\x2d\xde\xaf\xf2\x74\x85\x64\xd3\xf0\x71\x59\xf2\x27\x4d\xf0\x7d\x96\x60\x89\xfe\x6d\xdd\x79\x18\x8a\x6e\x6d\x12\xcf\x66\x94\x8f\x50\x67\x55\x07\xc5\x81\x35\xf0\x2d\xd0\x1f\xcc\x5d\x2c\x01\x6e\xf0\xe3\x12\xa6\x8f\x21\xf7\x58\xfa\xfc\xd8\x33\x8a\x6e\xf2\xad\xce\xc9\xf9\xcb\x97\x34\x23\xf4\x57\x43\xbf\x29\x27\xcb\xed\x13\x62\x07\xed\x27\xd0\x80\x43\xc2\x99\xe8\x09\xea\xdf\xe4\x56\x9d\x32\x13\xa7\x95\x53\x67\xce\xbc\xf4\x36\xf3\xa4\x20\xb1\x5e\x8f\x44\x3b\xf5\x64\xfd\xaf\x76\x03\xf3\x5a\xaf\xd7\x9f\x74\xc6\x92\x82\x9f\xdb\x6c\x45\xbf\x60\x97\x33\xed\x96\xd2\x66\x49\x6c\x44\x96\x0d\xca\xec\xe4\xd2\x76\x08\x26\x51\xa6\x80\x60\xab\x26\x11\x38\x50\x63\xfd\xef\x73\xb0\xa9\x07\xcf\xdf\x9c\xec\x1f\x1f\xb2\xeb\xb7\x0b\xc7\xbb\x5d\x93\x46\xb7\x6b\x90\x1d\x88\x3e\xf9\x27\x0a\x73\xd8\x9f\x5d\xf8\xce\x31\x0a\xea\x07\x0f\x9e\xa3\xe3\x33\xaa\x5d\x76\x6e\xad\xee\x34\x25\x70\xed\x79\x6c\xa7\xb6\x7b\xca\xdb\x53\x91\xbc\x3d\xd8\xd9\x72\xce\x6e\x35\x07\x9d\xd0\xf3\xd1\xea\xca\xc3\x94\x1d\x30\x07\xd2\x5d\xa9\x8d\x0b\xe6\x31\xeb\xa6\xf7\x94\xa5\xcb\x7c\x48\xe6\xd6\x2e\x10\xda\x55\x5a\x09\xd8\xf2\xef\x31\xc5\x8a\x39\xfe\xe5\xfc\x0e\xb7\x47\x0f\x08\x90\x2a\x28\xce\x27\x12\x72\xea\xe3\x1f\x1d\x16\xf5\x02\x7b\x47\xd0\xa7\x0b\xbf\x04\x97\x77\x86\x2a\x49\xb9\xd9\x4b\x39\x54\x7a\xc8\x20\xda\x1a\xf6\xd0\x18\x8c\x1f\x42\x89\x48\x0c\x8d\x97\x41\xb6\x28\xae\xcb\x6a\xa9\x7d\xe6\x4b\xed\x7e\xdf\x21\x26\x36\x52\x95\x68\xc7\xb3\x41\xdc\x9e\x3f\xcd\xe7\xaf\x20\x39\xf3\xed\xfd\x8c\x8e\xd6\x04\x90\x70\xdd\xb6\x6b\xf5\x06\xff\x1e\xbf\x0e\xc4\x04\xe8\x06\x0e\x1e\x7a\xd0\xb5\x59\xdf\xcb\x0e\x57\x4a\x9b\x65\xe2\xc6\x46\xe6\xca\xaa\x68\xe1\x88\x92\x71\xe1\x1b\x1c\x77\x36\x3a\x8a\xe3\xbb\x9c\xd4\x6c\x7f\x4c\x96\xc6\xcc\x39\x1c\x97\x04\x98\xeb\x79\x05\xc0\x01\xc4\xe7\xd0\x64\x1a\x87\xfd\xa8\x79\x77\xe1\x2a\x17\x38\x59\xe3\x9b\x9e\xd3\x31\xec\x86\xd8\xf6\xe1\xa0\x3a\x0e\x44\x8a\x6f\x71\xce\x2a\xef\xaf\xcb\x50\x5b\x64\xb8\xad\xba\xc2\xde\x4b\xea\xe3\x34\xdc\xaa\x85\x31\x8d\xb1\xb7\x08\xf4\x0d\xfb\x20\x55\xb9\x97\xc6\xdc\x60\x46\x92\x45\x80\x28\x81\x6f\xe5\x64\x5a\xd6\xe0\x65\x0e\x9e\xdb\x7e\x02\x4b\x8e\x2f\x56\x68\x57\x51\xbf\x05\x4e\x84\x20\xb3\xc4\x72\x97\x81\xd1\xa2\xa4\xfe\x8d\x5e\x4f\xee\x95\x89\x4d\x3b\x2c\xb0\xef\xe0\xb8\x01\x2b\x6a\xb8\x6c\x89\x57\xc7\x94\xdf\xa7\x5c\x62\x5c\x7b\xfe\xca\x9e\x34\x2a\x0c\xd8\xd6\xf3\x87\xf3\xca\xd4\xda\x82\x09\xfe\xc8\x43\x34\x54\xc1\x40\x28\xb4\xa1\x87\xb0\x02\x18\x02\xcb\x30\xff\xdb\x0f\x5e\xb0\x38\x3e\xde\x00\xf5\xc6\xe5\x37\x7b\x6f\x67\xca\xce\xd7\x4b\xbd\x2f\x5a\xf8\xd8\x70\x20\x3a\xfc\x91\xca\x4e\xc6\x90\xa4\x85\x37\x4e\x74\xe0\x6f\xde\xfa\xdd\xfe\x8e\x16\xa3\xd8\x04\x86\x7a\x9e\x5f\x91\xcb\x0b\xff\xb1\x61\xe1\xfd\x1c\x82\x41\x90\x75\xe7\x5d\xf2\xad\xea\xab\x4d\x2e\xf9\x57\xe1\xa6\x89\x4c\xa8\x8a\xd2\xf0\x38\x33\x51\x1f\x07\x08\x6e\x4c\xe1\xeb\x55\xc8\xaf\x65\x2e\x00\x37\xb8\xfe\x9f\xfb\xa9\x82\xbe\x73\x2a\xba\x7c\xa7\xbe\x3b\x4b\x1b\x4c\xd1\x6f\x99\xee\x2a\xe6\xf1\xca\xb4\x88\xc1\x4e\x36\x68\x14\xef\xc9\xf0\xa6\x06\xa9\x4e\xfe\x60\xd8\x34\xff\xbc\xf5\xe0\x93\xb4\x63\x51\xbc\x45\x7f\x82\xee\x36\x5b\x80\x79\x61\xb6\x4a\x7b\xdb\xc9\x11\x7a\x5f\x9a\xc3\x81\xd1\x6a\x91\x14\xa9\x94\x15\xea\x98\xde\xc1\x36\x45\x81\x10\x77\x87\x1a\x82\xc6\x45\xdd\x2b\x6e\x01\x3a\x12\xae\x12\xdc\xe9\xb0\x84\x92\xab\x03\x2d\xf3\xa5\x7f\x3b\x1b\x9e\x51\x0c\x76\x11\xf1\xf2\x93\x3c\x61\x1c\xaf\x0b\x0a\x48\xfe\x6c\x38\xa2\x0f\xb1\x5e\x0c\xac\x44\x34\x56\xad\x55\x80\x68\x0d\x06\xa3\x88\x03\xc6\x85\x72\xc5\x2f\xfc\xd2\x85\x5d\xe5\x7e\xc2\xb0\xb6\x22\xe4\x9c\x7e\x24\x96\x39\x63\xf6\xc4\x79\x81\x45\x89\x4b\xac\x9c\xce\xee\xae\x75\xa7\xa8\xaa\x35\x40\x0a\x3d\x4c\x74\xf8\xf4\x34\x5d\x76\x4d\x88\xcd\x0d\xd5\x7b\xbb\x4b\x3d\x85\x53\xb5\x83\xa7\xcd\xb2\xb1\x04\xb4\x40\x6c\x8c\x8b\x99\xa4\xf7\x6d\x0f\x1a\xd6\xdb\x0f\xef\x1b\x0c\x40\x83\x9b\xed\x5d\x6a\xe2\x9d\x09\xf7\xe5\xe3\x28\x50\xc9\x5c\x54\x9e\xfc\xd6\x98\x13\xe1\x61\x64\x10\xe3\x5f\x69\x93\xd7\x01\x29\xac\xb9\x12\xef\x1a\x58\x80\xc7\x76\xef\x09\x70\x1b\x31\xa5\x25\xf9\xe7\x5d\x71\xaf\x18\xd7\x89\x78\x2d\xc5\xa4\xb6\x09\x3a\x31\x19\xe5\x78\x3e\x4c\x4c\x1b\x6d\x3f\x1e\x3a\x46\x81\x88\xc7\x1a\xa5\x81\x5e\x9f\x78\x9c\x1a\x11\x77\x45\xaf\x29\xbd\xfb\xef\x71\x10\x95\x4e\xb3\x74\xf4\xaa\x55\x0b\x97\xc0\x64\x27\x77\xf5\x11\xed\xf4\x6c\x8e\x67\x70\xad\x3e\x38\x0c\xbb\xbb\x5a\xe7\x65\x7d\xb3\x4b\xc2\xb5\x7f\x70\x55\x54\x45\xe3\x8c\x2f\xfd\x1d\x39\xa2\xaf\xb5\x6d\x44\x56\xdc\x24\x53\x74\x04\x53\xc6\xbd\x3f\xf9\x11\x08\x33\xe7\xc5\x65\xc9\x05\x7b\x07\x66\x05\x71\xb6\xf9\xe2\x16\xad\xa5\xd6\xf9\xe4\xf4\xf8\xcd\x9f\x4e\xe7\x87\xb0\x0b\x5b\x47\xa4\xa7\x38\x8e\x26\xdf\x98\x70\xf0\xca\xda\x63\x7c\x62\x96\x21\x67\x9c\xb9\x1b\x79\x07\x26\x1d\x9f\xc8\xbb\x20\xb2\x07\x2f\x28\x1e\x88\xfd\x04\x7f\xff\x4c\x05\xb6\x63\xb5\x24\x88\x1f\x08\x03\xe4\xda\x90\x89\x41\x00\x51\x36\x1c\xa2\xb1\x8e\xda\xee\x9b\x66\x27\xe1\xac\xda\x12\x5d\x47\x49\xee\xd1\x2a\xac\x35\x5b\xba\x2d\x2e\xbe\xa9\x81\x0d\xc3\xf9\xe7\x6d\x51\x89\x57\x67\xf5\xda\x1a\x82\x44\xfa\x00\x42\x54\xb3\x78\xfa\x60\x38\x44\x3d\xc6\x04\x80\x83\x85\x1d\x25\xdd\xa0\xc0\xf4\x4b\x14\x3d\xe9\x0f\xbe\x68\x90\x3f\x8a\xc5\x11\x09\x2e\x39\x63\x30\x73\xda\xa6\x5e\x03\x87\x66\x71\x8b\xc7\x69\xed\x65\x35\x76\xaa\xa4\xb5\x85\xe1\xaa\xb8\xd4\x98\x4b\xd1\x3d\x2e\x38\xb8\xe1\x01\x6f\x16\x60\xbc\xcf\x9b\x95\x76\x5e\x9f\x4a\x30\xde\xe7\x7a\x36\x71\x75\x30\xd5\xcb\x34\xda\x65\xe9\x3c\x56\xfa\xde\xa8\xc2\x06\xe2\x98\xdc\x5c\x55\x09\x74\xd7\xd8\xee\xe4\xb0\xdf\x96\xda\x53\x5d\x72\xdd\x80\x77\x06\xfe\x73\xb9\x16\xdd\xe7\x4d\xba\x68\xa2\x5d\x7c\x21\xc0\x02\x21\x07\x3d\xe7\x29\x03\xcc\x25\x64\x4e\x43\xcd\x7f\x53\x2b\x65\x0d\xb9\xb6\x54\xcf\xa0\x12\x0a\xe7\x78\x4b\x61\xb7\xc6\xa3\x5a\x73\x38\x7f\xc4\x11\x3b\x43\x03\x84\x8f\x61\x7c\x12\xa6\x1f\x04\x9c\xd9\xfb\x73\x3d\x76\x15\x2e\x3e\xbc\x6a\xd3\x06\x86\x0e\x7c\x99\x39\xf9\x65\x77\x79\xc5\x77\x06\x96\x5e\x35\x9e\x52\xfd\xaf\x32\x23\xa4\x4d\x91\xa6\x7b\x6c\xc8\x9c\x36\x17\xd4\xd2\x1e\x03\xc6\xee\x8c\x8b\x1f\x21\xee\x6b\x48\xee\xb9\xa8\xd1\xfe\xdb\x17\xc0\xe4\xb8\x0e\xde\x6f\xc6\xa4\xb2\xe6\x81\x20\x28\xb8\xb2\x08\x80\x17\x4e\xc1\x65\x71\x5b\x6a\x0b\xd5\x80\xab\xe3\xef\x5d\xa8\xcf\x28\x3f\xaf\x98\x0a\x2e\x51\xd7\xe2\x97\x77\x08\xb4\x85\xaa\x76\x48\x22\xdc\x1e\x9a\x24\x05\x30\x64\x3f\x15\xf7\x4a\x64\x5d\xf0\x0a\xb6\x21\x55\x5e\xeb\x8f\xc6\x0c\x2c\xd8\x35\x98\xde\x5e\x9a\x41\x81\xb9\x3e\x72\x08\x13\x75\xc2\x63\x8c\xd9\x2b\xaf\x73\x9c\xf5\x94\xf6\x64\x8f\x44\x98\x15\x23\xc2\x71\x55\xfd\xac\x19\x7f\x4b\x67\x42\x6d\x1a\xfc\x96\x03\x78\x49\x85\x70\x22\x13\x80\x87\x01\xd9\xa6\x1b\x2d\x88\x1e\xef\x65\xe2\xb4\xa5\x1c\x40\x3f\x50\x25\x51\xac\xbe\x0c\x8e\x1d\xb7\xb9\x0b\xf8\x42\x42\x46\x9c\x40\xd7\x1e\xda\xbd\x5c\xbf\xe0\x52\x45\x60\x58\x9d\xd3\xbd\x3a\x79\x6a\x40\xf3\x4f\x71\x60\x43\xb9\xb9\xed\x8d\x37\xc3\x14\x5b\x52\x4c\x45\x62\xb1\x87\x6b\x3d\xa7\xe5\x60\x48\xb9\xe6\x60\x48\xbe\x5c\xee\xd2\x61\x68\x17\x8c\xd8\x0e\x8d\xf2\x15\xec\x90\x0d\x83\x92\xac\xc5\xb4\x51\xd5\x76\x98\xb9\xe4\x42\x1f\x03\x71\x6b\x0a\x26\x91\xc8\x86\x56\xcd\x14\xd2\x8d\xb9\x9e\x4b\xab\xec\x58\x1b\x3c\x91\x9f\xf3\x58\x7f\x2d\x3c\x5b\xb5\xf0\xac\x18\x0f\x46\x41\xf9\x4d\xdd\x11\xd7\xfc\x0d\x8a\xcc\x9e\x14\x7b\x57\x7b\xd9\x57\x5f\x7e\xfd\x87\xe3\x59\xf6\xd5\x0b\xfd\xff\xbf\x7c\x21\x33\xcf\xc3\x61\x1b\xe6\x2f\xf7\xb4\x84\xe3\x29\x77\xfe\x04\xae\x5a\x8a\xb7\xc5\x8d\xde\xd7\x07\xf2\x36\xd1\xc8\xe0\x02\x41\xca\x0c\x62\xa1\x3c\x9a\x8a\xcb\x9a\xd2\x62\x4c\x5a\x2d\x24\xc0\x30\xcc\x49\xb3\xb5\xfe\x55\x77\xb3\x00\xec\xe6\x4b\x36\xc3\x82\x62\x27\xe4\xbb\xa0\x56\x06\xa9\x4f\x82\xcb\xeb\x0b\xee\xa7\x83\x4f\xeb\x63\xc7\x79\x84\xa3\x79\xd8\xf3\x06\x06\x64\xca\x5a\xc4\x27\x63\x8b\x2d\x2e\xf8\x7c\x7f\xdf\x79\xbe\x8c\x7d\x48\xb4\x80\xfa\x48\x7c\x59\x5e\x61\xe0\x42\x7c\x1d\x77\x57\x70\x7e\xbe\x6f\x41\x0d\x6d\x86\x97\x89\x47\xd0\x01\x5b\x4b\xeb\x9a\xd4\xb9\x08\x0a\x75\xf5\xaa\xa6\x88\x82\x0d\xf5\xd9\xd8\xb8\xdb\x21\xd1\xe6\x2e\xa0\x2e\x4d\x6f\x03\x37\x22\x76\xc8\x84\x5e\x2c\x97\xb0\xeb\x89\x37\x6b\xd3\x87\xfe\xe1\x2e\x6f\x96\x00\x02\x74\x06\x69\x6f\xde\x69\x11\x24\x99\x64\x23\xbc\x17\xdb\x4c\x8f\xb3\xfd\x17\x87\x52\x0e\xc0\x77\x27\xf3\xfd\x7f\x3f\x4c\x34\x14\xeb\xee\xa9\xa5\x90\x76\x78\x7e\x76\xf8\x7a\x03\x28\x42\x59\x88\x84\xc3\x77\x3e\x3f\x7a\x79\x74\x86\x8d\x05\x30\xbe\xf3\xca\x5c\x3a\x93\x13\x13\x0d\x63\xee\xa1\xd3\x4b\xa8\x3d\x32\xc6\xc8\x8d\x36\x0c\x74\xfe\x5e\x22\x52\xd2\x7b\x08\x49\xf9\x20\xcf\x49\xa1\xa3\xda\xd1\x55\xa8\xde\x9c\x30\xdb\x8c\x90\x85\x88\x30\x93\x81\xb1\x68\x2e\xeb\xad\x7e\xad\x27\xa5\x48\x5c\x14\x6a\x09\xa1\xff\xa6\x64\xa6\xc5\xa5\x97\x4e\x48\xc2\x2c\xf4\x3b\x31\xdb\xe7\x18\x9a\x03\xe9\x04\x12\x04\xa8\x57\xc9\x15\xe4\xd4\x67\x44\x21\xc0\xd3\x10\x91\xa8\x28\xc5\x0a\x03\x9b\x3d\x00\x22\xc9\xe5\x71\x1d\x90\xdb\x3d\xe3\xf8\xc0\x8e\x09\x10\xec\x4c\x84\xc8\x70\x7d\xe7\x16\x3e\x1f\xde\xeb\x1b\x47\xa2\xe9\xc9\x9c\x02\x9a\xe1\xab\xd6\x62\xe4\xba\xc8\x0e\x0e\xf0\x68\xff\x2d\x21\x8f\x44\x31\x5d\x37\x3b\xd9\xbb\x4e\xea\x05\xa4\x38\x9b\xf8\x2c\xc6\x65\xc0\x30\x14\x36\xe2\x8a\xe7\x2b\xfb\xaf\x69\xb3\x58\x0b\x2d\x10\x0b\xa5\xb0\x5c\x83\xcc\xdf\x6d\x58\x0e\xe8\x6c\x1a\x95\x3f\xa2\xb0\xde\x3e\x55\x7f\x44\xe8\x5e\xf8\xd5\x11\xff\x53\x0f\xf5\xa6\xa3\x81\x9e\xb7\x76\x09\xc8\xa7\x66\xb2\xe9\xe4\x0d\x7b\x55\x75\xab\x61\xc5\x01\x54\x9c\x91\x0c\xbe\x75\x49\x5f\x9e\x9b\x9e\x1d\x95\x5c\xb4\x6c\x1d\xf5\x79\x68\x1d\x08\x28\xec\x0a\x12\xfa\x85\x12\xe9\x14\xfc\x90\x9c\xe2\xc1\x45\x1e\xe7\xd5\x82\xb2\x36\xc2\x0a\xdb\x8d\xc6\x1d\x78\x19\xf2\x52\x99\x41\x8f\x96\xde\xb2\xfd\x19\xff\x0a\x09\x75\x08\xf4\xbf\x25\xff\x28\xc4\xfe\x87\x85\x12\xcb\xc1\x79\x44\xd5\x01\x2d\x45\x1f\x48\x16\xe4\x61\xc6\x99\x01\xc2\x35\x45\xd3\x70\x02\x70\xeb\x43\xde\xda\x63\x56\xfb\x6d\xdf\x3a\x0f\x93\xb8\x37\x7d\xf1\x5e\xf9\x23\xcf\x3f\xb4\xdb\x1b\x5a\x90\xb4\xc8\xe4\x35\x6f\x7c\x80\xe2\xd4\xc2\x76\x46\x4f\xb9\xcd\x65\xad\x2e\x40\x88\x3e\x39\x6f\xe8\x5f\x62\xe3\x68\x1a\x25\x99\x23\x09\x19\xea\xa3\x25\x59\x4a\xe3\x24\x67\x5c\xf2\x6c\x4a\xc0\x58\x7d\xea\xa4\x4c\x37\xaa\x37\xf9\xbd\xd6\x0c\xce\x9d\x98\x2f\x73\xa3\xff\x2f\x21\x94\xf6\x6e\x2a\x6e\xbb\x15\x5c\x7e\xe8\xb5\xf0\x4d\x86\x07\xd4\x72\x78\x50\x93\xd1\xf1\x38\x95\x51\xf9\x8e\x14\xba\x10\xcf\xea\x20\x8c\xa3\x9f\xbb\x28\x8a\xa5\x14\xbb\xf9\xdc\xd5\xce\x9e\xdc\xff\xbe\x12\x8e\xcf\x4e\xf7\x18\x6b\xfc\x74\x9d\x3e\xd6\xbc\x1e\xd3\x5a\x8d\x63\x2c\xe3\x9b\x70\xd2\x79\x6f\x5b\x42\x4d\x3a\x35\xc2\xaf\xd8\x73\x0e\xbc\x15\xd6\x4d\xc7\x8b\xb6\xcb\x4d\x71\xde\xba\x0a\xb2\xd0\x87\xdb\x54\x6f\x05\x79\x5a\x7e\x8c\x21\xb1\x7b\xd6\xe7\x36\x24\x79\x12\x0a\xe6\xf1\x47\x45\xff\x40\xf6\x8e\x4e\x7e\xc4\x30\x82\xf3\xd8\x4e\xdd\x4f\x3a\x3a\x49\x7d\x36\x1e\x8d\xe2\xed\x1a\x58\x28\x96\x7c\x87\x04\xa1\xf5\xfa\x02\x4b\x0a\x97\x4f\xf1\xe4\xcc\x97\x45\xe3\xf7\x6a\x90\x33\xa4\xcf\x31\xcb\xae\x08\xaf\xd8\x42\x31\x82\x1a\x68\x4f\x98\x33\xca\x24\xbf\x40\xd9\x2c\x97\x38\xd2\xd5\x6e\x96\x37\x57\x1d\x44\x9b\xe5\x80\xb4\x62\x41\x5c\xf5\xc4\xc7\x28\xae\x9f\x35\xdb\x97\x11\x43\x11\x2a\xbe\x35\x1e\xd1\x0c\x66\x0c\x2b\x66\xf3\x6c\x4e\xc6\x31\x8f\x8c\x3e\xf6\xe0\x60\x54\x8a\x08\x11\x14\x58\xd5\x50\xf8\xe8\x67\xda\x50\x32\x24\x9e\xf0\x28\x15\x30\x11\xa1\xbf\x85\xef\xaa\x1b\x9a\x11\x89\x65\xf1\xe1\xba\x42\x92\x35\x0e\x21\xde\x94\x8a\xae\xa2\x30\xf9\x4f\x52\x4c\x45\xf0\xea\x26\x1f\xa8\x7a\x45\xcd\x11\xbc\x3a\x99\x64\x48\x77\xbd\x2d\x9a\x93\xf5\x8a\x0a\xbe\xf8\x2b\xc8\xbd\x7e\x00\xb2\x13\x69\x93\xc0\x76\x42\x2b\xf2\x00\x6c\x27\x7f\xe4\x3a\xa7\xb6\x8c\xf4\x64\x8f\x05\x8f\x89\xf5\x44\x09\xa3\x7a\xcc\xc7\x32\x4e\x8f\xc3\xd4\x51\xc0\x94\x99\x9e\x3a\x6a\x7b\x99\x04\x26\x35\xec\x2a\x6a\x4c\x47\xbb\x22\x9f\x26\xb7\x64\xc0\x93\xbb\x93\x91\xbc\xc7\x42\xfb\x83\xde\x17\x88\xd5\x3d\xb9\xe7\x28\x40\xf7\xc4\xae\x46\x98\x4f\x06\x9d\xc5\xcf\x56\xe9\xce\x2a\xaf\xee\xa6\x50\x5a\x8e\x09\xd6\x4c\x7e\x43\x0e\xb1\x60\x4d\x0e\x09\x50\xb6\x46\x66\x7a\xe7\x5e\x98\x68\xd3\x9e\xed\x4d\xf1\xa4\x4e\xa3\x05\x57\x63\x43\x9d\x92\x48\xd5\xa9\xfc\xdf\xe2\x06\x7c\x5c\x3a\x43\xdd\x6b\x20\xcb\x86\x81\xf9\x42\x45\x00\x61\x01\xd8\xf3\x0b\x25\x85\x03\x0d\x95\x0c\x76\xa6\xed\xcf\x28\xf8\xeb\x17\x8a\x2c\x29\xca\x4c\xab\x93\x53\xa2\x1d\x97\x22\x29\x0c\x57\xde\x62\x76\x0c\xfe\x61\x79\x70\xe0\x07\x2c\x21\xf7\xad\x2a\xee\xe0\x26\xfc\x3b\x4c\xc2\x63\x0c\x04\xae\xf6\xd1\x63\x72\xeb\x4e\x14\x61\xd3\x44\xd2\xdb\x4d\xf0\x7e\x16\x0d\x0b\x75\x2a\xb0\xde\x99\xea\x70\x3c\x54\xeb\x84\x86\x1d\xd5\x23\x73\x5e\x79\x01\x77\xf6\x30\xcf\x08\xd0\xc2\xa6\x73\x81\xab\x04\xe5\x03\x4e\x9e\xa0\xf5\xc8\xf0\x7d\x12\x70\x9c\x70\x02\x7c\x3e\x28\x38\x76\x18\x9c\x8b\xa4\x1b\xda\xe2\x86\x31\x3f\xad\x3f\xaf\xa3\xfb\x55\x5c\x60\x5a\x9d\x68\x74\x7a\xdb\xe1\x16\x30\x5a\x1f\x30\x5a\x13\x4e\x40\x13\xcf\x37\x7d\x4d\x27\x9f\x69\x36\x3d\xaf\x38\xd5\xfb\x7b\xf6\x76\xac\x58\x46\xe1\x29\x1b\xf9\x76\x11\xac\xbe\xc6\x8b\x3e\x27\xc7\xf6\xf3\x61\x84\xa4\xe3\x41\x33\x43\x0c\xf3\x0c\xb4\xde\x6c\x75\x15\xa3\xdc\x09\xb2\xf6\x53\x97\x5d\xec\x6a\xe8\x11\x16\xde\xe0\xb6\xe7\x61\x63\x1c\xf0\xa0\x7c\xfa\xf8\x70\xff\x1d\x45\x05\x2e\xbd\x8a\xf7\xa0\x64\xfb\x93\x07\x83\xd7\xab\x3a\xb7\x21\x76\xc8\x50\x51\x78\xb6\x42\xb7\x87\x28\x5f\xa5\xec\x98\x0f\xef\x57\x90\x10\x07\xde\x01\x1f\xfc\x95\x43\xea\x09\xab\x87\xf8\xf0\xe4\x0b\x1d\xd1\x66\xbb\x4d\x67\xa8\xd3\x63\x6c\x3c\x46\x27\x7f\x2f\xde\x44\x87\x62\xd0\x72\xbc\xa3\xbf\x96\xeb\xe7\xfa\x63\xfc\xf1\xbe\x2d\x14\xd0\x2c\xe9\x3f\xc1\xbf\x0f\x20\x81\x0c\xe6\x4f\x29\xd3\x93\x0a\x0a\x8c\x4a\xc4\x2f\xf7\x44\x04\x43\x3a\x17\x49\x03\xf6\x3d\x76\x00\xa1\xed\x83\xf0\x6b\xce\x1f\x07\x9f\xc6\x28\xe1\x55\x50\x23\x3f\x01\x92\xde\xb4\x54\x02\xcb\xbe\x2e\x18\x07\x44\x4a\x4c\xdc\x02\x07\x5a\x05\xf5\xd1\x36\x4f\xbf\xee\x1c\x27\xcb\x2d\x3a\xaa\xc1\xba\xd6\x1d\xd1\x5f\xbd\xda\x78\xf1\x08\xa8\xe0\xb0\x59\x57\xc5\x2e\x66\xd0\x40\x8e\xe8\x5d\xdd\xe0\xad\xc7\xaa\xbe\x2a\x47\x86\x0e\x4f\x60\x37\x35\x4e\x05\x4c\x2f\x15\x92\x65\xbc\x60\x70\xa5\x4f\x68\x72\x44\x21\x30\xb3\x6d\x2e\xd6\x20\x1d\x62\x81\x58\xdb\x5a\x98\x8a\x22\x86\x53\x91\xe8\x04\x12\xf6\xf1\x9b\x90\x1d\x9b\xcc\xdf\xe4\x8b\xef\xcb\x98\x94\x02\x03\x27\xcf\x4d\x70\x4b\x82\x1e\x9f\x26\xa4\x4a\xc2\xce\x27\xb6\x87\xad\x50\x4e\x8a\x84\x23\x96\x13\x24\x49\xa1\x5b\x34\x1f\xfe\xce\x1a\x66\xb1\x28\x32\xe0\x6e\xed\x22\xb8\x74\xbe\x88\x44\xbf\x4d\xc0\x02\x8e\xd7\x60\x53\x7a\x2c\x5c\x36\x53\xd8\x36\xd1\x15\xe1\xd9\xfd\x8c\xe0\x3f\xe3\x9b\xc7\xb0\xbb\x35\x8f\x4c\xaf\x79\xb4\xc7\x6f\x0f\x5f\x9f\x1d\x9d\x9e\x48\x5f\x97\x7f\x96\x40\x0c\xbf\x05\xa8\xce\xec\xdf\xce\xf4\x13\xf5\xe2\xef\xc0\xce\xc9\xc0\x8f\x9e\xe3\xb8\xcb\xd8\x85\x17\xbd\x0c\x50\x3d\xfd\xb4\x6a\xad\xde\x75\x67\x6e\x4d\x32\xfb\x4c\x59\xed\xae\x4a\x0c\xb9\x62\x96\x16\x7e\xeb\xbd\xec\x39\x42\x5c\x03\xa8\x1b\x26\x57\x50\x2d\x42\xb1\x4c\xc8\x55\x05\xc4\x83\x2f\x30\xc2\x4f\xbf\x52\xea\x66\x91\x02\xca\x96\x06\xfa\x54\xbf\x61\x4b\x2f\x8b\x10\xa5\x3e\x50\x25\x95\x92\xea\x8e\x3f\xfc\xda\x36\x85\x1a\xe6\xbb\x22\x24\x1b\xde\xca\x9a\xfe\x66\xc6\x9b\x2a\x2a\xaa\x4b\x47\xbb\x9b\x23\x0e\x8d\x43\x5b\x7c\xc5\xa6\x6d\x45\x55\xbb\xe3\xdd\x94\x5e\x75\x05\x54\xa4\x94\xd8\x3c\x1c\x04\x02\x75\x4d\xe3\x79\x4b\x16\xe6\xd1\x3f\x79\x59\x7d\x7e\x9f\x5a\x7c\xf5\x8e\x72\xfc\x90\x2c\x09\x5c\xc5\x5d\x73\x7e\xd9\xc5\xf2\xef\x1d\x43\xf0\xba\x80\x82\x97\xab\x1c\xae\x51\xe4\x18\x13\x43\x94\xf1\x39\xc8\x32\x9f\x45\xe5\x56\x9c\x0c\x0f\xd5\x33\x84\xff\x57\x7d\x78\x4f\x1d\x88\x1f\x8a\x51\x28\x4e\x46\x2c\x6f\x48\x9a\x23\x08\x23\xfc\x9f\x57\xbc\x7f\x4b\xd6\x82\x2a\xb0\xe9\x4e\x25\xd8\xb7\x45\xa9\x4a\xf6\x9f\x84\x36\xe0\xfb\x40\x6a\xf8\x0c\xeb\x3d\x9a\x96\xcb\xc9\xf8\x06\x4a\x11\xd4\xa3\xa9\x13\x92\xf1\xb6\xc8\xd9\x79\x87\x77\x5c\x06\xf8\x61\x46\xb5\x5a\x04\xe8\xa1\xc0\xd1\x59\x45\x16\x9c\xad\x0a\x92\x36\x8c\xbf\xec\xbf\x3e\x39\x3a\x79\x41\x78\x5d\xb4\x19\xc3\xe2\x40\x4f\xcd\x7a\x40\x50\xb7\x64\x2f\x33\x69\x05\x60\xc9\x24\x04\x2c\xaf\xcb\xab\xeb\xd5\x3d\x14\x3e\xc0\xb1\x3e\xbf\x2a\x96\x28\xea\xbb\x40\x00\xa4\x93\xe8\x69\x76\x5b\x52\xea\x28\x24\xa4\x82\xed\x54\x38\x1a\xfc\x23\x60\x1d\x37\xb4\xc8\xa8\x7b\x05\x85\x40\x5a\xbe\x02\x24\x01\x40\x53\x94\x86\x47\x1b\xfe\xf9\xd1\xd9\xd9\xe1\xf1\xe1\xc9\x3c\xa3\x37\x39\x5a\x61\x84\xf2\x12\x56\x22\x39\xe8\x80\x3e\x59\xa9\xa2\x5c\x31\x92\x3c\x19\x34\xe3\x34\x06\x13\x00\x81\x06\xc0\xd7\x75\xc5\xa1\x38\xf3\xd0\xf0\x79\x77\xaf\xd8\xd3\xb7\xc3\xf6\xe0\xe2\x35\xb9\x05\xbf\x34\x6f\x8d\x29\x01\x10\xa9\x81\x8f\x03\x1f\xc6\x94\xef\x58\x94\xd9\x1d\x7a\x59\x4e\xaa\x26\xdc\x8f\xa2\x01\x44\xd6\x96\x17\x9f\xe9\x5a\xe1\x78\x24\xbf\x68\x86\x05\x5f\x0c\x20\x5b\x63\xd9\x99\x36\x38\x8a\x00\x64\x29\xf1\x2f\x88\xec\x70\x66\x78\x58\x62\x3e\xa4\x0e\x00\xd7\x50\xcf\xe9\xea\x0a\x61\x98\x0c\x2a\x5b\x6d\xb9\xa0\x49\x0c\x4e\x22\xba\xd6\xcc\xbe\xfe\xf2\x4b\xf8\xfd\x0f\x5f\x7d\x39\x33\xd5\xdc\x43\xb9\x70\x81\xbf\x28\x00\xe9\x93\x78\xea\x66\x98\x7e\x44\xd8\xe0\xeb\x6b\x8c\x66\xc3\xf4\x00\x40\xda\xec\x60\x55\x77\x4b\x6d\x76\xbb\x6a\xd9\xdc\xef\xe8\x89\x9e\xb7\xf9\x22\x57\xda\x14\xef\xeb\x09\xf3\x53\x55\xdf\xad\x8a\xe5\x95\x05\xed\x18\xf4\x65\x8a\x25\xa8\xee\x73\x49\x17\x9d\x81\x50\x1f\x85\xd7\x0e\x13\xe5\x5f\x28\x5e\xc1\x96\xd7\x40\x2c\x28\xec\xcd\x4b\x53\x71\xbf\xd6\x86\x87\xbe\x08\x6e\x15\xaa\x60\xa8\x9e\x78\x58\xcc\x55\x1f\xda\x9a\xe9\x04\xc5\x2c\x1e\xd4\xa0\x04\xa9\xc2\xcf\xa8\x37\xe9\xaa\xe0\xa4\x7c\x2a\x66\x34\xc0\x59\x98\xcd\x8f\x1f\xa6\xa3\x0f\x53\x50\x50\x23\x1e\xe4\xca\x33\x3d\x03\xf5\x2c\xb5\x74\x7d\x7a\xb7\x5e\xe5\xa5\x52\xc6\x9d\x70\x95\x68\xc4\x51\x01\xdf\xac\x58\x01\xa6\x36\x4d\xec\x3c\x83\xef\x83\x77\x2e\x88\x61\x42\xd6\x29\x18\xf2\xbd\x6c\x4e\x45\xaa\x40\x77\xa1\xd7\x28\x09\x6a\x0a\x18\xcf\x4b\xd5\x07\x4e\x71\xba\xe9\xff\xad\x2b\x8f\x49\x70\x28\x79\x96\xdd\xc3\xba\x41\x77\x63\x85\xc0\x3a\x98\xc3\x12\xd4\x31\xb1\xf9\xc4\x8a\x4e\xef\xef\x92\x63\xf1\x51\xd6\x98\xe5\x08\x8d\xaf\x31\x5a\x3c\x90\x6c\x32\x28\xe0\xa2\xc2\xb6\x8f\xbc\x7c\xb6\x5b\x35\x4e\x47\x7f\xd9\x98\xb5\x04\x28\xf7\x19\xa4\xdf\xdc\xac\x5b\xdb\xc1\x4d\xbe\x2c\x0c\xa8\x5c\x7e\x11\x1b\xc7\x6f\x6c\xe2\x9b\x4f\x61\x8e\xf6\xa6\x46\x9e\x03\x3d\x13\xeb\x7b\x83\x90\xdc\xfb\x06\x5e\x09\x2c\x8f\xcd\x40\x57\x3d\x12\x97\x50\xa8\x19\xed\x05\x69\x6a\xf5\x96\x65\x92\x13\x01\x87\x9b\x8f\x02\x34\xf8\x06\x4f\x72\x17\x82\xf2\xbb\x14\xe4\xaf\x07\x3f\xb2\x36\xf8\x9e\x50\x24\xc8\x45\xe1\x17\xfa\xbb\x55\x9d\x88\xb4\xf0\xb1\x6c\x4a\x94\x49\x37\x62\x51\xd8\x4c\x78\xc5\xe0\xd1\xb2\x40\x58\x91\x7d\x93\xa1\x3e\xb9\xcd\x70\xe7\x97\x2d\xac\x44\xf4\xbd\xd8\x4c\x44\x2c\x08\xc0\x57\x5f\x74\x94\x89\xa3\xd8\x4b\xa0\xe9\x6b\x90\x97\xa2\x9f\xa2\xc2\xff\xce\x33\x28\x3c\x06\x48\xad\x6f\x06\x88\x0e\x21\x09\x3e\xf0\x7a\xa8\xa0\x04\x49\xba\x4f\x41\x44\x92\x5f\x1b\x3a\x87\xc5\x3f\x12\x0f\x38\xce\x77\xed\x64\xfc\x0a\xdb\x03\x9c\xc1\x58\x01\xfd\xf5\xc2\xce\x19\x34\x60\x0d\xd8\x25\xef\x02\xac\x77\x71\xda\x77\xc2\xb4\x27\x60\x1c\xaa\x7b\xa2\x02\x22\xdd\x53\x7d\xaf\xdd\xc7\x4d\x4d\x6e\x89\x0c\xc9\x10\xb3\x41\x70\xe6\xe0\x9b\x7e\xd3\x5b\xfb\x1e\xcc\xea\xc2\x7e\x20\xc0\x88\x40\x30\x51\x93\xac\x11\xa3\xe8\x0e\x5b\xe6\x2b\xdd\x21\xd4\x58\x22\x56\x8f\x9e\x50\x79\x73\x8f\x75\xdf\x17\x30\x63\x1d\x3e\x8f\xaf\x24\x16\x80\xaf\x57\x88\x07\x30\x30\x49\x58\xdd\x59\x82\x19\xa0\x29\x0c\x96\xe0\xf6\xab\xec\x2c\xe4\xc3\x87\x3b\x7c\xf6\xa9\x92\x0d\xbf\xc6\x27\x81\x2a\xa8\x80\xc4\xed\xb8\x39\x46\xf3\xad\xfb\x80\x54\x01\xd4\x4e\x37\xc3\xff\xde\xcb\xb2\xbf\x14\x8e\x79\x04\x60\x2f\x8c\x25\xe5\xc7\x6d\xfa\x1a\xe2\xdd\x75\x94\x4d\xb7\xac\xef\x2a\xf3\x90\xb3\x6d\x40\x44\x8c\x7c\x57\xcb\x25\x66\xcc\xe9\x8f\xd4\x53\x61\x51\x20\xd7\x10\xf1\x42\xec\x65\xa7\xd5\xc5\xd0\x63\xf3\x37\xb8\x9b\xf2\x0a\x30\x82\x96\x33\xd3\x99\x9d\xf1\xf0\x15\xe9\x6d\xa0\xd6\x3b\xb9\x53\x6d\x6d\x5e\xc1\x26\xd2\x74\xc3\xf8\x6e\x20\x14\x16\x2f\xf8\x10\xbc\x1a\xd5\x60\xa1\x1b\x08\x5c\x9e\x78\x60\x85\xd8\xa0\x78\xa9\x42\xe2\x72\x0d\x60\x7a\x57\x2d\xf2\x33\xc0\xd2\x3d\x88\xe9\xa8\xbf\x50\x75\x51\xae\x73\x9a\x17\x0e\xfc\x88\xe1\xc5\xa1\x2c\x1d\x0b\xaf\xa5\x8c\x2c\x98\x52\x64\x4f\x89\xda\x84\xd3\x47\xa2\xcf\x7a\x69\x25\x5f\xe1\x21\xc7\x17\x2a\x08\x32\x0d\xbe\x86\xcd\x88\xa6\x29\xfe\x2e\xbd\x3c\x06\x93\xf0\xdb\x06\xbd\x01\x00\xe2\xe0\xcf\x5f\xef\x99\xe3\x1f\x4d\x62\x3d\x2f\xe8\xc8\x07\x90\x1e\x88\xec\x6c\xd8\xe8\x7c\xbd\x29\x81\x12\x0c\xd6\x4e\x6e\x80\xc8\x7b\x56\xdb\x7b\x1a\x46\xf1\xc3\xfb\xdb\xb2\x2d\xfa\xec\x23\x5e\x9d\x3c\x98\x69\xf3\xf2\x90\x1c\xb4\x97\x41\xda\xf1\x65\x9d\xda\x61\x60\x7a\xd3\x66\xe9\xdb\x5a\x1f\x1d\xc5\x83\xa5\x36\x87\xfe\xe1\xc0\x0c\x76\x4a\xc1\xa8\xe6\x0d\x38\x38\x4f\x01\x1a\x91\xf0\x7a\xa1\x32\x3c\x04\x98\x22\xec\x3b\x48\xeb\xf2\x1e\x51\xc1\x33\x8a\x31\xa8\x2d\x59\x91\x7c\x56\xd7\x2a\xb6\xa5\x01\xdf\x78\x1a\x01\xf0\x45\x05\x3c\x14\x5f\xac\x17\x23\x4c\x3c\xa4\x32\x28\x23\x9f\x76\xc7\x72\x9c\x2c\xf1\xea\x42\xcb\x54\x28\x54\x4f\x0f\x4f\xaa\xc3\x05\x56\xe2\xe1\xd9\x0c\x08\x63\xd6\x00\xbc\x00\x11\xf2\x72\x1c\x4d\x15\xed\x1b\x60\xaa\x52\x6f\x16\xf7\x6f\x4c\xda\x87\xc8\x38\xde\x7b\x5b\x28\xfb\xfe\xd5\x9e\x65\x6c\x10\x0d\xa3\x11\x15\xdd\x9a\x4a\x1d\xa4\xb5\xa5\x24\x78\xa0\x43\x04\x8d\x21\xe2\x34\x51\x23\xce\x81\x77\x70\x52\xb9\xc7\x23\x16\x83\x23\x0d\xb0\x47\x05\xad\xf4\x47\x2b\x20\xb5\x4d\x7b\xf3\xf5\x12\xb1\xcc\x9f\x1f\x01\x41\xbd\x23\x31\x51\xed\x52\x7b\x90\x62\xb1\x75\x53\x36\xec\xbd\x36\x7a\xa6\xa1\xa4\x5e\xb0\x39\x7b\x02\x22\x7f\x07\x2e\x9e\xe1\x0c\x21\x99\x49\x9d\x0c\x61\xc3\x2d\x04\x47\x71\xd3\x63\xfe\xe0\xcb\x52\x4a\xbc\xfe\xf0\x1f\x46\x9b\x78\x6d\x87\xf1\x55\xa7\x20\x46\xfc\x15\x38\xcf\x1a\xad\xff\x6d\xe1\x2e\xd9\x38\x22\x3d\x21\x41\xf9\xe5\x8e\x69\xfc\x4e\x0b\xaa\xc8\x81\x29\x0b\xde\x12\x96\x1b\x41\xdd\x7e\x7f\x7c\xfe\x72\x7e\xf4\x6a\xff\xf5\xfc\xf7\xcf\x4f\x5f\x1f\xef\x3e\xdb\x9f\xef\x67\x07\xa7\x27\x73\xd8\xf7\xfe\x74\xf4\xec\xd9\xe1\xc9\x8f\x82\x1a\xdf\xd3\x63\xe7\xd9\xb3\xd3\x93\x93\xc3\xc3\xb3\xec\xd9\x61\x06\x32\xce\x5f\xee\x1f\xbd\x3e\xfc\x3d\x09\xd6\x9f\xfb\x78\xff\xec\xcf\xe7\x87\x3f\x0a\xfd\xbf\x7a\x7d\xf4\xed\xfe\xfc\x30\xc3\x8e\x47\x3a\x34\x1d\x41\x1b\xf8\x5f\x92\x7c\x78\x26\xc9\x8e\x21\xbd\x2b\x51\xba\xc8\x1d\x24\x89\xbf\x5a\xd5\x0b\x6d\xae\x18\x35\xee\x47\x7b\x30\xfc\xde\xd4\x67\xa8\xbd\xbd\xbd\x1f\xb3\xef\xcd\xdf\xcd\x83\x92\x02\x06\x7e\x8e\xe4\x16\x4e\x62\x31\x10\x69\x1e\xf5\x22\x81\x82\x96\x64\xbf\x84\x2e\xd9\x0e\x49\x2d\xdb\x5a\xca\xe7\x06\x77\x59\xba\xf2\xcc\x57\x52\xf2\x42\x2b\xaf\x4b\xdd\xa8\xbe\x13\x4b\x56\x19\x43\x42\x4c\x85\x9f\xc4\x99\x16\x80\xc8\x0a\x72\xc4\xaa\xdd\xf1\xea\x5b\xc8\xe9\xb9\x68\x72\x75\x2d\xbe\x45\x98\x6d\x8a\xc0\x82\xf5\xcd\x02\x9c\x31\x40\xb5\xcc\xf5\x6c\x13\x25\x8b\x1f\x70\xbc\xfc\x19\x33\x0c\x0d\x9e\xde\xa5\xde\x19\x64\xfd\x1c\x66\x60\x24\x91\x10\x62\x7f\x17\xd7\x75\x27\x7e\x04\x87\x06\x3f\x45\x59\x86\x8b\x13\x44\xe1\xb9\xe1\xa9\xcb\x05\x14\x24\x5a\xa7\xcc\x7f\x34\x2e\xd1\xd8\x54\xe9\xd2\x38\x6a\x33\xa5\xdc\x80\x05\x24\xf6\xe0\x49\x07\xd2\x88\xc4\x01\xad\xf5\x2a\x81\xb3\x98\x4b\x12\x02\x57\x3f\x2e\xf2\x62\xdd\x09\x52\xba\xaa\xa4\x23\x78\xa5\x7f\x10\x2f\xbb\xd2\x53\xcf\x4c\xb0\x54\x63\x99\x6e\x19\xa6\xa9\x9b\xa4\x82\x0c\xed\x10\xe8\x1d\x72\x9d\xc8\x2d\x92\xda\x21\x7b\xb3\xd0\xc6\x92\x3b\x0b\x8d\x4b\x95\xb6\x1c\x8b\x55\xfd\x0f\x79\xca\xea\xe6\xd2\x26\xab\x7f\x12\x69\xdc\xa1\x99\x34\x8f\xa8\x9d\x94\x7b\x30\x2d\xa5\x26\x48\x9a\x91\x04\x41\xbd\x94\xa4\x03\xd5\x55\xa5\x5a\x0e\x6a\xae\x90\x89\x90\xa1\x32\xe9\x91\x19\xd1\xd0\x54\x99\x9e\xe6\xf6\x8f\x09\x18\x55\xa9\x9a\x8b\x49\x06\x6d\x85\x9a\xc1\xab\xd4\x87\x96\x0a\xd3\xa1\x1c\x5a\x24\xb8\xf7\x55\x07\xd8\x90\x0e\x9a\xf7\x87\xca\x66\x7f\xfd\xed\xe2\xd2\x86\x91\x50\xd3\x5d\x6a\xf9\x37\x3a\x87\x85\x87\x23\x16\xaa\x6c\x87\x62\xfe\x51\x62\x44\xc2\x97\xe7\x11\x09\x87\xe9\xe1\x23\xc2\xaf\x1d\x19\x10\xa3\xfa\x94\x11\x99\x32\x14\xdc\xd3\xc8\x48\x88\x44\x8b\x56\x8e\x64\x17\xc1\x22\x4a\xc6\x1f\xcf\xd2\xe2\x4a\xa4\x72\x50\x71\xff\x87\xda\xce\x44\x5b\xe4\xd2\xc0\xe4\xc0\x57\x0d\x04\xdb\xda\x7b\x93\x24\xa8\xae\x7d\x58\x64\x60\x6e\x4b\xa5\x36\x08\x14\x18\x31\xc1\xf0\xdd\x80\xd7\x90\x2e\xd3\x38\x63\xc5\xe7\x6f\x13\x74\xbd\x95\xcb\x7f\x3d\x76\x77\xa1\x35\x6d\xdf\x59\xdb\x35\x44\x10\x79\x79\x89\xfb\x15\x10\x26\x17\x7a\x6f\xc6\x88\xa3\xbd\x6b\x87\xfd\xe2\xde\x2b\x5e\x7e\xe6\x0c\xb4\xb8\xa1\x22\xea\xa6\x01\xd7\x62\x96\xb3\x1d\x14\xed\x9d\x6f\xb0\x3f\x53\xde\x5f\xc1\xb5\x35\xe1\x21\xfa\x57\xdf\x62\xbf\xf1\xf7\xd2\xaf\x95\xc8\xb5\xab\x28\xe3\xc3\x1c\xf9\x04\x19\x4d\x81\x81\xc8\x75\x5e\x4a\xd3\x08\x02\x86\x9d\xfe\x66\x50\xda\x94\xdf\xcb\x15\x71\xc3\xba\x32\x6d\x0b\xe4\x65\x3e\x5a\x46\x06\xeb\x7d\x83\x9e\x8c\x37\xab\x0a\x69\xa6\x4c\xed\x94\xf1\x61\x4d\xf9\xf8\x06\x3a\x20\x7f\x2f\xb1\x1b\x3e\x40\x07\xc7\xb4\x6b\x40\x84\x33\x91\x96\x18\x70\xe2\x85\xae\x52\x24\xda\xf6\x2a\x98\x61\x3e\x57\xe5\x4d\x29\xc9\xc1\xdf\x7a\xd8\x9d\xee\x2e\x39\x2d\x1f\x3d\x4c\x03\x11\x72\x04\xf9\x4d\x90\xd8\xad\x3f\x94\xaa\x2b\x02\xa5\x7e\x5b\xb6\xc1\x54\x9f\xc1\x26\xdf\xbe\x51\x8e\x41\x11\x1e\x21\x42\x45\x71\x01\x5a\x6d\xe2\xfd\xe9\x35\x56\x5e\x66\x52\x7f\xe0\x2b\xe1\x1a\x54\x35\xb8\xc5\xd9\xb0\xd3\xe4\x2b\x6e\x06\x04\x69\x5b\x49\xbb\x85\x7d\xe0\x7f\xff\x53\xf0\x86\xca\x0a\x73\x12\xb3\xb2\xba\x2e\x1a\xb4\xa5\xfa\xa8\xa2\x77\x62\x93\xe7\x2a\x79\xfd\x44\xe3\x7c\x0d\x89\x5b\x38\xcb\x10\x5f\x18\x93\x1b\x0d\x84\xa7\xcb\x94\x4d\xf7\x7c\x6b\xb3\xe3\xcc\x26\x72\xf0\xfc\xcd\xd9\x7c\xff\xc5\xd1\xc9\x8b\x37\xf3\xa3\xe3\xc3\xd3\xf3\xb9\xb1\x64\xe2\x37\x63\xab\xef\xa9\x61\x72\xbb\xc5\x1d\x25\xd9\xcb\x56\x1a\xbf\x9e\x9f\xbf\xfa\xf8\x1a\x0b\xbd\x44\x35\x5e\xe5\x8b\x42\xda\x6d\x57\xa5\xfe\x4d\x1f\x8a\xa4\x96\x90\x42\x69\x2e\xcd\x24\x67\xc4\x84\x24\xbd\x2b\x8f\x84\xb8\x6e\x4d\x47\x35\xd1\xb7\x01\x71\x70\x57\xd5\xaf\xe8\x90\x7c\x1d\x32\x26\xe2\x59\x1a\x7e\x15\xdf\xaf\x06\x8a\x19\xe9\xdb\x18\xc0\x0b\xd1\xdf\xb9\x49\xa1\x36\x5b\xcb\x96\x6a\x2b\x0d\x82\x6d\x2c\xbd\xf4\xc8\x26\x2d\x34\xd2\xd3\x6c\x91\x2b\xbd\x3b\x98\x0b\x0b\x41\x84\xf2\x58\x3e\xab\x0b\xf9\xac\xac\x05\x4a\x5a\x10\x01\xa2\xd4\xac\xa5\xe9\x6e\xb3\x6c\x39\x2c\xa2\x5d\xaa\xc4\xee\x33\x58\x25\xcc\x0d\x42\xb1\x12\xf1\x2b\xc9\x18\x1e\x7e\x61\x8a\xd8\x56\x1a\xa3\x00\xd5\x5f\x68\x0d\x47\x96\xc4\x79\x1a\xce\x1a\xf1\x96\xe0\x3b\xd9\x1b\x28\xbc\x4d\x92\xa2\x25\xe6\xa6\xc9\x3e\x8c\xfe\x94\xf4\xc1\xc0\xb0\x6f\xb4\xb9\x80\xfc\x8d\x1b\x6c\xb6\x7f\x19\x9e\xd6\xcd\x1a\x51\x02\xb8\x14\x16\x65\x7a\x58\x25\x17\xda\x60\x25\xa6\xb4\xfc\xa8\x4c\x53\xd8\x2c\x21\x71\x98\xb1\xdf\x37\x7b\x51\x37\xc9\x55\x82\x02\xda\xf8\x0e\xc9\x39\xdd\x13\x25\xbd\x47\x4f\x96\x64\x4c\x18\x2b\x61\x09\x89\x5f\x4d\xb9\x40\xf0\x5c\x08\xad\xbc\xc1\x71\xd8\x31\xb8\xde\x1b\xbf\x6c\x5f\xa6\x75\x44\x1e\x4f\x24\x99\xd1\xc7\x93\x87\xd5\x33\x5b\x8a\x4b\xc1\xc3\x0b\x4d\x28\x9d\x4d\x8e\x15\x46\x98\x7a\xe2\x92\x26\xa1\xdc\xc4\x8a\xe9\x25\x71\x68\x4d\x36\x7a\x99\xc9\xe8\x37\xdb\x63\xdd\x4c\x04\x43\x89\x64\xa5\x4e\x93\x27\x7d\xbd\x58\x62\x40\x5a\xe2\x4f\x85\xe4\x17\x5c\x70\xba\xfb\xb4\x37\x4d\xd8\x5f\x93\x32\x31\x45\x9f\xdd\x24\x28\xd0\x06\x10\x40\x23\x8e\x83\xd0\x08\xc3\x74\x62\xbc\x9f\xc3\x90\x42\xdb\x52\xfe\xce\x5c\x61\x2d\x34\x4c\x94\xb1\x52\x05\x46\xa2\x1d\x15\xea\x8b\x27\x2a\xfa\xd5\xd5\xf1\x4b\x86\x15\x7f\x15\xa5\x50\x63\x25\xed\x33\x4a\x5d\x5b\xca\x1c\x2f\x18\x01\x91\xf6\x44\x84\x8e\x39\x85\xa0\x11\x08\x08\x83\x0f\x2a\x1d\xbf\x1b\xe9\x11\x4e\x84\x0c\xe7\xfc\x90\xbe\xb9\xb2\x22\x89\x0c\x2d\x68\x92\x0e\x4e\xca\xdd\x6f\xf5\xda\xdc\xd9\x03\xde\xfa\x01\x6f\x6c\xc7\xfc\x52\xbc\xfa\x8d\xf7\x6b\x87\x79\x2d\x23\xee\x49\x7d\x6d\xf7\xa6\x0f\xf9\xb0\x66\x8c\x37\x7a\xcb\xcd\xdf\xf0\x01\x9f\xf2\x01\x2f\x07\xc7\x1c\xff\x3b\x4e\xec\xd5\xc5\xea\xb6\xfb\x9c\x78\xab\x55\x6d\xdf\xeb\x94\x1e\xdb\xd4\x05\x2e\x14\x10\x8b\x16\x11\x68\xad\xa6\xb8\x3c\x78\x1b\x03\x24\x55\x90\xf9\x24\xca\x1a\xf1\xa2\xe5\x76\x9d\x78\xf4\x85\x1f\x5b\xa9\x61\x0d\xa8\xcb\xdb\x5d\xac\x70\xe3\x2c\xc7\x42\x86\xaf\x80\x85\x0b\x49\x79\xc7\xa4\xe5\x94\x08\x0e\x99\xec\xa6\x89\xec\x06\x02\x4e\x82\x14\xbb\x2d\x3a\x31\x18\x41\x8c\x42\xdb\x05\x6e\x93\xa4\x54\x10\x98\xde\xc8\x55\xe8\x2a\x28\x77\xa9\x0c\x47\x4a\x2b\x79\x51\xcb\xa6\x2e\x5b\xc8\xd8\x04\xd4\x86\x4e\xf2\x01\xba\x2a\x1d\x1c\x2a\x57\x1c\x1e\x92\xda\x8b\xf0\x1f\xf9\x28\xfc\x87\x6e\x2b\xe6\x5f\x50\x63\x35\xd2\x5a\x5a\x60\x41\x73\x69\xa1\x75\x4a\x2f\x1c\x49\x82\xba\xaf\xda\xfc\xad\x78\x39\x0e\x49\x8e\x52\x0e\xc4\x28\x82\x45\x00\x5f\x98\x3c\x9e\x0f\x31\x24\xe2\x12\x6f\xb7\x28\xf4\xbd\x17\x5d\xd4\xba\x93\xee\x5f\x7e\x26\x76\x1f\x4e\xa1\xfd\xe5\x97\xec\x09\x62\x07\x52\xef\x4f\x09\xcf\xa6\xe4\xaa\xe3\xb3\x16\x0a\xc3\x7e\xf9\x45\xe2\x29\x1b\xca\x32\x94\x29\x78\xa5\x07\x82\x45\x89\x92\x72\x07\xcf\x0d\x3c\xd3\xba\x94\xb2\x49\xb5\x5c\xff\xc9\x71\x59\x29\x20\x95\x03\x8b\x88\xb2\x99\xcc\x3b\x28\x1d\xed\xca\x55\x4b\xc5\x11\x2f\xea\x60\x10\x5f\xd4\x16\x8c\x50\x1e\x3c\xf7\xae\x5c\xb6\xc4\x7c\xbe\x06\x52\xd7\x43\x3a\xd4\xe2\x07\x72\x45\x15\x01\xf8\xe7\xf4\x92\xcb\x38\x94\x96\x6f\xaa\x17\xa4\xec\x01\xb1\xd1\x87\xf7\x4f\xd4\xef\xa4\xfb\x7b\x68\x45\x79\x40\x06\x6a\x28\x9d\x16\x34\x7c\x7e\x24\xc9\x07\x32\x19\x4a\xf5\xd3\x39\xac\x72\xc0\x88\xbc\xcc\xf8\x2f\x8c\x27\x26\xf7\xe3\x37\x53\x04\x14\xe3\xb7\x13\x7b\xd3\x56\xd9\xe8\x96\xc8\x2e\xe8\x3d\x69\x76\x31\x19\x61\x29\x7a\x39\xcd\xe4\xd5\x16\x41\xe9\xb9\x19\x7b\x0f\x08\xc9\x20\x19\x79\xf5\x97\x8a\x78\x86\x89\x88\xdb\x61\x19\x25\x3e\x6d\xac\x6b\x4b\x45\xdd\x05\x10\x4c\x31\x1d\x42\xe4\xa3\xd6\x94\xbe\xb9\x42\x0c\x70\x1a\x23\xbc\xde\x45\x3b\x81\x1e\xd4\x5c\xea\xfc\x50\xfd\xd0\xe2\xff\xa3\x41\xf9\x63\x48\x93\x6f\x8a\x01\xb2\x3b\xa0\xe4\x86\x58\xfa\x0f\xd0\xf2\x55\xa7\xae\xad\xa2\x3f\xfc\x13\x3a\xc1\x48\xf6\x64\xaa\x6f\x60\x65\x32\x2b\x33\x39\x15\xb0\xf5\x63\x95\x2c\xe7\x3f\x2b\xcb\x47\xca\xa0\xbb\x50\xa1\xbc\x07\xe9\x2f\xe6\xb3\x58\x4d\xc2\xaf\x02\x58\x1a\x31\xf4\x0d\xc7\xef\x1f\x48\x89\xc3\x63\x01\x7a\x5a\x7b\xcd\x4c\x5b\x16\xe5\x2a\xfd\x25\xfd\xa1\xb2\x1f\x71\x84\xf6\xdf\x16\x32\x28\x4c\xb9\xc7\x22\x4d\x8f\x01\x3c\x3a\x96\xe0\x28\xdb\x8a\x3c\x47\xb6\x46\x75\xdd\x45\xd3\xa2\x5b\xe4\xd0\x5d\x56\xcc\xfd\xc6\xc3\xd8\x47\x3b\xa5\x94\xa2\x00\x58\x2b\x36\xb0\xe1\x54\xeb\x61\xba\xc4\x5e\x2f\x04\x73\x89\xf4\xd2\x17\x4e\x75\x4e\x1e\xa2\x98\x96\x48\x85\x05\x2b\xae\x3a\xa5\x14\xc0\x15\x55\x39\x8d\x4e\x5a\x9a\xae\xdd\x83\x50\xd0\x7c\x71\xc2\xba\xdc\x1a\x1a\x0d\xb0\xe0\xa8\x92\x04\x0c\x68\xb5\xba\xcf\xee\xea\x46\x0f\x64\x87\x0c\xbc\x07\xcf\x33\x6f\xf7\x07\x2b\x79\x9c\xbf\x2d\x6f\xba\x1b\x87\xa4\x4b\x90\x1a\x0e\x29\x38\xd8\xce\x65\x7c\xe0\x09\xda\x58\xf0\xe2\xa1\x16\x06\x24\xd8\x76\xf3\x2f\xdb\xea\x11\x38\x24\x58\x42\x77\x99\xf3\xfc\xec\xe3\x6a\x80\x1e\xf6\x68\xa6\xc5\x5b\xd9\xb0\xe0\x06\x8e\x4d\xef\x61\x5f\x17\x78\x1e\x41\x89\x6c\x7d\x90\x9e\xc9\xb6\xd4\xc6\x7d\x4e\xda\xfc\xb9\xe4\x6a\x59\x40\xc5\x95\xe3\x24\xae\x4a\x62\xea\x37\x9d\xdd\x22\x6e\x49\xa7\xe7\x54\x49\xa9\x51\xa9\xe1\x92\x47\x7f\x45\x95\x99\x16\x1b\x90\x6a\x77\xe4\x89\xd9\x6f\xa0\xdf\x99\xb3\xb6\xc4\x3e\x8e\x8b\x9b\x70\xc7\xd6\x7f\x18\xdd\xb0\xbd\x46\xbc\x5f\x7b\xad\xc4\x9e\xb4\xc5\x59\xcd\xf5\xe9\x4b\xb7\x32\xff\x34\x1e\xd5\x94\x1c\xfd\xb4\x88\x20\x83\x5f\x7e\xdd\x53\x93\x39\xc0\x52\x92\x49\xef\x91\xe7\x47\x33\xdd\x23\x6d\x4a\x44\xcb\xba\x6a\xe4\x5a\x8b\x48\x23\x3b\x5d\x27\x77\xa3\xba\x0b\x20\x40\xda\xec\x6d\xf4\xfe\xd0\x29\x95\x38\x7e\x84\xb9\x8d\x96\x1c\x36\x07\xa6\x5a\x82\x8e\xc0\xcc\x49\xca\x3d\x91\x7b\xee\x89\xc1\xf4\x48\x42\xbe\x81\x28\x82\x03\x8e\xd2\x5b\xc3\x87\xff\x26\xe8\xb0\x49\x39\x93\x13\x34\x7c\x64\xcd\xa6\xea\x31\x39\xbb\x74\xd8\x74\xcb\xfc\xd1\x9f\x43\xf0\xec\x27\xb4\x2c\xb5\x13\xf5\x12\x22\x0a\xbf\xfc\x72\x1c\x84\x53\x66\x7e\x12\x59\xf0\x5c\x16\xcd\x9b\x9b\x59\xbc\x3f\x65\x9e\xa3\xeb\xc5\x99\x07\xab\x6b\x7f\x32\xfe\xe6\x2c\xf3\xf3\x06\x08\xc1\xb9\xae\xfe\x08\x19\x1f\xa6\xc9\x3e\x25\xe9\x27\x0f\xae\xc1\x7b\xc5\x52\xf5\x8a\x6c\xf0\xb6\xb3\x2c\x9d\xd3\x47\x6d\xa2\x23\xb0\xed\xbb\x7a\xc8\x73\x94\xf2\x90\x7e\x5d\xe9\x2b\xbe\xa6\x3b\x58\x63\xc5\xc9\x2e\x23\x43\xb7\xf9\x93\xbb\xfd\x4b\xdf\xd7\x0e\x85\x99\x96\x70\xfc\x89\xdf\xe6\xb2\x45\x0f\xfa\x13\x55\x3d\xe3\xe0\xa9\x79\x70\x24\x98\x1a\x69\xb1\x51\x7c\x35\xd1\x23\xce\xf7\x67\x54\x30\x92\x9c\x4b\x13\x15\xe8\x89\x4b\xa8\xd3\xf6\x8c\xfc\x9e\x3d\x25\x46\xce\x67\x75\xe3\xff\x12\x1e\x53\x30\xcd\xd6\x43\x84\xa0\xa8\x70\xe2\x84\x61\x3a\x37\xaf\xa0\x7b\xf6\x1d\xd1\x58\xf7\x9d\xd0\x3d\x7a\xaa\xb7\x3e\xde\x1d\x85\x9d\x19\x5b\xd1\xa6\xd1\x25\xbc\x6c\xe3\x12\x80\x23\x82\x9e\xae\x3e\x62\xd1\xb2\xd2\x7f\x7c\xeb\x2f\xb6\xc1\x34\x4e\xf9\xa5\xff\xef\xc7\xff\x0b\x00\x00\xff\xff\x49\x86\xd3\xe3\x39\x2a\x03\x00") + +func cfI18nResourcesFrFrAllJsonBytes() ([]byte, error) { + return bindataRead( + _cfI18nResourcesFrFrAllJson, + "cf/i18n/resources/fr-fr.all.json", + ) +} + +func cfI18nResourcesFrFrAllJson() (*asset, error) { + bytes, err := cfI18nResourcesFrFrAllJsonBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "cf/i18n/resources/fr-fr.all.json", size: 207417, mode: os.FileMode(420), modTime: time.Unix(1456502789, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _cfI18nResourcesItItAllJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xbd\xdb\x72\x23\x47\x92\x20\xfa\x7e\xbe\x22\xb7\xf6\x8c\xb1\xd4\x06\xb0\x24\x75\xcf\xd8\x1a\xd7\xd6\x7a\x21\x12\xc5\xc2\x8a\xb7\x06\xc1\xea\x51\x8b\x6d\xec\x24\x32\x08\x66\x57\x22\x13\x9d\x17\x50\x94\x46\xfb\x3c\x9f\x31\x8f\x73\x5e\xe7\x6d\x9e\xf5\x63\xc7\x2f\x11\x91\x91\x97\xc8\x1b\x40\x96\x66\x77\x66\xac\x55\x04\x90\xe9\xee\xe1\x11\xe1\xe1\xe1\xd7\xef\xff\x1f\xc7\xf9\x09\xfe\xe7\x38\x6f\x7c\xef\xcd\x91\xf3\xe6\x36\xbc\x0d\x17\xb3\xab\xa3\xdb\xf0\xcd\x88\xbf\x4f\x63\x37\x4c\x02\x37\xf5\xa3\x50\x3d\x70\x7d\x73\x7a\x3a\x9d\xcf\xce\xa7\x17\x8b\x4b\x7c\x12\x1e\xfc\x79\x54\x07\xe9\xbb\x28\x8b\x9d\xff\x75\x7d\x79\xe1\x24\x69\xec\x87\x2b\x27\x79\x0e\x53\xf7\x07\xc7\x4f\x1c\x3f\xdc\xba\x81\xef\x1d\x3a\xce\x55\x1c\x6d\x44\x6c\xfc\x94\x3e\xfa\xc9\x91\xe3\x2c\x1f\x9c\x44\xa4\xe3\x38\x0b\x43\x78\x75\x2c\xc2\xad\x1f\x47\xe1\x5a\x84\xe9\x78\xeb\xc6\xbe\x7b\x1f\x88\xf1\x2a\x8e\xb2\x8d\x73\xf0\xd3\xed\x9b\xd0\x5d\x8b\xdb\x37\x47\xb7\x6f\x00\x6c\x06\x7f\x8d\xaa\x5f\xfd\x7c\xd0\x30\xa6\x33\xd7\x49\x7c\xa0\x20\x49\x7c\xc7\x13\x41\xe0\x4a\x92\x5d\xa6\x3f\x8c\x42\xe7\x97\x7f\x75\x88\x66\x17\x88\x36\x1f\x5f\x46\x71\x2c\xd2\xd4\xc5\x07\xf0\x3d\xb1\xca\x80\x48\xf1\x42\x43\x78\x51\x66\x27\xa9\xbb\xfa\x0f\xce\xec\xbd\x0e\xc1\xc2\xec\xdf\x38\x8b\x47\x91\x08\xc0\x17\x6f\xfd\xa5\x70\x36\x01\x0c\xd1\x79\x74\xb7\xc2\x71\x43\x07\xe8\x8c\x96\xbe\x9b\x0a\x0f\xa8\x4d\xd2\x43\xe7\x38\x16\x30\x7c\x98\x11\x57\xbf\xe1\x87\x40\x67\x08\x7f\x3c\xf9\x41\x00\x9f\x96\x30\x77\x38\x15\xfc\x86\x95\x75\xbf\x71\xfe\x90\x89\x24\xf5\x9d\x8d\xef\x86\xc0\x3b\x9f\x01\xfe\xe8\x47\x80\x3d\x0c\x23\x27\x0b\x09\x42\xa4\x89\x88\x0e\x91\x7d\x4b\xa0\x00\x1e\x0a\x05\xbe\x92\x85\x07\x3e\x62\xff\xd1\x45\xe6\xe7\x10\x96\xd1\x7a\x13\xc5\xa9\x88\x7f\xf9\x17\xe7\x6f\x88\x26\x62\x58\x87\x36\x36\x4c\x36\x1b\x98\x38\x17\x5e\xf1\x1a\xe4\x05\x3c\x15\xf8\x4b\x89\xde\xdd\x6e\x81\x28\xd7\x2e\x34\x10\xe6\x4f\x3f\x1d\xc2\x3f\x17\x30\x1d\x3f\xff\xec\x3c\xb9\x89\x42\xe2\x64\x09\x72\x51\xf2\x69\xbd\x76\x43\xcf\xf9\x0b\x3c\x7c\xcc\x7f\xff\xfc\xf3\x5f\x1a\xc8\x38\x3b\x70\x4d\x42\x0a\x38\x60\x2d\x01\x0a\x58\x54\x92\x3c\x27\x4b\xfd\xc0\xff\xf1\x47\x00\x1a\x39\x7e\x80\xc8\xe8\xcf\x0a\x32\xcb\x20\x2e\x80\xff\x1b\xdf\x11\xa1\xb7\x89\x60\xe1\xe2\xba\xb4\xcf\xe9\x85\x48\x12\x98\x36\xfd\x30\xbe\xe9\xc3\x4c\x20\x45\x76\xde\xcf\xa3\x2c\x15\x0e\x4c\xd1\xbd\x80\x09\x5d\xc3\xd8\x80\x3f\xc0\x97\x30\x4a\x1d\x58\x4c\x31\x2c\xfb\xe0\xd9\x91\xdf\xc3\x63\xe9\x23\x30\x9f\x19\x80\xa8\xed\xe4\xc0\x6a\x89\x23\xdc\x60\xb0\x52\x96\x99\x0f\x0b\x3a\xcc\x60\x87\xc6\xc2\x09\x0e\xe4\xa2\x62\x0e\xca\x5d\xea\xa6\x69\xe6\x06\xb8\xcd\x84\x5e\x74\xc0\xc8\x20\x28\xf0\xdb\x3a\x0e\x3c\x6c\x1c\xe7\x06\x36\xd3\x01\x6c\xe0\xb5\x1b\x7f\x12\x29\x6c\x27\xd8\x19\xe3\xc4\xb9\x9e\xce\x3f\xce\x8e\xa7\x07\x38\x80\xad\x2f\x9e\x60\xbd\x26\xcb\xd8\xdf\x20\xb5\x89\x13\x3d\xc0\xc6\xf1\xfc\xad\xef\x01\x01\x72\x0f\xc2\x77\xae\xb3\xf2\xb7\x22\x54\x5b\xcd\x3e\xd2\xc2\x31\xe6\xe8\x39\x6f\x24\x04\x85\xe7\xd6\x4f\x00\x21\x3e\x8a\x4c\x11\x92\x28\x1c\x26\x4a\x33\x1f\x65\xd5\x2a\x0a\x8c\x3d\x0a\xb3\xeb\x09\xd8\x57\x6b\x3f\x84\x29\xd5\x1b\xae\x99\x27\x13\x90\x76\xab\x10\xe6\x22\x10\x09\x48\x89\xf4\x11\xc4\x16\xac\x3e\x9e\x5a\xe0\x57\x0c\xeb\x16\xe5\x5d\x14\xaf\xc6\xf8\xd0\x81\x83\xdb\xa1\xfe\x99\x64\x03\xe3\xe0\xa7\x3a\x72\x03\x66\x52\xac\x42\xd7\xf1\x9d\x38\xc3\xb1\x2c\x61\xb2\xdb\xf0\x8b\x0e\xd8\x9b\x46\x4c\x8b\x00\x21\xbc\x5f\xb8\xf1\x4a\xa4\x7a\xa7\xd1\xfc\xa7\xf4\x9d\x13\xc2\x2a\x20\x80\x1d\x07\x92\xcf\x6a\x3d\x64\x3a\x0d\x37\x62\xe9\x3f\xc0\x52\x85\xf9\x84\xdd\x1e\x66\xd1\x36\x42\x24\x30\x47\xdd\x08\xb6\x11\x0a\xbc\x19\x44\xa6\x9d\x3c\x38\xf2\x90\x3c\x17\x41\xc3\xea\x82\x37\x68\x7b\x35\x92\x99\xc9\xcd\x15\x44\x70\x30\x3a\x63\xd7\x99\x5c\xcd\x9c\xf1\x38\xf9\xe4\x6f\xc6\x49\x12\x8c\xf9\x9c\x45\xca\x0e\x00\x2c\x3d\x8a\x32\xa8\xe1\x29\x5c\xc4\xd9\x66\x13\x83\xe4\x62\x69\x2c\xe2\x38\x8a\x7b\x0f\xb5\x2b\x4d\x5d\x48\x42\x46\x89\xc0\xc7\x2d\x06\x6c\x92\xc7\x17\x91\x65\x61\x0e\xfc\x75\xfc\xfe\xee\x62\x72\x3e\x75\xdc\x0c\x76\x17\x9e\xfe\xff\x53\xfc\xe0\xae\x37\x81\x38\x04\x81\xef\xdc\xbe\xb9\xbd\xbd\x7d\xb3\x81\x9d\xf0\x14\xc5\x1e\xfe\x7d\xfb\xc6\x79\x0b\x7b\xdd\xdd\x20\x82\x28\x85\x7d\xe9\x3f\x20\x77\x41\xf0\x86\x8e\x7a\xf0\x0b\x0b\x1b\x06\xe2\x03\x25\x06\x84\x09\x68\x3c\x74\x74\x4b\xec\x30\xa1\x8a\x8b\x30\xca\x90\x34\xa8\x1c\xff\xd0\xe1\xae\x9f\x35\x10\xc4\x8c\xcb\x46\x0e\xf3\x01\x96\x85\xfa\x49\x0a\x23\x97\x77\xe1\x17\xd6\x13\x77\x00\x42\xb5\x30\x8c\x31\xe3\xb4\x82\x88\x55\x8f\x91\x1c\xca\x42\xb5\x3b\xbf\xb0\x1d\xc1\x06\xf2\x65\xb4\x79\x1e\x27\xa0\x1b\x83\x24\xbf\xbe\xbc\x99\x1f\x4f\xc7\x93\xab\x2b\x67\x31\x99\x9f\x4e\x17\xf4\xe7\xf7\xe3\x48\x7d\xbc\x9c\x9f\xfe\x19\x3e\x27\xea\xf3\xf5\xd5\xe4\x78\x8a\xdf\x8c\xc3\x68\x0c\xcb\x1d\xf5\x90\x3f\x5b\x87\xdc\x4a\x0b\xaf\xf6\xb7\xd1\xda\x4f\x71\xdd\xc4\xc8\x13\x12\xdb\x7a\x7c\x30\x9d\xfc\x10\x68\x02\x22\x76\x97\x29\x1c\x65\x70\x8e\x8f\xc7\x1a\x06\x29\x8c\x9b\x18\x74\xb5\x94\xe6\xe5\x3e\x4a\x1f\x3b\xcd\x82\x46\x0e\x8c\xf5\x49\xce\xc1\x9f\xb0\x8e\xe8\xe4\x26\xc9\xa2\xa9\x20\xae\x1f\xb8\xcb\x25\x6c\xf0\x08\x17\xf7\x3a\xf2\x60\xaf\xa5\xa0\x18\x32\x5d\x00\x01\x64\x90\x41\x55\xec\x2f\x1f\x7d\xe1\x91\xee\x08\x00\x63\x77\x7d\xef\x77\x99\x1d\xb9\xff\xc7\x88\xe7\x6d\x79\x88\x70\xb2\x03\x7b\x9c\x2c\x0e\x90\x2f\xd1\x7d\xea\xc2\xb3\x20\xfa\x42\x31\x4e\xfd\xb5\xa8\x72\xad\xc3\xde\xab\x45\x08\x7c\x0c\x7d\x24\x1d\x4e\x6a\xc4\x86\xe3\x07\x1d\x48\x84\x22\x46\xed\xca\xe0\xcc\x3a\x0a\xa3\x0c\x5e\x25\x71\xf3\xf0\x20\x50\xf9\x61\xd5\x88\x99\xd5\xbe\xfb\x24\x01\x59\x75\x43\x8c\x37\x83\x65\x4e\xf7\xf9\xef\x85\xb8\xbf\xf0\xe9\x3e\xe5\x36\x3a\x5e\x4c\x0a\xf5\xc4\xfb\x22\xc2\xa8\x91\x86\x8d\xfb\xf7\x7f\xff\x14\xcd\x4f\x9c\xb7\x7c\xe2\x3f\x5b\x64\x04\x5c\x88\x40\xc5\xc8\x50\xe5\x4e\x76\x1f\x79\x19\x2b\xe8\x19\x25\xc9\x60\x8c\x17\x49\x01\x76\x20\xea\x4e\xdb\x7b\x93\x25\x8f\x70\x6a\x5f\xf1\xa7\xef\xc7\xf7\xce\x37\x37\xb3\xb3\x13\x90\xaa\xdf\xd2\x57\x28\x5a\x97\xce\xf1\xe5\xf9\xf9\xe4\xe2\x04\x3f\x78\xce\xc9\xe5\xf9\x64\x76\x81\x7f\x3f\x38\xf0\xed\xec\xfd\xf4\x7a\x71\x77\x35\x59\x7c\x20\x31\xec\x45\xcb\x4f\x22\x1e\xfb\x6b\x77\x25\xe0\xd1\xe3\x6f\xa7\xf3\xbb\xd9\xf9\xe4\x74\xba\x83\x54\x26\x22\xab\xe8\xfa\x03\xbc\xa4\x8b\x09\x5c\x7d\x9e\x0d\xe9\x15\xc0\x5d\x1b\xaf\x25\x74\x61\x1d\x7b\xa4\xa3\xe0\x5d\x36\x75\x57\xa8\x3c\xb9\x29\x8b\x3b\xb8\xc6\x3d\xc5\x3e\xca\x1c\x75\x5b\xfb\x78\x3c\xb9\xba\x93\x17\x8f\x6b\xc7\x30\x67\x38\xca\x9c\x41\x3b\xc2\x0d\x9f\xe1\x0c\xc8\x60\x81\x18\xd7\xbb\xc4\x76\xeb\x81\xaf\xde\xa3\xb0\x4b\x96\xbe\xf3\xe0\x2e\xa3\x00\x2e\x99\x20\xca\xf9\xfa\x86\xb7\xd0\x40\x84\xcb\x08\x77\x3b\xd0\xe7\x48\x6a\x5d\xdc\xff\x7a\x27\x38\x4b\x20\x6e\x0b\xaa\x15\xc8\x4b\xbc\xf8\xa4\x5a\x0a\x30\x5d\x7e\x40\xd2\x02\x4f\x00\x82\x5a\x1c\x07\xee\xa1\x34\xc3\xdd\x14\xe8\x0b\x29\x5f\x9d\xb4\xd9\xc4\x72\x2f\xaa\x67\xb0\xbc\xe5\x8d\xd5\xe2\xc5\x4d\xf9\xe0\xaf\xb2\x98\x86\x0c\x6b\x17\x8e\x22\xbc\x7b\xa1\x11\xcc\x71\xd9\xa6\xc4\x56\xa6\xe8\xfe\xaf\x62\x99\xc2\xd7\xe3\xc0\x87\x0b\xea\x6d\x68\x2c\x89\x6c\x03\x7a\x25\x00\x95\xd6\x1a\x58\xa3\x9d\x6d\x46\x68\xdf\xb2\xad\x85\x07\xe4\x0d\x10\x88\x07\x19\x59\xe8\x76\x24\xfe\xd0\x21\x5c\x8b\x47\xdc\xa4\x20\x0e\xe5\xca\x31\xde\x63\x8c\x6e\x88\xeb\x0b\x4d\x53\xf7\x49\x14\xa0\xe1\x00\x16\x4e\x2c\x70\x59\x6c\xf3\x57\x99\xbe\x36\x46\xe0\xde\xb8\x5b\x5c\xde\xbd\x9f\x9d\x4d\xe5\x58\xa7\x2c\x51\x70\x95\x57\x48\x3c\xa2\x27\x7e\xa2\xff\xc2\xff\xdd\xbe\x59\x06\x59\x02\xa4\xdd\x85\x11\xdc\x9b\x81\x75\xf9\x6f\xfc\x33\x2c\xe5\x14\xbf\xfe\xfb\x51\xe1\xfb\xb5\x58\x47\xf1\xf3\xdd\xfa\x1e\x7f\xfb\xea\xcb\xaf\x7f\xa7\x7e\xfd\x99\xfe\xf8\x79\xc8\x7a\xf7\x15\xa7\x62\xba\xa6\x6b\xe6\xb3\x7d\x43\x4d\x8a\x5f\xb4\x92\xf9\x28\xf3\x9d\x68\x05\x77\x3c\xe0\x19\x8d\x94\x06\x4d\xbf\xe0\x4a\x72\xe5\xac\xec\x6f\x2d\xbd\x2f\x11\x3e\x62\x85\x05\xc7\x04\xa4\xe8\x45\x05\xea\xca\xfe\x47\x25\x07\x33\x23\xa5\x68\x19\xc5\xa0\xfb\xe0\x8b\x84\x14\x8d\x1d\x39\xae\x4d\xf6\xcb\xbf\x81\x8e\x90\xb0\xce\x94\x3f\x8e\xfb\x1a\xd6\x1c\x28\x70\x6a\xc9\xe1\x52\x93\x84\xb7\xf2\xaa\x6e\xb9\x25\x62\xbd\xf1\x49\x48\xd5\x10\xfc\x6a\x0b\xee\x33\x08\xa9\x23\xc9\x01\xc5\xae\x7b\x3f\xf4\x34\xb3\xf4\x31\x2b\x65\xed\xdd\xec\xe2\x7a\x31\xb9\x38\x9e\xfe\x5f\x2c\xbe\xba\x33\x68\x57\xb1\xb6\x41\xf3\x5e\x92\xe0\xd9\x8b\x0b\xe6\xf6\x4d\x2c\x5c\x6f\x1c\x85\xc1\x33\xa8\xd2\xbf\x36\x09\xf5\x7a\xeb\xe8\xff\x1e\xd1\xb5\xdb\x52\xeb\x27\xd2\x3a\x2c\xb6\x5f\x81\x74\x42\xa7\x93\x21\xcc\x25\x2b\x9c\xab\xb3\xc9\xc5\x7f\x20\x19\xb5\x7f\x11\xb5\x2b\x9f\xfe\x53\x03\xeb\x2b\xdf\x5e\x7a\x25\x7e\x56\x29\xf7\xa2\x42\xee\x25\xd6\xea\xaf\x5b\x7d\xbb\xc2\xbd\x9a\x3c\x46\x59\xe0\xd1\x96\x76\x7e\xf4\x37\xc4\x8a\x51\x6e\x8a\x34\xbf\xc4\x2b\xb8\x13\x44\x4b\x37\x80\x11\xc5\xb0\xdf\x00\xed\xa1\x73\x15\x25\x3e\x09\x18\x3f\x81\x9f\x37\xf4\x69\x2b\xc8\x7a\xba\x12\xf1\x08\xfd\x62\x09\x48\x2d\x3f\x82\xfb\xf3\xf3\x88\xec\x3b\xf0\x64\x12\x91\x9b\xfb\x21\x8e\xd6\x00\xf2\x49\x24\x29\x62\x7b\xf4\x57\x8f\xc2\x1e\x15\x50\x99\x7d\xc0\x93\x4f\x33\x2d\x04\xa0\x76\x84\x1f\x6e\xe6\x67\xf9\xd4\xd2\x18\x22\x32\x6f\x6a\xc2\x79\x20\x82\x62\x06\x90\x68\x5e\x92\xbf\xfc\x2b\xbe\x13\x66\x6b\x11\x47\x6c\x00\x8e\xd4\x90\xa2\x91\xf2\x55\x93\x01\x99\x07\x84\x36\x60\x0f\xdf\x8a\x62\x0f\x5d\x9e\x80\xc0\x25\x2b\xa1\xff\xcb\xbf\x3b\xf7\xb0\xde\xc8\x3f\x2c\x3f\xbb\xb0\x71\xec\x37\xfe\x2b\xb4\xcd\xac\xb3\x20\xf5\x37\x6c\x2f\xd0\x86\xbf\xb5\x1b\xfa\x0f\xc0\x16\x7b\xa8\x12\x7c\x75\xe2\x63\x60\xc9\x7d\x46\x5b\x91\xd1\x99\x41\x00\x6c\xc0\x2b\x80\xb2\x11\x42\x27\x00\x9f\x32\x1e\xcb\xf3\x01\x6a\xe9\x2c\x55\x2b\x8b\x63\x45\xc8\x55\x8c\xe3\x8a\x63\xf7\x99\x07\x66\x08\x6e\x3c\x92\x12\x3c\xd5\xd8\xc1\x7c\xcf\xb1\x0f\xc2\x89\xb3\x40\x34\x19\x78\xcc\xd5\x40\x72\x08\xa8\xd8\x45\xc3\x39\xc1\x15\x05\xf4\xf2\xab\xec\xdd\x8e\x24\xcd\x7a\x13\xfb\x4c\x39\xfa\xfd\x69\x85\x84\x11\xd9\x89\x98\xf4\x6d\x04\x1f\x61\x9c\xb1\x40\x03\x92\x7d\xb6\x77\x65\x32\x43\xa0\xc5\x6d\xf0\x99\x06\xb1\x13\xaf\x19\x2e\x3d\xfe\x8d\x9b\x08\xe7\x52\xea\x3d\x09\x33\x08\xfd\x39\xb8\x6f\x71\x17\xa3\x12\x46\x6f\x26\x7f\x23\xcf\xc0\x7d\xec\x2e\x3f\xe1\x66\xc7\x1f\xcd\xc8\xa0\x47\x1f\xc8\x93\x0a\x14\x3e\x18\x8b\xbf\x65\xb0\x0d\xc9\xae\x9f\xca\x51\x00\x62\x29\x34\x3f\xd2\xa9\xfe\xd7\x24\x92\x7b\x57\x1a\x71\x59\x5a\x7e\x2f\x65\x5b\x2e\x19\x41\x45\x8c\xa3\x34\x82\x53\x89\xf5\xc3\x74\xb9\xc1\x13\x2c\xff\xd9\xc3\x28\xa2\x90\x56\x0d\x3f\xf1\xd5\x97\x87\x5f\xff\xee\x77\x87\x5f\x1d\x7e\xf5\xdf\x8a\x4f\x62\x48\x90\xd4\x32\x7f\xfb\xdb\x2f\xff\x41\x2a\x98\x4a\x8e\xfe\xf9\x55\x96\xe1\x4c\x1f\x68\x6a\x25\x12\xf2\xfd\xac\x46\xc7\x39\x3b\x50\x07\x11\x00\xb8\xc7\x09\xe6\x03\xc9\x87\x03\x5b\xcd\x30\x79\xc2\x04\x1a\x3a\x35\x29\x08\x46\x8e\x05\x5d\xe1\x68\x13\x07\x09\x1e\x44\xec\x23\xc0\x20\x08\x91\xf8\x0e\x2c\x03\x2f\x26\x07\x9b\xc6\x02\xc7\x7d\xe0\x17\x42\xb4\x9c\xea\xd9\x48\x58\x68\xc2\xcd\x83\xf1\xb3\x4e\xb5\x6d\xdb\x7e\xc4\xd0\x1c\xe0\x75\xf4\x44\x56\x69\x74\xd7\xb8\x2a\x66\x45\x29\x0e\xfc\xa5\x2d\xfc\x84\x80\xa8\xa8\x1a\xf6\xf7\x38\xee\x1a\x99\xce\x42\xba\x02\xc6\x46\xca\xf7\x63\xdf\xb9\xb8\x39\xd7\x3a\xc8\x35\x7a\x0d\x3e\x39\x27\xb3\xeb\x6f\xf1\xaf\xb5\x73\x3e\x3d\xbf\x9c\x7f\x47\xbe\x84\x47\x38\xb6\xc8\xbb\xf2\xe1\xf2\x7a\x81\xdf\x6c\x1c\xe5\x67\x48\x1c\x78\xfd\x98\x5e\x49\x9d\xc5\xec\x7c\x7a\x79\x43\x4f\x64\xce\x87\xe9\xe4\x0c\x54\x9a\xe3\x0f\xd3\xe3\x6f\xef\x16\xdf\x5d\xb1\x77\x38\xc6\x68\xac\x31\x49\xa3\x39\x3c\x3a\x6d\xf1\x20\x7c\x26\x42\xad\xc7\x9b\xeb\xa1\xc0\x85\x39\xb3\xce\x8f\xbb\x5a\xf9\xa0\x68\x45\xec\x03\xb2\xf1\xdf\x8b\x04\x47\xa0\x89\x1f\xd0\xeb\x81\x8e\x2a\xd8\x65\x9b\xc8\x06\x15\x43\xc8\x60\x8f\x80\x7e\xc7\x70\xf1\x59\x50\x2b\x40\x11\xb1\x20\x40\x87\x87\x0d\x18\x7a\x16\x2c\xaf\xa1\x12\x16\xe0\x1d\xf9\x59\x85\x12\xda\x80\x80\xd2\xb2\xf2\x41\x7f\xe1\x40\x40\x4b\xf8\x4f\x11\x5e\x84\x21\x76\xad\xf0\x62\x8a\x1e\x68\x82\x08\x3b\x3f\x7d\x6e\x80\xb3\x85\xa5\xdf\xf0\x3a\xb2\x5d\xdd\x5f\x41\x4d\x1d\x39\x70\x3c\xa0\x28\x2b\xf8\xd1\x47\x8e\x38\x5c\x1d\x3a\x8f\x69\xba\x39\x7a\xf7\xee\x39\xca\xe2\x3b\xe4\x39\xfa\x02\x9b\xe6\x88\x15\x40\x54\x7e\x59\x16\xfd\xf7\xc2\xfd\x86\xe0\xba\x1e\xcc\x24\x0b\xaf\x5a\xe8\xcd\x74\x6f\x5d\x3f\x20\xd9\x01\x87\x1f\xbe\x62\x5f\x88\x92\x1c\xcf\x4f\x36\x51\xe8\x93\xb3\x09\x65\x72\xbe\x72\xac\x8b\x53\xe2\x82\x79\x80\x37\x41\x2f\x05\x3e\x5c\x31\x8b\xd6\xee\x27\x38\xaf\x33\x8c\xfe\x4a\x59\x61\x67\x36\x6e\x82\x6c\x25\x09\xb2\xaa\x5b\x48\x4f\x4c\xc4\x78\x70\x94\x60\xd0\xde\x92\x6c\x0b\x74\xde\x24\x3e\x1d\x62\x06\x71\x20\xd8\x11\xea\xd8\x57\x62\xdd\xa6\x0c\x21\xa9\x0f\xe8\xd6\x6b\x42\x9c\xc2\xdc\xda\xd7\x54\x0c\x57\xa0\xad\xbe\x4e\x48\x37\xa4\xa6\xc5\x17\x89\x0d\x74\xec\xaf\x23\x3c\xee\x50\x6b\x3f\xc8\x3d\x82\x6d\xbb\xf3\xf6\xcd\x15\x31\x0c\x8e\x10\xa5\xd8\xe8\x51\x28\xad\x46\x72\x1f\xa8\xf2\x5c\xd4\xfb\xeb\x29\xb8\x94\x07\xa5\x09\xd1\x18\x2f\xcc\xb8\x8f\xef\x23\x49\x70\xb6\xa5\x19\xdc\x44\x2c\x7c\x3c\xc8\xb7\x06\x1c\xf7\x28\x69\x62\x0a\xcb\xa6\x00\xbb\x43\xe7\x5a\x70\x68\xdc\xa3\x08\x36\xb6\x25\x77\x60\x6c\x01\x15\x08\xcc\xb0\x62\x3a\xbb\x3f\x0a\xe0\x4d\x0e\xa4\x96\x8c\x2f\xb4\xbc\x20\xc9\x68\xd5\xde\xbf\x50\xe2\x10\x85\x86\x65\x48\xbf\xf9\xcd\x04\xdd\xc4\xf8\xca\x91\x23\xf9\x43\x1a\xe4\x3d\xc6\xbe\xf9\x18\x2d\x2a\x1d\xc9\xf7\xcf\x70\x4d\xa3\x47\xc9\x48\x06\xf2\x3b\xc6\xbb\xb4\x47\x01\x59\xa0\x77\x81\x62\x85\x61\xe8\x41\x40\xca\x29\x46\x5a\x6c\x14\xb8\xd4\xc1\xed\xeb\x44\x4f\xb4\xba\x3f\x1d\xfe\xe6\x37\xa8\xa1\x9c\x44\xf8\xb5\xf3\xe4\x86\x74\x31\xf5\xe5\xdb\x64\x11\xe3\xbd\xf2\xd3\x4f\x87\x4c\xd2\xcf\x3f\xff\xde\x79\xfb\x8c\xca\xba\x35\x2a\x47\x0e\x84\xae\x62\x47\x4e\xbe\x31\x12\x54\xac\x78\x30\xd2\xc1\x8c\xb3\x8d\x44\x47\x68\xc6\x88\xe8\x1d\x15\x72\x8c\x73\xe3\x22\x18\x0f\x85\x81\x0f\x37\xd7\x03\x49\x96\xbc\xe3\xa1\xe2\x25\x83\x39\x22\xb6\x88\x48\x34\x18\xbb\xec\xa4\x59\x84\x12\x12\x2f\xae\x38\x50\xd0\xca\x23\x39\xd6\x8f\x59\xe4\xab\x11\xca\xc0\x50\xf5\x66\x65\x90\x38\xc6\xda\xb9\x9a\xe8\x38\x75\xb4\x4b\x01\xcf\xa2\x80\x19\xc7\xc1\x5d\xac\x23\x1d\x07\x51\xe6\x39\xef\x71\x9b\xc4\xb6\x03\xe0\x06\xc3\x4c\x60\xfa\x70\xd0\x48\xe9\x8a\xe3\xb3\xe5\x72\xc4\xa3\x8f\x61\xae\xe0\x0a\x41\x1a\x53\x11\x68\x3d\x71\x27\x27\xef\xe6\xa0\x65\x7c\x44\xfb\xcd\xcd\xe9\xec\xc2\x82\x7b\x72\x7a\x3a\xbb\xb9\x38\x9d\xbd\x9b\xcf\xce\x6f\x2e\x3f\xce\xd4\xd3\xdd\x80\x3a\xf3\xe9\xd5\xe5\xf5\x6c\x01\xca\x4c\x57\xf8\xf9\x1b\x2d\xa8\x3e\xa2\xe6\x74\x62\x03\x0b\xbf\xfe\x69\xb2\x98\x5a\x5e\x3e\x9b\x4d\xae\x7b\x05\x78\x60\xf0\xa9\x0a\xd2\xb7\xbc\x38\x55\x31\xfc\xf0\x6c\x3b\x10\xe7\xad\x3e\x8c\x13\x38\x2f\xdd\x8d\x7f\x68\xc4\xe6\xd8\x76\x8d\x89\xc3\x79\x9b\x1f\xbb\x23\x3b\xa0\x56\x4a\x8e\x3a\xe0\x3a\xea\x00\x86\xb3\x2a\x7c\xf5\xda\xcf\x36\x9b\x70\x01\x6e\xf5\xa5\x01\x88\x9c\xb7\xf8\x3b\xdc\x0c\x13\x12\x8b\xfc\xf3\x47\xfe\xf8\xf3\xcf\x5d\x78\x59\x07\x53\xc2\x13\xe6\xef\x06\xd0\x6e\x74\xf6\xe7\x46\x3b\x2b\xae\x6c\x4b\x17\x7e\x3a\x9b\x1d\x4f\xfe\x34\xbb\xbc\xb0\xad\x40\x0a\x54\xe4\x60\xba\x3c\x65\x02\xee\xab\x29\x68\x2e\x20\xe9\x9c\xfb\x38\xfa\x24\x6c\xc1\xdc\x13\x19\x13\x4a\x12\xc7\x9a\xe1\x20\x41\xb4\xe1\x57\x56\x64\xba\xdb\x94\xc9\x50\x3f\x46\x0f\x0f\x02\x73\xc3\xba\x10\x24\x63\x5a\x0b\x86\x73\xa2\xce\x35\xc8\x73\x19\x24\x67\xb8\xc8\xc7\x6c\xa4\xa2\x49\x06\x4d\x41\x32\x83\x0f\x1e\x07\xed\xce\x4f\x9f\x1d\x4a\x24\x4b\xe8\xca\x04\x13\xa6\xe2\xf4\x7e\xb6\x66\xbd\x11\x28\x65\x4f\xc5\x53\x68\x15\x67\x9b\x0d\x67\x70\xa1\xc6\x28\xf0\xde\xeb\xe3\x6d\x08\x30\x28\xe3\xe4\x5a\x54\xa0\xb7\xd0\x29\x93\xdf\x4a\x74\x22\x99\x05\x38\xdd\x88\x0c\x98\xc8\xa8\x42\xe4\x03\x2a\xcd\xa8\xc9\x82\x46\xe8\xc6\xae\x41\x6e\x11\x4b\x3d\xb1\x1e\xe8\x1f\x94\x1d\x61\xa8\xd7\x52\xad\xb4\x90\x45\x77\xcf\x95\xcf\x46\x68\xcc\xcd\xa8\x55\xa8\x9b\xd0\xe1\xd5\x25\x56\x19\x53\x68\x4c\xdc\x6c\xda\x91\xa9\x44\x28\x65\x35\x2f\x24\x34\x59\xb1\xd1\x72\x21\x54\xc0\x0c\x78\x15\xe4\x08\xe2\x2c\xa7\xb5\xc1\xc0\xa3\x78\x85\xdf\x5d\xc6\x2b\xf9\xdd\x3b\x8e\x66\xc5\x2f\xaf\xf1\x0f\xf9\x35\xcf\xde\x8d\xe6\xeb\xe1\xa1\x4d\x7d\x64\xe2\x53\x57\x26\x55\x32\xf9\x9a\x8c\x72\x4e\x56\x91\x20\x0c\xe1\x3b\x28\x66\x95\xd4\x50\x87\x3b\xaa\x44\x9e\x9a\xf8\x22\x81\xf5\xec\x09\x7c\x18\x4c\x31\x8b\x4e\xdd\x0c\xe4\x6a\xb8\x17\xc8\x40\xa9\x77\x71\x4a\x1b\xac\x16\xb6\xf6\x1e\xbf\x57\xea\xd4\x3b\x17\x21\x1d\x3a\xce\x5c\x90\xf0\x40\x00\x25\xb0\x4a\xf1\x6a\x01\x8f\xd3\xe0\x61\x4c\x62\x04\x52\x9b\xaf\xa0\x6c\x0c\x26\xbd\x8f\x5c\x38\x52\x39\xb6\x31\xfd\xec\xc0\xad\x1b\x16\xde\x4a\x95\xc2\x48\x11\x93\x64\x4d\xd4\x80\xa3\xe2\x8d\x82\x07\x84\x23\xa4\xb1\xa2\x49\x70\x0e\xb7\x76\x10\x67\x3e\x66\x61\xd9\x52\x10\x0b\x58\x3c\xb7\xa0\xaf\x52\xd4\x3e\x5e\xe2\x50\x1f\x24\xeb\x64\x1c\xa2\x32\x6c\x57\x8f\x7b\xcd\x1a\xce\x4b\x61\x36\x28\x20\x9d\xb9\x7c\xa0\x35\x64\x5e\x23\x07\x30\x9c\xef\xe0\xe2\xb0\x24\x9b\x7c\x1a\xe3\x5d\x44\x92\x81\xd3\x61\x7b\x8b\x38\x0f\x93\x17\x1a\x37\x0d\xc0\x2b\x1f\x37\xa7\xce\x0f\xb7\x70\xe2\x34\x2c\x03\x20\xe0\x43\xf4\x24\xb6\xe8\x7b\xc3\x2b\x8c\x74\x0f\x3c\xf8\x31\x5c\x8b\x1f\x32\xbe\x1e\x01\x30\xcc\x8b\x25\x9c\xe8\xd6\x42\x0d\x1d\x8e\xa5\x02\xad\xf8\x13\xdd\xe1\xf0\x43\x95\x62\xa6\xad\xe7\x52\xa9\x5b\x09\xe6\xc4\xd6\xb1\xf3\x0a\xaf\x27\x68\xdb\xc1\xb9\xc6\xa3\x2c\xa9\xbf\xab\x54\x49\x44\x03\x2d\xe6\x4d\x3a\x85\xe5\x22\x33\xa6\xd4\x6b\x78\x9c\x52\x4e\x87\xbb\x96\x00\xeb\x17\x20\xba\x46\x32\x90\x32\x5b\xdf\x1d\xa1\x4d\x1c\x69\xf2\xd7\x2e\x9c\x63\xae\x4c\xc5\x82\x05\x07\x9c\x24\xe3\x3a\x09\x25\x83\xd2\xfc\xa0\x69\xa0\x96\xee\xc3\xa1\x35\x2a\x78\x12\x18\xa9\x9f\xe4\x77\x91\x7a\x03\xf1\x45\x5e\xba\x39\x39\xc3\xd7\x21\xd3\xf0\x0e\x48\x3a\x9b\xfd\x03\x07\xe4\xe7\xda\x8d\xa9\x4c\xd0\xd5\x94\x0d\x7a\x12\xa4\x8f\x89\x9e\x66\x4c\x73\x41\x84\xda\x14\x8b\x01\x44\xd3\xd2\xb7\x27\x14\x0e\x22\x9a\x26\xbd\x5b\x2e\x61\x27\x92\x61\xc6\xf7\xcf\xe9\x1c\xe8\xcb\xf1\xba\x42\xf8\x3e\xb8\x5d\x25\xbc\x1f\xbf\xa3\x27\xe7\xfa\xfa\x83\x9c\x34\x49\x95\x68\x4c\x7e\x3d\x96\x82\xde\x51\xa9\x5b\xf8\x3e\x65\xad\x34\xe7\xb3\x4e\x02\x0e\x1b\x11\xe8\x76\x09\x75\xda\x38\xa9\x31\xb6\xb9\x9b\x72\xb2\x25\x3c\x8f\xa7\x9b\x9e\x12\xd4\x39\xf2\x44\x70\xdb\xe0\x58\xf9\x59\x67\x20\x7c\xef\x85\xcc\x98\x15\x18\x6f\x01\xa3\x54\x9f\x65\xc1\x84\x86\xe1\xfe\xf2\xcf\x20\x26\x71\xa0\x2e\x9a\x6f\xcc\x34\x59\x50\xd6\x4a\xaa\x8c\x87\xd3\x44\x8e\x30\xfe\xcc\x62\x0a\x35\xdb\xc2\x6b\x2d\x7c\x02\x2d\xce\xa6\x7a\x99\x8a\x95\xfd\x6d\xd2\x56\x7c\xf6\x8b\x48\x7f\xef\x83\x2f\x02\x9b\x95\xf7\x82\x32\x6e\x4c\xd0\xf2\xac\x80\xdb\x3d\x66\xc4\xdd\x07\xfe\xca\x45\xb3\x58\x03\xc1\x05\x2d\xaf\xe8\xa1\x69\x38\xa7\xec\x7a\xa2\xf6\xd9\xd8\x24\x72\x45\xd5\xc5\xe1\x3e\x45\xf1\x27\x0a\x7c\xf9\xe4\xc3\xbd\x47\xeb\xc8\x14\x4f\x84\x58\xfb\x13\xc2\x9c\x08\xdc\x6d\x14\x47\x23\x8c\x3e\x31\x8a\x5c\x18\xea\xaf\xcc\x54\xf1\x57\x61\x14\xc3\xe5\xaf\x07\xcd\x52\x36\x70\x72\x4d\xca\x7a\x2f\xcb\x0e\x7e\x68\x08\xf7\xb4\x3f\x28\xaf\x94\x50\x03\xd7\x46\xa3\x00\x42\xd0\xbe\x80\x6b\x07\x83\x83\x3c\xdf\x85\x61\xc1\xaa\x5e\x26\x1c\x05\x11\x44\x2b\x72\x1c\xb7\x5d\x6e\xf2\x17\xf5\x5d\x81\x12\x38\x51\x3a\x21\x02\x8e\x36\x7b\x90\xa9\x3c\x00\xd5\x4a\x92\xca\x38\x72\x1e\x85\x1b\x60\xc0\xc6\xa3\x58\x7e\x72\xd2\xe7\x8d\x90\xe6\xad\x03\xf4\x2a\x73\x62\x39\x2c\x1d\x71\x60\xb3\xc5\x2c\x7c\xbe\x69\xc2\x7c\x71\x12\x1a\xc5\x4a\x71\x34\x11\x92\x58\x64\x6a\xc1\xf0\x25\x51\xbc\xc5\x7f\xdc\x2f\x30\x5f\x9c\x30\x39\x6f\x43\x2a\xad\x11\x7d\x61\x33\xd5\x18\xe4\xeb\x82\x2c\xa0\x1a\x89\x1f\x2c\x34\xce\x40\x6d\xc2\x47\x64\xf5\x94\x0e\xf7\xc1\xcd\x26\xb1\x19\xd7\x0c\x89\xe1\xdb\x8c\x6b\x5c\x03\x82\x3d\xe2\xae\xbc\xbb\xda\x4f\xa5\x89\x2c\xda\x80\x57\x57\x7e\xc3\xad\x4a\xc2\x16\x4c\x7c\x03\xe5\xb7\x3d\xf1\xe0\x87\x1c\xc6\x46\xab\xab\x49\x16\x9b\xb8\xf9\x3d\x2d\x77\x15\xb0\x40\x9f\x42\x44\x57\x8b\xa8\x2d\x12\x84\xd5\x23\x98\x08\xb4\x2f\xb4\xd2\x40\x55\x2b\x0a\xd8\x64\x3a\x63\x33\x32\x3e\x96\x86\xe1\x2a\x9d\x37\x1d\x71\x82\xfc\xff\x88\xc1\xa4\x16\x2c\xf0\x1b\x1e\x88\xb2\x1a\x87\xcd\xd3\xc7\xa0\x58\xa8\x06\x24\x70\xe6\xf0\x2f\x1b\x1e\x70\x08\x4e\xa5\x2c\x47\x6e\x7d\xe0\x82\x18\x70\xcb\x87\x6f\x1b\x0c\x0b\x4c\x40\xae\xb0\xf3\x98\x73\x4c\x68\x5b\x90\x09\xa3\x15\x64\x16\xcb\x42\x19\xf3\xe0\xa1\x31\xa0\xc6\x91\x19\x96\x15\xfe\x9a\x0c\x18\xda\xb6\x52\xa0\x77\x6f\x5c\x28\xd0\xd5\x81\x09\xa6\x81\xa5\x48\xa5\x32\xb1\x54\xe8\x7c\x49\x9e\xfd\x9a\x58\x33\x94\x01\x25\x3b\x28\x40\x50\xdf\xdc\xd1\x37\xcc\x14\xbd\x36\x12\xc9\xef\x9c\x21\x92\x2c\x1a\xa7\xe6\x49\xd6\xc5\x14\x57\x66\x48\x9d\x2d\xb5\x8e\x1e\xd7\x10\x93\x06\x49\x16\x26\x95\xe8\xab\x1a\x61\xbb\x30\xc9\x10\xf9\xf0\xee\x1f\xf0\x0f\xa9\xae\x98\xcc\x19\x68\x92\x2c\xf1\x21\x50\x47\x13\xa9\xde\x6a\x94\x26\xce\x12\x03\x86\x9a\x1a\xe1\x1a\xb2\xde\xd0\x25\x02\x4d\x0f\xd1\x53\x18\x44\xa0\x33\x90\x5b\xf9\x99\x35\x1b\x8a\x8b\xe0\xf0\x40\x91\x62\x0c\x14\xd6\xb3\xb1\x8f\x64\x01\x0b\x8f\x23\x13\x91\x74\xb8\x2f\xe8\x82\x41\x04\x8d\x1d\xd6\x32\x68\x02\xed\x2b\x31\x79\x9c\x67\x12\x7e\x47\x42\xd7\xfe\x2a\x76\x79\x8f\x48\x9d\x70\x26\x15\x93\x93\xbc\xf4\x55\x13\xbf\x0b\x54\x12\xb4\xb8\x13\x34\x2b\x6d\x32\xd0\x80\x42\x73\xe1\x1a\x4d\xf6\x9f\x2b\xf8\x83\xa7\xe4\x2f\x78\xab\x56\x37\xea\xbf\x94\x35\xd9\xbf\xa8\xe8\x8b\x87\x58\xa8\xe8\x5c\xad\x68\xfd\xa5\x4a\x95\x7a\xcb\x28\x8a\xe7\xca\x1a\x7a\xce\x31\xe6\xf4\x2c\x65\x5c\x82\xeb\xc1\xdd\x53\x46\x60\xc4\x58\x11\x03\x6d\x7a\x70\x67\x0f\x3f\xf1\xcd\x9d\x6a\x1e\x72\xf9\x1f\xeb\xc2\x34\x63\x0f\x02\xba\xc9\x47\x95\xc1\x15\x6e\xf6\x35\xc3\x93\x91\x21\x38\x67\x99\x4f\x81\x9c\x67\xba\xb6\x5e\xc3\xf8\xcc\x4a\x7b\xaa\x62\x9f\x1a\x22\xde\x59\x40\xd9\x5d\x1b\x03\xa4\x9a\x1b\xa0\xfc\x27\x1c\x55\x24\x4d\x75\x32\xb8\x88\x6b\x1c\xd9\x26\x30\x43\xf3\x29\xaa\xf9\x98\xde\x8f\xb2\x1f\x28\x1e\x17\x6a\xcb\xd8\xd8\x43\xc2\x1a\xf5\x70\x29\xb5\x0b\x55\x60\xc2\x28\x34\x2b\xc1\xb4\x22\xc7\x68\x2b\xbb\x88\x50\xa8\x58\x48\xa0\xbd\x1c\x83\x82\xed\xab\xd2\x80\x8b\x17\x0f\x10\x46\xe2\x87\x0d\xde\xa5\xd1\x2e\xca\x21\x5d\x78\x11\xba\x77\xe1\x26\xe2\x93\xee\x1a\x8b\xb1\x6b\xb0\xe2\x50\x95\x39\xa5\x12\x5e\x7f\x31\xeb\x50\xdd\x66\x5f\x7e\xf9\xdb\xa5\x72\xe0\xd2\x27\x81\xa5\x33\xf8\x7b\x64\xa1\xfa\x2e\x92\xdf\x81\x08\x56\x5f\x25\xf2\x2b\x92\x99\xfc\xe5\x5f\x64\x71\x1a\x4d\x0d\xda\x97\xcb\xe4\xd8\x2f\x92\x45\xd6\x60\x9d\xc2\xa5\xeb\x65\xa9\x7b\xe8\xa0\xe3\xd3\x23\x07\x22\xfb\xc4\xd8\x62\x2b\xb0\x20\xa6\xcf\x15\x69\x0a\xef\x1e\x3a\x95\xca\xad\x79\x25\xae\x17\xe6\x00\x93\x86\x36\x29\x0f\x83\xa5\x05\x5d\xdd\x98\x4c\x4d\x7e\x85\x5e\xfb\xdc\x47\xb1\x3c\xf0\x68\x6b\x02\x6c\xcf\xf7\x64\x68\x1f\x27\xb2\x70\x58\x0d\x32\x8c\xca\x04\x2d\x23\xcf\xa6\x5f\xcf\x82\x1c\x86\x0c\x30\xd2\xa7\xab\xdc\xdb\x14\xb5\x09\xa0\x95\x48\x77\x29\x08\x36\xe4\x7d\x4b\xd7\x41\x59\x13\xa8\x9e\xe0\x6f\x66\x67\x67\xb3\x8b\x53\xac\x2d\x32\x01\xd6\x5b\xe8\x38\x9d\x5e\x2f\x2e\xe7\x53\xe7\xfd\x64\xb1\xb8\x99\x93\xfb\xde\x12\xb7\xa2\xeb\xa7\xd8\x22\x00\xe0\xb7\xe3\x0f\xd3\xc5\x62\xe6\x9c\xcc\xb8\xda\x8a\x05\x90\x8f\x09\x09\x65\x0d\xa9\xf5\x9e\x37\xa5\x99\x43\x89\x89\x09\xaf\xd2\xf7\x5f\xa7\xdb\xb4\x5f\xf1\xac\x14\xa0\x99\x53\xc5\x2b\x96\x3d\xee\xb2\xe2\x25\x16\x40\x42\x8b\xa8\x72\xcc\x9b\xb5\x4f\x76\xa6\xbc\x10\xf5\x58\xe7\xa8\xf7\xf2\x0a\xa1\xb1\x2e\x0b\x54\x28\x66\x52\x70\xe5\xbf\xdc\xf0\x95\xbf\xff\x57\x38\xfc\xba\x20\x81\x16\x46\x94\x4a\xe3\xd2\x5a\x24\x33\x61\xaf\x38\xad\x26\x70\x4d\x9e\xff\x3a\x06\xd5\x17\xca\xed\x18\x0c\x40\x84\x2c\x11\x37\xba\x9a\x7b\x8f\x01\xe7\xf5\x5e\xa4\x4f\x42\x50\xc4\x61\x51\x87\xa0\x63\xa4\x68\xd9\x95\x42\x90\x0c\xbb\x76\x71\x47\x63\x83\xaf\x6b\x40\x5a\x0d\xbd\xcd\x34\xae\xdd\x67\x18\x25\x46\x8f\x4a\xb3\x24\xfb\x2a\xaa\x31\x10\x98\xc7\x15\x70\x00\xee\xfd\x73\x75\x7e\x6c\xea\xd2\xa1\x53\x0a\x3b\xdd\xc4\xd1\x52\x08\xef\xf7\x96\x41\x7e\x76\xba\x9c\xb7\xcf\xef\x6c\x01\xa1\x8a\xb8\x2a\x15\x9d\xf1\xf6\x0f\x1d\xe9\x78\x87\x6f\xa6\xb8\xdb\x55\xda\x13\x0f\x6e\x16\x28\x56\x2b\xe1\xdc\x2d\xfc\x68\x9a\xc7\x3e\xe1\x76\xe3\x5d\xd8\xef\xe6\x2c\x54\x36\x2a\x8b\x21\x90\x3d\xd2\x86\x29\xc5\xd4\x41\x39\xbe\xaa\x43\xc0\x52\x3f\x06\x68\x89\xfc\x6a\x63\x76\x77\x8b\xc7\xca\x87\xc7\xeb\xcf\xba\xec\xf6\x12\xc5\xd4\x71\x29\xda\xd8\xa2\x45\xb0\x95\xca\x17\x0e\x72\xea\x66\x80\xb2\xf3\x74\x9f\xbc\xec\x62\x7e\xe9\xc1\xc8\xd7\x61\x60\x07\xd3\x8d\xe2\x9e\x29\x1d\x4d\x22\x7a\x8e\xd6\x37\x22\xe0\x2a\x70\xea\x09\xc8\xfc\xc0\xdb\xe0\x7d\x0d\x1e\xd7\x1f\x34\x7f\xcc\x44\x0e\xfb\x41\x0b\xaf\xc0\x65\x5d\x25\x95\x22\x90\x3a\x68\x46\xba\xc7\x00\x5a\xba\x79\x73\x3b\x13\xd3\xea\xda\xfd\xe6\x39\x45\xf3\x03\x9c\x77\x28\x07\x95\xfb\xde\x0d\x55\x5d\x03\x95\x9b\x9f\x81\xc4\x45\xed\x75\x0d\x77\x71\x10\x5e\x54\xb4\x30\xf0\x3f\x09\xe7\x7c\xe4\x9c\x7f\x33\x72\x4e\xa9\x6c\xc2\xe9\x37\xb6\x7b\xaf\xab\x90\xa0\xef\x0f\x08\x46\xb4\xa5\xba\x06\xc5\x6a\x04\x7c\x21\x3b\x40\xbc\xfc\xca\xda\x07\xc4\x2e\xaf\x3a\x85\xd4\x89\x10\x65\xed\xc0\x74\xa5\x62\xcf\x1b\x73\x08\xd7\x98\xd2\xd0\x30\x13\x81\x7f\x81\x05\x84\x17\xe8\xe9\x3f\x4e\xce\xaf\xce\xa6\x9c\x8c\x8b\x55\xa9\x4b\x2f\x5c\xc5\xfe\x16\x6e\xf4\x73\xfc\x5b\xe6\xc1\xad\x9f\x37\xfc\xa5\xca\x85\x7b\x87\x7f\xbc\xeb\x75\x08\x6b\xfa\x30\x2a\x44\x16\x54\x4f\x92\x47\x87\xea\x13\xd3\x4f\xc3\xc0\x81\x66\xff\x3d\x8c\xcc\x96\xc5\xdd\xf6\xf6\x46\x17\x3a\x1a\x06\x00\xeb\x42\xdf\x5c\x4f\xe7\xf4\xe9\x6a\x72\x7d\xfd\xc7\xcb\xf9\x09\xb2\x79\x10\x38\xaa\xc0\xc4\x99\xb8\x4a\xf0\x72\x31\xd1\x6a\x65\x92\xef\xc7\x0f\xd5\xcc\xda\xbc\x20\xe9\xd5\x64\x0e\x7f\x2f\xa6\xf3\xeb\xbb\xc9\xf5\x1d\x26\x83\xff\xd9\x98\xfc\xeb\xa3\x6a\xe1\xa7\x22\x5a\xb3\xc4\xea\xfa\x19\x0d\xba\x5c\xf5\x33\x76\x0c\x94\xeb\x67\x60\xe0\x0e\x90\x96\x9c\x1c\x8f\x29\xe2\x3b\x41\xc1\x62\x37\x94\x8b\x48\xa5\x6d\x08\x5c\x5e\xd9\x66\x16\x3a\x7f\x04\x78\xd1\x53\xe2\x5c\x45\x4f\x22\xbe\x7e\x84\x03\x80\x52\xc5\xbc\x28\xc3\x8e\x2a\x94\xab\xed\x8d\x64\x71\x60\x2e\x3c\x84\x09\xe4\x3f\x61\x0d\x61\x06\x7b\x8b\x80\x6f\x25\x68\xf8\xf7\x67\x99\x58\x6e\xc0\x96\x01\x85\xce\x19\x66\x49\x21\x74\x2e\xd6\x60\x81\x7e\xd0\x04\xdc\x16\x81\xdf\x65\xed\xc8\x3e\x3d\x4a\xcb\x92\xed\x62\xae\xa7\xc7\x37\xf3\xd9\xe2\xbb\xbb\xd3\xf9\xe5\xcd\xd5\x70\xf0\x8d\x60\x9d\xcb\xf9\x29\x6f\xe7\x5d\x10\xb4\x55\x1f\xb3\x2c\xee\x1d\x50\xca\x6e\x3b\x2f\xc0\x32\x75\x38\xd9\xce\xd8\xe6\xd7\x29\x0e\x85\xb7\x01\x6d\x6e\x25\x0a\x60\xd3\x53\x9a\xbe\x4c\xd0\xb7\x6d\x6a\xf3\xf5\xf5\x33\xee\xd9\xc2\x26\x32\xfe\xef\xbf\x9a\x3f\xf4\x81\x21\x09\x79\x88\x22\x80\xc1\xbf\x9b\x69\x5b\xef\xe0\x07\x5b\x98\x5f\xf3\x18\x5b\x18\x43\xe5\xa6\x90\x0f\x6e\xf2\x1c\x2e\xa9\x92\x3a\x40\x50\xc5\x03\x60\xad\xdc\x9d\xcf\x2e\x6e\x16\x5c\x91\x60\x0c\xa8\x61\x45\xbd\x4d\xe3\x4c\x38\xff\x04\x37\x8d\x20\xc1\x7f\x91\xf2\x77\x69\xf4\x0e\x25\xd0\x17\xf4\xdc\x32\x0a\xe0\x48\x2f\x3c\xc7\x3f\x70\x45\x21\xe7\xed\xd9\xe5\xf1\xe4\x6c\x0a\xbf\x1d\x9f\x4d\x27\xf3\x2f\x86\xad\x39\x59\x7e\x0a\x04\xe7\x58\x15\xed\x31\xcb\x4b\x6f\x9c\x77\x8a\x32\x36\x43\xe3\x83\x54\xb5\x8b\x2c\xd1\xfa\x9d\xc3\xe7\x75\x60\x2d\x5d\xd2\x89\x02\xbd\x3a\xf3\x82\xd6\xb4\xa4\x1c\xca\x5c\x9c\x5d\xd2\x42\xe3\x84\x82\x7f\x1a\x8f\x3d\x3f\xc1\xbf\x76\xc2\xe8\x45\x6b\x2c\x7f\x8f\x62\x42\x4e\xf3\x0e\xc0\xf0\xa2\x01\x90\x76\x01\xc1\x5e\xdc\x3f\xdc\x5c\x2e\x26\x54\xaf\x62\x01\x7f\x9c\xdd\xe5\x55\x2b\x7c\x47\x49\x1d\xe3\xcb\x98\xcb\x63\x5c\xcb\xd2\x15\x25\xf1\xc4\x2b\x8e\x75\x9c\x8d\xeb\x6b\x81\x36\xa6\xf8\xdd\x9d\xb8\xc7\x9b\x84\xe4\xab\x21\x09\x6a\x8f\xff\x6e\xf2\xc1\x04\xbb\x7e\x66\x95\xcc\x26\x22\x2a\xff\xd7\x20\x33\x5a\xe1\x96\x35\x88\x22\x5c\xfa\xea\x70\x8f\xd0\x4b\x52\xaa\x04\xbd\x8b\x90\xfa\x35\x4d\xc0\x4e\x8c\x0f\x5f\x84\xe1\x61\x77\x46\x77\x59\xe8\xcd\x4a\x86\x2a\xc7\x87\xa7\xfe\xdd\xfc\x06\xb8\x4a\x95\xf9\x76\xd9\x59\xdd\x4a\x01\x5a\x14\x0f\x2e\x5b\x33\x39\xbd\xde\x69\x73\x2b\x31\x81\xf7\x89\x71\x1a\x7d\x12\xa1\x73\x36\xf9\x66\x7a\xe6\x5c\xcd\x2f\x3f\xce\x4e\xa6\x73\x10\x4e\xdf\x4e\x77\x12\x98\x0a\x05\x67\xb6\xea\xf1\x7d\x33\x07\xc0\xf3\xea\x1d\x86\x72\x06\x61\x25\xcb\x9b\xda\x32\x02\xe5\x75\x2f\x43\xfc\x24\x9e\xab\xcc\x55\x5f\x7c\x3b\xfd\xae\xe9\xfa\xe2\xbc\x62\x01\xfd\xbe\x64\xff\x6a\xcb\xbf\xbe\x64\x75\xea\x01\x4c\xda\xa9\xf6\x6b\x97\xc2\xc1\x15\x23\x47\x03\xb1\xeb\x67\xef\x1e\xfe\x83\x7f\xca\xf9\x2b\xc2\x2f\x80\xc7\x79\xeb\x03\xee\x7f\xbf\xc3\x94\x01\xda\x40\xef\xd2\xf5\xe6\x9d\xf2\x8b\xdc\xf1\x0c\xd2\xbd\x77\xa7\x1d\xf5\xe8\xc6\xc2\x53\x6a\xd5\xee\x2a\x15\x8b\x76\x3e\xe0\xb0\xa3\x94\x6c\x25\xf5\x37\xfe\x6a\x4c\x8a\xd2\x6e\x22\x80\x64\x49\x51\xed\xaa\x55\xb2\xcc\xda\x61\x9f\x4d\xe1\xa2\x60\xa3\x8a\x5c\xdc\x15\xe2\x58\x55\x87\x2c\x1f\x3b\xe6\x49\xb3\x71\x8e\xe7\xd3\x93\xe9\xc5\x62\x36\x39\xa3\x11\x06\xce\xf5\x77\xd7\x67\x97\xa7\x77\x27\x73\x98\xe4\x3b\x34\x78\xe5\xac\x51\xad\x49\xe8\x6b\xb9\xa5\xae\xdc\x44\x76\x18\x05\x01\x82\x1b\x9e\x2a\x36\xa2\x33\x89\x6a\xe9\xe4\x32\x80\xf2\x79\x12\x33\x79\x38\x0f\xad\xc2\x70\x29\x51\xbb\x87\x3a\x8e\x84\xda\x12\x11\x15\xa3\x9c\x8c\x51\x8e\x7c\xc4\xd8\x6f\xdf\x14\xa8\xae\xa1\x92\xea\x14\x90\x54\xc0\xd8\x15\xa2\xc1\x70\x90\x57\x22\xc2\x76\xa4\x19\xe5\x00\xec\xe1\xaf\x72\xa1\xfd\x15\x09\x72\xf8\xee\xeb\xfc\xbb\xaf\x0d\x49\x7e\x2d\xdb\x1d\xb9\x25\x69\x69\x0a\x72\xb2\xfc\xec\x46\x58\x59\x76\x36\x89\xb9\x7a\xa8\xa0\xc1\x79\xf7\xe3\x35\x1a\xa9\x68\x72\x94\x6f\x6d\x64\xb4\x8e\x1a\x0a\x4d\xdf\x5c\xf3\x19\x4c\xaa\xc6\xbd\x56\x80\x31\xf0\x2b\xef\x9f\x11\x38\xc9\x73\x12\x44\xab\xa3\x77\xef\x5a\x54\x54\x2b\xc4\xa2\x25\x11\x76\x8d\x2a\x33\x53\x00\x48\x20\xcf\xfc\x30\xfb\xe1\xdd\xb9\xbb\x1c\xcc\x52\x5c\x3b\x8a\xa9\xb4\x56\x28\xd0\x93\x96\x4f\xce\xe1\x23\xfc\xc0\x4d\xab\x8c\x45\x54\x67\x4a\x1c\x3e\xb3\x64\x61\xd4\x94\x28\x23\x23\x53\x73\x8b\xf4\x94\xba\xa5\x1d\xf1\x17\x92\x2a\x65\xe4\x2c\x10\x96\xdb\x4f\x77\xe0\xce\xae\x54\x0d\xb3\x8e\x2e\xb1\x7e\x06\x99\x37\xe0\xc8\xd9\xa2\xf0\xfc\x47\x38\x63\x16\x1f\x2e\xa9\x67\xd7\x07\xac\x35\x09\x5a\xb6\xec\xdf\x35\x81\x73\x0e\x8f\x15\x58\x37\x9b\x2c\x75\x70\xb7\x29\xb9\xfa\xcd\xb3\x0a\x10\xc8\x2b\x7a\x22\xec\x03\xd9\xf2\x4f\xc4\x0f\x51\xbc\x86\xdd\x7f\x3a\x5d\x28\x7d\x4b\x6a\x6e\x20\x80\x91\x80\x43\x67\xf6\x40\xa5\xe3\x08\x1e\x16\x03\x50\xe5\x82\xb7\xbe\xeb\x8c\x3d\x2c\xd2\x7d\x85\xa6\x30\xd5\x54\x4b\xc2\xa4\x52\x0f\x49\x0a\xea\xc8\x48\x55\x15\xa0\x70\x5b\xec\x0e\xbe\x78\xde\xf0\x4a\x51\xef\x24\x22\x95\x1e\x5a\x15\x54\xf5\x0e\x37\xe2\x21\xd5\x30\xc0\xb0\x92\x08\x93\x0a\x51\xe1\x7c\x04\x80\x28\x5f\xc9\xef\x05\x8c\x90\xa0\x09\x9a\x4a\xd2\x03\x11\xfc\x18\x79\xf2\x91\x7f\x3c\x54\x25\xe3\x41\x49\xc4\x4c\x3b\x2f\x5a\x52\x51\x2f\x42\xa3\x8b\x36\x6e\xfd\xc4\x4f\x95\x03\xc9\xdd\xf8\xf0\x54\x72\xb8\xc4\x92\x5e\x0f\x5c\xd1\x0b\x03\xff\x0f\xab\xb7\xe3\xe5\x03\xcf\xd5\xed\x9b\x77\xdb\xaf\xdf\x61\xb9\xec\xdb\x37\x80\x94\xf8\x09\xf3\x1f\xd6\x5e\x8a\x91\xf0\xdb\x37\x26\x37\x8e\x0a\x63\xff\x61\xfc\xf4\xf4\x34\x46\x2e\x8e\x01\x36\x06\x86\x01\xbf\x01\x6e\x03\x40\xcf\x39\xf8\xdb\xff\xc0\x45\x7a\x44\x37\x59\xb5\x47\xeb\xc9\xf3\x9c\xff\xf9\xce\x34\x28\x0e\x5a\xa2\x32\x7b\xd9\x30\x06\x3e\x80\xb0\x1a\xa6\xc2\x30\xac\x5a\x1b\x1f\x3a\x8e\x76\x81\x59\x50\x37\x77\x86\x26\xcd\x78\x7b\x80\xb3\x79\x74\x43\x21\xdd\x46\xc9\xce\xf0\x8a\x4a\xea\x6e\xb0\xd8\x76\xd2\xdd\x64\x44\x08\xed\x76\xa3\x02\xd4\xae\xf6\xba\x06\xbb\x91\x15\x5e\xc1\x92\x46\xc6\xff\x02\xbc\xaa\xc1\x7f\x28\xd8\xdd\xfd\x08\x7d\x38\xfd\x60\x29\x03\x5d\x82\xd5\x6c\x86\xda\x75\x4d\x34\x28\xff\x7b\x01\xdc\x60\x49\xda\x17\x86\x7a\x43\xd2\xbe\xa0\x77\x30\x13\x15\x36\x49\xed\x1e\xa9\xbf\x9b\x77\x5b\x4b\xfd\x09\xb9\x9e\x9e\x5f\xcd\x2e\xfb\x10\xd2\x89\x21\x35\xb7\xfc\xdd\xb9\x5c\xb8\xea\xef\x01\x96\x14\x98\x86\xa5\x60\xac\x0e\xb1\x9d\x80\x17\x2f\xe1\xc3\xa1\xb1\xfb\x6a\xfc\x00\x9a\x6a\x16\xc3\xbf\x81\xbb\x72\xde\x4f\x27\x8b\x9b\xf9\x0e\xc1\x27\x0a\x6a\x62\xb4\x88\x1d\x0c\x68\xbf\x71\x31\x7c\x99\xdf\xf3\x78\x25\xd0\x9d\x87\x2b\xc2\xed\x8e\x00\xb6\xd8\x39\x78\x37\x18\xfb\x65\x8d\x09\x6d\x98\xbb\x1f\xf5\xc6\xc4\xd0\xfe\x94\x2a\x90\x1b\xc8\x50\xca\xa4\xf4\xff\x94\xf9\x85\x72\x66\x11\x71\x9e\x05\x97\x89\xc3\x8b\x46\x2a\x01\x61\x31\x4a\xca\x15\xd0\x31\xcc\x11\x97\x91\x3b\xf1\xc5\x2a\xa2\x5c\x2e\x11\xc2\x55\x02\x43\x55\xf4\x4d\x06\x66\xd6\x76\xbd\xfa\x35\x90\x09\xca\x37\x51\xd8\xc8\xc7\x95\x48\xc7\x5c\xc9\x63\xcc\x95\x3c\x76\x5a\x25\x58\x11\xdb\xf9\x5e\xb5\x77\x1e\x04\x42\xd6\x0a\x93\x41\x76\x32\x8c\x60\x8c\x7c\x7b\xb7\xb8\x7c\x27\x4b\x0c\xff\x13\xf9\x5b\xfe\x09\xad\x13\x79\xc4\x1e\xff\x46\x7f\x7f\xa1\x8f\x19\x40\x70\x45\xbd\xf3\x39\x42\x9d\x6c\xc9\xf1\x9a\x9d\x01\x59\x18\x60\xa1\xa5\x83\xf1\xc3\x81\x79\xb3\xac\xbf\x66\x95\xe8\xfa\xdf\xef\x4e\x64\x8a\x71\xf2\x4e\xc6\x03\x82\xde\x75\xef\xc6\x96\xe7\x6b\x8c\x28\xc5\xf7\xee\x02\x34\xa6\xdc\xb9\x6b\xef\x1f\x7e\x67\x81\x01\xa3\x3d\x7f\x1e\x53\xa8\xa1\x7c\x55\x2c\x1f\x6d\xba\x5e\x33\x97\x71\x7d\x99\x71\x8c\xc3\x36\x21\xa7\x10\x7e\x3f\xa6\x1a\x32\xca\xcc\x9a\xe9\x03\x48\x75\xae\x60\x53\xf0\x9f\x4d\x2b\x79\xc2\x12\xfb\xcf\x83\x63\xff\x00\x35\x68\xaf\x43\x5f\xdd\x51\x18\xae\xdd\x8d\x54\x9e\xf5\xce\xde\x87\x8b\x3b\x07\xbb\x7e\xc6\x90\x97\x7d\x5c\x57\x1a\x61\xee\x76\x65\xe9\x09\x7a\xf7\x6b\x4b\x4f\xb6\xb7\xcc\x21\x27\xde\x6b\x5d\x53\xb9\x9b\x12\x67\xfb\x95\x72\x11\xe0\x9f\xfa\x22\x80\x7f\xa3\xab\x7b\xfb\x75\xfe\xf3\xd7\xf4\xd5\xe0\x45\x1c\xe5\xd7\x8e\x61\xef\xef\x10\xd5\x03\xef\x92\xba\x98\x0c\x86\x40\x86\xc7\x7e\x69\x6e\xfa\x55\x6e\x3b\x30\xec\xdd\x2c\x5e\x55\xa7\xad\x72\xe9\xd8\x03\x6c\x55\x89\x5a\x87\x3a\x90\x38\x93\xeb\x61\xd8\xe9\x66\x18\x4a\x86\xbf\x3f\x8c\x6f\xdc\x1d\xa4\x3e\xda\xbd\x2e\xd2\xbd\xe6\x79\x23\xd8\x7d\xe0\x8a\x8f\xb9\x7c\xaf\xde\xbf\x17\xd3\x3f\xde\xed\x24\x8a\x19\x60\x9d\xe9\x2e\x47\x50\xfc\x6a\x17\x34\xca\xfe\x86\x50\x87\x6e\x1b\x09\xca\x6a\xd2\x40\xd8\x7b\x59\xcc\x45\x44\x16\x03\x84\x89\x8d\xbf\xda\x09\x97\x71\x51\x26\xc8\x83\xe3\x9b\x71\xbd\x8d\x55\x77\x92\xef\x4d\x3d\xaf\x6a\xc6\x58\x3e\x14\x1f\x87\xa7\x8d\x95\x3a\x10\x3d\x06\x3a\x8b\xdd\xd4\x04\x02\x12\xa7\x7b\x01\x42\x21\xb0\x5a\xd8\xe9\xfd\x33\xbb\x38\x99\xfe\xe3\x30\xb8\x32\xf6\x1d\x6e\x97\x7e\x1c\x85\xe8\x92\x18\x6f\xdd\xd8\xa7\x3b\x2b\x19\xf1\x06\x81\x4d\x28\xf8\xd7\xb0\xca\xe7\x37\x9d\x86\x8e\x67\x03\xed\x14\xfb\x0f\x42\xb7\xed\xca\x5d\x80\x19\xc6\xc5\x61\x92\xbb\xab\x6d\xcd\x6a\xdf\x1b\x64\xd8\xeb\x85\xb5\xce\x98\x37\xc4\x8a\x67\xbc\x53\x8d\x5e\xe9\x32\xbe\x84\x50\x75\x1f\x9a\x05\x4b\xcb\x78\x24\x96\x96\xa1\xa4\x63\xd3\x74\xe3\x4c\x2f\x3e\xde\x7d\x9c\xcc\x8b\x1f\x3e\x4e\xce\x6e\x86\xae\x2e\xcb\xcd\x5d\x96\xc7\xfc\x27\x2e\x8a\x39\x18\x36\x2a\x88\x54\x4f\x4e\xdb\x13\xf1\xe4\x9b\x5f\x72\x2c\xc5\x60\xb0\xac\x01\x21\x28\xd2\x82\x76\x82\xd5\x2e\xc3\xba\x07\x19\x0e\x26\xa2\x6a\xd0\xa5\x9f\xca\xb6\xdd\x1d\xe1\x57\x67\x82\x4f\xd9\x9d\xe7\x43\x25\xf4\x7c\x3e\x1e\xa2\xc5\x7e\x2c\x53\x26\xf7\x94\xf5\x60\xe8\x21\xc3\xdf\x37\xe7\xf4\x8e\x26\x72\xf8\x29\x6e\x00\x1c\x78\x06\x28\x53\x37\x47\xef\x09\x6f\x57\x93\x37\x03\xd4\x37\xc0\x5d\x99\x35\x70\x54\x86\x6d\x9c\x74\x05\x53\xcb\x19\x53\x65\x5e\x4e\xd0\x94\x5d\x1d\xf0\xc3\x99\xf3\x3d\x66\xa2\xdd\xc9\xfa\x7d\x47\x7f\x46\x69\x77\x84\xd7\x7f\xfa\x0f\x7e\x22\x8b\x0b\x16\x9e\x26\xab\xc0\x98\xa2\x64\x89\xa2\xfc\x07\xbc\xdd\xc0\x72\x13\x3f\x80\x0a\xa1\x7f\x91\x11\x1c\xe3\x4d\x22\x32\x2f\x1a\xa7\xe9\x33\x7d\xfd\x10\xc5\x18\x22\x59\xfc\x52\x79\x33\x8c\xaf\x87\xb2\x60\xdc\x50\xb0\xaa\xfd\x65\x76\x33\x78\xbb\x69\x99\xc0\x71\x38\x41\xa8\xb5\xec\x8e\x40\x06\x2e\x84\x56\x29\x34\x14\xec\xae\xfa\x37\xf6\x7b\xdd\x0d\x02\x57\xb7\xaf\xb3\x7e\x0e\x02\x97\x85\xbd\xf2\x9e\x6d\x5e\x7d\xab\x32\x55\x0b\xbf\x7b\x82\xf3\x4e\x63\x7a\xb1\x7c\x5c\x89\xe0\x25\x33\x72\x35\x8a\x96\x9c\xdc\x9d\x80\xbf\x58\xf6\xad\xee\x79\xa3\x9c\x0d\xec\x4d\x19\xae\xba\x64\xe1\x0b\x59\xc9\x4d\xc0\xfb\xb3\x93\xb7\x40\xdd\xcd\x52\xde\x1b\xf8\xee\xb6\xf2\xde\xec\x6f\x9b\xcd\xc6\xeb\xcc\xc0\x15\xf2\x42\xd7\x0c\x06\x5c\xd1\xe1\x76\xbc\x70\x98\x50\x5f\x44\x1b\x07\x04\x2f\xa0\x0a\x67\x1b\xcf\x96\xbf\x6c\xf6\x95\xf7\x75\x22\xf3\x9f\x6b\x33\x99\x65\x66\xf7\x27\xf8\x2a\x0b\xf1\x8f\x81\x87\x17\x53\xd3\x3f\x97\xf8\xfb\x71\x48\x16\x45\x25\x2a\x76\xc9\x73\x41\xc7\xf1\x58\x07\x91\xec\x2b\x0f\x46\x0e\xed\xf5\xf2\x31\x35\xc2\x86\xc4\x18\x64\x19\xba\xa8\xac\x65\x4e\x76\x4c\xc8\x2c\xd2\xf0\x22\x09\x99\x25\x14\x3d\x12\x32\x77\x42\xd7\x1c\xa6\xe5\x3b\xe7\x93\x7f\x1c\x2b\x56\x8f\xeb\x73\xb1\x3a\xac\xd8\xcf\xb8\x50\xff\x0f\x48\xaf\xea\x37\x92\x5f\x47\x7a\x55\x6f\x9a\x5f\x2b\xbd\xaa\x37\x61\x9d\xd2\xab\x1a\xa1\xee\x23\x17\x68\x18\xae\x6e\xc9\x57\xad\x00\x7b\x27\x5f\xb5\x41\xec\x92\x7c\xd5\x77\xd3\x2f\xe6\xa8\x9a\x4c\xe7\xf3\xcb\x39\xee\xe4\xc9\x02\xcb\x53\xc3\xf6\xa5\x4c\x1d\x2c\x0b\x77\x05\xbc\xf8\xf9\x67\x98\x37\xf8\x7b\x1a\xc7\xd6\xda\x95\x16\x0c\x6e\x48\x25\xe9\x68\x38\x98\x09\xec\xe4\xa1\x14\xd1\x83\x83\x52\x4b\xef\x0d\x92\x5a\x16\xe8\x33\x2c\xe4\x49\xbd\xf3\x44\x5e\x2e\x1c\x0b\xf5\x2b\xb8\xb8\x6c\xb1\xa1\x84\xea\xc7\xc4\x7d\x95\x75\x4b\x6a\xa3\x5a\xef\xc6\x5d\xb9\xd4\x38\xdf\x4e\xf1\xae\xd4\xfe\xf2\xcf\xce\xaf\x92\x5c\xe7\xed\x09\x27\x5c\x1d\xe9\x30\x59\xe1\xd9\x5a\x70\xbd\xc8\x20\x9c\xb7\xb3\xbc\x24\xab\x30\x4a\xb2\xba\x47\x54\x70\x50\x35\xa7\x4d\x23\x4b\xc9\x5c\x18\x2f\xae\x27\x99\xe0\x53\x2e\x93\x3b\xd2\xdf\x90\x1f\x06\x63\x24\xef\xb9\x7e\x64\xc2\x05\x0a\xb9\xc5\xeb\xbd\x90\x00\x6c\x01\x2a\x85\xe5\xc6\xad\x0d\xb9\x79\x69\x4d\x01\xe8\xff\x8e\x75\xe1\x8d\xce\x83\xf9\xf3\xdc\x55\x10\x45\xeb\xa3\xef\x6e\x7d\x07\xe8\xac\xd6\xdc\x6c\x1c\x26\x45\x7a\xae\xdd\xf8\x93\x48\x61\x02\x97\x7a\xc0\x9c\x63\x86\x85\x9a\xdc\xbc\x5f\x62\x53\xa1\xf6\xe2\x80\x44\xc8\xcd\x4a\x14\x11\x44\x50\x11\x0d\x8e\x32\x2f\xd9\x5e\x6e\x98\xd8\x4e\x34\x75\x07\xf1\x43\xcc\x13\xe3\x78\x4a\x0c\xb0\xac\x94\x17\xdd\xc7\x28\x48\x11\x20\x3c\x5c\xe6\x37\xc9\x54\xff\x8e\x8d\xa8\x41\xb9\xd3\xd0\xfe\x43\x89\x31\x24\x38\x91\xa7\xfd\x7d\x04\x67\x3d\xde\xcc\xb8\x7f\x35\x5d\xd2\x9c\x88\x6a\x66\x24\xd6\x4a\xa1\x06\xb1\x66\x5f\x4c\x40\x0a\xba\xce\x3d\xf7\x5c\xdd\x30\xd3\xb1\x2e\x27\xc0\x5c\xc2\xf2\x27\x3a\xf9\x83\xa5\x70\x68\x1d\x6d\x78\xba\xb0\xad\x3a\x2f\x67\x7e\xc2\xd7\x4b\xcf\xde\x5c\xd1\x46\x22\x76\x43\x29\x40\xc4\x4e\x29\x25\x88\x9d\x48\xd3\x17\xe3\x7b\x6c\x04\x8e\x74\x21\xe7\xde\x31\x03\xfb\x52\x85\xbb\x3f\xa5\xd2\xcc\xd5\x02\xac\x05\x6e\x12\xf7\xdc\x77\xcc\x45\xd7\x46\xea\xa3\x1b\xae\xa8\xbc\xc8\xd6\x17\x4f\xdc\xa5\x5a\x85\x80\x2c\xa3\x2c\x4c\x47\x28\xe4\x3f\x49\x77\x17\x59\x64\x39\xdb\x75\x2d\xd6\xd8\x2b\x9f\xbe\xe1\xbe\xbc\x4d\x85\xf0\xcf\x23\x8f\x3b\x30\x46\x98\x87\x9a\xb9\xdc\x23\x04\xd6\xac\xac\xb9\x0a\x23\x90\x4b\x75\x84\xdf\xb2\xe5\xd7\xe8\xe7\x94\x64\x48\x06\x2d\x8c\xc2\xcf\x44\x05\x4c\x13\x6e\xd2\x4e\x05\xf4\xe5\x78\xcd\x6d\xc6\xd4\x57\x4e\x81\xb6\x91\xb0\x74\x30\xb7\x93\x24\xa2\x4e\xbc\x37\x12\x43\x29\x35\x4a\xff\x6c\x45\x2b\x9f\x6b\x6c\x04\x48\x80\xa9\x0d\xba\x7c\xda\x5e\xdf\x58\x03\xe6\x46\x5a\xe6\x0b\x16\xd0\x62\xf9\x09\x41\xeb\xc2\xf7\x76\xd8\x98\xff\x1b\x47\xd8\x7b\xcb\xe8\x9e\x6a\x87\x8c\xb9\xc8\xce\x7b\x4e\x46\xa6\x44\xe6\x2d\x5c\x84\x50\x4c\x52\x85\x65\xff\x23\x75\x76\x93\x3d\x6e\x13\xe7\xf8\xac\xf0\xc0\x71\xe0\x9f\xfb\xd8\x78\x8a\xdb\xc2\xe3\x4e\x59\x72\x61\xed\xe0\x19\x53\x18\x8a\x8f\x12\xac\x43\x4c\x83\xc8\x36\xab\xd8\xf5\x04\xf7\x80\x02\x98\xc5\x7c\xe9\x23\xad\x1d\xaf\xe0\x90\xc9\xee\xc9\x34\x6a\x26\x4d\xc3\x07\xff\xbf\xaa\x56\x60\x36\x81\x7d\xe6\x2a\xf4\x82\xc6\x55\x1c\x69\x61\x74\xd4\x32\x15\xc8\x09\x8c\x57\x70\xa4\xc5\x11\x5e\xc3\x1d\x4b\xf7\xcb\xc0\x0e\xea\xe6\xe3\x85\x11\x5e\xc1\xd2\x72\x57\x2b\x3f\x8a\x59\xf9\x80\x33\x32\x73\x79\x9c\x34\x40\xb7\xef\x08\xeb\xa7\x4e\x16\x48\xf8\x20\x02\x9b\x04\x38\xcd\x7c\xcf\x95\x1d\xdf\x2d\x6d\xb5\x15\x14\x3c\x63\x2d\x50\xa8\x79\xb1\x6c\x1b\xdf\x0c\xa4\xd4\x0f\xdf\xe7\x24\x16\xe9\x79\xb8\x17\xb8\x82\xa5\x3b\x02\xf3\xf8\xb1\x9d\x70\xe8\x92\x0d\xe0\xf8\xbd\x72\x05\x73\xdb\x7c\x60\xf7\x9c\x43\x4a\x11\x40\x09\xac\x7c\xb2\x0d\x3c\x96\x61\xf7\xb0\xcb\x78\x6e\x75\x48\x13\xdd\x2a\x9f\x34\x1b\x3a\x51\x13\x6b\xdf\xa6\x99\xad\x5b\x7e\xa1\xab\x3f\x1e\x50\x20\xc7\x43\x91\xc3\x8e\x54\x7b\x67\x7e\x9b\xc7\x84\x83\xa4\xe1\x62\x8b\xb0\x39\xdc\x10\xc3\x88\x1a\x6f\x5b\x7b\xf2\x17\xb0\x78\x85\x2e\xff\xdc\xc4\x0b\x9b\xd4\x69\xbd\x3b\x0e\x49\xcd\x2d\xb4\xe4\xc7\x6f\xe4\x8a\xb5\x9e\xe8\x96\xa9\x4b\xa8\x63\x9b\x31\x25\x88\x53\xb2\xba\xd2\xdd\x5f\xee\x7f\x38\xbb\x02\x6c\x4a\xf2\x9c\xbb\x9d\x48\x1e\x5a\xde\x52\x55\x16\x42\x35\x32\xee\xf9\x26\x1f\x37\xe7\xcf\x0f\xb7\xd1\xa7\xa6\xb5\x00\x04\x7c\x80\x1b\xd1\x16\xad\x3d\xd8\xca\x23\x79\x24\x52\xf8\xce\xf0\x90\x61\x6d\x31\xd8\x57\xb0\x59\x53\x55\x34\xc2\x5f\x6f\xb0\x0b\x1d\xa8\x80\x05\x5a\xf1\x27\x2a\xc2\x8e\x1f\xaa\x14\x33\x6d\xfd\xd7\x4b\xdd\x72\x30\x67\xb7\x8e\xa3\x57\x59\xe4\x93\x7a\x49\x0d\xee\xf1\x28\x36\x17\x40\xc3\xbb\x0e\xd6\x76\xc7\xbb\x93\x53\x58\x33\xb2\xdd\x9c\x7a\x8d\x9b\x79\xe1\xfd\x66\x2d\x01\xd6\xd3\x8e\xed\xfe\x32\x38\x42\xb6\xbe\x3b\xc2\xe2\xed\xbe\xbc\x1c\x89\xc4\xcd\x2f\x57\xc0\x4c\xd2\x89\xe8\xc4\x31\x28\xcd\x6b\xf8\x37\x50\x4b\x95\xea\x43\x6b\xb1\x7a\xb5\x42\xb1\x7b\x57\x16\x62\x21\x37\x58\x24\x94\xaf\x28\x4b\xb6\xd1\x3d\x14\x76\xfc\x9a\x7a\xce\x3f\x62\xf7\x5f\x50\x25\xec\xe7\x23\x8f\xd2\x73\xb5\x1e\x7f\xe8\xfc\x81\x79\x83\x4c\x5b\x72\xa7\xbe\x4d\xf6\xcb\xbf\xa9\x32\xf5\xf2\xa2\x0b\xbc\xf3\x7f\xf9\x77\x6e\x28\x04\xa2\x3f\x0a\x52\xab\x82\x17\xad\x37\x19\xf5\xe0\xf7\x70\x29\xb2\x8a\x97\x3c\xba\x5f\x39\x64\xd4\xc3\x55\x67\x4a\xae\xbc\x97\xa5\x8d\x66\x37\x58\x46\xc0\x59\x34\x96\x62\x2f\x41\x9c\xad\x2d\xb7\x14\x26\xa8\xc8\xe0\x62\xf3\xca\x9c\xe3\x4d\x14\x52\x65\x3d\x04\x80\x7a\x45\x2e\x3a\x65\xc0\xf5\x88\xf7\x23\x16\x4a\x49\xdd\x4f\xb8\x06\x9f\x1e\x11\x49\x83\xee\x41\x74\xb2\x82\x86\x60\x71\x8d\xf9\x7a\xea\x73\xd1\x3b\xe2\xc5\x08\x9a\x29\x3c\xa1\x0c\x0a\x51\x1a\x8b\x7b\x98\x4e\x75\x1c\xe3\xaa\x0f\x96\xb0\x3b\x1d\x58\x67\x40\xab\x5d\x87\x89\x42\xb8\xc4\x93\xd1\xd7\xcb\xd6\xdc\x94\x1e\x2e\xf5\xd8\xab\x00\x53\xc2\x48\xd3\xdc\x6f\x93\x0e\xab\x27\x90\x48\x49\x92\x88\x29\xa1\x1b\x20\xf6\x0c\x64\x72\x7c\xd9\xbb\xe6\xb5\xba\x72\xdc\x5a\xe7\x5e\xf3\x0b\x54\x1a\x12\x7b\x9f\x91\x51\x70\xa1\x8a\x3c\x69\x62\x52\xfc\xfa\xb5\xf0\x69\xf3\x4c\x3b\x04\xb4\xd4\xa5\x6c\x33\x2b\xf9\x73\x4d\x5f\x01\x41\xdc\xd5\x44\x86\x02\xc9\x1f\xb9\xe1\x31\xff\xf8\x22\xcd\x60\x80\x30\x9f\xef\x0e\xc0\x04\x7f\x85\xb6\x6f\xaf\xae\xdd\x8b\x49\x65\xe5\xf7\x92\xf1\xa4\x4c\xf8\x6b\x34\x88\x39\xa6\x43\x1a\x6f\xed\xdc\xcd\x2c\xb2\x36\xda\xb9\x0d\xa7\xd8\x1e\xf5\xc8\x69\x31\x65\x5f\x98\xbd\x1e\xeb\x0d\x36\x84\xca\x6d\xe8\x9c\x23\x71\x09\x03\x59\x0b\xf5\x4b\x58\x28\x45\x61\x7e\xe4\x28\xab\x7b\xd4\x9b\xd8\x25\xce\xae\xa6\xb5\x2c\xce\x4b\x90\x5b\x28\xf3\xd0\xaf\x45\xce\x11\x3c\x6f\xe4\xdd\xcc\xc1\x82\x9c\x64\xae\xa2\x2e\x9b\x51\xfc\xfc\x5f\xfa\x51\xa8\xa0\xca\xcb\x8d\x06\x83\x6b\x2a\x70\xb7\x11\x35\x72\x21\x54\xf6\x33\x5d\x51\xf8\xc0\x5d\xfe\x54\x39\x31\x0e\x8e\xe8\x47\x4e\x2a\x75\x24\x60\x98\x87\x2a\x35\x5a\x05\xb4\x75\xda\x7a\x63\x29\x12\x00\x3b\x17\x17\xab\x47\xfa\x89\x16\x34\x07\xa4\x68\xcb\x62\xf3\xc3\x88\x2a\xef\x3a\xa9\xf5\xc3\xd9\x57\xc2\x14\x92\x21\x57\xa2\xea\x42\xb3\x2c\xc8\x8f\x60\x6e\xc2\x04\xdb\x8c\xc5\x20\xd3\xcf\xe8\x5b\xd2\x20\xb1\xe2\xed\xa7\x10\x2e\x91\xf2\xd1\x04\x2f\xe8\x47\x7d\xa3\x58\x8a\x48\xc9\x76\x43\x25\xd0\xe8\x76\x96\xef\x9d\xbc\xdb\xf2\xe0\xc9\x63\xe3\x0e\xb6\x00\x0a\x23\x1b\xec\x2e\x34\xda\x84\x08\xf5\x08\x94\x82\xc6\xe4\xfd\x60\x82\xad\x22\x04\x37\xc2\x32\xf3\x6b\xe4\x4e\x11\x71\xa7\xd1\x14\xce\x0a\x7d\xa4\xe8\x6e\xf1\x52\x2a\x0f\x1d\x46\xb5\x47\x7b\xa3\xf0\x6f\x27\x1a\x98\xe2\xa3\xa9\x51\x98\x3e\x84\x7e\xb4\x29\x10\x3f\xd6\x38\x09\xba\xa3\x67\x9f\xac\xd5\x46\xde\xc2\x97\x55\xe0\x6b\x1b\x0e\x2a\x27\x7e\xab\x24\x93\x4a\x00\x17\xf4\x63\xfb\xd2\x80\xa3\xca\xb4\x3a\x57\xe6\xa0\x74\x66\x97\xf0\xd8\xe9\x0b\x0f\x52\x15\xd0\x80\x4d\xea\x65\xdb\x7c\x50\xf7\xb2\x0d\x1a\x98\x7a\x9e\x4f\x00\xc8\xe8\x97\x8f\x00\x23\x78\x51\xb0\x2d\x16\xef\x91\xd4\x52\xbf\xc9\xc3\xa1\x68\x02\xf5\x3f\x34\x2c\xf5\x0d\x37\x20\x0b\x2d\x2e\xdc\x45\x0d\x5a\xe8\x9c\xac\x58\xe8\x5b\x88\x78\x8a\xd1\xae\xfd\xa3\xbf\x19\x80\x1f\x9b\xef\x6f\x85\x41\x01\x80\xb1\xa0\x53\xf1\x24\x7a\xb8\x36\xe5\x0e\x1e\x44\x63\x41\xe7\x71\x28\xc0\x32\xae\x90\x5a\x93\x93\xd2\x89\x13\x1c\x60\xbf\x32\xb4\x71\xb5\x60\x53\x07\xa7\x4f\x0d\xb1\xcb\xcb\xae\xd0\x27\x38\xc9\x96\xe8\x31\xf5\xb7\x34\xc5\x36\x63\x78\x89\x2a\xb8\x96\xa7\xea\xbe\x4e\x5d\x8f\xef\x9f\x51\x25\x45\x4c\x89\xf3\x96\x22\x42\xa8\xbe\xb8\xcd\xa5\x5d\xa6\x13\x8d\x6e\xe6\x15\x5d\xd1\x97\xd2\xc5\x3e\xcd\xd2\x94\xdd\x32\xe6\x40\x7c\xe7\x6d\x82\xb7\xd3\x62\x4f\x7e\x9b\xb7\x5a\x0d\x20\x14\x4f\xe4\x2c\x68\x21\x8c\xbb\x9f\x37\xfa\x07\x14\xc4\x18\xed\x0f\x6b\xd9\x3a\x16\x27\x89\xae\xd9\x76\x3f\x8e\x44\x21\x4d\xf9\xc0\x45\xf4\xe5\x70\x23\x54\x79\x8d\xee\xe0\x82\xc9\xc3\x99\xcc\xee\xa7\x2d\x83\xaa\xe9\x5e\xda\x0a\x9e\xcf\x5e\x6a\x09\xd7\x54\x01\x43\xa1\xe0\xa8\x42\xee\xda\x6e\xb6\xc8\xef\xe0\xc8\x29\xe3\xe4\x10\xc2\x16\x7c\x32\xce\x10\x6f\x9a\x12\x7c\x47\xe8\x2d\x2e\x2a\x09\xbf\x8f\x23\x4a\x63\x68\xf0\x9b\x4b\xb0\xcd\x0d\xd8\x35\x24\xac\xc9\xca\xcb\x8a\xba\x20\xb0\xea\xd0\x43\x0c\xa8\x25\x86\x55\x98\x48\x12\xe4\xae\xf6\xe1\x22\x80\x0b\x5b\xe9\x36\x4f\xb9\xdb\x92\x85\xc2\x23\xdc\x7b\xef\xb1\x37\xf6\x26\x4b\x1e\x31\x8a\x80\x61\x93\xd1\xb6\x65\x2e\x35\x4c\xcf\x2f\x6c\x81\x3a\xcf\x24\x5a\x25\xd3\xd8\x07\x41\x8a\x5b\x08\x6f\x27\x30\xd0\x4e\xd4\x83\x0c\x69\x99\xf3\xa2\xb8\x6c\x81\xe7\x21\xd9\x58\x83\x00\xcb\xe6\xb2\x85\x50\x46\x86\x8c\xe4\x27\xc1\xe6\x18\xfc\x80\xf5\x0f\xe2\x34\xb1\x9b\x51\x90\x02\x50\x56\x50\x29\x48\x96\x7e\xb1\x79\xbb\xd0\x41\x22\xc2\x74\x00\xa3\x81\x45\x48\xc8\x56\xd3\x47\x85\x5a\xbc\x3f\xc2\x91\x47\xd6\x22\x34\xd9\x64\x21\x17\x32\xdb\xb8\xcf\xd4\x16\x14\x75\xb4\xce\x64\xc2\xa5\x48\x82\x80\x99\x7b\x70\xd3\x34\x8b\x73\x8f\x45\x29\x28\x84\x9c\xee\x32\x60\xa2\x85\x5c\xcc\x48\xef\xe5\x57\x26\xba\x28\xc4\x47\x0c\x70\x24\x23\x52\x62\x47\x79\x85\xa3\xa1\x48\xdd\xb5\x13\x58\x67\x14\xc4\x84\x35\xde\xe0\xa9\x06\x4a\xb4\x8e\xd7\xb4\xb4\xbd\x6a\x77\x6c\x79\xd7\xf6\xd9\x22\xd4\xf1\x2c\x20\xc2\x5f\xa5\x75\xb1\x31\xb4\x32\x7d\xaf\xdf\x93\x58\x8f\xfd\xbe\xa1\x1f\x6f\xc7\xb1\x74\xeb\xc6\xdb\x4e\x8a\x54\x91\x30\xc8\x85\xfe\x92\xa3\xc2\x95\x5c\x99\x8d\x81\x6c\xd7\x7a\x53\x19\x09\x5b\x5a\x9b\x98\x3e\x84\xb9\xfb\x22\x7b\xff\x94\x71\xe4\x3f\xbc\xf4\x07\xfc\x63\x47\xea\xdc\x7a\x70\x43\xe8\xe2\x53\x1b\x5e\xfa\x20\x33\xb8\xfa\x50\xc1\x87\x76\xe5\xe5\x8e\x18\xb9\xa5\x76\xed\x6a\xdb\x79\xef\xb7\xd0\xd0\xa1\x15\x7f\xc7\xfe\xfb\xc5\xd5\xde\xb5\xeb\x7e\xd7\xde\xfa\x06\xc1\x65\xf5\xb6\x5f\x3f\xfc\x22\x99\x5d\x74\xdf\x9e\x1d\xeb\x2b\x94\x4a\x7d\x17\x00\xec\x28\x41\xaa\x8a\xb3\x01\x74\xc8\x92\xb7\x52\x58\x38\x85\x6a\x56\xe1\x7e\x57\x60\x51\x51\xa8\x9a\xf2\x7a\x9f\x89\x43\x96\x42\x7d\x7c\x72\x95\x98\x9d\x8f\xc8\x81\xab\x08\x35\xab\x9c\x98\x6f\xc5\xb3\x71\x46\x35\xb0\x70\x26\xbf\xda\x9d\x3f\x5a\x4d\xb3\xf0\x27\x27\x89\x4f\xb4\x16\x76\x96\x08\x1b\xca\x1d\x2a\x4a\x6e\x3b\xbf\x87\x6e\x34\x63\xe7\x87\x9e\x0f\x8a\x7b\xf5\xd4\x1e\xb4\xdd\x68\xc5\xd6\x1e\x58\xfb\xd4\x34\xf4\xa1\x98\xc7\x91\x96\xb0\xbd\x8c\xca\x51\xbb\x21\xeb\xf6\xee\x0e\x8b\xb0\x62\x2a\xef\xba\x2b\x07\xae\x2f\x8e\x51\x55\x8d\x71\xac\x6e\x8d\x57\x91\x50\xf9\xb2\x84\xd5\x42\xc1\x30\xe4\x72\x66\x83\xd7\xe7\x17\x54\xc4\x2a\xed\xc2\xee\x29\x7b\xf3\x41\x94\x5f\xb7\x21\x55\xb9\x65\xce\x13\x1a\x1f\x63\xf1\x57\x19\x4f\x21\xc3\x58\x31\x04\x0e\xee\xac\xf6\x48\xb1\x33\x21\x33\x10\x7f\x44\x67\x85\x93\x44\x68\x69\x49\xf1\x0e\x1b\xfb\x0f\x7e\x86\x7f\x1d\x3a\x73\x9f\xa2\xbf\xda\xa9\x18\xe5\x8b\xc4\x0f\xb1\x87\xa7\x43\xe1\x3c\x32\x3d\x70\x44\x7e\x2f\x0c\x6b\x83\x3b\xa3\xd0\x61\x93\x1f\x8f\x27\x57\x2a\xa9\xf3\xda\x31\x0a\xb4\x38\xaa\x40\x0b\xc9\x85\x7b\x0c\x48\x35\xdb\x08\xf5\x2c\x04\x23\xaf\xc1\x57\xcd\x91\xd6\xea\x67\xed\x37\x6e\x86\xa6\xe3\xb1\x3d\x9f\x7d\x2f\x6b\x37\x5d\x3e\xda\x03\x81\x37\x65\xf0\x32\x63\x29\x8e\xfd\x64\x03\x52\xd6\x8a\x2e\x49\xe1\x2a\x6f\xa4\x12\x3c\xb3\xdb\xf3\xad\x38\x5c\x1d\x62\x5e\x9f\xfe\xe9\x0b\x64\xf9\xa9\x9f\x92\xe9\x8c\x7f\x3e\x68\x8b\xf1\xfd\xab\xbb\x75\x73\x08\x87\xf0\xd8\x41\x01\x0c\xb9\x59\x5d\xd0\x8f\xe0\xa4\x7a\xc4\x1f\x52\x77\x35\x1c\xf6\x7f\xdd\xfe\xf6\xf0\xb7\x87\x5f\x1e\xd0\xac\x1e\xa8\x0f\x00\xf2\x0b\x0e\xc9\x86\x65\x8b\xcf\xa7\x18\xa9\x95\xf7\xec\x77\xd0\x28\x3f\xd2\x59\x15\x07\xd2\x4f\x7f\x80\xe4\x1c\x84\x19\x6c\x9e\x9e\xcb\x81\x38\xaa\xda\x6d\x51\xc8\xdd\x32\xc8\x3c\xa1\x56\xa5\x2c\xd5\x34\x2a\x04\xf8\xe5\xad\xc3\xd6\x80\xdb\xc7\x26\xa9\xd8\xed\xde\x9a\xaa\x03\x13\xac\x8d\x23\x70\xda\x24\xd8\x5d\x96\x9c\x03\x82\xc3\x68\x09\x23\xec\xdb\x90\x6f\x4f\x14\x6f\x06\x2f\x8c\x28\x7e\xb6\x36\x02\x50\x7b\xe5\x54\x10\x20\x46\xff\x59\x56\x0d\x17\x75\xb8\xb6\x10\x07\xbf\xce\x2e\x66\x96\x37\xdd\xe4\xf1\x3e\x72\x63\xef\x48\xdf\xcb\x7a\x71\xf7\x84\x02\x21\xa5\xcf\x22\x16\x32\x6e\x89\x8e\x63\x1b\x35\x14\x24\x81\x26\x39\x34\xfe\xa2\x0f\xc3\x38\xbe\x61\x73\x44\x71\x62\x1b\xa5\x89\x8b\xcf\x9a\xbd\x61\x2c\x1c\xb6\x36\xf4\x94\x45\xd8\xee\x4e\x9b\x72\x4e\x5f\x1f\x8f\x9a\x86\xdd\x18\x8c\x62\x00\x96\xc6\x95\x16\x68\x4d\x5c\xc9\x81\xa9\xe7\x9a\x61\xd1\xe5\xbd\x03\x2c\xb2\x0c\xb4\xc0\xea\xec\xb2\x31\x46\x3c\xdc\x6b\x53\x41\xdb\xe8\xb5\x31\x50\x76\x75\xdc\x54\x10\xb4\xd8\x80\x73\x14\x3d\x6c\xbf\x15\x24\xf6\xba\xab\xe6\x74\xd4\xdc\x61\xda\xe0\x9b\x57\x8c\xce\x2b\x31\xbf\x3a\xb4\x81\x6f\x70\x3d\xe5\x60\x3b\x6e\x45\xf3\x86\x21\xa3\xaf\x7c\x95\x64\x11\xc2\x09\xec\xaf\x42\xd9\x09\x32\x7f\x8e\x83\x2a\x83\xa0\xb9\xda\xa0\xc9\x43\x86\xac\x6d\xe5\x0a\x9d\xa1\x9d\xa3\xdf\x02\x8f\x26\x17\xfd\x0c\x20\xbf\x57\x61\xe3\xf5\x44\xfa\x8b\x7d\x0a\xf9\xa0\xef\x5a\xc6\xd9\xe0\x0d\x36\xa6\xa2\xc9\x15\xac\x40\x91\x03\x9c\x5b\xf6\x39\xb2\x65\xdf\x5b\xff\x10\x54\xbf\xf4\x31\x4a\x04\xfb\xc7\xd0\xdf\xc6\x2a\xce\x66\x23\x28\x76\x89\xfd\x0d\x36\x4f\xb9\x22\x41\xfb\xc0\x51\x06\xa0\x46\xf8\x00\x68\xd0\xd5\x8e\x51\x49\xeb\x8d\x1f\x1d\xa1\xf7\x18\x9d\x09\xa8\x0b\x01\x9f\xa2\xa5\x2f\xbd\x88\x45\xcf\x99\xc5\x41\xae\xc6\xd0\x94\x81\x68\xec\xad\x76\xb7\x44\x0e\xd0\xee\x71\x33\x00\x76\x71\xba\x49\x90\x4b\xdc\xfe\x18\xd9\xde\x02\x55\x2e\x1b\x0a\xf7\x69\x02\x98\x74\xf5\xa3\x1b\xcb\xa1\xb3\x2b\x9d\x50\xbc\x9e\x77\x46\x92\xf8\xab\x71\xd0\xe8\xe1\x0f\x73\xd0\x94\x87\xb3\xa3\x8f\x46\x53\xb3\xb3\x8d\xa7\x42\x98\xcd\x23\x33\x84\x57\x9f\xc1\x3c\x57\x59\x37\xfa\x74\xfb\x3c\x46\x39\xcd\x8b\x1d\x0c\x59\xd5\xbd\xb0\x27\x2b\x95\x26\x6e\x47\xf7\x53\x0d\xd3\x77\xf5\x40\x69\xd2\xb4\x3f\x68\x8e\x7f\xf4\xa4\x42\x7b\xa0\x8c\x97\x3b\xa2\xa3\x6b\xce\x30\x64\xfa\xd5\x66\x54\xfb\xf3\x32\x55\x36\xf1\xbe\x1d\x4d\x06\xcd\x5d\x1c\x4d\x5d\xc9\x1c\xee\x68\xea\x48\xe6\x0e\x5e\xa6\x0a\xb1\xfb\x72\x34\x55\x88\x7c\x35\xc3\x69\x65\x48\x9f\xdd\xa1\x93\xf3\xc2\xee\x05\xd8\x83\x18\xb2\xda\xfc\x07\x4d\x9b\x9a\x07\x36\xca\x16\xc3\xdf\xf3\xef\xd9\x47\xb8\xdb\xd9\x65\x1a\xf6\x8b\xd8\x2c\xf3\x63\xa2\x1e\x38\x13\x75\x16\xeb\x1d\x87\x61\x31\x64\xf7\xa6\x10\xa3\x9a\xa9\xc0\xcc\x91\xb1\x60\x8d\xaf\xad\x82\x87\x9f\x21\x82\xec\xaf\xd6\x23\xe5\xf2\x2e\x18\x5a\x86\xbd\x1b\x65\x14\x97\xb6\xfb\x99\x09\x0f\x36\xdc\x08\xc1\x0f\x30\xbc\x8f\xc2\xcb\x30\xbb\x50\x05\x75\x95\x26\x30\xb7\xe6\xd9\x74\xf0\x22\x35\x54\x69\x4f\x49\x11\x43\xa5\xd2\x85\x4c\x22\x36\xb9\xab\x80\xe6\x3e\x14\xd2\xe5\x40\xcb\x87\xc8\x5a\xe1\x04\xab\xb8\x58\xc2\x9a\x7b\x8c\x41\x33\xd4\x1c\x42\x6f\x72\xab\x34\x1a\xf6\xd1\x66\x6a\xf2\xb2\xfa\xc8\xad\x68\xd9\x71\x46\x0b\xd7\x78\x03\x46\x33\x32\x6c\x43\xc0\xf1\xd5\xc2\xf4\x60\xb4\xa3\xc3\x17\xab\x39\xa8\xcd\xc8\x28\x40\x32\x4f\x65\x40\xbb\x06\x97\xa4\xa0\x70\x77\xd2\xc4\xb9\xca\x77\x17\x76\xab\xa2\x0d\xb6\x2b\x0c\x11\xe7\x62\x9a\x1b\x56\xaf\xec\x48\x1d\x9a\xf8\x31\x0a\x51\xb5\xe9\x75\x60\x3e\xc9\xc4\xc0\xdd\x22\x1e\x51\x79\x37\x56\x4b\xe8\x91\xfd\x3d\x4b\xf8\x6d\xf9\x52\x27\xea\x93\x48\x65\xc9\x3f\x64\x21\x4f\x9a\xaa\x58\x81\x81\xfb\x68\x68\x61\x45\x84\x52\x29\x70\x31\x21\x5e\xb2\xc9\x0b\x33\xce\x38\xc8\x01\x34\x0d\x4f\xc6\xa4\x22\xe1\x58\xd2\x0b\x77\xe5\x4f\x58\x65\xc0\x0d\x6b\xee\x41\x95\x23\xb8\xfb\xb9\x97\x0f\xd2\xbc\x2e\xcb\x9d\x41\x33\x45\x1b\xa3\x88\x5b\x26\xc5\xd8\x55\x80\x3e\x67\x63\x79\xb8\x38\x4f\x41\x20\x4b\x04\xc2\xd8\xad\x83\x7c\x30\xc4\x93\x31\xe2\xb6\xeb\x74\xe3\x88\x95\xdd\xac\xae\xca\x59\x85\x00\x64\x83\x2d\x2d\xc3\xe4\x40\xdb\x85\x7c\x27\x0e\xe0\x3a\xde\xe1\x7e\xb8\x5f\x6e\xec\xef\x76\x59\xc3\x93\x9a\x4d\xd0\xc6\x9c\x17\x63\x4c\xfd\xbe\x68\xd6\x8b\x5f\x88\x41\x28\xd8\x65\xaa\x2c\xfb\x41\xff\x2e\x39\xe8\x35\x2c\xf5\x76\xa4\xcf\x08\x05\xa2\x27\x66\xd6\x6e\xf7\x80\x3f\x57\x5e\x5b\x29\xc1\xaa\xa1\xce\xf5\xf5\x07\x53\xcb\xd2\x06\xf9\x86\xc4\x37\x5d\x62\x48\x9d\x0f\x11\x41\x29\x60\xb7\x62\xfd\x24\xcb\xd5\xb1\xe3\xfa\xeb\xbf\xff\x87\xf3\x91\xf3\xd5\x97\x5f\xff\x0e\xff\x39\xb5\x19\xb1\xcf\x64\xb1\x39\xb4\x93\x51\x09\x3a\xc3\x6e\x3d\xaa\x02\xb1\xe1\x86\x5d\xf0\xec\x70\x33\x35\xce\xad\x48\xe1\x0c\xd3\x85\x2e\x2c\xb8\x3f\x1a\xb5\xf2\x40\x9b\x5e\xc1\x45\xfe\x97\x7f\xc1\x64\x0a\xca\xfd\xeb\x18\x63\x7f\x12\xc9\xca\x00\x41\x14\x63\x32\x6a\x94\xa5\x1b\x6b\x5f\x6b\xe6\x31\x3c\x29\x93\x3e\xf9\xd9\x26\xb8\xdc\xdf\x88\x3c\x81\xd4\xf0\x48\xd5\x41\x6a\x40\xa0\x73\x91\xf3\x42\x44\xfc\xb2\x6d\xea\x22\xe5\x76\x50\xfe\x46\xaa\x74\x21\x53\xd5\x64\x76\x0a\xb6\x92\x55\x9e\x0b\x52\x79\x40\x23\xd9\xfa\x11\xf0\x98\xb2\x79\x12\xae\x74\xd3\x98\xdd\x76\x91\x7b\x1f\x88\x38\x65\xdf\x71\xeb\x92\xdb\x30\x71\xc5\x5f\x67\xd1\xd6\xcf\x3d\x1b\x9c\x11\xa1\xd2\x7b\xa4\xd7\x1f\x2b\xae\x78\x9c\x14\xe1\x77\xcf\x92\x93\x63\xe6\xf6\x42\x32\xad\xc3\x7d\xc0\xd4\x29\x1c\x8e\x5d\x77\xa3\x31\x6c\xb7\x72\x04\xa5\xbc\xa3\x68\x13\x71\x95\x84\x9c\x40\x2b\xfa\xe5\x27\x11\x8f\xfd\x35\x25\xdc\x44\x3a\x57\x92\xb7\x0e\x6a\x69\xef\x3c\xe3\x91\x31\x8a\x3d\xdb\x0e\x9a\xc1\x7a\xe0\xca\x20\xf4\x46\x29\x81\xab\xb0\x9d\x6c\x80\x6d\x34\x66\xe8\x20\x21\x44\x98\x70\xd6\x1a\xab\x80\xa1\x2c\x9e\x7a\x2b\xbf\x1b\xf2\x2b\x16\x1c\x64\x6c\xe7\x61\x1b\x15\xb2\x6d\x63\x3d\x91\xa6\x74\x63\x54\xa5\xf7\x1a\xd0\x24\x47\x8d\x50\x8f\x6c\xef\x72\x6d\x3e\xc7\x4d\x31\x01\x1a\x64\xba\xeb\x07\xc2\x53\x35\x43\xb0\x36\x07\xd6\x4e\xbf\xe1\xc2\x73\x14\xe7\x42\xc5\x8f\x46\xba\xbc\x59\x42\x4b\xcd\xdd\xc2\x7b\x1c\x6c\x85\xdb\x07\xa5\xf1\xca\xdf\x0a\xe2\xac\xed\x58\x58\x30\xfb\xb7\x5c\x00\x57\x11\x82\x5e\xbc\xd8\xcf\x92\xa5\x9f\x46\x65\x32\x6a\x8b\xd7\x96\x8a\xc5\x8d\xcc\x9a\x62\x21\xa7\x3b\x7b\x14\x1e\x25\x53\xad\x41\xee\xe1\x54\x1a\x57\x3d\xdb\x51\x23\x49\xd2\x95\xa4\x64\x51\x94\x83\xc4\xa1\x8e\x96\x49\xb6\x06\xb2\x45\x92\x47\x6e\x51\x36\x9a\xb3\x16\xa9\xeb\xb9\xd6\x18\x09\xac\xae\xa6\x5f\x17\xb5\xc5\x51\xb0\x4d\x6d\xcc\x51\x3a\xa5\x00\x2f\xc7\xf5\x15\x7c\xae\x99\x8c\x18\x13\x1f\xab\x96\x58\x06\x81\xf5\x9b\xcc\x32\x52\xc8\x2c\x01\x7c\x46\x89\xc6\x55\x93\x6c\x66\x19\x62\x70\x7d\x01\x28\x3f\xdc\xc2\x5f\x5a\x3f\x52\x85\x8f\xea\x49\x98\x5e\x7c\x9c\xcd\x2f\x2f\xce\xa7\x17\x0b\xe7\xe3\x64\x3e\x9b\x7c\x73\x36\x75\xa8\xdf\x88\x2d\xb8\xe8\x74\x7e\x73\x75\x35\x73\x4e\x66\xf2\xf9\xd9\x19\x7d\x98\x9c\x7f\x33\x03\x20\xd3\xee\x68\xae\x6d\x9b\xa2\x16\xae\x65\x8f\xe4\x8d\x03\x6c\x9c\xd2\xed\x58\xdb\x00\x38\x95\x52\xfb\x89\x2e\xae\xef\xdd\x63\xe5\xff\x55\x14\x78\xed\xcf\x2d\xa9\x1b\x41\xec\xae\xef\x56\xf7\xb7\x6f\x8e\x7e\x57\xdf\x69\xa0\xfc\xce\xff\x7e\x87\x15\x73\x48\x4b\x7a\x97\xae\x37\xef\x94\x2b\xed\x0e\x14\xa3\x07\x7f\x65\x6d\x30\x50\x84\x93\x3a\xb7\x6f\xb0\xc0\xf6\x28\x7a\xc0\xc2\x5b\xab\xe4\xf6\x4d\x2b\x5f\xfe\x4f\x1d\x77\xfb\x74\x9f\xf9\x61\xf6\xc3\xbb\x73\x77\xc9\x1f\x0d\x24\x85\x76\x6c\xd4\x9b\xae\x30\xc8\x0d\x96\x26\x4a\xb0\x2a\x6b\x42\x6d\x25\x62\xd8\xb4\x54\x5a\xc0\xe8\xa4\xf1\x47\x00\x11\x3d\x25\x8e\x2a\x2d\x08\xc8\x44\x1f\x3c\xb7\x6f\x7e\xba\xbd\x2d\xa2\xba\x45\x64\xb7\x26\x3a\xf8\xf0\xb3\x6e\x3a\xa2\x30\x5e\x45\x4f\x22\xbe\x7e\x84\xfd\xdf\x73\x5c\x9d\xd0\xe1\xf8\xd2\xc2\x8c\x34\x00\xed\x32\xbb\x5d\x16\xe8\x8b\xce\xd4\xdc\x5f\x91\x5b\x41\x69\xac\xf0\xa7\x64\xe5\x7f\xce\x57\xdd\x7c\xed\xb2\xb1\xb8\x42\x8c\xc6\xee\xdd\xeb\x3f\x13\x3f\xd8\x82\x0e\x69\x97\x25\xdd\x77\x55\x67\x24\x72\xce\x24\x9e\x5b\xc2\xd4\x67\x7a\xfa\x8c\xa6\x8c\x47\x8d\xa8\x37\xac\x6e\x12\x73\x08\x6c\x2d\x45\x9d\x7e\xc7\xc7\xcb\x4d\x77\x8f\xad\xf9\x9f\x93\xbe\xc7\x49\xaf\xdf\xe2\x7c\xd1\xd0\x6d\x81\xd8\x86\xa0\xcd\xbe\x32\xac\x5e\x15\x95\x40\x9d\x38\xb1\x46\x5b\x4e\xb4\x21\x5f\x42\xd1\x50\x0b\x46\x5c\x15\x37\xcf\x97\xf2\x04\x0b\x12\x58\xee\xb5\x92\xb8\x0f\x8b\xc5\x15\x66\xaa\xfc\xf0\xac\x4a\xd9\x63\x5d\x76\x45\x5a\x0b\x31\xdc\x6a\xe3\x87\x67\x09\x05\x4d\x4f\x26\x09\x00\xa9\x11\xf7\x70\xbf\xe2\x64\x5f\x4e\xc5\x22\x25\x7b\xf2\x29\x56\xa9\x7b\x31\x87\x62\x1d\xfd\x7d\xfc\x89\x16\x52\x07\x38\x13\x25\x25\xc0\x1d\xd9\xc6\x92\xad\x67\x2d\x78\x23\x7e\x5a\x2f\x27\x7a\xa7\x79\xc5\xf6\x73\x20\x4e\x06\x78\x0f\x25\xa2\xa2\xf3\xd0\x30\xfd\xb4\xfb\x0d\x27\xfb\x77\x1a\x1a\x44\xbd\xa4\xcf\x70\xf2\x19\x1c\x86\x34\xb4\xd7\xf2\x17\x4e\x3e\xab\xb3\xb0\x3c\xd4\x5d\x7d\x85\xc3\x47\xfb\x22\x8e\xc2\x97\x1c\xfd\x8e\x7e\xc2\x3d\x72\x62\x6f\x3e\xb0\x1a\x7e\xbc\xae\x8f\xb0\x81\x29\x9f\xdd\x41\xa8\x99\xd3\xcf\x3f\x58\x1e\x52\x4f\xe7\xa0\x15\x6b\x17\xdf\x60\x3b\xee\x8e\x8e\xc1\x69\xb8\xcd\x33\x7e\x81\x5d\x1f\x5d\xe9\x83\x77\x9e\xdc\x44\x96\x54\x4d\xad\x79\xcc\xae\x7c\x97\xaa\x6f\xfa\x8e\xbb\xbe\xf7\x55\x08\x5a\x0e\x28\xcc\x8b\x67\xba\xaa\x74\x95\xb5\x77\x02\x99\xad\xe5\x2a\xad\x8d\xe7\x46\x0e\x9d\xde\xcc\x4e\x0e\x8e\x6c\xc5\xb4\xb8\x7e\x37\xd1\xa3\x97\x58\xf3\x5a\x91\x72\x57\x81\x6d\x20\x8c\x8e\x52\x6e\x31\x40\x7a\x6b\x0b\x09\x19\x7c\x9d\xd2\xb9\xb4\x2c\x17\xed\x51\x69\xa7\x4d\xd8\x96\x2a\xbf\x3d\x2f\x2e\x06\x9c\x6e\x1d\xb8\x05\x2b\x97\x28\x55\xa0\x9a\xc7\xa9\x31\xcb\x71\xb6\xb7\x11\xed\x31\x64\x13\x58\x17\x1a\x52\x59\xb3\xb6\xb5\xfe\x7b\x27\x06\x00\xb4\xb6\xda\xee\x25\xfc\x8d\x65\x72\xdb\x70\xb6\x96\xc3\x2d\x23\xab\x09\x0c\x3d\xec\x50\x4e\xbe\x8d\xff\xb6\x32\x07\xed\xf5\xe4\x99\x40\xaf\x36\x33\x87\x37\xd0\x00\xf2\x0e\x44\xb7\x54\x9d\x1a\x04\x5d\x88\xac\x4f\xd8\xe9\x52\x98\xb9\x9d\x50\x4b\xea\x4e\x87\x6a\xcc\x92\x48\x6b\x54\x48\xe7\xa9\xf5\xba\x84\x86\x0c\xa3\x81\x4f\x9f\xfd\x52\x92\x9f\x45\x8d\x34\xe9\xee\x2d\x24\x72\x72\x21\x61\xf7\x20\x15\xc9\xc1\x0e\x00\xec\x76\x2b\x88\x9b\x02\xa0\x4e\xf8\xd9\x40\xb2\x3b\x01\x64\x15\xe9\x8c\x5f\xd8\x14\x82\xae\x2b\x75\xb7\x25\x61\x45\xdf\x6b\x45\x74\x20\xa2\xdb\x6a\x78\xe0\xf6\xbf\x86\x8b\x1c\x2f\x24\x43\x76\x30\x2d\x05\x11\x2f\xc9\x5c\x59\xba\x52\xe4\x2e\x6e\xbf\xf3\xfe\xad\x52\xc6\xd9\xcb\x03\x8e\x48\x83\x30\x62\x49\x85\x9e\xce\xc4\xec\x4f\xe0\x19\x54\xed\x41\xd8\x29\xfa\x5a\xda\x68\x34\x13\xd1\xdc\x18\xa3\x88\xa8\xac\x30\xe6\x47\x47\x97\x14\x86\x46\x3a\x1a\x95\x48\x1b\x9e\x1d\x48\x7e\x41\x2a\xbb\x11\x56\x97\x0b\xb5\x23\x71\x96\x22\x5a\x1d\xe9\x8a\xe2\x27\x37\x26\xd2\x50\xa4\x74\xb8\x01\xf8\x61\x14\xa4\x71\x44\x8f\xbb\xcd\x2a\xef\x8a\x4b\xf5\x52\x6c\xe3\x32\xf2\xec\x6a\x76\x57\x20\x58\xc7\xd8\x16\x48\x51\x3d\x38\x64\x33\xbe\x48\x75\x91\x36\x8b\x20\x03\x34\x5b\x90\x45\x01\xab\x61\xa4\x04\xb1\xbb\x5e\x53\x2b\xa2\x41\x14\xc0\x07\xb1\xf1\x83\x68\x15\x15\x8a\x4a\x77\xe3\xa0\xea\xd0\x49\xfd\xc4\x39\x2e\x90\x03\x81\x60\x8e\xdf\x83\x0a\x7e\xe5\xa6\x8f\x5d\x97\x4f\x99\x33\x07\xd4\x3e\x3c\xca\x3d\x4f\x3e\x46\x00\xea\x08\xa0\x22\x86\x0e\xb4\xd2\x95\x00\x99\xbd\x97\x89\xc2\x16\xe6\xd4\x46\xa2\x03\x66\x7c\x91\xb9\xb3\xfd\xfa\x1d\xad\x95\x61\x53\x55\xa9\x98\xed\x1a\x00\x3b\xd0\x81\x22\x02\xeb\x29\x71\xb2\x69\xe3\xca\x6f\x59\x33\xf0\x2e\xb9\xb3\x28\xd1\x14\x03\x5f\x95\x04\x5a\x47\x61\x94\x25\x1d\xe9\x91\x6b\x45\x85\x83\x31\x8b\x30\x5e\x6b\x18\x59\xa5\xc0\xaf\xbc\xa1\xaa\x19\x04\xd6\x8d\x32\xae\x50\xc5\xfd\xae\x04\x77\x60\xd2\x69\x72\xcd\xb7\x9f\x26\xe8\x54\x28\x05\x23\x8e\x11\xc5\xfc\xea\x58\x99\xe0\x3a\x5f\xf3\x0f\xa8\x20\x0a\xc7\x2c\xd7\x24\x9d\x02\xc8\xe6\xe1\x81\x98\x48\x1e\x5d\x52\xfd\xfe\xd7\xf5\xe5\x45\xab\x4c\x95\xcf\xe7\x2f\x34\xc0\xc6\x16\x2f\xb9\x50\xa5\xc6\x83\xc4\xb1\xce\xda\x24\x28\x8c\x58\x1e\x5e\xd5\x18\xe0\xbe\x81\x34\x48\x14\x8a\x8d\xe3\x52\xb8\x3b\x75\x98\x69\xc4\xdc\xbf\xbd\x0c\x53\xb0\x01\x4e\x75\x66\xab\x8b\x65\xca\x12\xbf\x95\xa5\x0a\xa8\xac\xa2\xd6\x19\xae\x12\x15\x79\x75\xb4\x46\x2c\x22\x46\x99\xd2\xdf\xd4\x75\x20\x30\xfd\xbd\xb7\xa9\x6b\x13\x47\xca\xe4\x87\x51\x2f\xc8\x70\xea\x39\x4c\x0d\x63\x49\x9a\x1f\xec\xb8\xcf\xea\x30\xec\x0f\x64\x2e\xaa\x70\xe3\x89\xb8\xfb\x12\x17\x70\x87\x88\x62\xbd\x73\x51\x80\xa7\x7c\xa8\x69\x48\x0d\x24\x60\x44\x51\xd5\x42\x38\x40\x49\x0b\x44\x5a\x5c\xee\xda\x50\xd8\x4d\x37\x53\x84\xa8\xdb\xf3\x10\xc4\xc6\xa5\xb9\x0f\x2a\xe2\xfb\x8e\xf8\x80\xe1\xbd\x51\xf6\x9d\xea\x06\xdc\x7a\xb2\x9b\x89\x78\x00\xfc\x8f\x74\x68\xe7\x95\x21\x7a\x08\x53\xa3\xa1\x59\x64\x54\x86\x20\x60\x6d\xcb\x2c\x74\xd7\xfb\xb3\xfe\xe1\xd8\x55\x2f\xc4\xfd\x5a\x00\xa5\xb0\x22\xd5\xae\xcf\xaa\xd0\x42\xaa\x75\x21\x68\xf8\x5a\x71\x42\x9d\xa9\xb8\x20\x76\x92\x2a\x58\x48\x31\xd8\xea\x2a\x29\x43\x36\x33\x56\x52\x0c\xb2\x4a\xd5\x94\xce\x5b\x39\x05\xf5\x9f\x28\x00\x86\x2c\x3f\x0d\xba\x09\x95\x81\xec\x2a\x6b\x13\x77\x6b\xca\xb9\x1d\xa1\x51\xa8\xf2\x1e\xad\xd9\xd5\xad\xb5\x8f\xc5\xac\xa9\xe4\x24\xb6\x3b\x4a\x80\xb8\x4b\x9f\x37\xa2\x9f\x5d\xb0\x48\x9c\x5f\x03\xae\xcd\x38\xc8\x2e\x90\xd2\x1d\xb3\x53\xa3\xc3\xaa\x72\x6e\x78\x44\xaa\xf9\x74\x5d\x9a\x1a\x96\x49\xda\xcb\x1c\x56\x09\xdb\xcb\x14\x62\x7b\x41\xba\x3b\x44\xbb\xb8\xb1\xd0\xa0\xc4\x27\x47\xd8\xdb\x8d\xf5\xa3\xbf\xd9\x94\x26\xae\xbb\x0b\x29\x5a\x6f\x62\xa5\x70\x77\xcc\x7d\x64\xac\xb5\xc6\x30\x4c\x7b\xe2\xaa\x08\x58\x92\x99\x8b\x51\xbb\x09\xc7\x57\xc5\x2b\x4a\x11\x63\xbf\xfb\x15\xde\xcb\xe0\x95\x03\x60\x7b\x6a\x7e\x44\xf1\x0b\xf7\x2f\x8c\x64\xe4\xf4\x4c\x11\x1f\x3a\xce\x7b\xbc\xc5\x50\x3b\xfc\xe7\x30\x75\x7f\x80\xf5\x1d\x6c\x46\xd4\x4a\xeb\x2f\xcb\x07\x15\x6d\x99\xaf\x92\xf1\xe3\x5f\xac\x1e\xed\x03\xc1\x4c\xa8\xa7\x7f\xeb\x0b\x14\xfa\xb1\x9b\xac\xc9\xb1\x4c\x41\x06\x40\x7a\xc4\x8b\x86\x7c\xfe\x48\x2c\xb1\xe7\x60\x04\xd2\xca\xfc\xac\x7b\xdb\x73\xc7\xc0\xb5\x88\x23\x1a\x44\x1c\xc1\x18\xae\x30\x2c\x2f\x80\x0f\x3e\xa2\xc7\x7a\x99\x49\x2a\xb0\x5c\x5a\x42\xb5\x2c\x41\xc9\x4c\xf1\xcb\x91\xb3\x85\x1b\x68\xc3\xb8\xec\x73\xd2\xa2\x28\x34\x2a\x00\x47\xce\x45\xc4\xc5\xaf\xa9\xc4\x74\x4b\x0e\xad\x02\x88\x77\xb5\x4c\xf6\xf3\xa5\xce\xaa\x92\x47\x9d\x97\xd1\x11\x1d\xb0\x1e\xc6\xb3\x3a\x4f\x2e\xef\x24\x42\x0d\x13\xbd\x74\xfe\x1a\xdd\xd3\xfd\x00\x1e\xa5\x74\xc2\x03\xdc\x65\x54\x5f\xd8\x56\x0c\x5c\x11\x86\x50\x11\xa6\x21\x23\x53\xb8\x17\xb9\xd2\x8c\x81\x99\x83\xa9\x21\x08\x64\x57\x6b\x17\x26\x61\x19\x63\xb1\xf6\x02\xd6\x46\xfa\x3b\x6d\xf5\xd6\x8d\xcc\xf9\xbe\x09\x25\xfc\x92\xfe\xc1\xc9\xb8\x42\x76\x9d\x05\x0e\x61\x2c\xad\x08\xbd\x4d\x04\xeb\xa4\xdf\x79\xf8\xc3\x86\xcd\x19\xa6\xf1\x90\x43\x10\x5d\xb6\xe0\x45\x0f\x58\x61\xf0\xdd\xd6\x0d\x32\x38\x28\x5c\x3f\x4e\x64\x8f\x74\x27\x5a\x52\x9f\x33\xcf\xec\x93\x0d\x93\xee\xc6\xa0\x68\x20\x8b\xbe\x5b\x07\xd7\x21\x88\x1f\x91\x22\x9b\x6c\x3b\xae\xd4\x21\x7b\x2b\x74\x57\xcf\xd0\x31\xad\x7d\x20\xc6\x84\xac\x32\x88\xc4\x00\xdf\x54\xaf\xf6\x42\xf7\x6c\x87\x24\x56\x54\x4b\x42\x67\x0e\x24\x05\x16\xd8\x48\x17\xc5\x8e\x7b\x40\x3b\x2e\x8e\x32\xf5\x2d\x58\xf5\x91\xa2\x51\x26\x42\x31\xdd\xf9\x1f\xb7\xd9\x97\x5f\xfe\x56\x38\xc4\xfc\x11\x49\x43\x3f\xa5\xd0\x1c\x2a\xe0\xb5\x80\xb3\xfb\xe7\x9f\x6d\xc2\x2c\x87\x5c\xe4\x2a\x45\x1e\xfb\x64\x1c\x90\x45\x1b\x0d\x34\xc0\x4e\x92\x5b\x22\x2e\x60\x68\x1d\xc3\x55\x1c\xa1\xc5\xe4\xb9\x34\x96\xfb\x28\x0a\x84\x6b\xed\x84\x50\x7d\xb1\xb4\x00\x98\x22\x05\xc6\x96\x73\xda\x81\x10\xb5\x94\x31\x0d\x3b\x5c\x59\xfb\x42\xb7\x12\x94\xaf\x48\x86\xf4\x68\x6b\x72\xdf\x81\x26\x38\x03\xee\x45\x5c\x9d\x56\xf5\x78\xeb\xf4\x36\x93\xca\x47\x8c\x39\x9b\x65\xc0\xb5\x84\xbf\x9f\xcc\xce\xa6\x27\xb6\x5c\xf7\xcb\x0b\x67\x3e\xbb\xb9\x3e\x9e\x2d\x2e\x2d\xaf\x4f\x27\x8b\x9b\xf9\xd4\x79\x7f\x36\x39\xb5\x65\xaa\xce\x2e\x4e\x66\xc7\x93\xc5\xe5\x7c\xe6\xbc\xbf\xb9\xf8\xd3\xec\xf2\xc2\x92\x9d\xfa\x9e\xf2\xaa\x1d\x2e\x1f\xad\x7c\x65\x71\xc4\x49\xd5\x18\x2a\x63\x3d\xd4\xcc\xa4\x67\x59\x3f\x8a\x1b\x35\xc7\x19\x76\x01\x2e\xf9\xc8\xf2\x66\x26\xb6\x63\x50\x52\xf2\x20\xd2\xe5\x63\x41\xe9\x4c\x06\x44\xe7\x20\x19\x20\xd2\x37\xa8\x01\xa0\xc9\x47\x69\x9a\xbe\xd6\x34\x3b\xc4\xe5\x94\x29\x62\x17\xf0\x3e\xc8\x61\xa7\xef\x00\x12\x60\xfd\x85\x69\x32\xf0\x5e\x60\x90\x80\x11\xdf\x04\xcb\xef\x72\x1f\x28\x53\x01\x73\x3b\xe6\x00\x75\xd4\x15\x68\xb5\xb0\x0f\x74\x0e\x7f\x2e\x22\x59\x19\x44\x96\x1a\xda\x95\x5b\x46\x70\x7a\x9d\xf3\x55\x86\x16\xf2\xa2\xeb\x48\x45\xd7\x41\xee\x81\xd1\x41\x25\xca\x7a\x08\xc3\xc9\x4e\x11\x73\x81\xd5\x7c\xfd\x0d\x5d\x7d\x54\x55\x95\x76\x02\xc3\x3d\x6c\xb3\x5a\xd4\x92\xb3\x2b\x1d\x81\xaa\x30\xd2\x1b\x3d\x79\xcd\x6b\x16\x20\xb9\xbb\x5f\x61\x09\x6a\x17\x7b\x79\xed\x75\x23\xa0\xfb\x18\x4d\x51\x33\x20\xb8\xa2\x3a\x08\xa2\xdb\x0a\xb4\x89\x30\x38\x0d\xf8\x3a\xe4\x60\xba\x1d\xb3\x5d\xf6\x23\xb9\x53\x35\x26\x9a\xbc\x18\xe6\x69\x81\x80\xf8\xa8\x20\x58\x32\x6f\x26\x37\x10\x16\x01\x77\x24\x4b\x69\xa7\x23\xd4\xbf\x64\x51\x10\xf4\xe4\x88\xda\xde\x4b\xd6\x53\xad\xd8\x94\x2b\xd7\xb9\xf3\xea\x1f\xee\x88\x63\xac\xd5\xd1\x27\x9b\xdf\x70\x76\x4c\x6d\xb4\x76\xcb\x89\x07\x84\x4a\x8f\x5f\x93\x1f\xab\xb6\xc6\x88\x1f\x14\x9c\x85\x48\xb2\xdd\xbb\x95\xa3\xe3\x02\x3c\x6c\xe2\xee\x3e\x6d\xaa\x02\x4f\x61\xae\x08\x88\x05\x9f\x4c\x69\xc2\x90\x01\xfe\xf3\x7d\xe0\x62\x45\x57\x59\x34\xd1\xb3\xe9\x5d\xef\x55\x8e\x52\xe5\xcd\x3c\x18\xd2\xe6\xc0\xb0\x22\xe5\xa4\xab\x01\x38\xbb\x21\xb4\xb9\x09\x25\x5c\x8b\x2b\x10\x43\x29\x28\x07\x80\x2f\xfd\xe8\xf0\x0e\xb0\x1f\xd4\xda\xfd\x84\x5d\xe0\x63\x99\xe6\x45\x73\xfe\x83\x4f\x09\xa6\xa9\x2c\x60\xb3\x71\x61\xf2\x80\x58\xfc\x71\xd3\x14\xef\x21\x71\x84\xda\x40\x40\x58\xa8\x35\xfb\x88\xf4\x3e\xb8\x62\xa2\x43\x0c\x13\xc1\x7c\x69\xfb\x12\x68\x1c\x61\x5b\x18\xec\xce\x65\x14\x27\x85\xb4\xc1\x12\xde\xfa\xa1\x45\xd8\xaa\xe8\x5e\x06\x3a\x61\xaf\x2d\xb4\x07\x50\xca\x6e\xbc\x6e\x32\x92\x35\x81\xf3\xb8\xe1\xc4\x5b\x8f\x0b\x49\x6d\xe2\x88\x6a\x03\x61\x78\xb7\x01\xd8\x56\xc7\x08\x60\xfc\x08\x9a\xba\x19\x6e\xfc\x96\x37\xb6\xb4\x1a\x21\x10\x01\x40\x2c\x05\x8d\x0c\x1a\xf0\x0e\xdf\x63\x4c\x35\x98\x13\xb2\x3d\x29\x8c\x4d\x08\x65\x19\x21\xce\xa5\xa3\xd0\x8d\x3d\x71\x73\xed\xaf\x62\x77\xd8\x50\xe8\xd5\xbe\x03\xe9\x53\x9c\x96\xd1\x58\xea\xd2\x36\x21\x89\x85\x94\x6e\xdc\x0f\x5e\x8d\x8c\x97\x4a\x23\x32\x90\xdc\x20\xe1\x6a\x4c\xe6\x6a\x88\xb4\x48\x62\xd1\x69\xac\x59\xb8\xb7\xa5\x7f\x3a\x5d\x2c\x66\x17\xa7\xce\xf5\x62\x32\x5f\x58\xef\x8d\xb3\x8b\xc5\xfc\xf2\xe4\xa6\xe1\xaa\x77\x7a\x76\xf9\xcd\xe4\xcc\xb9\xbc\x5a\xc0\x33\xd6\x0a\x44\x97\x57\x08\x62\xe6\xf0\xd3\x33\x8b\xbf\xf4\x54\xa4\x70\x93\xd6\x0e\x3a\xdd\x00\x90\xc2\x99\x93\x47\x67\x19\xe0\xc9\x67\x13\x8a\x97\x70\x11\x13\x21\x27\xa4\xea\x57\x65\x0c\x13\x2b\x55\x12\x00\xc2\xb2\x13\x80\xb2\xb1\xea\x69\x61\x33\x1a\x4e\x7f\x53\xeb\x1c\x45\x02\x48\x3c\x69\x01\xa9\x42\xa2\x94\xd9\x0e\x96\xd4\x53\x15\x1d\x18\x04\x2a\xb6\x48\x96\xeb\x83\xc3\xf9\x93\x48\x41\x11\x5c\x0a\x7b\xaa\xd9\x5c\xc7\x52\xf9\x3a\x7d\x51\x06\x17\x91\xe3\xba\x04\xa4\x99\x84\xcd\x26\x79\x99\x46\x36\xf3\x62\x44\x5c\xc1\x2e\xf7\x1a\x8d\x6b\xd4\x08\x0d\xb3\xc0\xe1\xa1\x35\x6f\x60\x6e\xc6\xa7\xd5\x5c\xfe\xe9\xd5\x46\x3c\xf2\xb2\xdf\xd0\xe3\xb6\x27\xd7\xd4\xad\xbf\x7b\x3b\xdb\x1e\x5c\x11\x46\x96\xa1\x2e\xc0\xe9\xfc\xf4\xe2\xed\x8d\x4a\xab\x42\xa9\xbf\x7e\x21\x59\xb1\xea\x91\x28\x52\xf6\x9a\xcb\x87\x0d\x28\x2f\xc1\xa1\x2e\x6b\x31\x37\xbb\xbc\x32\x53\xda\x56\x3b\x87\x83\x7d\x96\x75\xe3\xb3\xca\xf9\x6b\x5a\x24\xb6\x43\xa5\x21\x26\xc0\xdc\x08\xf6\x13\xc5\x1e\x05\x70\x5a\x08\x5a\xde\x2d\x15\x7c\xde\x10\xbc\xbc\xd7\xbc\xee\x0a\xd1\xfb\x6b\x05\xd4\x36\x06\x7f\xff\xcd\x81\xaa\xa3\x69\xeb\x90\x32\xb0\xeb\x79\xeb\xfc\xf4\xee\x97\x32\xb4\x15\xba\x1a\xf2\x67\x68\x70\x56\x60\xc2\x67\x6e\x6e\x66\xb0\x21\x79\xb5\x31\x4b\x57\xab\xff\x8a\xe3\xb3\x55\x1c\xe9\x72\x74\x55\x0d\xd9\xc3\x4e\x1a\xbe\xc2\x26\x79\x67\x52\x9d\x24\xe0\xc3\x09\x04\x00\x3a\x48\x58\xdf\xc8\x32\xd0\x2a\x73\x9e\x6c\x40\x40\xba\x13\x91\xbf\xe8\xd8\x7c\xe8\x16\xdc\x41\xf1\xdd\x46\x94\xb5\x3d\xa1\x48\xd4\xec\x47\xb0\x73\x14\xcb\xae\xed\xea\x0a\xd4\xf6\xa9\x4e\x53\x22\x0d\xdf\x17\x43\x10\x17\x3c\x1d\x15\xfc\x4e\x67\x9d\xbf\xec\xe3\xa8\xa1\xc5\xe9\xb0\x5a\x65\xed\xf5\xa1\x74\x68\x1f\xc7\x6e\xe8\x6b\xf5\x81\x8e\x3a\x58\x23\xa9\xc3\xb1\xf7\x42\xd3\x05\xa0\x0d\x62\x33\x85\x99\x52\x5b\xa9\xcf\x42\x51\xfb\x70\x64\x8f\x2c\xfe\xf2\x14\xbf\xbb\xe8\xb7\x8a\x63\xb1\x8a\x02\xd1\xa0\x6f\x34\x61\x68\x24\xbc\x48\x6a\x32\x40\x2b\x32\x97\x78\xae\xff\xf4\xd5\x75\xd4\x41\x27\xab\x16\x0d\xdc\xef\x66\xa9\xa1\xa4\xdc\xef\xb0\xc7\xe6\x2f\x51\x83\xf3\x9a\x77\x3e\xfc\x86\xfe\xc2\xa5\x17\x16\x0b\x0b\xca\x75\xa4\x3f\x0f\xd7\x95\x6b\xc7\x21\x67\xbf\x86\x10\x61\xd3\xa4\x4d\x52\x5e\x94\x0d\xd5\x62\x52\xbf\x22\xfe\x8c\x2c\xa5\xd6\x7e\xc5\x9c\x7b\xa5\x65\x63\xe5\xcb\xcb\x0d\xf9\x55\x46\xb6\x1f\xf2\x5f\x79\xed\xbe\xda\x4a\xfc\x15\x6d\xd6\xcf\xbe\x2b\x5f\x6b\xfb\xed\x7f\x9b\xe9\xb4\xb0\x64\xf0\xdd\xcf\xdf\xa1\x61\x70\x67\x42\x79\x7b\x0e\xbe\xee\xf9\x75\x7d\x82\x07\x5d\xf8\x12\xb3\xf2\xae\xbc\xb2\xd0\x4a\xef\x50\x05\x74\x0f\x06\x15\xac\x18\x50\x5f\xa3\xb7\x53\x21\xd0\x61\xcc\xef\x35\xd6\xd7\x1c\x57\xd7\x11\x54\xfd\x57\x2f\xd6\xcd\xb9\xb0\xe8\x2c\x7e\xaf\xd7\xea\xe3\x5c\xe1\xc2\xab\x0e\xfa\xb5\x07\x59\xd3\xab\xfa\xe5\x6c\x12\xd5\xde\xd5\x03\x05\x71\x4e\xf5\xce\xf6\x89\x9c\xa6\xa1\x84\x24\x75\xfd\xb2\x1b\x17\x44\x57\x37\x11\x97\xab\xaa\x59\x12\x35\x98\x6c\xf3\xdf\x2a\x9a\x31\x6f\x94\x72\x6d\xae\xf1\x2f\x4c\xf0\x29\x2c\x78\x7d\xee\xbf\x88\xbb\x30\xaa\xc3\x6f\xdf\x03\xb5\xc4\xec\xc7\xdf\xc3\xf9\xb3\xaf\x37\x76\x9a\x5f\x1a\xfb\x67\x19\x2e\x47\xce\xd6\x37\x7a\x7f\x67\xf3\x7a\xd4\xac\xe6\x6e\x03\x95\x81\xb3\x1d\x3a\xbd\xbf\xb3\xba\x3d\x6a\x17\xf8\xf0\x41\x0e\x15\xd5\xfd\x86\xd3\x4f\x2a\x53\xdf\x05\x2a\x72\x41\xdd\xec\x96\x41\xe6\xd1\x99\xcb\x35\x71\x38\x27\xed\x3e\xf2\x9e\x47\x58\x97\xff\xe0\x7f\x1e\x80\x4a\x81\xfd\x46\x85\xe7\xdc\x3f\x63\xfd\x78\x8a\xf2\x73\xd7\x14\xf7\x8a\xc5\x14\xe8\x45\x5d\x34\xa3\x97\xfd\x8f\x48\x59\x8b\xf4\x31\xf2\x9c\xb7\xa7\xd3\xc5\xe8\xea\xf2\x1a\xfe\x73\xb3\x18\x9d\x4c\xcf\xa6\x8b\xe9\x48\xa4\x4b\x5b\x8c\xdd\xb9\x48\xb1\xaa\x3c\x81\xa8\x7f\x77\xb9\xb4\x84\xd7\x7d\x88\x92\x94\x46\xc0\x8d\x09\xd7\xcf\xe3\x24\xbb\xe7\x30\x0c\x1b\xb6\x0b\x64\xf1\x23\xbc\x57\xec\xb8\x58\x7c\xb5\x19\x99\x32\x1e\x72\x0b\xce\xb7\x32\xff\x55\x46\x32\x3d\xba\xf8\xa7\x0c\x05\xb1\x11\x51\x0f\xaa\x05\x6d\x26\xb3\x73\x61\x91\x60\xa3\x3d\x1d\x85\xe7\x9c\x5c\x9e\x4f\x66\x17\x14\xa5\x4b\x01\x97\xcf\x06\x75\x98\xd6\xe4\x5b\xbb\x90\xbe\x10\x46\x8e\x64\xdb\x01\x27\xae\x67\xea\x15\x6a\x42\xde\x03\x2f\x67\x17\xd7\x8b\xc9\xd9\xd9\xf4\xc4\xb9\x3a\xbb\x39\x85\x11\x1c\x5f\x9e\x9f\x4f\x2e\x4e\x6c\x39\x51\xf0\x33\xfc\x3a\x53\x4f\xcb\xd7\x27\xb6\x34\xab\xd9\x2a\x44\x27\x7e\xa1\xee\x8b\x2d\xf6\x0e\x1f\x75\x8b\x55\x5d\x2c\x40\xe5\xc6\xd6\x65\x4e\x64\x91\x21\xb5\xd3\x1b\xfb\xd8\xf2\xcb\x7e\xa1\xc4\x10\x79\x38\x54\x99\x13\x16\x4a\x0d\xed\x6d\x01\x42\x14\x63\x75\x2d\xe7\x26\x71\x57\x02\xbb\xe6\x58\x70\xdd\xa8\x66\x17\xaa\xd1\x23\xa6\xe9\xd3\xf3\x5d\x00\x1f\xf6\x85\x7c\xd8\x1d\xb4\x33\x09\xf3\x64\x76\x3f\x71\xa8\x07\x18\x39\x37\x65\x4b\x60\x7a\x38\x78\x76\x04\xb0\x2b\x82\x05\xd8\x9f\x18\xe7\x26\x34\x92\xce\x81\xbd\x59\x00\xdc\x85\x99\x5d\x52\x5e\x05\x3f\x1d\x63\x54\x99\x9f\x51\x92\x3a\xbd\xe7\x52\x4c\x75\x9f\x91\x1c\xeb\x3a\x7e\x70\x7a\x3c\x04\xee\x2a\x01\xd9\xf7\xc3\x52\x6c\x52\x67\xfc\xf0\x05\xb6\xfa\xc0\x11\xdd\xcb\x68\x3b\xd8\x4a\x4f\x8f\x18\xf9\xcd\xbd\x72\x9d\x35\x50\xe5\x6f\x38\x16\x4f\xf9\x53\x8b\xcb\xd5\x76\xa4\x59\x46\x7d\xc1\x75\xe4\x8d\x88\x7f\x8e\xc6\x89\xb9\x43\x08\xc6\xb3\x62\xf4\x77\xec\xeb\xf2\x3a\xc5\x0e\x55\x6f\x41\xb6\x53\x35\x07\x24\xfe\x6f\x19\x7d\x97\xf8\xba\x33\x2f\x36\x9a\x0e\xb1\x61\xce\x2f\xff\x5e\x4a\xeb\xa5\x46\x35\x85\xdd\x63\x39\x24\x2b\x1c\xfc\x30\x9d\x9c\x2d\x3e\xdc\x1d\x7f\x98\x1e\x7f\x7b\xb7\xf8\xee\x6a\x0a\x5c\x49\x88\x65\xb7\x6f\xb0\x24\xe5\xed\x1b\x5c\x17\xb7\x6f\x60\xa0\xe2\xf6\xcd\x2d\xcc\x4d\xdf\xa5\x50\xc5\x60\x26\x81\xe6\x58\xca\x48\xba\xd1\x7f\x11\xe5\x6b\x59\x1d\x3d\xfd\x97\xeb\x05\x97\x01\x30\x97\x2c\xe7\x67\xf4\xd8\xb1\x56\x52\x48\xb7\x84\x27\x7a\x96\x81\xa9\xc0\x9f\xab\xca\x12\x18\xe4\x45\x2d\x90\x31\x6a\x31\xff\x83\x42\xac\x0e\x50\x37\x53\x64\x24\xfd\x39\x31\x57\xa1\xfc\xcd\x48\x0a\x65\x25\xfc\x1e\x4c\x6a\x18\xc4\x0b\x92\xbe\x17\x82\x95\x4b\x50\x47\x5c\xef\x8f\xe0\x1a\xd0\xbb\x13\x3c\xb9\xba\x72\xae\xa7\xf3\x8f\xb3\xe3\xe9\x1d\x9d\xd5\x17\xc7\xd3\x7d\x51\x5c\x0b\x7b\x2f\x24\x73\xff\x39\x14\xea\x52\xad\xda\x1f\xc5\x0c\x5a\x28\xc0\x7b\x26\xb7\x2a\xe7\xf6\x4f\x79\x15\xc7\x9e\x07\xf1\x82\xeb\x45\x8d\xe1\x45\x97\x4d\x4e\xed\xae\x84\x16\x0b\xe7\xec\x83\xa2\x7d\xb0\xaf\x48\xd5\x10\x5e\x7d\x73\x33\x3b\x3b\xb9\x9a\xc0\xfa\x41\x80\x23\xe7\x62\xfa\xc7\xbb\xe2\x77\xfb\x9a\xf3\x0e\x98\x76\x9f\x7a\x25\x24\x76\x58\xbb\x43\x51\x52\x89\xa7\x0e\x93\xdb\x17\xfe\xd9\xe4\x9b\xe9\xd9\xc8\xb9\x9a\x5f\x7e\x9c\x9d\x4c\xe7\x34\xb6\xc5\xe5\xb7\xd3\xbd\x89\xc2\x32\x02\x21\xc1\xef\x3e\x1b\x15\xd2\x5f\x86\xe0\xdd\x09\xbd\x9c\x9f\x16\xce\x98\x3d\x10\x89\x1a\xbe\xa6\x89\x10\xa8\x93\x66\x1f\x04\xee\x87\x91\x26\x55\xfb\xe1\xa2\xdc\xdb\x7f\xb8\xb9\x5c\x4c\xf6\x48\x65\x01\xec\xee\x84\xce\xa7\x57\x97\xf9\x21\x77\x33\x3f\x7b\x29\xd9\x70\x3d\x3d\xbe\x99\xcf\x16\xdf\xdd\x9d\xce\x2f\x6f\xae\x08\xdb\xd5\x04\x4e\xec\xc5\xe5\x1d\xe6\x95\xdf\xcd\x6f\xce\xa6\xd7\x77\xef\x67\x67\x7b\x93\xb2\x25\x8c\xc2\x8a\x6f\x77\x2e\x16\x51\x8d\xf4\x1a\xbd\xbe\x9a\xec\x4f\x53\xa8\x43\x22\x24\x8a\x7d\x0c\x81\xcf\x88\x6f\xe6\x20\xf1\xe6\x7c\x26\x15\xbf\xdb\xdf\x38\x5a\x31\xed\x7f\x38\x37\xf0\x05\xef\x9c\xab\xc9\xf5\xf5\x1f\x2f\xe7\x27\xa3\x3e\xab\xbd\xef\x98\x6c\xe8\xf6\x37\x30\x7d\x96\xab\x2f\xbe\x9d\x7e\xb7\xef\xd1\xd4\xe2\x78\x81\x21\xe0\x56\x31\x57\xc1\xbe\x75\xec\x0a\x5c\x51\x8f\xee\x85\x86\xf6\x1a\x33\x24\xf6\x3d\x47\x97\x37\xf3\xe3\xe9\x18\x6f\xb3\x8b\xc9\xfc\x74\xba\xa0\x3f\xf7\x45\x7d\x2d\xf0\x3d\x10\xcd\xe2\x76\xef\xca\x01\xc3\xdd\xa3\x7a\x90\x13\xba\x57\xf5\x40\xd1\xb9\x2f\xe5\x80\xe0\x8d\xf3\x2b\x30\x7d\x24\xe0\xe3\x7d\x5e\x87\x0c\x34\xa2\x8a\x64\x4f\xc3\x60\x25\x87\xb6\x7d\xfe\x71\x9f\x03\xa8\x45\xb0\x57\xe2\xf7\x73\x63\xb6\x51\x37\xe8\xce\x9c\x9f\x73\xa0\x8d\x8c\x9c\xf9\xe5\xfe\xd4\xb7\x3a\xd0\xbb\xb3\xb3\x04\x95\x98\xf1\xa2\x74\x9b\x18\x76\x27\xbf\xdb\xbd\xba\x8d\x44\xd3\xa0\x3f\x88\x8a\xcd\x86\x03\x02\xf6\xb3\x22\xfd\x80\xcb\x0c\x17\x32\xb4\x77\x5f\x9b\x00\xee\x0e\xa9\x1c\x49\x2f\xfb\x5d\x99\xe4\x5d\x66\xb9\x1e\xf8\x1e\x26\x78\x1f\xb4\xed\x42\x80\x2e\x82\x21\x87\x47\xc5\xa0\x50\xfa\x6f\x64\x21\xef\x7d\x71\x10\xa7\xfc\x4e\x97\x69\xf7\x7c\x42\x3c\xca\x8b\x42\x09\xc2\x58\xb3\x18\x06\x0d\x8b\x22\x39\x70\x18\xb2\xd9\xe2\x9e\x06\x41\x60\x85\xee\xb4\xb8\x3b\x9d\x51\xe0\x19\xdb\x0b\xe8\x0d\xc5\x53\xed\x7e\xdb\x85\x6a\xac\x4c\x23\xd0\xc5\x1c\xd5\x6c\x3c\xde\x8f\x59\xb4\xad\xfb\x71\x3f\x03\xc4\xb8\x29\x5e\x5d\x38\x3a\xf5\xe9\xa5\x46\x57\x0a\xa5\x2a\x8f\xaf\xf4\xf3\x1e\x46\x18\xaf\x5e\x4e\xee\xd4\x03\xdf\x9d\x68\x19\x96\x3c\x2a\xc4\x99\x8f\xaa\xd9\xea\x7b\x1a\x86\x8a\x22\x1f\x55\x03\xcd\x47\x4e\x6d\xbe\xfa\x1e\x86\xc8\x61\x91\xfb\x3f\xb7\x18\xf0\xee\x07\xd6\xf6\x2b\x75\x25\xc5\x3f\xb5\x4d\x17\xff\x3e\x9b\x5c\x38\xdb\xaf\xf3\x9f\xbf\xe6\xaf\xf6\x34\x1b\xfd\x11\x0f\x9c\x0d\x5b\x65\xb0\x5a\x02\x2d\xf5\xc1\x72\x90\xaa\x5c\xe8\xda\x4d\x8f\xf2\xee\x1c\x68\xdd\xc3\xc2\x84\xd8\xe7\xe3\x36\x85\xff\x0f\x3f\xba\x81\xef\xc9\xa7\xb9\xde\xa1\x8b\x5d\x02\x8e\x6e\xc3\xef\x6f\x43\x80\x8e\xff\x71\x30\xde\x22\x8e\xd2\x68\x19\x05\xb7\x80\xe6\xf6\x4d\xba\xdc\xdc\xbe\x19\xa9\xdf\x3c\x6a\x1c\x44\x04\xf3\xcf\x5f\x7d\x79\xf8\xf5\xef\x7e\x77\xf8\xd5\xe1\x57\xff\xcd\x78\x0c\x43\x36\x12\x7e\xe0\xb7\xbf\xfd\xf2\x1f\x6e\xdf\xe0\x0f\x40\xc8\x9f\xed\xe5\xe1\xd6\x58\xf5\x90\x88\x2b\x0c\xbe\x69\x40\x53\x8e\x46\xc4\x5d\x43\x03\xa2\xb7\xb7\x38\xca\xe8\x75\x07\x65\x99\x20\x2e\x2a\x78\x7c\x36\x93\xd5\x10\x7a\x9a\x90\xe9\x75\xa3\x9d\x24\xf0\xe0\x8a\xfe\xe2\x66\x72\xf6\x78\x5a\xf9\xaa\xd9\x96\x2a\xef\x2d\x5a\x06\x61\x47\x0e\x72\xce\x86\x80\x25\x53\xf3\xbb\xce\xb9\x58\x47\xf1\xb3\x35\x8a\x15\x7e\xf4\x5d\x25\xe4\x5a\x40\xa9\x90\x23\x17\x17\xc7\x38\x14\x2b\x80\xb3\x15\xaa\x7d\x8a\x05\xc5\x99\x51\xf1\xa3\xa6\xa8\xbc\xec\x5b\x42\xcb\x4d\x42\xb4\x7a\x71\x69\x51\x51\xe1\xd7\xda\xf6\x69\xd6\xb8\x66\x19\x35\x48\x2f\x86\x6a\x71\x9a\xcd\xd2\x9a\x11\xce\x65\xd9\x65\xfc\xd7\x1e\x0c\x4e\xb5\x91\x35\xf4\xc8\x78\xa1\x11\xf8\xf5\xf5\x99\x73\x2c\x64\x83\x74\x0c\x41\xc2\x4e\x20\x14\x8c\xb4\xf0\x37\xe7\xc0\xad\xa6\x88\x24\x7c\x51\x95\x2a\x45\x40\x06\xfa\x8d\x68\x02\xd7\x48\x12\xf7\x44\x19\xc2\x61\xd5\xd7\xc4\x1d\xc2\xe6\x0e\x8d\xe8\x16\x96\x74\xc2\x7c\xdc\x47\x96\x82\x28\x0a\x09\x15\xa7\x5c\x65\xb2\x1c\x28\x88\xa3\xad\xef\xc9\x20\xe8\xf1\x92\x42\x13\x0f\x9d\xab\x40\xb8\x30\x6e\xf9\xa3\xe3\x3a\xc6\xba\x8b\xee\xff\x8a\xc2\x9e\xba\x67\x12\xb9\x2a\x24\x1d\x00\xa7\xa0\x01\x51\x6d\xc2\xea\x0b\x36\x19\x71\xac\xc8\x29\x8d\xc3\x45\x8a\x42\x1f\x58\x2a\x8b\xe6\xa8\x90\x44\x01\x64\x1e\x62\x9b\xa2\xd0\x4f\x96\x58\xb6\xd1\x89\x56\x2b\x8a\x45\x24\x6c\x72\xf2\x31\x98\x39\xbf\xbb\x28\xc1\x8c\x24\x8a\x90\x2a\xd5\xd5\xbf\x67\x15\x43\x3c\x9e\xbc\x33\x25\x66\xb2\x60\x45\x18\x4e\xcd\x38\x70\xc6\x4a\x38\xd2\x23\x5e\x04\xea\x03\x06\x74\x52\x29\x5f\xcb\xc8\x4f\x5c\x4c\x2e\x50\xe3\xa5\xd8\xc8\x2a\x54\xd5\xc2\xd2\x90\x9d\xf8\x0a\x55\xed\x8d\xc2\x16\x39\xe1\xf9\xc9\x27\xce\x9f\xa2\x83\xeb\x04\x3e\xca\x74\xac\x7e\xc5\xc6\xff\xa0\xd2\xba\x3c\x0c\xec\x34\xe6\xa8\x2b\xd8\x1d\xa9\xdc\x1f\x61\x6d\xb4\x70\x1d\xb7\x31\xd5\x71\x1b\x73\x1d\x37\x37\x76\xd7\x04\x8e\x7f\x3b\xc6\x9f\xb8\xe7\x87\x85\xa8\x2b\x7c\x43\x60\xa7\xf4\x2a\x34\x73\x9b\xd6\x82\x6c\xa4\x4e\x6b\xfd\xcb\x28\x0b\xb9\x6d\x9f\x3a\x99\x92\x63\xfc\x0a\x07\x3a\x2b\x3c\x64\x9c\x58\x6c\x30\x68\x3d\xad\x2e\xf8\x50\xc2\xe0\x73\x3a\xb5\x2a\x44\xd7\xa0\x0c\xd4\x51\x66\xbc\x55\x3a\xeb\xe4\x21\x27\x89\x68\x59\xb8\x7a\xa0\x6b\x3a\xba\x1d\xac\xa6\xcc\xe3\xe5\xb3\xfc\x0c\x3f\x77\x58\x1f\xf4\x1c\x37\x5a\x2e\x1e\xf3\xe5\x31\xd9\xc0\x76\xa2\xb2\xc0\x95\xc2\x14\xf4\x66\xfe\xac\x4c\x9e\x5b\x01\xde\x51\x9b\xe8\xc7\xe8\xf6\x21\x04\x98\xcf\x9f\x3e\xba\xa1\xf9\xa4\x5c\x01\xfb\x1e\x8c\x8f\x45\x97\xb9\x77\x5b\x1d\xb6\xc6\x11\x91\xee\xdd\x96\x0c\x45\xa2\x57\xeb\xf8\x5a\xfe\x36\x43\xd6\x01\xeb\x4e\xde\xe5\x0a\xbe\xb4\x95\x1d\x3e\x37\x1b\x0a\xc8\xd3\xc5\x99\xc6\x2e\xf6\xd4\xda\x52\xcd\x75\xac\x38\x9c\x24\xd1\xd2\x6f\xaa\x38\xac\xb1\xd7\xec\x84\xe1\xdb\xa0\xba\xfc\x7b\xae\xfd\xbd\x6f\xcc\x7d\x6c\x48\x0b\x51\x7d\x8f\xbb\x8e\xc4\x0d\x3c\xee\xcc\xb2\x67\xce\x2a\xf3\x3d\x02\x79\x0a\x7f\xf4\x0e\xbb\x67\x80\xaa\x01\x5f\x7e\x52\x2d\xf8\x9b\x0e\xf3\x90\x9f\x55\x0a\x4a\x69\xa8\x75\xa0\x1a\xa9\xc9\xcb\xa7\x52\xbb\xf1\x42\x53\x2d\x6e\x3b\x7e\x4d\xbd\xbe\x3e\xba\x41\xa7\xd6\xa2\x1f\xb9\xc0\x6a\x49\xaf\xef\x0b\xdb\x46\x32\xce\x33\x5a\x75\x61\x6f\xc3\xb5\x80\x33\x49\x47\xf4\x8d\xe0\xd6\x22\x0f\xb2\xe7\x03\x17\xcc\x95\x0d\x19\x28\x6f\xd6\x6a\xdd\x21\xb0\xae\x23\x9c\x15\x5e\xe7\x51\x47\x35\x92\x49\x85\x6a\x32\xe1\x20\x70\xd9\x31\x82\x86\x04\x12\xdc\x13\xb0\x32\xb0\x6f\x40\xaa\xca\x82\xda\xed\x38\x16\xd2\x13\x11\xa0\x76\x8e\x3f\x2c\x41\x58\xaf\xd8\x70\x28\xc7\x84\xcd\xf0\x92\x8d\xe0\x62\xf5\xb4\x4b\x92\x41\xa3\x60\x34\x48\x3a\x3e\xb0\x8e\x3c\xba\x81\x81\xae\x8a\xc6\x43\x1c\x23\x75\x4d\x49\xf1\x1b\xc2\xc2\x95\xcb\x36\x22\x71\x6d\xe3\x39\x73\x41\x50\x5e\x02\x1b\x18\xbf\xc5\x2a\x15\xc0\x22\x75\x1d\x9c\xf5\x26\x89\x79\x86\xdd\xe9\xd0\xe0\xa1\x2a\xa4\xe7\xcd\x1d\x79\xe6\x2c\xe0\xa7\xd8\x8d\x8e\x8b\x4c\xe2\x71\x57\xad\x7b\xae\x6b\xb5\xe2\x61\xc1\xa6\x9a\x4e\x64\x6c\x5d\x3f\xa0\xc5\x24\xaf\x08\x4b\xce\x05\xb3\x95\xcc\x37\xe8\xc0\x62\x97\x9c\x72\x45\x2c\xd4\xe5\x28\xf1\xb6\x19\x62\xe2\x96\xa5\xd9\x88\x15\x37\xf1\x43\xb6\xf7\x80\xf3\xcb\xa8\x69\x09\xcb\x1b\xdd\x30\xf8\x8e\xe7\x99\x3f\xf9\xd6\x86\x27\x2d\xb8\xf3\xf2\xed\xdd\x06\x5a\xad\xdd\xde\x82\x00\x6b\x9c\x76\x9c\xcb\x62\x39\xd3\x16\xb8\xb2\x76\xa1\x5c\x39\x4b\xce\xe9\x96\xc9\xf2\x32\x57\x55\x7d\x69\xd6\x73\xea\x48\x0a\x17\x89\x2c\xac\xa7\xa8\x36\xc7\x9c\x4c\x8f\xa1\x2d\x25\x56\x53\x5b\xaa\x2f\xd8\x8d\xd7\x35\x05\x05\x5b\xd1\x14\x3d\x0f\xbb\xec\xac\xfc\x8a\x60\x38\x14\x76\xd8\x61\x79\x7d\x0e\x97\x8a\x00\x74\xe1\x41\x5e\x78\x03\x5e\x03\x4d\xac\xc8\xfc\x36\x84\x5c\x45\xe2\xad\x2b\x7d\x0d\x3e\x36\x9b\x04\xbd\x8e\x1a\x08\x73\x42\xa6\x93\x3c\x27\xa9\x58\x8f\x64\x82\x3f\x59\x45\x42\x96\x5d\x5c\x88\x42\xfe\x0c\x2a\x75\x8a\xe9\x9f\x4e\x9c\x51\x13\x0b\x6b\xee\x79\x95\x7a\x42\xfd\x36\x0b\x55\x75\x8d\x5f\xfe\x55\x27\x57\x32\x74\x24\x69\x09\x82\x38\xce\x60\x23\x4b\x4a\x12\xb2\x8c\x50\x47\x64\x25\x4b\xf1\x9a\x30\xa2\xa6\x40\x9b\xec\x97\x7f\xcb\x5b\x4e\x95\x64\xa0\x25\xbd\x5e\x33\x85\x5a\x4f\x93\xec\x90\x72\xae\x83\x08\x29\x2d\x4b\x43\x1e\x19\xe2\x0e\x7b\xae\x83\xe6\xdf\xb6\x6d\x75\x0e\xb9\x3c\xac\xf3\x85\x11\x3d\xec\xbe\x61\xf1\x88\x2e\xaf\x9c\xba\x26\x85\x1d\x77\xad\xae\x59\x41\xa9\xe0\xdd\x97\xac\xbd\x26\x45\x13\x42\x7d\x0a\x44\x0f\x78\xb3\x0a\x57\x1a\xb5\x51\x79\xa9\x99\x04\xf5\x32\x29\xc6\xfa\xf8\x91\xdd\x82\x73\x18\x5d\x88\x60\x49\xaa\x5a\xbf\xc9\x02\x3f\xad\xd8\x75\x1d\x9f\xd8\x4f\x22\x6c\xf6\xe6\x15\x05\x46\xa7\x23\x51\xd3\x90\xa1\x19\xb8\x37\xea\x4c\xf9\xc5\xba\xa1\x33\x1a\x8b\x18\x92\xb2\x75\xb6\x1b\xdb\x87\x74\x97\x8c\xba\xc4\xb9\x5b\x11\xde\xad\x23\x36\xea\x95\x83\x6c\xac\x73\x00\x37\x20\x2e\x14\x76\x6e\x46\x55\xae\xdd\xdc\x00\xb5\x5c\x47\x57\x32\x55\x36\x78\x2e\xff\x4a\x5d\x0b\xb3\x30\x2c\x75\xeb\x6f\x21\xa7\xbe\xd2\x6e\x48\x29\xf0\x89\xea\xf3\x5c\xf7\x08\xd9\xa8\x4b\x2a\xa3\x8f\x66\x5a\x20\xab\x6d\x9e\x6c\x03\x4b\xdd\x15\x17\x28\x4b\x55\xb7\x8e\xbd\x8d\x02\x50\x3c\xa0\x81\x1f\x85\x2c\xc8\x5c\x37\x36\x3a\xac\x96\x86\xd1\x48\x78\xa1\xd8\x63\xc2\xe5\x78\xda\xb7\x93\xbc\x1d\xe8\xa2\x16\x35\x45\x1d\xbb\x60\xcd\xcb\x33\xb6\xb1\xa3\x4b\x0d\xc6\x0e\x18\x65\x9d\xc5\x36\x6c\xd5\x6a\x8a\x76\xd8\x38\xc1\xd2\x4b\x0a\xe7\x26\xbb\x44\x13\xbb\x43\x75\x2a\x1b\x66\x1b\xa5\xe9\x65\xcb\x38\x78\xc4\xea\x44\x3d\xc3\x2e\x80\x0e\x7a\x8d\x71\x21\x3d\xb9\xb1\x67\x74\xf8\x03\xc8\x87\xce\xe2\x11\x34\x18\x74\xfd\x90\x26\x72\x8f\x9c\x79\xf0\x43\x81\x9d\xba\xa8\x31\x21\x6a\x2e\x20\x36\x6c\x64\x5d\x2b\x68\x7c\x22\xfa\x61\x14\xa4\xb1\x6a\xf7\x80\x78\x5d\xee\x44\x28\x0e\x9d\x3f\x60\x75\xa3\xc8\x31\xbc\x39\x52\xe7\x20\xc3\x1f\xa1\xf5\x53\x59\x39\xc2\xe3\xb6\x61\x5b\x80\xe6\xda\x87\xf6\x89\x76\x8b\xbe\x6c\x50\x33\xd0\x98\x3a\xef\x38\xd9\xc6\x73\x53\xab\xee\xf1\x0d\xd0\x84\x13\x16\xe8\x9b\x47\xa4\x6f\x1e\x5c\x5d\x71\xbd\x11\x9e\x2f\x4b\x62\xa0\x12\x12\x51\xea\xbb\x5d\x13\x89\xb8\x16\x95\x63\xf5\xb0\x1f\x47\x30\xcf\x2b\x97\x4f\x71\x9b\x4c\x50\x50\x22\x6b\x75\x98\xeb\x65\x37\x38\x2b\x98\x41\x81\x16\x90\xc4\x16\xe8\x41\xf6\x11\xd4\xbb\x56\x58\xb9\x03\xbe\xb6\x04\x79\x20\x30\xaa\xbc\x92\xa5\xf6\xd5\x79\x42\x65\x3f\x42\x98\x4b\xdc\x5d\x0d\xcb\x71\xb5\x8a\xd1\xcf\x0d\x42\x4d\x84\xde\x26\xf2\xd1\x4d\x21\x4b\xbb\x90\x73\x8d\x5d\x94\x4d\x65\x78\xa6\xea\x3d\x13\x98\xae\xda\x82\x4a\xc9\x83\xec\xcc\xba\x2c\xf8\x17\x6d\x14\x45\x9f\xa8\x90\xd8\x86\x0c\x4b\xf8\x2a\xc7\x25\x1c\x54\xdb\x46\x14\x3d\x74\xf6\x42\x62\x22\x5e\x92\x67\xaa\x0c\xb0\xdc\x4a\xa2\x04\xaf\x96\xbe\x73\xec\x11\x8a\x15\xdf\x37\xcf\xaa\xd9\xa1\xd4\x9d\x96\x91\x27\xdd\xd3\xd4\x79\x3d\x3f\x22\xc8\x2f\x1b\x46\xb0\x35\xe2\x43\xc7\xb9\x09\xc9\x7c\x1f\x6d\x61\x35\xf8\xa0\xa2\x87\x23\xbe\xc5\x02\xc0\xb1\x86\xc4\x05\x6a\x9e\x7c\x6a\xd4\xc1\x9d\x15\x49\xa5\xcf\x81\x5a\x7d\xb8\xb1\x70\x69\xab\x02\x40\x9f\xd5\x04\x20\x0c\x45\x26\x68\x6a\x2b\x72\xb7\x56\x3b\x2d\x7a\x6e\xb9\xe5\x1e\x75\x8e\x77\x41\x74\xb8\x87\xce\xc4\x81\x8d\x16\xd1\xa5\x84\x4c\x7f\x22\x84\xe5\x9e\x44\xdb\xd8\x45\x43\x6b\x4a\xd7\x99\x40\x97\xa3\x31\x07\xc2\xbd\x1d\x45\xfc\xcb\xbf\x94\x9a\x4c\x59\x96\xa3\x64\x2e\x6e\xb9\xb1\xf6\x86\x57\xe3\xec\xb4\xe6\x08\x8c\x3d\x7e\x4f\x37\x35\xdb\xe4\x0b\x36\xd7\x28\x0d\x51\xd8\x5a\xbe\xb0\x83\x3b\xc2\x25\xa1\x3a\xe6\x23\x0b\x4a\x6a\xc4\xf1\xfb\x06\xba\x49\xf4\xd1\x79\x73\x90\x14\x42\x05\x61\xb2\xc3\xe0\xd9\xd9\xfa\x89\x8f\x44\x63\xf5\xaf\x82\x16\x8a\x63\x6c\xb8\xb1\xdb\x50\x1a\x15\x87\x64\x37\x66\x80\x93\xd1\xf9\xfd\x90\x05\x80\x10\x2e\xb3\xb6\xd0\x2a\xb3\xe8\x0f\xbf\x5c\xaa\xa7\x84\x6a\x49\x17\xc4\x7e\x62\x34\xd2\x2d\x59\x69\x50\x5e\x2f\x71\x67\x8d\x80\x0d\x85\x20\x06\xe1\xe3\x66\x90\xad\x22\x39\xec\x90\x65\x06\xd7\xf0\xb2\x58\x41\x83\x62\xb1\x22\x5a\x8c\x70\xcf\x86\xe9\x04\xea\x55\x9b\x5d\x56\xad\x34\x6a\x7d\x07\x1c\xf1\x14\xcb\x30\x85\x6a\xf4\x2e\x5d\xc5\x9b\xab\x88\x9d\xbb\x1b\x79\xb1\x8d\xd4\x7d\x02\x57\x60\x8a\x07\xb6\xbd\xe5\xe5\x84\xdd\x4a\xb8\x45\x54\x28\x34\x01\xc0\x0a\xad\xd4\xcb\xb9\xbd\xd3\xe5\xb9\xfb\x83\xf3\xe4\xfa\x29\x77\xfd\x54\xed\xe2\xf4\x7e\x20\xf9\x90\x6d\xd0\xa8\x00\xb2\x3b\xcc\xec\xc7\xec\x42\x80\xba\x07\xa3\x04\xf9\xce\x8d\x2f\x5d\xb8\x4e\x27\x2a\xac\xc3\xe8\xc3\x6a\xec\x91\xe2\xc6\xcd\x91\x58\x0e\xde\x2a\xad\xb9\x3a\x20\xd5\xe8\x5d\x09\x75\x8b\x8a\x32\xc5\x63\x54\xb4\x86\x2e\x84\xfa\xeb\x6c\xed\xb8\x6b\xf2\xcd\x83\x2c\x97\x2e\x2b\x5e\x95\x5a\x78\xe7\x8e\x7e\xf8\xe1\x11\xbb\x65\x71\xa1\xc4\xaf\xbe\xfc\xfa\x77\xe7\x23\xe7\xab\x53\xf8\xdf\x97\xa7\x36\x4b\xd1\x1f\x32\x38\x05\xfd\x14\x04\x20\x0f\xc6\x35\x5d\x59\xda\xcc\x03\x50\xc9\x6f\x6c\xe7\x7b\xb1\xd2\x62\x19\xf7\x6b\x0c\xf0\xd0\x19\x7f\x85\xa7\x25\x9c\x47\x18\x52\x8b\x50\xb2\x90\x5c\x0a\xe8\x7c\x25\x1c\xb6\x33\xe9\x55\x98\xc0\xf4\xc1\xe3\x4c\x20\x1f\x82\x7f\xd3\x98\xe1\x28\x45\x5a\x5d\xab\xfa\xfa\x19\xd8\xe5\xbc\x3d\x11\x0f\x6e\x16\xa4\x47\xf9\x6f\x9f\x75\x21\x75\xe7\xa1\xf3\x76\x96\xdf\x1c\x51\xb0\x0b\x79\x5f\x70\x8f\xf2\xc7\xa2\x96\x95\x49\x22\xe2\x2d\x7a\x41\x04\xa8\x86\x5e\xf2\x05\xc9\x0b\x8c\x8d\x85\x8d\x4c\x42\xa4\x74\xd9\x66\x51\x37\x72\x48\x97\x92\x61\x7c\x70\xad\xf6\x84\x72\x99\x26\xc0\x9d\x67\x7a\xc3\x16\x63\x5a\x94\x2c\x39\x72\xff\x0b\xaa\xd2\x99\xf9\x28\x5f\x90\x04\x94\x38\xa1\x27\x8a\x72\xb1\x28\x0a\x37\x51\x1a\x8b\xfb\x7b\x0c\xf1\x90\x97\x26\x4d\xab\x83\xba\x93\xaf\x3d\xb9\x01\xb9\x11\x1b\xc2\x0e\xcf\x0d\x77\xb9\x5c\x50\x5f\xff\xfd\x3f\x9c\x1b\x33\x64\x5b\x18\x55\x0f\x79\x61\x86\x2b\x50\x2c\xe8\x29\x16\x53\x7a\xd4\x9b\xc3\x3c\xf9\x77\xb8\x81\x95\x9e\xae\x07\x4c\xcd\xce\x45\x8d\xcb\x42\x6b\xca\x85\xea\xfd\xb9\xaa\x6c\xc3\x8e\x00\xad\x8e\x0b\xae\x69\x58\x2d\xd0\x4f\x5f\xe3\x94\x58\x6c\x0b\x98\x94\x68\x8b\xc1\xba\x3c\xb7\x74\xf6\xc6\x97\x6c\x97\x39\x7c\xcb\x72\x7f\xc3\xeb\x85\xed\x2d\x50\x4b\xec\x2f\xd1\x7d\x43\xde\x0f\x45\x5c\x70\x19\xf6\x52\x1d\x5b\x60\x61\xb9\xcb\x98\xd5\xd9\xdc\x3b\x29\xdd\x08\xa0\xe9\x50\x07\x79\xd1\xaf\x32\xed\x85\x78\x72\xae\x64\x91\x3a\x6b\xa8\x1b\xe8\x6f\xba\x92\x9d\x1d\x4c\xd8\xc0\x3d\x9d\xb8\x64\x79\x3d\x72\xfe\x2e\x61\x55\xd5\x06\x81\x2b\x3a\xc2\x53\x52\x9d\xb4\x02\x9a\x5c\xcd\xf2\x0b\x73\x22\x40\x96\xdf\x80\x7e\x8b\x37\x48\xb8\x05\xfb\xe1\xc2\xdf\xe0\x05\x53\x46\x5e\xc0\xc3\xf2\x0b\x54\x17\xd9\xf2\x0c\x6b\x5d\xbd\x6f\x3b\x36\x25\x35\x1a\x0d\xe2\x94\xf6\x3a\xaa\x96\xca\x06\x70\xb7\x8a\xb5\x84\x14\x95\x26\x6d\x64\xe2\xf8\xb4\x1c\xb5\x6d\x80\xee\x92\xaf\xae\x70\xb3\x09\xe1\xd6\xfa\x5d\x94\x71\xf8\x19\xdc\xa5\xe8\xea\x25\x0d\x8d\xb8\x5f\x83\x40\x5d\x73\x1e\xaa\x1d\x3d\xd4\xee\x56\x6e\x20\x6e\x86\x19\x52\xa1\xec\xd0\x81\xbd\x0c\x03\x33\x3a\xd4\xe8\x47\x64\x41\x56\x5c\x85\x85\x66\x0c\xf0\x63\x33\xbf\x40\xa1\xe6\x33\x09\x86\x07\x47\x19\x9c\x64\x70\x5a\x39\x27\x62\xeb\x33\xed\x14\xf1\x11\x93\x5c\x57\xb6\xce\xdc\xed\x4d\x31\x13\x96\x5e\xa0\x46\x5f\x54\x8b\x2f\xdb\x41\xf7\x04\x9a\xd3\xd0\xd2\xb1\x84\x13\xb1\x80\xa6\xf1\x45\x59\xc2\xb5\xb1\x11\xc5\x3e\x26\x4b\xf2\xf3\x0a\xe6\x4b\x8d\x07\xc5\xee\x7f\xd4\x99\x53\xcd\x58\x8a\x43\xfa\x0f\x38\x81\x1b\xdf\x22\x4e\x54\xf8\x39\xe9\x0f\x05\xb1\xd1\x51\x6a\x20\x68\x9b\xd4\x50\xc0\xa5\x85\x15\x9f\x29\xca\x87\x06\x82\x37\xba\x7b\xb9\xbc\xfa\x53\x1c\x18\x5b\xd6\xfa\x1d\x0e\x91\x2c\xa5\xdc\x2a\x98\x8b\x77\x65\x29\xa3\x2d\xc1\x12\x00\x35\x0f\x7a\xe9\x22\xf4\x6b\x0c\xcf\x6d\x87\x00\x47\x75\x25\xce\x93\xa0\x8a\xe5\x9e\xf5\x60\x92\xd4\xeb\xe8\x2c\xf1\xf0\x00\x98\xb2\x26\xe2\x95\xbf\xb2\x03\xe5\xca\xac\xd0\x46\x6e\x43\x13\xfe\x96\xb5\xb4\xa5\xf2\xc6\x2d\xbd\xe2\xad\x78\xb9\xc4\xb6\xd6\x25\xa8\xe6\x71\x85\x75\x2d\x87\xa0\xe1\xa4\xc8\xfd\x25\xb2\x78\x76\x12\x71\xd8\x45\x4a\xfa\x37\xba\x38\x52\x1d\x09\xf7\x68\x33\x35\x02\x0d\x98\x5c\x4d\xa1\x78\xe4\x03\x57\xb6\xb8\x11\x9a\x1f\x69\x31\xcb\x3a\xe1\x95\x73\xbb\xf0\x9e\x55\x93\x33\xe8\xf2\x4d\x1f\x4f\x55\xe4\x90\xdb\x7c\xa4\x1c\xda\x6e\x19\x77\xf5\xf8\x2e\xcb\x18\xfc\x4e\x79\xdf\x1b\x47\xab\xbb\xab\xd7\x0c\xf6\x3d\x37\xd1\xc8\x11\xef\x3c\xb2\xa8\x7e\x64\x55\x44\x4d\x24\xef\x42\xa9\xdc\x76\x25\x6e\xe5\x14\xbb\x7b\x27\xcd\xbe\x62\xda\x8e\xbe\xee\x44\xf6\x58\x19\x8d\x6b\xbf\x9b\xc4\x2d\xd1\xd5\x26\x73\x8b\x8d\xa4\x3b\x08\xaf\xbc\xbd\xaf\x7c\xb5\x4d\x8a\xe9\xb0\xa2\x76\xda\x31\x5a\xc8\x6d\x27\x59\x86\x26\x88\x70\xeb\x6c\x5d\xb8\x40\xdf\xe3\xb1\x46\x96\x9d\x7b\x81\x11\xc6\xc2\x7a\xd4\x16\x85\x8f\x3a\x65\x85\x04\x83\x31\x39\x68\xba\x5c\xdf\xfb\xca\xa4\xde\x16\x84\x60\x90\x53\x0e\x45\xe8\x48\x46\x7e\xd8\xd7\x87\x1e\x74\x23\x22\xc1\xd1\x53\x4e\xe1\xa3\x9b\xb4\xb1\xc1\x0e\xa5\x53\x38\x64\x65\x21\xb4\x84\x41\x5e\x44\x95\x6e\x8b\x1d\xd6\x59\x4d\x5f\xc5\xb6\x95\xa6\xb0\x7c\x12\xcf\x85\x4e\x82\xda\x02\x98\xab\x96\x2a\x2d\xa6\xc3\x69\xea\x72\x40\x8f\xa8\x34\x10\xb4\x78\xa6\xac\x48\xba\x90\x9d\xbf\xfc\xad\x90\xc1\xf9\x52\x61\x7b\xe1\x01\xd5\x21\x96\x1b\xf1\x45\x06\x9b\x07\xd3\x75\x12\x6a\x14\x3d\xe7\x1a\x14\xb7\x4a\x89\xbc\x43\x63\xfb\x5a\xd3\xc3\x69\x5d\x61\x3b\x1f\xc6\x84\x50\x47\xde\x19\xaa\xd1\xf0\xa3\xad\x9f\x3a\xd4\xac\x05\x75\x26\xaf\xe9\x50\x6b\x55\x6d\x64\x68\x29\xda\x74\x57\xa1\xd5\x34\x55\x22\x06\x9e\x16\xab\xb0\x75\x76\xba\x4c\xb8\x86\xd9\x3a\xdf\x32\x8e\xec\x35\x8e\x9a\xba\xa0\xb2\x56\xc2\x4a\xbd\xfc\xf7\x77\xe6\xf4\xa3\x86\x22\xa6\xf3\x08\x80\x17\x67\x17\x7b\xff\x05\x17\x07\xe0\x70\x6c\x2b\x71\x14\x9c\xa0\x62\xb2\x5e\x9c\x32\xe9\x55\x11\x66\x60\x82\x8d\xb4\xd4\x09\x38\xce\xc8\x0f\x73\xfb\xc1\xf1\x7b\x32\x0d\x16\x37\x2f\x3c\x87\x0f\x35\x90\x28\xa3\x9a\x2a\x16\x83\x2a\x38\xdc\xaf\xea\x3e\x6b\x9a\x4b\xac\xba\x67\x2a\x8e\xd8\x67\x8e\xae\x1a\x34\x59\x01\x3f\xd6\xec\xc1\xb1\x12\x84\x6e\x25\xe9\x2e\xcf\x53\x8e\xb4\xff\x45\x36\xde\x21\x73\xcd\xdf\x32\x37\x40\x77\x18\xb9\x7e\x6d\x3b\x31\x5b\xdf\x63\x50\xd7\x43\xee\x8e\xe8\x9a\x80\x5d\x0f\xf0\xf2\xdb\x5e\xaa\xd1\xe5\xd5\x62\x76\x79\x61\x6b\x98\x76\x79\xf5\x27\xf8\x75\x66\x79\x75\x7e\xea\x4c\x4e\xce\x67\x17\xb6\x68\x83\x73\xf8\x6d\x76\xbd\x98\x4f\x16\x97\xf3\x29\x96\x59\x9c\x5c\xcc\xfe\xf4\xa7\x09\x82\xb4\xb8\x31\x08\xe4\xcd\xc9\x0c\x5e\xb0\x45\xd1\x4c\x3f\xce\xae\xfb\x80\x3b\x9f\x5c\x4c\x4e\xa7\x36\x70\xa7\xd3\xeb\x3e\xc4\x59\xf9\x64\xbe\x6e\x63\x97\x35\xbe\xfb\xb2\x43\xc0\xfe\x25\x5e\xf2\x28\x27\x84\xcb\x69\x24\x66\xe8\xb8\xe1\x96\xec\x84\x82\x9c\xb4\x08\x08\x36\xb6\x28\xdb\x51\x3a\x45\x92\x5f\x96\x5b\x22\xbb\x01\xb6\x9c\x7c\xe6\xca\x16\xb6\x25\x7c\xd6\xd8\xdb\x98\x8a\x57\x08\x67\xe5\xff\xf2\x2f\x1d\x91\x16\xeb\x69\x50\xae\x1a\x7f\xe6\x7d\x8f\x21\x4e\x83\x28\xd1\xa5\x34\x54\xa7\xb7\x5f\xfe\x55\x83\xc4\xe0\xc3\x21\xd4\xd9\x24\x5c\x57\x4a\x2c\x32\x0c\x1e\xb5\xf9\xfd\x8a\x73\x6e\xf1\x00\x5e\xb6\x27\xbe\x74\x5a\x9e\x1c\x42\x28\x74\xf1\x17\x8f\xa3\x09\x54\xcc\xa6\x0e\x82\xb2\x85\xae\xaa\x10\x3e\xce\x2e\x90\xe5\x59\x4a\xf1\x53\x95\xb0\x4d\xd3\xd7\xdf\x93\x2e\x9d\x73\xf9\x92\xe4\x99\xe5\x59\xba\x93\xaa\xa2\x2c\xe1\x4c\x28\x05\x5a\x52\x54\x1b\x6f\x79\x38\xed\xfd\x38\x0a\xa9\x57\x9b\xfb\x80\xc6\x8a\x52\xd4\xe6\x26\x10\xf6\x98\x26\x73\x3c\x7e\x20\x63\x23\x6b\xe2\x0a\x38\xd5\x24\xd7\x00\x8a\xa2\x01\x7d\x1e\x12\x93\xcb\x5d\xe7\x38\xc4\xb3\x12\x7c\x59\x3f\xe0\x2b\xd7\xf7\x8a\xc1\x89\xb6\x6c\x74\x76\x85\x15\x7c\xe8\x1b\x77\xe5\x36\x34\x36\x42\x0f\x2f\x67\xbe\x63\xee\x34\xb5\x09\xa7\x72\x3e\x18\x5b\x48\xf1\x89\xe8\x71\xce\x8d\x2d\x9a\x95\x4a\x81\x62\xa5\xd3\x16\xb7\x01\xbc\x5b\x0b\x95\x9d\xca\x99\xf2\x3e\xd7\xda\x23\x24\xa8\x86\x20\x16\xf6\x5f\xe4\xc6\x84\xc1\xa6\x98\x2e\xa3\x31\xf4\xf9\xcf\x3c\x9a\xee\xfa\x75\x8b\x1f\xbe\xf9\x25\x07\xf6\x8b\xce\x55\xc8\x85\xed\xda\x4d\x97\x8f\x36\x59\xeb\xea\x97\xb4\x7b\x5f\x97\xf3\xa3\xc0\x5c\xcf\x4a\x29\x88\x8f\x62\x47\xda\x7e\x34\xcb\x92\x58\x9b\x8d\x21\x30\x10\x1c\xae\xe5\x1f\x7d\x76\x60\xa9\x1d\xcf\xe5\xa8\xd2\xc4\x90\x00\xad\x12\xea\xca\xa8\x69\x65\x88\xa4\xca\x86\x8e\x38\x7d\x82\xf1\x21\x62\xb4\x42\x31\xc2\x2c\xf5\xab\x32\xad\x0c\xa0\x79\x7c\x85\xb1\xa9\x61\xf5\xa2\x38\xd2\x94\x35\x63\x6a\x09\xd0\xbd\x32\x84\x74\x4b\x28\x2d\x41\xec\xdd\xa6\xd8\x02\x4b\xc4\x58\xe8\x12\xb7\xa3\x8f\x72\xd1\xa1\x1a\x4f\x7c\xee\x70\x0d\x07\x81\x21\x2d\x1c\x71\x2c\x1b\x2c\xcb\x10\xe5\x40\xe9\x4e\xb2\x8d\xad\x2d\xc3\x41\x5e\x6f\x28\x5b\x57\xac\x71\x62\x78\xc1\xc4\xd8\x0c\x9c\x36\xab\x2e\x17\x81\x57\x20\x0a\x50\x4d\x04\x59\xb7\x38\x6f\x86\x2c\xd1\x16\xf2\xd1\xff\x5e\x52\xaa\xd4\xa2\xb7\xf9\xe4\x1b\x64\x76\x64\xa8\x2f\xa1\xcc\x95\xf5\x1b\xdc\xe1\x0d\x44\xe5\x8f\x1a\xbe\xf5\xbc\x3b\x6e\x93\x5d\x84\x82\x03\x65\x3b\x5b\x32\x8a\xc4\x54\x12\x56\x3b\xeb\x2b\x70\xfb\x92\x81\x66\xe9\x30\xaa\x09\x2b\xc3\x65\xca\x31\x67\xf6\x30\x72\x3b\x19\xc4\xbc\x47\x37\x0f\x2e\xf3\x0b\xb1\x65\x04\x39\xb6\xed\x47\x80\x72\x54\x3f\xb8\x86\xe9\xb2\xbc\x61\xc5\x90\x18\x7a\x36\xf7\xa0\x07\x79\x9f\xfa\xcb\x2c\x70\xe3\x2e\x19\xd5\x7c\xae\xe7\x8a\xb5\xec\x03\xac\xc0\x44\x01\x4e\x55\x97\x6c\x66\x59\x97\x70\xf9\x18\x45\x49\x1e\xd1\x8f\xcd\xf1\x71\x33\x61\xc0\x06\xfe\x7d\xe8\x7c\x13\xa1\x14\x27\x17\xb0\x4b\xc5\x63\x52\x5c\x93\x6b\x3f\x4d\x79\xf7\xdf\x73\xff\x52\xa1\xd3\x07\x12\x59\xb5\x19\x35\x1a\x6b\x96\xdb\x52\x50\xea\x37\x6d\x43\x0c\x55\xc5\xd4\x30\x55\x22\x57\x7d\x51\xd3\x5a\x39\x95\xe7\x2e\x5a\x0a\x04\x46\x99\xc0\x11\x5a\xee\xb2\x2c\x8b\x1f\xa4\x14\xf3\x21\x15\x2b\xcb\x45\x40\xf2\x80\xcd\x29\x0e\x68\x47\xd6\x6c\xb3\x09\x30\x9c\x0b\x87\x50\x79\xed\x46\x70\x2a\x4b\x82\x23\xf0\xd0\x18\x6b\xa4\x8c\x98\x53\x6c\x96\x79\xec\x75\x33\xd5\x15\x1b\xf3\xa4\x6d\x97\x92\x05\x81\x31\x61\x64\xc9\xa5\xd7\xe5\x1a\x87\xdc\x5d\x39\x9d\xd2\x69\x89\x7d\x54\x8a\x7b\x23\x8c\x3c\xcb\x12\x39\x80\xbb\x1e\x13\x36\x6d\xbb\xdd\x5a\xf6\x16\xe4\x58\x86\x50\xac\x62\x99\x90\x51\x6e\x8a\xae\x90\x5b\x7b\xc9\xb4\xcb\x19\xca\x32\xa9\x2d\xb5\x5b\xb9\x69\xf6\x27\x02\x93\x4e\xe4\xfd\x9f\xe2\xbe\x76\x20\x03\xb6\x08\x1a\x00\xb4\x49\xde\xaa\xe0\xe7\xb5\x24\x88\x26\xcf\xb9\x7d\x53\xc8\x99\xbb\x7d\x53\xb2\x49\xe8\xcc\x1f\x74\x22\xc8\xc0\x5e\x7a\xd5\x5a\xa6\x38\xb0\x14\x9e\x00\x1d\x21\x92\xe5\x98\xaa\x48\x0d\x2b\x86\xe1\x58\x50\x21\xbf\x0d\x21\xa1\x7a\x44\x64\x5c\x84\x01\xc9\x73\xe5\x1e\x4f\xf2\x67\x23\xd3\x0c\x4f\xe4\x67\xb8\x57\x39\x97\xd7\x47\xb6\xac\xaa\x59\xce\x61\xdd\x09\x5c\x1d\x28\x6e\xb0\x44\x27\x24\x82\x2d\x54\x48\xd0\x07\x74\x9a\x45\xce\xf5\xa5\xc5\x60\x70\x55\x2a\xf6\xac\xb4\x01\x33\xdb\x2b\x0b\x7d\x95\xbc\x6c\x63\xee\x95\x65\xfe\x81\x1c\xbd\xa9\xca\x7d\xf5\x7b\x11\xb4\x85\x2f\x3e\xc2\x65\xc9\xc7\xd2\x6b\x45\xf2\x06\x13\x57\x84\xd9\x97\xce\x58\x05\xce\xca\x29\x86\xb1\xba\xab\x30\x02\x71\xb5\x24\x5d\x21\x49\xbd\x86\xdc\x5e\x00\xbe\x71\x8d\x57\x5c\xdd\x82\x9f\xa7\xd7\xe5\x98\xdc\x50\x81\x69\xa0\x01\xb3\x00\x5c\x27\x20\x93\xd9\x83\x0c\x9d\x43\x29\x54\xba\x9a\x94\x6e\x22\xae\x76\x85\xe9\xcb\x8a\x4c\x9a\x53\x17\xe9\x88\x8f\x85\x93\xe9\xc4\xb9\x77\x97\x20\x07\x6c\x92\x50\x0e\x06\xc3\xb9\x64\xe6\xba\x2c\xc4\x4b\x35\x77\x0a\x74\x70\x3a\x27\x5f\x4f\xe4\xdd\x25\x77\xde\xf1\x65\xa1\x69\xa8\x48\xcf\x96\x67\xac\x99\x96\xc0\x55\xcf\x75\x85\x87\x0c\x38\xe5\x28\x56\xcc\xd1\x78\x72\xb9\x29\x4b\xca\x67\xaf\x55\x16\x57\xf1\xe1\xa8\x00\x50\x92\x51\xca\x87\xcc\x22\x74\xf9\x66\xef\xca\x14\x10\x1b\x4d\x11\x08\x04\x4c\x44\x5e\xc3\x31\x0d\x33\xe0\x45\x4f\x61\x10\xb9\xe8\xa8\x92\x62\x03\x8f\x6a\xb8\x26\xe4\x2c\xb5\x8a\x0c\x09\x0c\xb8\x9f\xc5\x94\x2e\x4d\x8b\x6b\x1d\xe5\xc7\x95\x12\x19\xc9\x12\xfe\x59\xd6\x65\x38\x22\xaa\x08\xde\x16\xee\x91\x25\x65\x13\xb0\x70\xfc\xaf\xac\x68\x87\x94\x3e\x3b\xe8\x2c\x75\x83\x23\xe7\xef\x12\xac\xa2\x49\x79\x49\xa8\x67\xd8\x29\xe5\x28\xd8\xbc\x2c\x1e\x97\xd2\x46\x20\x82\xa1\x2c\xf4\x4f\xb0\x7a\xac\xa4\x50\xa1\xc0\xba\xaa\x81\x79\x28\x69\x5e\xde\x93\xab\x21\x70\xe1\x3f\x36\x34\x83\xce\x12\xae\xd0\x47\x9c\x51\xac\x1f\xc6\x13\x4a\xbd\x89\x66\x04\x9e\xe2\x92\x7b\x29\xca\x6f\x5c\x15\x56\x81\x03\xd8\x63\x5f\x60\x62\x53\x1d\x31\x2a\x5a\x21\x34\x2e\xb3\xb2\x66\x82\xab\xaa\x05\x0a\x65\xa8\xa6\x1a\x09\x92\x22\x4a\x8f\x9a\x62\x26\x0f\xcc\x5c\x80\x55\xf9\x62\x7f\xc3\x77\x20\xab\x94\x22\x85\xcf\x96\xf2\x62\x79\x29\x8b\xa5\xcb\x96\xaf\x40\x46\x71\x56\x19\x6d\xdc\x50\xba\x82\x88\xab\x16\xde\xa8\x07\xd2\x15\x7d\xe1\x5e\x39\x10\x7b\x05\x86\x05\x79\xf2\x88\x75\xff\x65\xff\x1f\x0c\x65\xc1\x22\xf1\x2a\xa8\x94\x92\x88\x58\x03\x91\x35\x67\xec\x55\x12\xd2\x18\xbb\x2b\x71\x5a\xb0\x4b\xca\xb9\x5b\x4e\x0c\x96\x65\xe4\x49\xa7\x08\x8c\xc8\x52\x5c\xe5\x95\xbc\x79\x7d\xf3\x6e\xa4\x1c\xeb\x2b\x70\x72\xb9\xf3\x16\x37\x1d\x0e\x01\xff\xe5\x53\x42\x2d\xb7\x2f\x8e\xac\x25\x21\x2b\x94\x23\x44\xb8\xbc\x15\x69\x7f\x8b\x14\xe2\x2d\x39\x64\x75\xa8\x00\xb8\x96\x3e\xae\xe2\x7d\xc2\x46\x73\x14\xb8\x30\x27\xf4\x5d\x2f\x97\x93\x2b\xfd\xd6\x7a\x8e\x03\x97\xeb\x3b\x95\xc1\xb5\xba\x9f\x98\x9e\x34\x92\xc1\x1d\x2a\x85\x01\x66\x1e\x74\x0a\x95\xf5\x8e\xc1\x98\x6f\xc5\x0f\xaa\xb6\x1b\x39\x97\x23\x2a\x00\x8b\x76\xfd\x2c\x48\xf9\xa8\x25\x08\x64\xa3\x85\x53\x44\xf9\x24\x88\x2c\x7b\xd2\x25\xd5\x34\x77\x55\xb0\x48\xcc\x75\x11\x4a\x57\x23\x60\xb9\x08\xf5\xd9\xf1\x36\x61\xa9\x90\xe8\xa8\x88\xdc\x73\x2d\xf3\x06\xb7\xe4\x02\x54\x01\x28\x74\xdc\x30\x77\x0c\x7f\x85\x25\x51\xaf\x13\x3f\xf8\xd2\xf8\x8a\x1c\xc9\x6f\x91\x06\x2b\xa2\x57\x61\x45\x69\x41\x75\xba\x9a\x9d\x59\x56\x63\xdb\x75\x6c\x3e\xfd\xc3\xcd\xf4\x7a\x61\xf3\xfd\xcd\x67\xc7\x1f\x66\xf0\xfb\xc4\xa2\xc5\xcf\xa7\xd7\x57\x97\x17\xd7\xd6\x9c\xc1\xf9\x0c\x7e\x6f\x78\xfd\xf2\x6c\x7a\x6d\x97\x08\xf3\x9b\xcb\xb3\x99\x75\x5f\xcf\x2f\x6f\x16\x53\x9b\x27\x7d\x7e\xb9\x58\x58\xfc\xef\x73\xd8\xed\x63\x2a\x5f\x91\xe7\x10\xe1\x76\xf3\xc3\x87\x88\x8e\x59\xbc\x87\xc5\x0d\xb5\x6b\x27\x32\x79\x06\x95\x64\x94\x4f\x01\x5a\x52\x63\x58\x3f\x04\x22\x5e\xeb\x28\x78\x06\x54\x67\x7b\xb0\x8e\x49\xb8\x78\xb3\x80\x37\x04\x3a\x8d\xe3\x0d\x88\x7f\x21\x8b\x3a\x27\xbf\xe7\x23\x7d\xbd\xb1\xd7\x44\xbf\x66\xc5\x0f\xc3\x94\xc8\x32\xb3\x8d\x02\x8c\x65\x91\x27\xb7\x51\x6f\x30\x8a\x1f\x00\x72\x01\x62\x07\x82\xa4\x01\xf7\x3c\x82\xcf\xdc\x51\x40\x7f\x54\xc2\x14\x6b\x1b\x83\x46\xfa\x8c\xd6\x9d\x95\x23\x0b\x90\x2b\x45\x0c\x14\x99\xdf\x0f\xa4\x1c\xf4\xf7\x66\xcc\xc2\x28\x63\x08\xd4\x52\x21\x25\x8d\xdf\xff\xfd\x5e\x86\xf7\x52\xc4\x37\x53\x27\x8d\xbf\x35\x91\xa4\x85\xba\xe0\x9c\x7e\xbc\x91\xf6\xe5\xcb\xc0\xab\x9a\x82\x53\x52\x48\x2e\xc4\x53\xe5\xa7\xdf\xdf\x66\x5f\x7e\xf9\x5b\x9b\x21\xab\x7e\x7c\xd2\x74\xdc\x4a\x97\x67\xe6\xb4\xd5\xd2\xe5\xb6\x91\xd5\xc4\x9e\x0d\xa8\x6d\xd5\x6c\xec\xaa\xde\xc7\xfc\x39\x0e\xa2\xcc\x73\xde\xa3\x5a\x1e\x3f\x0f\x9d\x4f\x7b\xa8\x6f\x09\x25\x9c\x2a\x25\x84\xdd\x47\xa2\xe2\x7f\xab\x2e\x93\x7d\x0e\xa4\x26\x6e\xb8\x82\xaf\xf3\x28\x96\xc2\xdf\x92\xd5\x3b\x6f\xbd\xb4\xd4\x1d\x94\x64\x25\x29\x0b\xa5\xbf\xfc\xb3\xac\x7a\x03\x57\x42\xb1\xc5\x4b\x3a\x28\x77\x4b\x7b\xfb\x25\xa0\xc9\x4a\x45\x06\x17\xe2\xad\x00\x86\xca\xeb\x53\x5e\xa1\x92\x0b\x97\x63\x22\x1c\xb7\x0d\x4a\x6a\x78\x49\xed\x1d\xee\xf1\xf6\xa5\xd4\xd7\xb5\x4b\xf5\xbb\xa4\xbd\x85\x95\xf1\x52\xc0\xbe\xed\x18\xf2\xd7\xa0\x7e\xfb\x8e\x19\x41\xcd\x05\xdf\xb8\x3b\x10\xda\x2b\xe0\x13\x5f\x3c\x35\xde\x22\x39\x78\x79\x8c\x3c\x62\x4c\x84\x03\x53\xca\xaf\x11\xa1\xa8\x8c\x37\x82\xab\x02\x74\x2d\x11\xd8\xc8\xaa\xbc\x36\xd5\x67\xe3\x59\xfd\x2e\xfb\x35\xf1\x4f\xf2\xac\x5c\x91\xd8\xe6\x5d\x37\x96\x43\xad\x49\xb8\x05\x8d\xac\x6c\x8b\xdd\xd2\x68\x0a\xb8\xac\x58\x07\x5c\xd4\x3a\x4d\x95\xb2\xa5\x21\x36\x85\xdd\x6a\x7c\x59\x2c\xab\x95\x4b\x74\x61\xc3\xbd\x33\x47\xa7\x92\x94\x6e\xe6\x67\x35\x55\xd8\x9a\x51\x52\x59\x7d\x23\x6f\x98\xdd\x3f\xb0\x90\x5a\xb0\xea\x1c\x66\x65\xd2\x7b\x24\x73\x98\x99\x31\xdc\x8c\x38\x2c\xc4\x3d\x77\x18\xa3\x0a\x5b\x11\x66\xd8\x4a\x1b\x0e\x54\x33\x87\x4e\x5f\xb9\x50\x6f\xb7\x69\x2c\x87\xe6\xa3\x70\xff\xe8\xc6\xe6\x41\x52\x4e\x9c\xc5\x0d\x13\x95\x83\x10\xdf\xc9\xc5\x87\x67\x03\xfe\xa1\x0e\xee\x04\xbf\x39\xe6\xd0\x83\x1b\x18\x4d\x93\x95\x64\x6e\x5a\x01\x03\x0b\x0b\x8b\x04\x52\x88\xb8\x35\x3d\xb7\xb6\x82\x71\x95\x6c\x65\x87\x31\xe8\xa6\xb0\xa4\x3a\xca\x9b\x39\x19\x17\x1a\x15\x32\xfb\xa8\x98\x26\xb6\x32\xa1\xa5\xca\x90\x0c\x16\xf2\xd7\x40\x51\x91\x89\xfc\x35\x91\xb4\x13\x1b\xe5\xe2\xc8\x69\x32\xab\xfd\x95\xa9\xb2\xb0\xab\x42\xa2\x64\x58\x91\xc6\xcf\xc3\xb2\x5f\x0f\x67\x06\x8f\x3f\x63\x7c\xd4\x28\x72\x5f\x3b\x0e\xb1\x87\x2d\x46\xc9\xf2\x76\x63\xa9\xac\x29\x79\xe9\xad\x55\x24\xb1\x0f\x93\x86\x0e\xa9\x01\x0f\xb7\x81\xce\xcb\x27\x58\xe1\xb3\x4f\x16\x3b\xcf\xd4\xd6\x4f\x68\x81\xdf\x51\xbf\x29\x20\xe9\xae\x6c\x94\x90\xb4\x54\x5b\x2f\xa2\xe9\x51\x64\x3d\x47\xd4\x90\x06\x57\x84\xde\x9c\xce\xa6\x00\x36\xab\x0f\x05\x6a\xbb\x68\x0c\x0a\xa8\xbd\xe0\x7d\x09\x68\x97\x10\x20\x02\x2b\x2d\xec\xc5\x0d\xa1\xef\xce\x2f\xbb\x67\x55\x50\x40\xbe\xcc\x1b\x36\x29\xfb\x96\x73\x9a\x5e\x67\xd3\x4a\x0e\xe5\x45\x30\xf9\x5a\xff\x8d\xfa\x5c\x66\x58\xe9\x87\x5e\xa3\xaf\xab\x61\x52\x8f\x4e\xf3\xa2\x06\x5d\xf3\x40\x2a\xd3\x58\x9e\xea\x1d\xe7\xaf\x69\x42\xca\x33\x38\x64\x22\x8a\x52\x47\xb2\xa7\xe3\x50\x7a\xcc\x44\x4d\xba\x79\x01\x55\xfb\x50\x3a\x8e\xa3\x62\x7f\x28\x9b\xad\x5e\x5c\x4f\xad\x0e\xde\x5e\x7b\x49\x0f\xbb\xf8\xf5\xab\xa9\xa6\x8a\x79\x6a\xd8\x68\x60\x33\xc0\xe5\xbc\x33\xbe\xac\xe3\xdc\xae\x2c\xca\x6f\x98\x55\x22\x72\x1e\x19\x5f\xb6\x72\xa8\x2f\x27\x36\x51\x6b\x30\x9e\x71\x43\xb7\x02\x89\xd3\x44\x07\x57\x5f\x5f\x7f\xe0\xa8\xb4\x20\x7a\xe2\x70\xce\xe6\x63\x71\x46\x31\x97\x18\xc4\x89\x6f\xfe\xf2\xaf\x3a\x74\x93\x9a\x12\x74\x38\x29\x6b\xd1\x73\xb3\x40\x0f\x03\x63\x4a\x95\x5b\x65\xb4\x24\x35\x05\x68\x6e\x65\x5f\x26\x4c\xd6\x1e\x4b\x29\x60\xa4\xa4\x1f\x70\xa0\x8c\x4f\xa5\x89\xda\x9b\x75\xcc\x35\x4f\xad\x31\x21\xb6\x17\x39\x7e\x69\x93\x88\xcc\x8b\xc6\x69\xfa\x4c\x8c\x6e\x0c\xf3\x9c\x73\x5a\xac\xaf\xfc\x6b\x32\x7f\x4b\x43\xb0\x61\xc2\xb4\x96\x56\x15\x44\x66\x9a\x74\x55\x40\x54\xaa\xcc\x2b\x5e\xa0\xcb\x55\xa2\x7f\x15\x97\x63\x4e\x33\x6b\xe1\x2d\x66\x86\xf5\xe1\x6c\x4c\x71\x0e\x75\xd6\x7c\xac\xbb\xf7\x50\xd8\x05\x85\x61\x77\x3e\xe1\x6a\x6a\x83\x17\xb1\xb4\xf0\xb7\xfb\xf9\x96\xc6\xbe\x60\x03\x10\xc6\x64\x6f\x7d\x2f\x73\x03\x1d\x01\x44\x7d\x51\xc8\x39\x86\xf6\xef\xcc\x5a\xf6\x1f\x17\xbe\xbb\xe6\x84\x0d\x0a\x8c\x28\xb4\x39\xc1\xc8\x37\x15\xc0\xb3\xe4\xaa\xc2\xb6\x90\x57\x83\x1e\xea\x8e\xbe\x09\x5c\xce\x53\xb9\x9c\xe8\x9e\x37\x3a\x5d\x43\xb7\x27\xe4\xb6\x1b\x6d\xc4\x09\x6c\x09\x00\xa3\xa3\xc0\x12\x0c\x01\x25\x60\x0c\x58\x16\x3a\x97\x90\xda\x5a\x99\x59\xa9\xe4\x1e\xa9\x30\x2d\x07\x09\xf5\xb7\x3d\x74\x9c\x09\xd6\x69\x24\x81\xc9\x1d\xcf\xb9\x94\x19\x71\x13\x83\x14\x37\x59\x9e\x7e\x42\x55\xe6\x13\x8a\x6b\x8a\xb1\xc0\xb1\x35\x76\xd3\x3a\x24\xc4\x59\xb3\x34\x8c\xea\x56\x40\xd1\x42\xbb\x22\xb9\x68\xb2\xa4\x02\x93\xee\xb1\x41\x77\x4c\xb5\xa7\x85\xf4\x78\x54\x81\x61\x3f\x0a\x2c\xa8\x20\x1d\x35\xa9\x6f\xdd\x7b\x8d\x4c\x82\xcd\x5f\xc7\xa4\x12\x4b\xc8\xf7\xbd\x27\x96\xd8\x4b\x7e\x1d\xda\x78\xc2\xa5\x73\x4a\x2f\xee\x89\x01\x52\xa3\xec\xc0\x04\x7d\xa9\xde\x0b\x23\x72\x75\xb1\x50\xd9\xaf\x89\x05\x66\x42\xd3\x7e\x47\x3f\xfe\x24\x9e\x5f\x9d\x03\x41\x6d\x09\xa5\x4e\x9b\xe4\xa5\xb8\x81\x27\x5c\x17\x3e\xd0\x31\xbd\x27\x2e\xd4\xd5\x09\x6a\x1e\x79\xfe\xca\xbe\xc6\x8d\xcd\x3b\xf5\xb8\xed\xc3\x56\x9d\x46\xf7\x34\x6c\x02\x57\x18\x75\xcb\xa0\xe9\x85\xde\x63\xd6\xd1\xe7\xc6\x69\x9a\x98\xc7\x29\xfe\x28\xdc\x25\xe7\x6b\x8d\xcd\xa6\xdb\xad\xa3\xd3\x31\xe5\x46\x26\x55\xf9\x9c\x65\xca\xd9\x3a\xb1\xf4\xdd\x64\x89\xbe\x21\xf3\x09\x4c\xcf\x92\x91\x60\x2d\x43\xa9\x4b\xd9\x1d\x9c\x5b\xae\x47\x51\x8c\x7b\x07\xd1\xb4\x87\x3c\xf2\x46\x92\x07\x27\x90\xef\x44\x72\xf7\x64\xf1\x02\xf1\x71\x16\x18\xfd\x5c\x59\x0c\x16\x6b\x14\x96\x23\x98\xb4\x88\x68\x1b\x05\x86\x5a\x89\x55\x14\x98\xbd\x5d\xeb\x6b\x49\xe9\x20\x25\x33\xee\xb0\x91\x78\xba\xf0\xeb\xe5\x8d\xa4\xe3\xea\xc6\x3a\x49\xba\xa1\x7c\x1f\x9b\x15\x51\x1c\xe5\x3b\x97\x97\xb3\xf6\xa9\xea\x3e\xf2\x85\xe5\x2c\xfa\xd9\xaa\x6a\xe8\x86\x57\xdf\x33\xb9\xef\x81\xfa\x9e\x76\xb6\x7a\x9a\x2b\x20\x87\xd1\x38\x6c\x2b\x0e\xa4\x7f\x97\xfd\xb9\xc7\xf1\xb5\xef\xdb\x57\x1b\x5f\x6d\xf3\xd0\x3e\x23\x55\xee\xa4\x0f\x51\x92\x4a\x2b\x30\x7c\x3a\xa1\xfa\xd3\xf2\xf6\x06\x9f\xa7\x3f\x50\x5c\xfb\xd2\x7e\x49\x1c\x0c\xfe\xdd\x4f\xaa\x70\xf8\x5e\x10\xd1\x1f\x00\xeb\xc9\xe5\x48\xe0\x7b\xca\x2a\x49\xab\xc9\xe2\x35\xb1\x78\x58\xa3\x7d\x10\x52\x76\x13\x76\x8d\x8e\x2f\x79\x17\x5b\xa3\xe0\x4b\x68\x8c\xd4\xcf\x3e\x83\x93\xdc\xef\x3f\x40\x59\xcf\x57\x33\x37\x3e\xc5\x8f\x14\x30\x9d\x36\x96\x01\x68\x80\x69\xbd\xba\x63\xc4\xad\xfd\x3d\xdc\x74\x98\x73\x77\x33\x9f\xa9\x3e\x95\x3a\xff\xc7\x4c\xc3\x56\xf5\xf2\x71\xb3\xe2\xb3\x2e\xec\xa8\xb5\x8b\x29\x7c\x41\xf0\x6c\x63\x01\x3e\x88\xc0\x49\x8b\xc1\x1e\x9c\x9e\xcb\x25\x76\x54\x37\x4b\x50\x09\x8b\x79\xdc\xa5\xca\xf9\xc1\x41\x11\x57\x53\x6a\xe2\x1c\x4f\x53\x1b\x13\xe8\x2c\xb4\xbd\xc7\xa2\x75\x6a\x88\x9e\x8f\x4a\xf4\xd0\xc4\x58\x3b\x8c\x9e\xea\xf3\xb4\x83\xb4\xb4\x44\xa1\x5f\x4f\x8f\x61\x8c\x8b\xef\x9c\xd3\xf9\xe5\xcd\x95\x0d\xd1\xfc\xe6\xea\xea\xd2\x39\x99\x39\xd7\x33\x78\x7c\xfa\xa7\x3f\x4d\x6c\xd0\xe6\x1f\x67\xc7\xd3\x3e\x25\xed\xe8\x95\x3f\xcd\x2e\x1b\x01\xda\x22\xdd\xe5\xcb\x96\x77\xaf\x26\x3d\x49\xb9\x9a\xd8\x09\x61\x60\xdd\xea\xea\xb5\x03\x3a\x99\x7e\x9c\x9e\x5d\x5e\x59\x6b\xea\x5d\x7f\x9c\x9d\x01\xcf\xbb\xd2\xd5\xad\x40\x5f\x2b\x1c\x2b\x9b\xf1\x45\xcb\x7b\xd7\x1f\x64\x7e\xd6\x20\xd3\x3c\xbe\x5e\xd3\x09\xbd\x9f\x11\xfe\x1a\xa4\xc0\x2b\xdb\xa2\x3d\x1f\x36\x2a\x9a\xf2\x5c\x5d\xb4\xeb\x57\x60\x8e\xbe\x56\xfa\x7b\x57\xb9\xa1\xf5\x70\x9b\x74\x28\xd6\x8f\x05\x42\xd4\x15\xe1\x6e\x25\xcf\x8c\xae\xc5\x13\x6a\xea\x81\xd7\xc2\x6b\x4b\xda\xe9\x40\x12\x7c\x47\xad\x99\xef\xd6\x2d\xad\xcf\x4e\x3b\xd2\x54\x03\xd0\x42\x5b\x20\x96\xba\x88\xb2\xf3\x16\xae\x56\x64\x4e\xc0\xda\x24\x82\x0a\x55\x25\x9f\xfc\xcd\x17\xb6\x79\xc1\xd7\x7f\x2c\x45\x95\x00\x10\x84\xb1\xf6\x9d\x59\xb8\x95\x95\xc5\xfd\x55\x18\x61\xf2\xc1\x17\xd6\x59\x63\x32\x78\xf5\xef\x42\x45\x79\xcd\x0e\x22\x86\xba\xfa\x11\xff\x46\xfc\x0f\xb5\x56\x3e\x72\xbe\xfa\xf2\xcb\xaf\x47\xce\x5a\xb5\xaa\x93\x95\x88\xf0\x94\x37\x62\x7d\xef\xc5\xd2\xcd\xb8\xe0\x84\xae\x4c\xb9\x31\x2a\xfb\xd9\x03\x60\xba\x90\x23\xef\x63\x4c\xcf\xef\xbe\xfc\x6d\x85\x40\xfc\x4a\x53\x88\x7d\x98\x54\xcd\x1b\x6c\x91\x1f\xc5\xfe\x8f\x5c\xf4\x66\x23\x6b\x56\xd1\x5d\x49\x17\x9f\xe0\x36\x4e\xb6\xb4\x59\x44\x24\x64\x13\xc1\x91\x6a\xea\x8c\x4b\x11\xef\x73\x92\x9a\xfc\x5b\xa2\xab\x4c\x13\x35\xed\xa3\x0a\xc4\x82\x1a\xf0\x23\x41\x58\xee\xc3\x71\x4b\x25\x7c\x79\xf6\x74\x99\x83\x21\xac\x39\x72\x38\xf5\x0b\x27\xc1\x03\xd9\x8c\x89\xda\xc4\x11\x2f\x22\x86\x50\xb1\xe4\x0d\x56\x43\x0c\x84\x4c\xda\x15\x3f\xc0\x46\xa2\xd4\x22\x3f\x69\xab\x00\xd4\x81\x1d\x8a\x02\x4c\x99\xe7\x52\xc6\x34\x76\x59\x7c\x83\x3b\xf7\x4b\xfc\x3e\x97\x31\x86\xcb\x7a\xe6\x53\x11\x61\xaa\xdd\xd1\x5c\xfc\xa7\x61\xf8\x78\x8d\x89\xe3\x6b\xfa\xea\x18\xbe\xf9\xf9\xe7\xe2\x42\xe1\xdf\x27\x1b\x9f\x46\xa1\x9e\x58\x1b\x4d\x18\xe1\x87\x42\x5e\xd0\x40\x2e\xd4\x11\x52\x5d\x23\x4d\xe4\xa8\x3e\x8f\x15\x82\xac\x3c\x41\xe0\xe4\xc3\x5a\x90\x3f\x0b\xde\x3d\x73\xef\x45\xc0\x62\x51\xa5\xba\x77\x2e\xd5\x3a\x53\x7e\x31\x8f\x56\x2c\x86\x07\x2c\x2d\xa1\x26\xf5\x68\x5a\xab\xb9\x2a\x9a\xbf\xd1\x11\x41\xb5\xb9\xa4\x0d\x04\xd6\x07\xfb\x54\x92\x4a\x5b\xf0\xab\x6b\x9a\x92\x5a\x24\xc1\x54\x0d\x74\xdb\x5d\xb2\x3e\xeb\x43\x56\x25\xe0\xb2\xe6\x6e\x7b\xed\xf0\xeb\xf6\x7c\xb0\xb6\xab\xde\xac\x5b\x8e\x17\x52\xd6\xd8\x6a\xa1\x8e\x94\xda\x7b\x6c\xe7\x52\xbf\xbd\x1a\x4d\x74\x9f\x2e\x45\xe0\x51\x25\xca\xa9\x07\x87\x6a\x5e\x6e\x44\x6a\xeb\xe9\x51\x53\x3f\x70\x67\x83\xc0\x59\xe7\xc6\x1e\x46\xe9\xe6\x01\xbd\x3d\x5a\xf8\xac\x33\xfb\x8a\x63\xbc\x0d\x17\xb3\xab\x23\x67\xf6\x80\x65\x99\xe8\x94\x4d\xe3\x67\x32\xd7\x45\x32\x35\xd0\x75\xb6\x5f\x55\xf2\x03\x47\xf4\x38\x35\x47\x54\xe6\x81\xf1\x86\x0c\xc2\x0d\xb5\xa2\xab\x59\x7f\xf9\x88\x6f\xc3\xeb\x9b\x53\xb8\x4a\xcd\xce\xa7\x17\x8b\xcb\x23\x0c\x1a\x82\xc1\xf9\x0e\xee\x36\x2a\xc9\x8b\x72\x56\xa7\x10\xa2\x86\x54\x85\xb6\xfd\x6a\x04\xac\xda\xfa\x05\x4b\x82\x11\xaf\x30\xde\x74\xe5\x51\xdb\x2e\xbd\xac\x1f\x4a\xa7\x1d\x59\x09\xe6\xeb\x2c\x1f\xed\xf1\x80\x5d\x77\x9b\xb9\x4f\xba\x9c\x8b\xd7\x35\xfb\xab\xfb\xf1\x65\xad\xe0\xdc\x14\x72\xae\xde\xb5\xab\xc9\xf4\xb2\x55\xeb\x4d\xcb\x79\x55\xec\x69\x69\x0a\x14\x92\x2d\xb8\xed\x29\x56\xea\xaa\xdc\x1e\x46\x84\xf8\x55\x01\x08\x8c\x2a\x0b\xc4\x21\xee\xad\xb3\xcb\xe3\xc9\xd9\x14\x4f\xa4\x83\xe3\xb3\xe9\x64\x7e\x30\x42\x7d\x1e\x54\xf9\x2c\x91\x8f\xb1\x7a\x87\x19\xe1\x56\x55\x4d\x91\x89\xd9\xff\xfc\x8e\x51\xdc\xe1\xd0\xb9\x16\x0a\x0d\x1c\x59\x1a\x4d\xe1\x61\x6c\xc5\x89\xc3\xe1\x6a\x11\xca\xdf\x69\xeb\xe4\x8e\x63\xe1\xd8\x96\x3b\x2a\x05\x7b\x97\x3e\x6f\x64\xe8\x10\x2a\x99\x5c\xa9\xf2\x00\x83\x07\xb9\x43\x2f\x2c\x42\x61\x6b\xb0\xa3\x69\x37\xf7\x63\x15\x78\x92\x69\x80\x0a\x9e\x95\x34\x40\x09\xe3\x78\xca\xab\x35\xfa\x98\x3b\xd8\x82\x3f\x32\xbd\xc7\x98\x2c\x28\xed\x94\xed\x95\x17\x0b\x28\x1f\xf3\xc6\x3e\x85\x86\x80\x7d\xb0\x97\xae\x78\x79\xae\x64\x47\x6a\x64\x4d\x1e\x33\x71\x91\x24\xc3\x54\x7e\x6c\x32\xa4\x14\x9a\xce\x93\x0d\xa5\xd0\xe7\x14\xa6\xa1\x02\xa8\x91\x8c\xc2\x7e\xc3\x2a\x50\x3a\x9b\x8e\xfa\xa4\xc8\x6f\x3e\xba\x41\x26\xb8\x40\x55\xb5\x75\xe6\x8b\x19\x8d\x2a\x63\xb5\x6d\xf2\x12\xdd\xb8\x16\x4b\x74\xb7\x74\xee\x7c\x3d\x73\x13\x73\xbd\xb6\xf8\x8a\x2c\x2c\x52\x13\x66\xdd\xc5\x87\x56\xc3\xac\x5a\x2c\x49\xd6\x31\x8e\xba\x83\xe7\x4c\x0d\x67\x2f\x4e\xda\xca\x00\xf6\xe4\xa8\x55\x44\xbe\xb8\x97\xb6\x3c\x80\xd7\xf2\xd4\x36\x0d\x70\xaf\x6e\xda\xdd\x07\xb8\xab\xab\xf6\xfa\x91\xea\x2d\x91\xd5\x02\x63\x0a\xb8\x47\x30\x87\x5a\x34\xe6\x76\x1d\x47\x1c\x4a\x4b\x19\xd2\xaa\x5d\x30\x43\x89\x54\x15\xb3\x2e\x09\x5f\x48\x00\xab\xe2\x84\xb8\xec\x26\x96\x95\xcc\x06\x6f\x62\x49\x66\xa2\x39\xac\x48\x2d\x23\xa2\x60\xa2\xbd\x6d\xe3\xc7\xe8\x29\x2f\xc9\x56\x0c\x69\xb1\x10\x7a\x1e\xa1\x77\xd0\x8c\x2e\xee\xdc\xbd\x92\xb1\x05\x41\xa9\x75\x58\xab\xae\x27\x51\xea\x38\x93\xfa\x45\xd6\x5d\xdf\x43\x32\x1e\x45\xd0\x82\xee\x34\xf3\xbd\xa6\x81\xc8\x1a\x4e\xe4\xc3\xa1\x21\xc8\xd0\xb4\xb7\x6e\x1e\x23\x47\xb5\xbc\xc6\x5c\xa6\x93\x0a\x8e\x72\x7b\xb7\x11\xbc\xac\xea\x93\xe1\xe2\xc5\xb6\x5e\x2c\x4e\xe5\xcf\xdc\x79\xc9\xc5\x94\x7e\x62\x4c\x62\xab\x49\xf6\xd1\x88\xab\x33\x6b\x4a\x31\x33\x54\xb4\xdc\xdb\xfc\x4f\xd0\x33\x55\x37\x06\x46\x46\x3a\x26\x8e\x38\xf3\xb1\x35\x21\x11\x96\x44\x3c\xbf\xd4\x0d\x4e\x91\xb7\x85\x5f\xb1\x5c\xc2\x26\xfb\xe5\xdf\x72\x73\x61\x50\x74\x3a\x59\xea\x95\x11\xc3\x54\xed\xac\x9e\x43\xe9\xb6\x39\x25\x7c\x34\x1c\x25\x58\xe1\x13\x0d\xe2\xed\x88\xd8\xa8\x56\x1b\x92\x0c\x7b\x9c\x6a\x84\xb8\x32\x41\xbc\x01\x31\x95\x52\xf2\x04\x5c\x7d\x03\xb9\x9a\xcd\xc2\xf4\xe5\x6b\x78\x3b\x55\x1e\x96\xf6\xc5\xf8\x47\xca\x6b\xa4\x82\x48\x3c\x9f\x6e\xde\x6b\x21\xad\xeb\xe4\xd9\x40\x23\x6b\x04\x03\xd8\x4f\x2f\x36\x00\xc6\x1b\x0a\xa9\xa0\x1b\xd9\x64\xbd\x1d\x3e\x3d\xe7\x17\xcb\x35\x32\x98\xa6\x11\x54\x8c\x3a\x03\x06\xd3\x3d\xb9\xb9\x80\x12\x4d\x4f\x03\xb0\x55\x4d\x48\x4d\xb8\x38\x9c\xb8\x3f\x96\xa6\x30\x40\x03\xf2\x6e\x0b\xa0\x2b\x96\xe1\xfb\x4f\xdf\xa5\xba\x6f\x3c\x94\x98\x3a\xef\x84\xee\xcb\x9c\xef\xf3\x3a\x77\x94\x7c\x18\xa6\xe6\x8d\x74\xb8\x3a\x65\xe5\xd7\xe2\xeb\x96\xcc\xaa\x66\xbd\xec\xe7\x56\xd7\x45\xc1\xa9\x63\xd7\x41\x21\xc9\xc5\xd4\xfc\x5f\xfc\xd6\xd6\x45\x39\xfa\xe4\x6f\x64\x9d\x50\x95\xfd\x4d\x6e\xd6\x34\x6a\xaa\xc7\x33\x23\x1f\x6f\x31\xed\x30\xaf\x32\x52\x2e\x9f\xda\xe6\x9c\x40\x12\x1e\xe1\x74\x26\x11\x44\x15\xcd\x9a\x92\x1e\x25\x6e\x50\x11\xf9\xd1\x62\x82\x05\xc2\x69\x40\x53\x68\x6f\x25\x2f\x11\x68\x69\x51\x56\x06\x6c\x29\x92\xa2\x9c\x8e\xd6\x70\x99\xf0\x84\xf7\x5f\xfa\x39\x93\x1b\x6c\x2d\xd7\x4d\xc2\x85\x96\xdd\x8b\xd4\xe6\x55\xb2\xad\x9c\x94\xdc\xab\x4a\xaf\x41\x9f\xcd\xfc\x29\x0b\xc7\x2a\x51\x6d\x33\x83\x72\xef\xe9\xe1\x3d\x37\x99\x8b\xbb\xf7\xda\xbc\xae\xdd\xe8\x9d\x18\x1c\x59\x76\x5d\x37\x2e\x5a\xcd\xc7\xcd\x6c\xc3\xd4\x11\x6e\x06\x24\x7b\xa6\x91\x76\x4b\x75\x78\x01\x00\xd9\x72\xe9\x27\x8a\x98\xe0\x44\x13\xec\xed\xad\x0a\x42\xcb\x4e\x00\x89\x2e\x21\x8c\x6d\x1a\xe5\xa9\xf2\x14\xc5\x54\x9d\x4e\x57\x9c\xb7\x36\xe5\x51\x09\x2c\x54\x0e\x46\x35\x03\x93\x99\x8c\x08\x38\x17\x04\x88\x8e\x2c\xbf\xb2\x3c\x70\x62\xbc\xaa\xf8\x37\xc2\xdc\x06\xa2\x4b\x53\xc9\xf6\x5f\x59\x5d\xb8\x5c\x07\x1f\xe6\x35\x70\xb7\x51\x1c\xe9\x93\xc7\x26\xd3\xe8\x12\xc0\x12\xec\x75\x6f\x2a\x8c\x19\xab\x91\xc9\x1e\x25\x70\x79\xf8\xfc\xf7\x12\x69\x24\x79\x99\x80\xd2\x3a\x9b\x87\x6d\x15\xb7\xa7\x46\x4f\xba\x27\x46\x4b\x68\x70\xae\x63\x67\xe9\x28\x4b\x6f\x43\xe9\x33\x9c\x18\x81\x87\xe4\x09\xbc\xe7\xd4\x28\x61\x36\xd4\x88\xfd\xd5\x63\xea\xa0\x4d\xff\x90\x3c\xf3\xb0\xf1\xf1\x40\x78\x74\x63\x8f\x22\x28\xa4\xc5\x09\x1f\xe0\x16\xf9\xf8\xe9\xff\xbd\xba\x9c\x2f\x6a\xad\x4d\xb6\x3d\xb3\x60\xda\x1c\xce\xaf\x36\x47\x85\xe4\x16\x5d\x8b\x65\x39\x86\x79\x39\x98\x7b\x16\x0b\x2e\xe6\xbd\x8c\x02\xaa\x50\x80\xdb\x82\x1a\x11\xe8\x16\x29\x87\xce\x24\xfc\xd1\x5f\x3e\xfe\xf2\xff\x99\x2e\xc6\xfc\x29\x50\x07\x70\x60\x18\x9c\xe2\x19\x0d\x74\xac\x16\x67\x1a\xa7\x7d\x77\x01\xdf\xb3\x30\xef\xfe\xa2\x19\x9f\xa9\x9e\xe4\x79\xf7\x70\x14\x55\xeb\x28\x16\xa6\x25\xa1\x61\xee\x39\xb4\x21\xf6\xb3\x64\x09\x3b\xa2\xca\xa2\xac\xd0\xab\xbc\xd8\xa4\x3c\x0b\xe0\xda\xe8\x63\x5e\x9a\xa9\xda\x37\x0c\x42\x78\xec\x3e\xe4\xbf\xad\xbe\x46\x5a\x93\xd8\xa0\xbc\xf0\xac\x1d\xec\xab\x46\x9e\x4e\x2c\x3d\x66\x3f\x8b\x06\x8e\xa3\xcf\x36\x2a\xb2\x6b\xc4\x1e\x78\x98\xd2\x0c\xd3\xc9\x22\xac\x4c\xcf\x5f\x28\x47\x24\xd7\x4a\x90\x8f\x5b\x6d\x86\x6b\xe5\x66\xa7\x3d\x34\xd2\xa5\xe6\x93\x8c\x21\xe3\xdc\x63\x07\x0e\xea\x06\x21\x0b\x4c\x2f\x4b\x6f\x19\x1e\x49\x9b\x0a\x96\xda\x5b\x0a\x5e\xdb\xeb\x07\x70\xe8\x95\x5a\x1b\xa9\x3d\x3a\xe4\x5a\x07\x6c\xa9\xe7\x2c\xf0\xa2\x4d\x8b\x88\x8c\xa9\x97\x71\x57\x21\x19\x81\x00\x7f\xd5\x05\x49\xe4\xfd\x6a\x96\x24\x1d\xb3\x63\x19\x2e\xe6\xd9\xce\x39\xea\x97\xa7\x3a\xde\xf0\xc9\x6b\x39\xc3\x50\xce\x59\x6b\xe1\x17\x64\x95\xad\xaa\x3d\x43\x80\xcf\x37\x28\x2d\x8f\xdf\xdf\x5d\x4c\xce\xa7\x52\x2f\x1b\xe3\x9d\x6b\xac\x62\xc2\xc6\x2a\x63\x9f\x7b\xb3\x7e\x62\xcb\x83\xfe\x59\x59\x6e\x12\xa3\x8d\x19\x3c\x78\xfc\x9e\x54\x94\x6e\x24\xc2\x13\xb9\x48\xed\x46\x0b\x6d\x37\xbc\x1b\x51\xa1\x0d\xd5\xe7\x0c\xd3\x39\x55\xc4\x09\x87\xa5\xf9\x85\x1a\x93\xd8\x1a\xac\xa0\xac\x00\x9d\x76\xfe\x38\xc7\xb2\xd3\xcb\x93\x1f\x04\x1c\x5e\x0b\xaf\x3e\x73\x0c\xa9\xec\xfa\xa2\x9c\x5b\xc6\x9d\x21\x81\x4d\x91\xfa\x94\xba\xfa\x4c\x21\x43\xb2\xeb\xb7\x3d\x74\xa1\x74\x00\x9b\xcd\x5f\xa8\xbc\xb6\x88\x63\x8c\x42\xd6\x48\xea\x06\x52\xf4\x6c\xa9\xfe\x30\x58\x8c\x39\xa4\x13\x99\x01\x71\x2a\x37\x37\x05\x77\xad\xaa\x6b\x39\xe6\xe9\x5e\x3c\xfa\xa1\x07\x8a\xeb\x03\xe8\x7b\x4f\x54\x11\x98\x7a\x32\xfc\x8d\xf4\x3f\x90\x13\x1f\x16\x8b\x2b\x0c\x22\xfc\xe1\x79\xc4\x97\x5b\xce\x76\x7f\x4c\xd3\x4d\x72\x47\xdf\xd7\x3b\xc7\x28\x00\x37\x46\xd5\x1a\xd8\x0a\x62\x19\x3b\x1a\x25\x62\x24\x7b\xeb\x52\x27\xbc\x50\xa4\x78\x35\xc0\x7b\x56\x28\x28\x72\xb9\x5f\x6a\x19\x8d\xe5\x22\x92\x32\x45\x85\x25\x8c\x72\x2d\xe1\x81\x2b\x8a\x1a\xc7\x38\x76\x3b\x91\x37\xc1\xc6\xb8\x85\xe2\xb4\x85\xa0\x86\x18\x01\xf2\x46\x9e\xfd\xa8\xa4\x30\x54\x31\xe2\x6a\xd6\x2f\x50\x00\x57\x73\xce\x31\x0d\xea\x46\x8e\x60\xb2\xf1\x8b\xc4\xd3\x95\x34\xcc\x84\x76\xd9\xc1\xfd\x16\xfd\x4d\x45\x23\x43\xa7\x41\x15\x08\x2f\x22\xa2\xe6\xe1\x8c\x09\x49\x66\xff\x5e\x1e\x6d\x81\xa8\xf8\xda\x05\x98\xbb\x0c\xe3\xf8\xbd\x06\x5e\x10\xd2\x34\x24\x01\x8a\x1e\x20\xa1\x15\x51\x88\xa6\xd0\xcd\x98\x50\x30\x61\x74\xf9\x72\xc0\xc0\xec\xa8\x71\x90\x2b\xb8\x50\x70\xeb\x57\xdc\x90\x85\xdd\x49\xdb\xb0\xfe\x52\x82\x7b\xcd\x35\xf7\x6c\x27\x16\xc8\xaa\x58\x25\xd5\xd5\x0d\x55\x0a\x26\xca\xd4\xd7\xe0\x47\x95\x0e\x95\x31\x5f\xb9\xef\xe5\xe9\xf8\xaf\xcd\xad\xc2\xa2\x7f\x61\x8e\x14\x19\xf1\xf2\x83\xcc\xc5\xd3\xcd\xc6\x83\x47\x75\x05\xcd\xe2\xa8\x33\xfa\x91\x53\x19\xda\x2a\xe9\x36\x0d\xaf\x01\x0b\x8e\x97\x02\xf4\x63\x52\x6b\x65\xd2\x42\xd7\x3a\xbc\x0b\x77\xc5\x7a\x29\xfe\xd1\x33\xd7\x7a\x01\xfa\x04\xc5\x8e\x19\xce\xaf\x20\x5a\x75\x70\x63\x4f\x96\x70\xc9\xc4\x80\xb2\x35\x3b\x98\x7d\xca\xda\x95\x8e\xaf\xee\xee\xeb\x85\x19\xc4\x66\xea\x85\x56\xdd\xeb\xb2\x54\x11\xbe\x68\x04\x2c\xc3\x68\x46\x5a\xa7\x05\xdb\x95\xbe\xda\xe8\xb8\xea\xdb\xf5\x28\x55\xc7\xc6\x42\xbc\x8e\x99\x39\xa9\xb3\x06\xdc\xd4\xa8\x63\x03\x4a\x81\xf8\x81\x74\x01\xf6\x14\xa6\x24\x05\xb8\x63\x9e\xf6\x1d\x4a\xfb\xb6\x09\x2d\xaf\xda\x01\x64\x31\x14\x9b\xe1\x82\x29\x2b\x06\x7b\x97\x34\xfa\xa2\xe6\x83\x26\x45\x50\x29\x48\x25\xf4\x84\x7e\x83\xe2\x2a\xcd\xea\x57\xd8\xb4\x02\x55\x4c\xa3\x21\x9f\x1d\x85\x2e\x2b\x23\x9b\x4c\x21\x2c\x0b\x2b\x61\x54\x64\x5a\xfb\x49\x35\x98\x9d\x52\xba\x11\x8a\xa2\x5a\xfb\x2e\xe0\xf7\x04\xd7\xfb\x91\x2d\x2b\x72\x0b\xa8\x75\xb6\x67\x41\x1b\x12\xc3\x0c\x5c\x67\xc2\x94\xcd\x2d\x0e\xad\x2b\x82\x72\xd8\x3c\xca\x94\x75\x9e\x1e\x41\xb2\x11\x85\x5a\xc4\x70\x97\x75\x52\xd3\x60\xa5\x7a\x59\x5c\xac\x3e\x8c\x49\x5f\x63\x74\xa0\x37\xa5\x9a\x9d\xc1\xcd\xcb\xf3\xe5\x94\x65\xbe\xd6\x4e\xa9\xa4\x49\x44\xad\xb7\x61\xe3\x2a\x41\xe3\xe7\xc5\x86\x55\x17\x53\x90\x0e\x31\x70\x61\x2b\x93\x5d\x75\x42\x3c\x97\x4a\x71\x03\xe3\x65\xfb\x28\x29\xa2\xc0\x28\x75\x60\xf4\xbd\x57\x35\x68\x60\xf7\xdb\x2e\x32\xba\xcd\xbf\x6a\x6e\x9d\xb7\xbc\x17\xc5\x23\xb3\x70\xcb\x1c\x4e\x0f\xf7\xd8\xb3\x86\x60\xb5\xd2\xa3\x3a\xe3\x75\x88\xf4\xa8\xa3\x06\xf6\xe2\x6e\xfc\xc9\x01\xec\x8d\x43\x15\x9a\xfa\xf2\xa8\x4a\x53\x4f\x2e\xc5\xd6\xc2\x19\x58\x60\x36\x11\x87\xd2\x32\xc9\xf7\x49\xbe\x1a\xc1\xc1\x84\x4e\x51\x96\x85\x63\xb8\x42\x5d\x5e\x2f\xe8\xde\x0b\x03\xc0\xc3\x7f\x3c\x8e\xd1\x76\xb4\x1e\x33\x70\x58\xdf\x2b\x11\x8a\x38\x17\xb0\xfc\x3d\xf5\xa0\x7d\x04\x59\xbc\xa1\x96\x9f\x4d\x9d\x68\xab\x15\x41\x72\x06\x00\xca\xe8\xb0\x6c\xe6\x94\x4a\x0d\x55\x7f\xa2\xee\xee\xe4\x1e\x45\x59\x58\xa0\x37\x57\x25\x4a\x34\x93\xa6\x44\x44\xd3\x95\x46\x89\x59\x26\x82\xae\xed\x79\x73\x51\x55\xea\xc2\x76\x23\x35\x43\xca\xcd\x5b\x0c\x90\x93\x81\x48\xa0\x0a\x2c\x78\xd3\x76\x61\xbf\x5b\xef\xd9\x56\xd8\x78\x8b\xa5\x0c\x5a\x7d\xf8\xa9\xe3\x4b\x06\x79\xe2\x94\x6e\x36\x36\xb8\x98\xef\x09\x63\x48\x50\x7a\xf1\x21\x52\x3e\x95\xc8\x01\x4a\x6b\xca\x3c\x57\xec\x83\x95\x04\xa5\x11\x55\x05\x79\x96\x5d\x35\x49\xf5\x97\xe5\xe4\x74\xcf\x7b\xca\x0c\xf0\xd9\x9d\x80\x2b\xca\x1a\xf6\x28\x09\x04\xd9\xba\x81\x37\xb8\x37\x26\x9a\x47\x8c\xa8\xfb\x58\xa0\x61\x73\x4d\xe2\x56\x4e\x7a\x23\x8d\xc8\x96\x50\xe6\x9c\xca\x64\x63\xa3\xc3\x14\x3a\x39\x50\xbb\xc4\x6a\xc4\x37\x71\x00\xca\xe4\x91\xad\x1a\x31\x37\x45\xd3\x7e\x71\x72\x3e\x71\xde\x68\xde\xb3\xfa\xc0\xe4\x67\xa9\x41\xba\x8c\x46\x8f\x4d\x4c\x7b\xa5\x9b\x73\x53\xa3\x18\x95\x28\xd4\x66\xfd\x8d\x55\x99\xed\x83\x22\xae\x45\xf1\x77\x89\x8d\x78\x4c\x83\xe1\xa8\x58\x2c\x0b\x88\x81\xba\x98\xcf\x1d\x47\x49\xa2\x25\x31\x6c\xe3\x13\xcc\x94\xa1\x55\x9c\xb2\xed\x2a\x36\x7a\x39\xe5\xc5\xd3\xb8\x85\xe5\x88\x64\x08\x3d\x46\xd6\x3d\x5c\x6e\x68\xa7\x95\x4a\x5a\x8e\x31\x0b\x69\x7b\x91\x9f\xe9\x36\x9c\xf0\x65\xcb\x51\xb7\x2e\xe7\xc9\x0d\xa5\x59\x5d\x37\x6e\xac\x0f\xe0\xfd\xbd\x6d\x11\xfc\x81\xaf\x16\x2a\x1c\x97\x4b\x75\x53\xa8\x2e\xae\x5a\xd7\x76\x52\x1c\x3a\xb7\xe1\x19\x2e\x01\x57\xe5\xec\xa8\xbc\x72\x6c\xd7\x24\x62\x10\x70\xfa\x4d\xee\xb4\x99\xdf\x58\x85\x34\x22\xa2\x10\x8c\x63\xbc\xe6\x64\xe1\x8a\xcf\x81\xf2\x35\x17\xe5\xde\xdf\x0a\x14\xa2\xc0\x14\x32\x14\x37\xb2\xf4\x98\xb4\xc4\x16\xff\xde\xba\x3c\x71\x5e\x65\x2c\x1c\x66\xbe\x85\x07\xa9\xea\xf8\xad\xfd\xec\x28\x92\x3e\x89\xe7\xc4\xb6\xd3\x25\x1f\x0b\x79\xba\xaa\x6b\x78\xc9\x49\x2e\x23\xe7\x6c\x35\x1d\x99\x1c\xba\x87\xa8\x13\xed\xd1\xa5\x85\xcd\xc1\x3a\xfa\x96\x42\xd1\x1d\x6d\xf4\xf0\x15\xe5\xd1\xe5\x43\x07\x0f\x84\xbf\x15\xc3\x35\xf2\x0e\xbd\x4d\xf4\xd0\x52\xe5\xf2\x0b\xaa\x7c\x30\xbb\x75\xd0\xc8\x7a\xe8\x58\x17\x26\xc7\xad\x99\xf6\x1d\x5b\x8b\xc6\x63\xff\x97\x7f\x43\x13\x3f\x75\x7e\xa7\xb5\x11\x48\x9b\x69\x8d\x47\x01\x03\x0c\xaa\x8b\x20\x36\x6a\xb1\xc4\x65\xac\xf5\x63\x93\x3e\x5a\xd2\xaa\xa8\xd1\x38\x59\x55\x55\xb7\xbe\x16\xcf\x2e\xc5\x3f\x98\x5d\xf3\xe8\x65\x57\x36\x15\xb7\xe9\x2e\xfe\x46\x5a\x1a\x5c\xcf\x1b\xf3\xf5\x63\x8c\x22\xe9\x80\x39\xba\xc2\x3b\x44\x2c\xcb\x47\x6c\x6c\xd1\x8c\xd7\xd9\x6a\x05\x82\x9b\x94\x70\xd3\xae\x50\x81\xc9\x36\x7b\x04\x1a\xcb\xdd\xd1\x56\xfb\x7f\x01\xcb\x23\x70\xce\x41\x7a\x59\xfb\xf7\xd1\x8f\x3e\x36\xab\x86\x47\x6d\xe3\x24\x30\xee\x3a\xca\xb8\x07\xf5\x9a\x00\x3a\x6f\xc5\xe1\xea\xd0\xf9\xea\xcb\xaf\x7f\x77\x3e\x72\xbe\x3a\x85\xff\x7d\x79\x6a\xef\x48\x8d\xd7\x5b\x8c\x9e\x63\x44\x38\xd3\x6b\x89\xfa\xad\xeb\xe1\x59\xbf\xde\xa0\x5f\xb0\x0c\xae\x0f\x41\xaa\x42\x0b\x06\x79\x50\xe1\x8a\x7d\x51\xa8\x83\x36\x00\x68\xc1\xbc\x3c\x98\xf6\x30\x5b\xdf\x63\xc5\xda\x07\x79\x8a\xd8\x34\xa3\x6c\x2d\x60\x5b\xe4\x14\xc5\xf6\xc2\x6b\x65\xc0\xe5\x28\xe4\xce\x38\x94\x0a\xd6\x1e\x7a\xbc\x88\x91\xdd\x9d\xf6\x19\x3c\x09\x47\x46\x69\x83\xd5\x43\xbd\x99\x4c\x72\xfd\x54\x96\x8f\xe3\x2e\x63\x70\x86\x3c\xf8\x2b\xba\xbb\xdb\x4a\x6d\xa8\xf7\x10\x88\x2a\x08\x87\x37\x78\xbe\xf0\x7b\xbe\x84\x91\x35\x16\x54\xc5\xd4\x4d\xd8\xc1\x7c\x71\xd7\x26\x33\x6d\x42\xce\x3d\x55\x24\x4b\xef\x31\x85\x09\xa4\xfb\xda\x5a\x00\xa2\x03\x16\xdd\x55\x34\xc7\xc4\x2b\x43\xe3\x80\x1f\x9e\xdc\xd8\xc3\x0a\x2d\xd7\xb0\x20\xd7\xc6\x65\x0d\x21\xa9\x18\x19\x72\x1a\xfd\xff\xcc\x5d\xdd\x6e\x24\xb7\x72\xbe\xcf\x53\x34\x02\x1c\xc8\x40\x46\x3a\xb6\x91\xab\xf5\x95\xac\x5d\x6d\x14\xec\x4a\x8b\xd5\x68\x8d\xec\x0f\x74\x7a\x66\x5a\x23\xc6\x33\xdd\x93\x66\x8f\x64\x1d\x63\xdf\x25\x0f\x90\x17\xc8\xb5\x5f\xec\xb0\x7e\xc8\x26\xbb\x59\xec\x9e\x91\xe4\xb3\x08\x90\xe3\xd5\x34\x8b\xc5\xbf\x62\x91\xfc\xea\xab\xdd\xf4\xb8\x3c\x7e\xfd\x4a\x28\x71\x35\x3d\x7b\x73\xf6\xf1\xa3\x40\x2f\x86\x25\xa5\xe7\x58\x5b\x54\x78\x83\xbd\xba\x7c\xf5\x7e\x24\x8d\xdb\xc7\xb3\x8b\xf3\x57\xd9\xd5\xd4\x1c\xab\x04\xbe\x32\x10\x26\xd1\x9c\x25\xcb\x95\xf6\xc1\x95\x13\xa7\xc7\x2e\x0d\x8f\xd0\x65\x25\xe2\x15\x99\x37\x02\xf0\x0c\x7c\x04\x06\x59\xf8\xb2\x9a\x87\x68\x4d\x59\xe6\xa0\x72\xf4\x54\x08\x3e\x07\xe0\xa4\x90\xa0\x86\x13\xef\x31\x63\x11\x79\x36\x66\x17\xdf\x40\x7a\x96\x51\x4a\x1a\x99\x5a\xa1\x39\xb3\x6c\x33\x6b\x73\xc0\x01\xe8\x1a\xbc\xf9\xc2\x5a\xd5\x84\xd1\x58\x78\x34\x44\xa9\x55\xd3\xea\xbb\x85\x33\x75\x83\x97\xf4\xc9\x40\x3d\xd6\xa5\xc5\xc2\x1d\x84\xec\x31\x82\x1f\xd3\xd6\x44\xde\xf2\x84\x4f\xf3\x07\xf6\x68\x7e\x30\x96\xf6\x20\xae\x84\xef\x07\x63\x90\x3b\x9d\xb9\x3d\xf1\x83\x94\x08\xbe\x8a\x14\x08\x53\x64\x27\x27\x78\xf6\xfe\x50\xd4\x1a\xe1\x9e\x11\x46\xcc\xdd\x8e\xde\x6d\x25\xd5\x0c\x60\xb8\xf6\x0a\x14\x6f\x46\xc0\x3a\x14\xee\x5e\x13\x8f\x47\xee\x5f\xa3\xa6\x31\x6c\x35\x65\x41\x9e\x06\xde\x5f\x60\x90\x0f\xdd\x7c\x32\xec\x9d\xfa\x6c\xa6\x22\xf2\x07\x14\xde\xe4\xb5\xee\xf6\x08\xbd\x92\xbe\x3b\xe3\x7f\x9a\x7e\xde\xb5\x37\xd0\xab\xce\xac\x63\xcc\x29\x69\x53\x6f\xd0\xc7\x65\x89\x48\xbc\x10\x04\xaf\x7c\xef\x7a\x38\x1b\xa0\xad\xb8\x4d\x5a\x15\x8d\x6a\x46\x75\x1e\x19\x9b\xc0\xfa\xfa\xf4\x84\x1d\xf8\xfe\xaa\x7f\x2c\xe8\xe8\xb1\x90\xcd\xd2\x2e\x41\x07\x57\xe5\x8c\x50\x0d\x61\x30\xe6\x2e\xbd\x6e\x26\x16\xca\xa0\x90\xd7\x18\x97\xe0\xa8\xde\x4f\xe8\x41\xfc\xe7\x0d\xf9\x43\x21\x0d\x3a\xac\x8f\x18\xfc\xe4\x09\x74\xc6\xf0\x1a\xe3\xd3\xe3\x54\x8a\xf1\xa3\xf3\x71\x43\x46\xa0\x3c\x7d\x53\xbd\xd4\x4e\xdf\x42\x53\xc7\xb3\xdb\x7b\x8d\xee\x84\xd5\xf1\x4c\x43\xdb\xbf\xa3\xa5\x48\x8b\x4c\xbe\x8d\xc6\x3a\x27\xce\xa5\x34\x36\x55\x38\xab\x33\x07\x0d\x56\xab\x5d\xbd\x48\x2c\x1c\x45\x07\x92\xc1\x91\x88\x81\x9e\x0d\x3b\xd8\x31\x51\xdc\x4d\x69\x24\x21\x62\xf6\x64\x02\xa2\x3f\x07\x67\xd8\x76\xe5\x3a\x7f\x30\x93\x16\x8e\x90\x88\x18\x59\x9b\xff\x4f\x94\x90\x9d\xa7\x8a\xbb\xed\x0a\xee\xe7\xcd\x9e\xf6\x53\x86\x67\x4d\xd5\x3f\x77\xc9\x2c\x66\x0c\xcb\xd3\xbe\xbf\x84\x8e\xc1\xcb\x2a\xb8\x79\x31\xdf\xcd\x8b\x62\x21\x5d\xb7\x7c\xeb\x6a\x67\xdf\x3d\xfc\xb5\x14\x4e\xc3\xad\xee\xb1\xac\xd2\xe3\x75\x7a\xae\xc9\x3c\xa4\xb5\x1e\xe6\xad\xc5\x96\x30\x58\xba\xb3\xeb\xa0\x26\x5b\x3d\x90\xd7\x4d\x5c\x50\xa3\xd9\x77\x17\x88\xaa\x51\x2d\x35\x86\xf2\xa0\xd4\x45\xeb\xcb\x75\x89\x3d\x3c\xd5\x9e\xa3\x1f\xdc\x96\xf4\x2d\xf5\x43\x9e\x26\x00\x79\xfa\x2e\x31\x3f\xb0\x69\xc3\x96\x52\xa6\x05\x1d\xa4\xd1\xff\x53\xba\x26\xad\xc8\xf8\xf6\x17\xbf\x6d\x8a\x39\xbc\x8f\xd0\xe3\x0d\x5c\x78\x57\x73\x0c\x53\x5b\xbc\xc0\x53\x2f\xbf\xd2\xec\xfe\x94\x65\x06\x0e\x68\xcd\x34\xdc\x93\x06\x92\x04\x4d\xd0\x6c\x70\x12\x1c\x0b\x0e\x81\xb1\xe6\xc8\x39\xc2\x68\x65\x79\xbd\xdc\x42\xc7\x09\xfa\xbc\x34\x87\x64\x92\x83\x7b\xbe\x3d\xff\xd8\x38\x04\xda\x9b\x8c\x8c\xaa\xed\x7c\x8e\x5b\x18\x50\x0b\xe6\x08\x6b\xe5\x70\x28\xe7\x03\xee\xbf\xa7\x4c\x1b\xa6\x67\x55\x8a\x48\x11\x34\x58\x55\x10\x5a\xe7\x03\x52\x08\x02\x88\x87\x33\xc2\xc4\x89\xd0\xf3\x99\x29\x4c\x6f\xda\x91\x3c\xd6\x08\x76\xa3\x34\xac\x66\xbc\x30\x31\x16\x43\xdf\xd6\x32\x67\xc2\x55\xa9\x23\x7c\x63\xbb\x9c\x81\x54\x92\x70\x2c\xd1\x11\x7a\x5f\xae\x1e\xeb\x05\xce\x03\x32\x9c\xc7\x32\xf7\x90\x42\x09\xee\x1e\x34\x18\x8f\xe0\xee\xe9\x75\x5d\xb7\x05\x09\x3a\x1f\x0c\x04\x48\xb3\xf9\x94\x63\x8f\x8e\x04\xbb\xcc\x07\x31\x97\xc7\x3c\x7b\x30\x56\x75\x24\x64\xd2\x09\x1f\x45\x12\xe4\xd7\x30\x9a\x1e\xc8\xab\x82\x1c\x94\xdc\xa5\x19\x1d\x51\xcd\x18\xa6\xe4\x91\xf5\x12\xa7\xf1\x88\x3a\xfb\xe4\xc7\x23\x6b\x18\xc8\xf4\xe0\xd5\x11\x3d\x03\xa5\x6b\x29\xbd\x40\x90\x42\x57\xdb\xda\x5e\x9d\x0c\xd7\xe6\xdd\x72\xd4\x4a\x57\x70\x99\x64\x83\x36\xa4\xc5\xd5\xaf\xd4\xbb\xac\xd9\xa9\x46\x3e\x6c\x8c\xab\x30\x1a\xee\x33\xd4\xaf\x29\x89\x14\xf0\xc8\xff\x2d\xbb\x04\xac\x39\xc7\xab\xb5\x9f\xcb\x92\xa1\x4b\xfe\xa2\x23\xc4\x99\x40\xb2\xf8\x17\x2d\xdd\xc6\x1d\x7b\x26\x1e\x57\x4f\x54\x46\x4e\x22\xd2\xb5\xe7\x84\x4e\xe3\xd0\x18\x8d\x97\x83\x77\x08\x25\xc1\x3f\x2c\x4e\x4e\xfc\xeb\x41\xc0\x7a\x95\xc5\x7d\x51\x1f\x01\x65\x7d\xed\x62\xe1\x39\xfa\x44\x69\x2c\xcb\x9e\x7e\x58\x54\xe6\x11\xce\xbb\xad\x01\xd3\x83\x78\x37\x7a\xbb\x5a\xc0\x05\xf1\x90\x5e\x19\xc7\xd5\x9a\x1d\xe0\x28\x43\x32\x07\x0f\x54\xec\x28\x57\xc0\xcf\x91\x15\x1c\xe8\xa9\x3f\x85\x0a\xa5\x33\xb4\xcf\x1c\x0d\x38\x76\xe7\x08\xc1\xb2\xa6\xa0\xc3\xdd\x0f\xf9\x4f\xbd\xf6\xc4\x9c\x98\xb8\xc0\xb4\x3a\xd1\x0b\xdf\xc7\xf4\xb3\xc0\x8c\xb9\x4f\x57\x8d\x38\x88\x8c\x3d\x66\xf4\xba\x6f\xec\xf1\x62\xf4\xf1\xa1\x55\xba\xbb\xb3\xee\x78\x0b\xd5\x53\x75\x54\x82\x82\x1d\x2f\x8c\xba\xda\xce\xba\xd9\x09\x1e\x31\x05\xd2\x09\x0b\xf6\x9b\x08\xe2\x75\x4a\x4f\xdd\x9d\x57\xd2\x20\x9f\x7c\x44\xf1\xb1\xab\x2b\xf6\xa8\xf2\x44\xeb\xab\xff\x4a\xb2\x67\xe7\x06\x89\x20\xfe\x09\xb7\xae\xbd\xe9\xe3\x86\xe0\xa6\x8d\x8b\x76\x91\xbc\xff\xb4\x2b\xd6\xcd\xaa\xca\xdd\x6d\x35\x60\x32\x34\x1e\x6a\xd0\x47\xa1\xf4\x92\x12\xa8\xcc\x1c\x8c\xe6\xae\x79\xca\xe1\x39\x42\xb6\x8d\xdc\x17\x34\xa0\xc1\x7e\x5b\x48\xa8\xc7\xe3\x37\x10\xab\x8d\xbf\x95\x8e\xac\x5d\xf5\x0a\x0d\xd7\xf1\x51\x6d\x4e\x4d\xcf\xfd\xfc\x60\x8e\xf8\x90\x3f\xc6\xfc\x09\xfe\x7d\x02\x50\x2a\x38\x60\x2a\x39\xdf\x61\x74\x04\x06\x45\x0a\x3a\x89\x5c\xea\xc2\xf7\x8f\x22\x25\xb9\x7a\x22\xc2\x11\xab\x85\x17\x59\x8b\x8c\xed\x98\xc8\xa3\xa1\xe0\x49\x76\x3e\x61\x91\x23\x7b\x5d\xe2\x19\x34\x50\xcb\x0f\x99\xf5\x11\xe5\xc6\x99\xf4\x13\x4e\x74\x96\x68\xe1\x65\x57\x1f\x45\x99\x05\x4d\xc8\x01\x48\x72\x88\x40\x92\x4d\xae\xf5\x7d\x55\xe3\x23\xc1\xaa\x5a\x2a\xb1\x07\x35\x1d\x81\xdc\xf7\x16\x2a\xc2\xf4\x77\x94\xc2\x49\xac\xd2\xb3\x8c\x4d\x2e\x46\xbb\x4c\xf3\x25\x1b\xab\x62\x38\x1b\x0e\x4a\x05\x28\x39\xf6\x37\x99\x9d\xd1\xd9\x66\x5a\x2b\x18\x14\x1f\x46\x75\xc0\x59\x6e\x07\x1e\x0a\xdb\x04\x09\x03\x65\xc4\x89\xf0\xa9\xa1\x82\x60\xeb\xc5\x80\x0a\x33\xb4\xe9\xce\xa3\xe7\x22\x9f\x57\xcc\xd9\x4d\x31\x6c\xee\x34\xa0\xf9\x72\xe8\x3a\xbf\x60\xa2\xb6\x3a\x48\xfd\x8b\xaf\x3c\xe9\x75\x61\x37\x6a\x17\x75\xe3\x15\x4c\xd4\x43\x2c\x5d\xbf\x23\x45\xcb\xb0\x39\x0f\xea\xaa\xc4\xc2\xd1\xfa\x3e\xbc\x7a\x7f\x79\x76\x71\x2e\x8d\x20\xff\xfc\x4a\x18\xc3\x0f\x40\x7c\x98\xfd\xe7\xe5\xc5\x79\x56\xcd\xfe\x1b\x52\xfb\x31\x99\x9e\xe7\xaa\x1d\xda\x80\xcb\x16\xb6\x88\x38\x2f\x78\x97\x58\x03\xae\x48\x4f\xda\x95\xc5\x39\x33\x54\x79\xb8\x02\xb4\x51\x85\xc1\x87\x39\xb3\xb8\x9d\x22\xd9\x2f\x10\x68\x21\x40\x80\xe0\xec\xc5\x22\x21\x57\x17\x70\x1f\x3a\xc7\xbb\x71\xfa\x95\xf0\x86\x45\x8a\x32\x58\xea\xe6\x8b\xe5\x12\xf7\x48\x6c\x2e\x52\x3e\x56\xcc\xcc\x4e\x14\x64\xb6\xe6\x5a\xf5\x31\x9a\x2e\xea\x54\x05\x7e\xcd\x04\x32\x08\x21\x37\x87\xc6\xe3\xb9\x69\x2c\xb4\x1b\xc2\x96\x31\xda\x82\x1b\xfe\x0e\xa3\x95\xb3\x62\x55\x94\x73\xda\xb7\x92\x55\x31\xce\xbf\x51\x90\x82\xad\xd4\x66\x77\x40\xcc\xbf\xeb\x08\xcb\x01\x0c\x4d\xbb\xcb\xb3\x7c\x04\xd7\xb1\x34\x7b\x9e\x7a\xfc\x55\xf9\xed\x8d\xbb\xd8\xf4\x2d\x01\xd4\x30\xdf\x0b\xdc\x29\x1c\xda\x43\xc9\x21\xc6\x33\x1f\xd8\xc4\x91\xb3\x82\xf2\x02\xaa\x3b\x11\xd4\xb8\x82\x09\x05\x8e\x00\xa7\xb5\x6a\x53\xc0\x44\x05\x83\x91\x67\x06\x3e\x64\x65\x63\xf1\xc2\xe6\xe5\x38\xf6\xce\x07\xcc\xad\xe3\x60\x13\xe4\x10\xad\xcb\x3b\xde\x3f\x25\x93\xc1\xcf\x5e\x6e\x9f\x15\x85\x69\xd9\xdb\xe1\x5f\x25\x45\xc0\x61\x01\x4c\xf3\x04\xc3\x07\xea\x86\x23\x98\xf8\x0d\x46\x13\xb5\x9e\x8d\x5b\x11\xf7\x02\x9f\x83\x19\xc4\x4d\xcc\xff\x90\xbc\x0c\x63\x7f\x82\x47\x56\xe5\x42\x7f\xc8\x55\x91\x36\x8a\x5f\x8e\xdf\x9f\x9f\x9d\xbf\x26\x4a\x23\xda\x66\x61\x31\xa0\x5f\xe5\x3c\x0f\x08\xa0\x71\x8f\x77\x34\xe3\x31\xba\x0f\xee\xfb\x6e\xd5\xf2\x76\x05\x11\xda\x7a\x6e\xca\xe4\xcb\x62\x81\xa2\xfe\x2b\x10\x00\x28\x89\x19\xa4\x29\xa2\x90\x57\x40\x4f\x82\xe1\xd4\xd8\x0d\xfc\x23\x30\x3a\xd6\xb4\xa8\xa8\x7a\x7d\x6b\xf6\x07\x23\x5f\x43\xb4\x05\x50\xda\x49\xe7\xb0\x0f\xc6\xec\x4f\x5f\x9d\x7f\x3c\xa6\x56\xa0\x3f\x43\x3c\x7e\xcd\xd6\xf3\x9f\xf0\xd8\x04\xcf\x42\x9b\x30\x22\x6f\x99\x93\x55\x22\xe6\x33\x4a\x0f\xd8\x14\x98\xa2\x3c\xd3\x60\x91\xd4\x72\xa5\x72\x60\xd5\x33\xc2\xdf\x78\x02\x37\x55\x53\x17\xb3\x99\x23\x1b\xc4\xe6\x21\xd0\x17\x9f\xe1\x56\x60\xef\x60\x93\xa0\x5f\x6d\x1c\x49\x93\x73\x78\x3b\x84\xb9\x54\xe0\x01\x5a\x2a\x5e\x6c\x30\x36\x34\x39\x54\x19\xc6\x14\x31\xc1\x65\x85\x81\x4d\xc6\x72\x68\x62\xdb\x24\x48\x5a\x70\x35\xc2\x08\xe5\x30\xd8\xb8\x4f\x98\x0e\x5e\x9c\x99\x56\xe5\x12\x1e\x14\x1d\x31\x56\xe5\x92\xc5\x92\x18\x9c\x1d\xf4\x58\x97\xfd\xf8\xfd\xf7\xf0\xfb\xbf\xff\xf0\xfd\xc4\x46\xf5\xf6\xe5\xc2\x63\xf4\xac\x80\x6b\x20\x4a\x86\x35\x41\xb8\x0c\x71\x26\x6f\x6e\xf1\xe6\x19\xc6\x5d\xc3\xb0\x9f\xac\xaa\xed\xc2\xd8\xcf\x6d\xb9\xa8\x1f\x0e\xb4\x71\xe7\x9a\x1c\xe8\xbe\x8f\xb2\x63\x33\x13\x7e\x2d\xab\xfb\x55\xb1\x58\x3a\x82\x86\x5e\x5d\x16\xb7\x4f\xc1\x83\x0b\x7a\xbb\x0b\x84\xfa\x94\xa5\xae\x9b\x08\x3d\xa0\x79\x4d\x3a\x56\x77\x31\x5a\xed\x78\x0a\xb3\x0d\xfd\x0c\x17\x77\x0d\xa3\x41\xd3\x0a\x52\x04\x83\xcd\x2f\x89\x6a\x45\x45\x6f\x95\x78\x4c\x1c\x83\x24\x8b\x49\x25\xad\xdc\xa8\x3f\xfe\xdf\x23\x0e\x83\x53\x0a\x71\x3e\x12\x6f\x84\xa5\x33\x62\x5c\x39\x8e\x0d\x0c\x4d\xc6\x8c\x2f\xf1\xbb\x22\x23\x17\x38\xb5\xf3\x36\x77\x18\x80\xaf\xf5\x5c\x11\x0b\x60\xa1\x78\x78\xcc\x60\xdd\x18\x2f\x14\xc3\x3a\xec\xa8\x84\x3d\x7b\x94\x4d\x6d\xc8\x62\xc0\x10\xcf\xfb\x36\xd1\x59\x47\x75\x70\x64\x61\xb5\x5a\x57\x1a\x80\x20\x79\x74\xd0\x80\xc7\x82\x50\x16\x58\x0b\x85\x01\x06\xa2\x84\x6d\xff\x59\x16\x8e\x4b\x2d\x18\x5f\x38\xb4\x22\x00\x0a\xd1\x0b\x0a\xa2\x40\xa9\x67\x5e\x13\xfb\x2d\x85\x56\x47\x7f\x2d\xd8\x05\x02\x24\xdf\x59\x6e\x06\x79\xbd\x69\x5c\x05\xeb\x7c\x51\x58\x0a\xaf\x7c\x1e\xeb\xc7\x9f\x1c\xfa\xca\xcf\x5f\x8c\x46\x04\xe2\x00\xe1\x00\x5d\x57\x0f\x96\x38\xb6\x33\x06\x5e\xe8\x24\xf7\x4d\x4f\x57\xd3\x13\x37\x10\xf4\x17\xad\x05\xb3\x5a\x9a\x0d\xc6\x22\xe4\x80\x89\x98\xbd\x76\xea\x7c\x4b\xd0\x77\x08\xd7\xde\x87\x74\x63\x5d\xf5\x7e\x64\x6d\x28\xf7\xf1\xc6\x85\x0b\xcf\xcd\xb8\x95\x5b\x31\xca\xfe\xf9\x0c\x85\x90\x7a\x33\x66\x26\x48\xba\x8b\x27\x76\xa1\x66\x5e\xee\x52\x8c\xb2\x07\x3b\xd0\xe6\x10\x2c\x9e\xd1\x0e\xec\xb5\xf4\x3d\xd5\x0b\x6b\x07\x82\xb5\x8f\x39\xac\x41\x20\xe4\x0b\xe0\xa4\xdd\x10\x18\xb3\x9a\x03\x00\x80\x3c\xeb\xbb\x8a\x0f\x20\xe6\x1f\x0d\x47\x74\xf6\x3b\xfd\xa7\x4e\xe4\xbe\xea\xe4\xbd\x36\xdf\x81\x11\x0b\xa2\xa6\x23\x43\xe7\x87\xe3\xc2\x06\x1f\xef\x7b\xec\xd0\x02\x90\x9c\x9b\x0a\x83\x1d\x39\x2a\xc6\x54\x17\xd6\x0a\x87\xaf\xca\xb8\x15\x25\x0c\xa7\x8b\x9c\x49\x4c\x62\x61\x0e\x13\x0b\x1e\x4e\x62\x4b\xfa\x6a\x67\xf1\x4e\xd6\x53\x81\x79\x6a\xe0\x52\x04\x49\x6a\x83\x61\xfb\xa9\xb3\x8c\x3d\x42\xca\x59\x61\x4d\x05\x10\x01\x20\x29\x23\xc1\x10\x74\x34\x3b\x6f\x58\x32\x87\x9b\x43\x08\xc7\x43\x56\x15\x33\x69\xf2\xfa\x01\xc3\x81\xe7\x30\x0f\x5b\x26\x15\x5f\x49\x8c\x0b\xde\xac\x30\x22\xbc\x67\x5d\x30\x10\x50\x41\x67\xac\x31\x3f\x1a\x2c\xea\xbb\x1f\xb2\xcb\x30\xf5\x35\xbc\x3d\xb3\xcf\x93\x2c\xf8\x23\x7e\x09\x09\x4e\x0a\x00\x02\xc7\x2d\x2b\x5a\x62\x53\x07\x3c\xbb\xa3\x76\xa6\x18\xfe\xf7\x51\x96\xfd\x52\xb4\x39\x14\x80\xdb\xc0\x1a\x45\xfe\xdc\x81\xa6\x90\x62\x6c\x4b\x08\xae\x45\x75\x5f\xda\x8f\x5a\x33\x05\xb0\x3d\x4c\xbd\xb3\x58\x60\x4e\x04\x33\x48\x1d\x15\x66\x05\xa6\x48\x21\x5e\xfb\xa3\xec\x02\x1c\xa8\xd4\x5e\xb5\x56\x4b\xe0\x72\x59\x4c\x6c\x65\x2d\x8d\xaa\x51\x96\x5a\x03\x61\xc0\xc9\x4d\x47\xb4\x94\xad\x0f\x6f\x4d\x1c\x92\xbe\x1f\x78\xf6\x92\x67\x1b\xac\x9e\xce\x64\x53\xb1\xe5\x17\xf0\x90\xda\x25\xdf\x28\x72\x1e\x2c\x80\xa5\xb3\x2e\xbb\x6e\x97\x2b\x6f\x89\x65\x1a\x48\xff\x0a\x1b\x92\x26\xa0\x82\xbd\xca\xa2\xb9\xa8\xaa\x80\x8b\xa7\x55\xdd\xb4\xc5\xfc\x11\x6e\xbb\x60\xe9\x9b\x53\x9a\x6a\xb6\x1c\x07\x18\x33\x1c\xb7\x45\x3b\xb5\x72\xc6\x3e\xfc\xdc\xff\xce\x8c\x01\x3b\x7d\x2c\x24\x5a\xd0\x4c\xaf\x75\xb1\x50\xc4\x48\x02\xe7\x1d\xe6\x92\x68\x0f\x41\x42\x07\x2c\x72\x85\x30\x0c\x65\x93\x6c\xfe\x90\x75\xff\xf2\xa3\x99\xb3\x97\x68\x50\xe9\x90\x84\xd8\x20\xe6\xb8\xb5\x60\x3c\x65\xc9\x8b\x4c\x79\x22\x96\x26\x22\xe6\xc0\x6e\xc2\x04\x87\x8b\xb4\xf5\xa6\x58\xf0\xd9\x2d\xe0\x7c\xb0\x0a\x12\xdf\x05\xec\x23\x47\xd9\x15\x64\xf7\xad\xe0\xb6\x88\x29\x0d\xa3\xad\xf0\xf6\x36\x9e\xc1\x13\x8f\x72\x17\xef\xc1\xc2\x36\x42\x34\x1e\x94\xb1\xc7\x36\xdc\x99\x54\x6f\x67\x3a\x12\xf8\x30\x7e\xc9\x6b\xf0\x42\x5e\x00\x01\x1d\x51\x98\x42\x78\x70\xc8\x00\x44\x3c\x63\x80\x2a\xf2\x3e\xd1\xc1\x37\x9a\x79\x78\x5d\x42\x15\xf9\xf8\x7b\x67\x66\x69\x03\x3b\xd2\x0b\xeb\xce\x57\xcc\x32\xc6\x50\x5e\x9f\xe0\x14\x95\x69\x59\x4e\x5f\x40\x92\x89\x76\xf8\x56\x07\x5b\x9a\xd8\xbd\x32\x9a\x0a\x28\xf1\x70\x6a\x9b\xcd\xc4\x54\x10\x3f\x4e\xa9\x39\xf9\xc2\x49\x17\xcd\x35\x64\xc8\xd1\xd7\xb3\x87\x6b\x8b\x49\x10\xf1\x4d\x5e\x9b\xf8\xa1\x83\xce\x0f\xed\x45\x93\x51\xf2\x66\x5b\xd2\x04\x91\x84\xa7\x35\x25\xb0\x34\x24\x66\x03\x6d\xe1\x7e\x66\x84\x36\x96\xe2\x47\x81\x5e\xd5\x82\xdf\xe6\x4c\x61\xa1\xb2\x1a\x5e\x56\x4c\xc7\x99\x99\x5e\x2d\x90\x88\xf9\xf4\x0c\x12\x47\xb7\x99\x13\x74\xb3\x30\x6e\xb0\x84\xfd\x9d\x9b\x55\x04\x23\x54\x1b\xef\x00\xc5\x80\xe7\xc5\x22\xee\x8a\x39\xf9\x12\x24\x21\xa1\x80\x25\x8e\xbf\x83\x5b\x40\xdc\x74\x38\x2b\xe8\x8d\x92\xe0\xb6\x5c\x33\xde\xf3\xf9\x98\x7d\x65\x6f\x2f\x46\x04\xf5\x7f\x84\x1c\x49\xb5\x39\xa8\xdd\x15\xed\x3b\x11\x5f\xb9\x8e\x80\xa2\xbe\x39\xa0\xc2\x66\x15\xff\x5d\xd1\xac\x75\xb9\x6b\x76\x40\xa7\x7e\x7a\x7b\xf5\x66\x7a\xf6\xee\xf8\xfd\xf4\xaf\xa7\x17\xef\xdf\x1e\xbe\x3c\x9e\x1e\x67\x27\x17\xe7\x10\xa4\x9e\xfd\xc7\xd9\xcb\x97\xaf\xce\xbf\x08\x1a\x7c\xa2\xcf\xae\xa6\x17\x59\x4c\xc8\xf9\xf1\xe5\xc9\xc5\xe5\xf4\xe2\x8b\x50\xf1\xbb\xf7\x67\x1f\x8e\xa7\xaf\x32\xfc\x78\xa0\x26\xf3\xcd\x59\x46\x05\xce\xac\xe0\x33\x49\x70\x8c\x9a\x5a\x8b\xa2\xa3\xdc\xae\x92\xe8\xe5\xaa\x9a\x19\x67\x81\xe9\xbb\xbe\xb8\x83\xd4\x27\x0b\xda\xd7\x47\x47\x47\x5f\xb2\x4f\xf6\xef\xf6\x43\xa9\x72\xcb\xda\x45\x72\xd5\x17\xe7\x44\x7f\xb2\x08\x7e\x45\x02\xed\x87\xfc\xbb\xa0\x1f\x59\x03\xa1\xb2\xe4\x9b\x68\x0e\x54\x92\x52\xc1\x06\x6c\x8a\x50\x6e\x25\xbd\x9b\xc3\x99\x4a\xaa\xcc\xec\xf5\xf7\x62\x58\x21\x18\x5c\x68\xb8\x5c\x7a\x44\x3e\xa5\xc1\xb4\x49\x72\x40\xe5\x70\x7c\x24\x40\x45\xe6\x75\xae\x6f\xe5\x36\xdc\xaa\xad\xde\x42\x32\xb3\xd2\x0c\xd8\x2a\xa4\x89\x13\x85\x8a\x23\xe7\xc5\xaa\x0a\x85\x01\x95\x66\xb9\xc8\x6e\x8c\xd1\x16\x35\x6b\x39\xd6\xfa\xc8\x33\x2f\x4b\x8a\x00\x34\x6f\x59\xab\x47\xa8\xda\xf2\x72\x09\xc2\xd0\xbb\x79\xd1\x82\xc8\x76\x7a\xb3\x71\xf6\x51\x7a\xee\xec\x5b\x40\xe1\xe1\x73\x06\x40\x11\x3c\x29\x00\x2e\x45\xec\x39\xf8\x0c\x48\xa7\x6a\x8c\x2f\x8c\x8b\x9a\x6f\xb6\x3b\x35\x22\x3d\x8b\xd8\x17\x6c\xf0\x01\xd1\x38\xd9\x15\x4f\x27\x61\x61\xa0\x30\x39\x4d\x6a\xce\x39\x34\x92\x32\x16\x85\x36\x5b\xdb\x26\x81\x5d\xa1\x2f\x12\x13\x99\xd3\xb9\x8a\xc5\x29\x43\xab\x50\x56\xe9\xb4\x71\xe0\x6d\x2e\x69\x20\x8c\x10\x69\xd3\xc4\x87\x18\xb9\x94\x34\x95\xb0\x98\x30\x7b\xc6\x41\x3c\x06\x91\x1c\x14\x60\x23\xd5\x4f\x21\x30\xa9\x92\xbd\xf0\x18\xcc\x4c\xc6\x94\x82\xf4\xc9\x84\x72\x5e\x94\x99\x99\xe9\xee\x8f\x92\xc2\x32\xd7\x1d\x27\x1c\xb3\xbf\x3a\x4e\xbf\x09\xda\x0f\xef\x17\x0c\x59\xac\xcc\x49\xa7\x68\xfe\xf8\xdf\xa3\x5e\xda\xa5\xcf\xa5\xe3\x16\xfb\xdb\xfc\xc6\xdd\xc7\xa0\xc6\x87\xa4\xdc\xdf\xf0\xdc\xe3\x5d\x25\xb1\xec\x36\x48\x28\xd9\x9b\xd1\x3e\x09\x9b\xcf\x7d\x12\x76\xd4\x88\x3e\x19\xe8\x94\xa0\xe9\xbd\x8e\x71\x5d\xd6\xed\x14\xa1\x4f\x06\x3a\x23\xec\xe7\x54\x87\x88\x29\xd9\x48\x92\x38\xc3\xef\xa5\x89\x09\x0d\x33\xee\x81\xf8\x5a\x4d\x21\x7c\xa2\x7d\xa3\xc8\x3c\x69\x1d\x33\xed\x3f\xa2\xd1\xde\xd5\x70\x61\xd0\x3c\x58\x54\x9a\xbe\xf5\x79\x62\x21\x88\x4c\xa8\x43\xcc\x46\x16\x93\x0a\xcd\xf1\x13\xa4\xa1\xdc\xb8\x6e\x77\x72\x84\x26\xfe\x26\xb4\x89\xf6\xe6\xcc\x1c\xfd\x28\x6d\xdc\xcd\x0d\x9a\x33\x48\x8e\x5a\xcc\x6f\x11\x1b\xdb\x3e\xa1\x1a\x31\xf5\x83\x17\xa3\xfa\xb2\x35\xce\xe2\x66\xa9\x3c\xc2\x1c\xb0\xa6\x30\x38\x84\xd4\x2b\xe6\x5e\x88\x1d\xd6\xc8\xf8\x84\x35\x72\x9a\xb5\x8f\xbe\xb6\x7e\xb1\xe6\x78\xcb\x4c\x8d\x09\x08\x18\x12\xf6\xdc\x88\x70\x84\x9b\xba\xc0\x8b\xbb\x4d\xae\xa4\xd9\x02\xd7\x13\x78\xf3\x5b\x61\xc6\xca\x25\x9d\x2e\xe3\xe2\xfa\xe1\x3e\x66\xe9\x0b\x72\xfb\xdf\x9a\xb5\xbc\x83\x58\xeb\x8f\x9a\x63\xf6\x2e\x35\x10\x53\x33\xa1\x12\x76\x6a\x06\x26\xe3\xa4\x94\x67\xa3\xeb\xe3\xe7\x0f\x57\x1d\x10\xec\x0a\x55\x42\xaa\xdb\x5d\x5c\x18\xf7\xbe\xcc\xa4\x87\x60\x9f\x24\x09\xf8\x5b\xc0\x64\xc8\x6f\x9e\x69\xd1\xe8\x22\x5a\x82\x85\x33\x40\xcd\x00\xac\xd7\xf4\xba\xae\x4a\xe2\xd9\xfd\x4d\x35\xc1\x14\x9d\xc0\x6e\xdc\x5c\xeb\x36\x8f\x1a\x7c\x42\x69\xd5\xe4\xa5\x43\xba\xc4\x6b\x5b\x57\x60\xe5\xa4\xda\xb0\x53\xaf\xc9\x73\xee\x57\x97\x6c\x9c\xe4\x28\xf1\x7d\xdd\x40\x61\xc9\xa0\x73\x69\xc1\xa2\x2b\xca\x72\x6c\xdc\xca\xdb\xa2\x56\x0d\x25\x79\x05\x1f\x93\xb1\x94\x92\x47\x6d\xb3\xb3\xc2\x33\x03\x1a\x6e\xba\x07\x26\xf8\x1c\xdc\xbd\x38\x01\xc9\x6a\xef\x1c\xdc\xca\x9a\xf8\x93\xd3\xeb\xcb\xe9\xf1\xeb\xb3\xf3\xd7\xd7\x53\xb3\x13\x5e\x5c\x4d\xad\xed\x11\x47\x8b\x31\x56\x9e\x02\x4c\x97\x10\x37\xf7\xc9\x1a\xf6\xd2\xf6\xfd\xf4\xea\xdd\xf3\x6a\x2b\xd4\x10\xd5\x76\x95\xcf\x0a\x69\x0f\x2c\x1a\x85\x27\x21\x61\x99\xad\x72\x00\xe3\xd9\x57\x21\x41\xc6\x76\xd5\xa8\xb5\x7f\x6d\x9f\x90\xb5\xdd\xd0\x41\x4a\x9a\x9c\x28\xcb\xb8\x41\x2d\x7e\x5f\x98\xa7\x64\x2f\xa4\x0d\x01\x7f\x15\x6d\x27\x70\x0a\xc8\x67\x39\x24\x0d\x90\x8a\xae\x53\x04\xb5\x6c\xb9\x52\x25\xa5\x76\x73\x51\xa1\xb1\x03\x9b\xa7\x50\xa8\xc2\x9c\xff\x6a\xee\x1e\x9c\x04\x11\xfe\xc3\x0f\x9c\x87\x73\x2d\x4b\x14\xd5\xa0\x94\x68\x52\xb9\x86\xa6\xb6\x83\x67\xf2\x7d\x84\x71\x77\x12\x9b\x4a\x77\x45\x1c\x60\x52\x02\x7b\x4b\x21\xd4\x25\xf3\x20\x8c\x61\x35\x48\xe4\xb7\x18\x93\xb3\x02\x8f\x0f\x92\x85\x84\x77\xfa\xc5\x56\xd2\x1b\xbc\x1b\xf7\x8c\x88\x8f\x82\x92\x1c\x7a\x75\xf1\x5e\xc2\x07\x5d\x1e\xb0\xe1\x3b\x6d\xdc\x50\x7f\xa2\x7a\xa9\x9a\x21\xad\x85\x62\xc0\x0b\x2d\x5b\x17\xf8\x39\x31\x62\x0c\x29\x96\x2e\x28\xe3\x85\xfe\x27\x95\x58\x3e\x5e\x04\x00\xa3\xcc\x71\xbd\x1b\x65\x6d\x3b\xd5\x75\x22\xe3\xab\x7d\x7d\x4a\xce\xed\x8e\x28\xa9\x01\x1d\x59\x82\x4d\xe1\xc0\xf5\x05\x1c\xd2\x20\x37\x07\x9c\x7b\xe0\xa2\xe3\x1a\x3b\xe7\xc0\xb2\x19\xef\xdc\xd6\xae\x4c\xe7\x8f\x3c\x9d\x48\x32\xa5\x4f\x27\x0f\x23\x29\xf6\x14\x97\xa2\xc4\x4e\x30\x60\x33\xe6\x4a\x72\xd1\x86\xf9\x15\x47\x31\x86\x8c\x66\x09\x61\xc3\x93\xde\x20\x84\x59\x39\x9a\x58\x64\x7f\x32\x91\x91\x4c\x14\xe3\x59\x3d\x7a\x78\x8d\xb4\xaf\xbc\x83\xc4\x5f\x0b\xc9\x3b\x40\xdc\x65\x80\x61\x4a\x4b\x1a\x32\xc2\xa3\x25\x1d\x26\xa9\x57\xc6\xd2\xad\x8c\x73\x22\x84\xb2\x78\x85\x26\x3f\xea\xd0\x95\x97\x50\x56\xc9\x03\xbe\x90\xa6\x73\x22\x92\x31\xc5\xcf\xea\x05\x6f\x8b\xc7\x27\xf8\xb5\x68\x63\xb1\x05\xeb\x8a\x92\x44\x19\x58\x54\x2a\xa9\x6f\x5d\x1a\x10\xef\x0a\x01\x2e\x6c\x12\xf7\x65\x6a\x65\x0b\x99\x03\xbc\x91\x60\x6f\x11\xb0\x58\xf2\x2a\x6d\xa0\x3e\x38\xfb\x51\xb7\x3c\xa2\x66\x7c\xfa\x76\xc1\x9f\x3b\xe9\x91\xbe\x26\x94\x2a\xdf\xaf\xcd\x5c\xd7\xde\x4d\x8e\xb7\x77\x94\x0a\xae\xbb\x6f\xc4\xb7\xd6\x48\xad\x41\x1f\x1b\x1f\x79\xb7\xaa\xf6\x68\xe6\x23\x07\xd5\x76\xf0\x4e\x8d\xdc\xbd\x85\x8f\x18\xc7\x47\x0c\x21\x9c\x72\xfc\x61\x1c\x5b\x2b\x5f\xc0\x75\xc7\x72\x5c\x8f\xe2\xeb\x52\xb9\x6f\x9d\xa3\x2a\x6c\x12\x0f\xa9\x62\x91\xba\x49\x7a\x37\x98\x60\x47\x2c\x9c\xf6\x92\xe5\x62\x5b\x71\x73\x4a\x95\x83\x1c\x69\x83\xcf\xac\xc9\xc2\x59\x8e\x38\xfa\x1f\xb2\xba\xa0\xd4\x9b\x83\x8f\xb6\x0b\x00\x2d\xc3\xf7\x00\xcc\xc2\x64\x05\x89\xe3\x1b\x44\xbf\x8b\x87\x52\x61\x07\xc4\x14\x29\xfb\xdd\xbb\xa6\xd2\xeb\xc0\x8d\xb1\xe4\xdd\xa9\x8d\xa0\xff\xb6\x84\x68\x8b\xd2\xe6\x7f\x68\x24\x07\x89\x12\x37\x40\x5a\x1b\x88\x1e\xab\xf4\x5c\x6d\xa5\x7b\xa9\x6d\x99\xbe\xff\x51\xab\xf4\x0d\xd0\x76\x47\x4e\x07\xf3\xbd\x34\xb7\x40\x94\x58\x46\xbc\xe6\xaa\x57\xc2\xf6\xbf\xd5\xf9\x52\x3c\xd9\x59\xd8\xac\x58\x56\xf4\xf2\x52\x11\xf6\x01\xeb\x9b\x50\x3e\x42\xcc\x12\x17\x76\x97\x8c\xf7\xbc\x4b\xc6\x7b\x3e\xc8\xde\xe5\x1f\xff\x17\x2f\xf2\x3b\x65\x26\x61\xd4\xe5\xd7\xaf\xd9\x77\x08\xdd\xa5\x6a\x5e\x10\xe9\x88\xe2\x28\xd3\xcb\x06\xe2\x8e\xbe\x7e\x95\xd2\x2a\xf5\x65\x59\x75\x01\xcd\x29\x0a\x93\xf4\x3a\x39\xb5\xe4\x38\x1b\x25\x42\x62\x90\x17\xc5\x7e\x39\x2c\x2a\xc5\x7b\x61\xf1\x9e\x3b\x09\xbc\xcf\x29\x9b\x78\x43\x38\xfd\xd7\x55\xd0\x77\xaf\x2b\x47\xf2\x26\xf7\x99\x93\xe5\x40\xb4\x88\x8d\x27\x36\x51\xb8\xc6\xb6\x9d\xf8\xba\xea\x09\x15\xf5\x03\x42\x96\x8b\x1b\x0e\x27\xd0\x46\xb8\x45\xd1\x4b\x0f\xf0\x89\x42\x12\x12\x00\x8a\x10\xc8\xc6\x52\xca\xa4\x31\x37\xfd\xef\xad\x41\x57\xe3\x50\x38\x00\x0c\x50\xfa\xd7\x2b\x58\xe2\x40\xbd\x77\x93\xf1\x5f\x98\xcc\x49\xae\xd7\x2f\x46\x5c\x3a\x7e\x31\xb1\x32\x63\x75\xad\xaa\x89\x97\xfa\xce\x97\xee\xe1\x5e\x38\xcc\x45\x1f\x7e\x39\xed\xad\xe3\xbe\x39\xb5\xa3\x10\x26\xb1\x47\x0a\x1a\x2f\xb8\x4f\x53\x3a\x53\x4a\xe2\xdb\x92\xd0\x24\x06\x39\x56\x75\x2a\xdd\x7d\x4c\x91\x1e\x6f\x0d\x00\x12\x95\x87\x6e\xb7\x41\xe0\xdd\xbc\xc0\x59\xc1\x0e\xa1\x3c\xa3\xf0\x1d\xe6\x73\xf9\xb9\xc1\xff\xa3\x5e\xf9\x39\xcc\xa5\x6d\x51\xec\xd9\x3d\x64\xf3\x85\xeb\xf0\xcf\x50\xf2\xdd\x56\xdf\x3a\x25\x3f\xff\x2b\x3a\xb2\x98\xa5\xc6\x06\x84\xc0\x0a\xe5\xec\xaf\x6d\x86\x6f\x8c\xc1\x64\x68\xb0\x76\x59\x12\x99\xa0\x14\x72\x2f\x21\x90\xc4\x8e\x4b\x2c\xeb\x3f\xe6\x8f\x2c\xa2\xcc\x0b\x6d\x12\xf0\x40\x4a\x9c\xd9\xc8\xb4\x6b\xd3\xdc\x72\x8a\x20\x47\x73\x94\x1e\x4a\xbf\xab\xc2\x51\x74\xe1\x07\xca\x62\xf2\x15\x33\x62\x88\x49\xc2\xbb\xc1\x67\xd1\x5e\x5d\x10\x1c\x1e\x22\x62\x2c\xe6\xa1\xed\xcc\x39\x81\xbb\x09\x29\x0d\x01\x5e\x14\x13\xac\xcd\x2c\xc0\xb7\xb7\x7e\x46\x48\xec\x16\x7f\xc2\xc5\x7a\xb8\x37\xdf\x3c\x92\x8f\x68\x8b\x5a\x6a\x0f\xc8\x78\xda\xa9\xa1\x23\x38\x08\x16\x5c\x20\xc1\x01\xc5\x32\x1a\x3d\xeb\xea\x06\x2e\x57\x44\x64\x99\x37\x08\x34\x53\xb7\x8f\xe2\xae\xf2\xc5\xa5\xd6\xe4\xfe\xac\x56\xc0\xd7\x45\xd1\x11\x60\x3f\xcb\xd5\x43\x76\x5f\xd5\x66\x59\x6d\x31\x31\xe8\xc9\x69\xe6\xed\xfe\x60\x25\xdf\xe6\xbf\xa9\xf5\x76\xdd\x52\x95\x12\xbf\x42\xcb\xba\x1a\xec\xe9\x32\xd7\xea\x08\x6d\x1c\x11\x6c\x5f\x0b\x4b\xbd\xea\xaa\xf9\xb7\x7d\xf5\xb0\x7c\x19\xd9\xc9\x9b\x33\xa8\xc8\xf1\xb3\x9a\xf2\xae\x30\x2c\xa9\x0f\x9e\xe7\xd2\xfd\xd0\xaf\x08\xbe\x45\xda\x19\x1e\x20\x0a\x21\x72\x01\x22\xed\x68\xd1\x1e\x3f\x01\x0c\x54\xcb\x94\x5e\x5b\x82\x59\x53\x43\x0e\x51\xdb\xe6\x14\x53\x45\x5b\x2c\x77\xe0\x8a\x02\xfe\x1c\xab\x1b\x85\x95\xc8\x33\xac\x5b\xc0\x43\x26\xcb\x93\xe6\x6d\xb1\x0e\x77\x5d\xf3\x87\xc1\x4d\xd7\x2b\x44\x7b\xae\x57\x48\xac\xc8\x58\xdc\xd5\xd4\x9c\x92\x4c\x21\xfb\x4f\xeb\x06\x8e\x01\xa7\xa7\x45\x0c\x42\xd7\x81\x06\xd1\xbe\xd6\xb3\x88\x24\xe4\x3b\xf2\xbd\xd7\x9f\xb2\x1b\xd3\x2d\x04\x59\xd6\xea\x6a\x59\xcb\x21\x06\xf1\x42\x88\x19\x19\x5d\x0b\x32\x15\x17\xf2\x21\x25\x52\x64\xb0\x25\x21\xce\xcf\xa5\xa6\xcc\x21\x4f\x26\x11\x0b\x20\xd4\x8f\xa0\x1e\x72\xbd\x1d\x31\x3e\x52\x70\x5b\x5a\xd2\x1f\x12\x09\xac\x4f\x32\x7a\x70\x84\x4a\x4f\xa8\xca\x58\x1d\x46\x63\x2a\xfb\x45\xc7\x03\x27\x7f\x0f\xf9\x83\xbf\xa3\x15\x67\xf6\xe5\x37\x70\x96\xff\xfa\xf5\x6d\x70\x9f\x31\xf1\xb1\x58\xc1\x77\x59\x14\x77\x36\x71\xb4\x6c\xda\x7e\x67\xb3\xa2\xb7\x0c\xa3\xee\x27\xeb\x9f\x4e\x32\xff\x61\x1e\xed\xf4\x79\x55\xfe\x0c\xb0\x0a\x5b\xe4\x98\x50\xe9\xc9\x73\x65\xd0\xae\x37\xbd\x2b\x97\x5e\x4b\x27\x99\x88\x87\x13\x9b\x1d\x6d\x60\x03\x61\x9b\x52\xfb\xfe\xae\x26\xce\xe5\xf5\x40\x04\x03\x8d\x94\xc6\xee\x3d\x3d\x69\x5a\xbb\x4c\x76\x16\x33\xfd\xda\x3f\xb5\xd1\xd1\xe9\xe7\xcf\xbe\x30\xb2\xbf\xa1\x30\x7e\x9a\x1b\xf1\x56\x4a\x1c\x79\x78\x25\x69\x4b\x0f\x5c\x51\x46\x4a\xa4\x6f\x2d\x13\x55\xe0\x44\x7e\x49\x91\x0f\xc9\x49\x22\xd5\xd8\x15\x90\x50\xa0\xe9\x18\xe3\x23\x77\x22\x8b\x1c\x83\xaa\xda\xff\x25\x3c\x11\x20\x40\xd4\xe3\x03\xa0\xeb\xd5\x84\x33\xef\x55\x8e\x46\xdd\xd4\x6c\x7d\x3e\xb1\x7e\xa1\x7a\x22\x5a\x28\x9b\xba\x32\xde\x79\x4d\xb4\xa1\x74\x6b\x8a\xc4\xbf\x0e\x66\x26\x3b\xb5\x76\xdb\x06\x77\x01\x7d\x56\x73\x98\xa1\xb5\x62\xfe\xf8\x9b\xbf\x82\x7a\x53\x53\x6e\xe1\x1e\x42\x3d\x9c\xe6\xbf\x7c\xf9\x47\x00\x00\x00\xff\xff\x9d\x45\xd9\x09\x7d\x02\x03\x00") + +func cfI18nResourcesItItAllJsonBytes() ([]byte, error) { + return bindataRead( + _cfI18nResourcesItItAllJson, + "cf/i18n/resources/it-it.all.json", + ) +} + +func cfI18nResourcesItItAllJson() (*asset, error) { + bytes, err := cfI18nResourcesItItAllJsonBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "cf/i18n/resources/it-it.all.json", size: 197245, mode: os.FileMode(420), modTime: time.Unix(1456502789, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _cfI18nResourcesJaJpAllJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xbd\x7d\x73\x14\x47\x92\x30\xfe\xff\xef\x53\xf4\xc3\xc5\x85\xf0\x86\x46\xd8\xde\xbd\x8b\x27\x14\xf1\xc4\x9d\x2c\x64\xac\xc7\x02\xe9\x24\xc1\xae\xc3\xda\xd0\xb6\x66\x5a\x52\x2f\x33\xd3\xb3\xd3\x33\xc2\x5a\x9f\x2f\x34\xc2\xc6\x80\x60\x61\xb1\x01\xb3\xb6\x17\x83\x31\xc8\xc8\x48\xb6\xf1\x7a\x31\xe6\xe5\xc3\x88\x19\x89\xbf\x9e\xaf\xf0\xab\xcc\xac\xea\xae\x7e\xa9\x7e\x9b\x96\xc0\xde\xbd\x8b\x35\xa3\x99\xee\xac\xac\xac\xac\xac\xac\x7c\x7d\xf3\xff\xd3\xb4\xb7\xd9\xff\x34\x6d\x8f\x59\xda\xd3\xaf\xed\x99\xaa\x4e\x55\x27\x87\xc7\xfa\xa7\xaa\x7b\x7a\xe9\xfb\x46\x5d\xaf\xda\x65\xbd\x61\x5a\x55\xf1\xc0\xe6\xf1\x0b\x9b\xc7\xef\x6e\x1e\x3f\x09\x8f\xb1\xa7\xde\xe9\x0d\x03\xf3\x86\xd5\xac\x6b\xff\x77\x62\xf4\x90\x66\x37\xea\x66\x75\x4e\xb3\x17\xab\x0d\xfd\x2d\xcd\xb4\x35\xb3\xba\xa0\x97\xcd\x52\x9f\xa6\x8d\xd5\xad\x9a\x51\x97\x7e\x6a\xcc\x9b\x76\xbf\xa6\x15\x67\x35\xdb\x68\x14\xea\xcd\x6a\x95\xbd\x5a\x30\xaa\x0b\x66\xdd\xaa\x56\x8c\x6a\xa3\xb0\xa0\xd7\x4d\x7d\xa6\x6c\x14\xe6\xea\x56\xb3\xa6\xf5\xbc\x3d\xb5\xa7\xaa\x57\x8c\xa9\x3d\xfd\x53\x7b\x18\xd8\x26\xfb\xd4\x1b\xfc\xea\x9d\x9e\x88\x09\x21\x96\x9b\xcb\x3f\xb0\x29\x6d\x1e\xbf\x0d\x73\x5b\xfe\xba\x73\x6b\xa5\x73\xe9\xfd\xcd\xd6\x99\xad\x77\xaf\xb5\x4f\xff\xb0\xd9\xba\xb5\xd9\xba\xb2\xb9\xb4\xdc\xb9\xf3\xf9\x66\xeb\xf2\x66\xeb\x5d\xf1\xc0\x46\xe7\xab\x6b\x9b\xad\xf5\xcd\xd6\xea\x66\xeb\xf4\xe6\xf2\x69\x7a\x72\x87\xe6\xb0\xa3\xd4\xb6\x1b\xfa\xdc\x4f\x9d\xda\xb9\xce\x41\x41\xed\x5f\x68\x93\xf3\x86\x6d\xb0\xf1\xea\x0b\x66\xd1\xd0\x6a\x65\x36\x47\x6d\x5e\x5f\x30\x34\xbd\xaa\xe9\xb6\x6d\x15\x4d\xbd\x61\x94\xb4\xa2\x65\x37\xfa\xb4\xc1\xba\xc1\xe6\xcf\x96\x44\x77\xde\x30\xab\x0c\xcf\x2a\xfb\x70\xcc\x2c\x97\xd9\x5f\x45\xb6\x78\xb0\x16\xf4\x86\x92\x76\xbf\xd0\x36\x5b\x1f\x6c\x2e\x9f\xd9\x5c\x3e\x05\x34\x58\xfe\xdb\xe6\xf1\x07\x9b\xc7\x3f\x40\x5a\xfe\xb8\x79\xfc\xf2\xe6\xf1\x2f\x81\x9c\xad\x35\x46\xa7\xa7\x97\xae\x3f\x5d\xfa\x7c\x73\xf9\x2e\xa7\x74\xeb\xcc\x93\x07\xdf\x31\x42\x6e\xb6\x1e\x11\x69\xfd\xaf\x2f\xdf\xc0\xa5\xf8\x61\x73\xf9\xb1\xf8\x70\xe1\xc9\xc3\x4f\x3a\x27\xcf\xc3\xf3\xcb\x2b\x40\xf2\xa5\x16\x20\x00\x43\xbb\x60\xb7\xae\xdc\xdf\xfa\xf0\x2a\xae\x12\x87\xac\xa2\xdb\x40\xad\xc6\xb8\x53\xaf\x33\xd2\x44\xc8\x97\xcd\xe5\xeb\x38\x95\xdb\x0c\xf6\xd3\x4b\x2b\xed\x5b\x6c\xe4\x8b\x30\x69\x00\xcf\x06\xb9\xaa\x16\x3a\x30\xc0\xdb\x6f\xf7\xb1\x7f\x0e\xb1\xc5\x7c\xe7\x1d\xed\x98\x6e\x8b\x11\xb5\xa6\x0d\x6b\xc0\xa9\x5c\xa9\xe8\xd5\x92\xf6\x3b\xf6\xf0\x20\x7d\x7e\xe7\x9d\xdf\x25\xc1\xc9\x0b\x9e\x91\xd9\xa5\xc7\xf1\xbf\xa2\x50\x3c\xe5\x83\xaa\x21\x19\x1f\x6f\x7d\xb8\x8a\xd8\xdf\x4c\x39\xa5\x43\x96\xa6\xd7\x4c\xcd\xa8\x96\x6a\x96\x59\x6d\x00\x8f\xab\xf9\x63\x60\x6c\x98\x0d\xb7\x4a\x78\x6c\x1e\xff\x94\xaf\x29\x2e\xd3\xf6\xea\x9d\xf6\xfa\x5f\xc4\xb8\x37\x05\x27\x7c\xbc\xb9\xfc\x41\xc4\x92\x8d\x5b\xcd\x86\xa1\x35\x2c\x6d\xc6\xd0\x9a\xd5\x8a\x5e\xab\x31\x4a\x32\x0a\x56\xad\x86\xc6\x98\xb6\xce\xb6\x57\x79\x51\xe3\xdf\xb3\xc7\x1a\xf3\x6c\x0f\xd4\x6a\x65\xb3\x88\x68\xa9\x51\x45\x72\x1d\x67\x44\xdd\xbe\xf5\xf9\xd3\x2b\x37\x80\x0c\xcb\x0c\xcd\x13\xb8\xb1\x2f\x73\x04\x97\x57\xb6\xfe\x76\x66\xfb\xef\x8c\xc8\x1b\x5b\xe7\x1e\xb5\x3f\x59\x15\xd4\x16\x1c\xb2\xfc\x0d\xb0\xf0\xf2\xdf\x37\x8f\xdf\xe2\x8c\x2f\xc0\xa6\x9d\x28\x1c\x7a\x9a\x76\x98\xed\xea\x1e\x26\x49\x2a\x7a\xfd\xa8\xd1\x60\xfb\x9a\x6d\xd1\x82\xad\x4d\x0c\x8d\x1f\x19\x1e\x1c\xea\x81\x19\x2e\x98\xc6\x31\xad\x64\xd8\xc5\xba\x59\x83\xe9\xd8\x9a\x35\xcb\x76\x70\xc9\x5c\x30\x4b\x4d\xbd\xcc\x85\x01\xfb\x4e\xd7\xe6\xcc\x05\xa3\x2a\xf6\x7c\x14\x29\xc4\x71\xaa\x69\x5b\xa7\x7e\xc0\x55\xf2\x6e\xee\xd6\x7a\x7b\x69\x65\x73\xe9\x3d\xf8\xde\xdd\xe5\xeb\xdb\xb7\xbf\xea\x7c\xf4\x27\xc6\x5f\xdb\xd7\x56\xb7\x6e\xdc\x17\xdb\x14\x76\x3f\xdb\xa9\x51\xf3\xf0\xf2\x64\xcc\xb6\x45\xd2\x0c\xd8\xb6\x39\x57\xd5\xea\x56\xd9\xb0\x99\xd4\x6a\xcc\x33\x31\xca\xd8\x9c\x58\x80\x91\xad\xce\xb6\x03\xc8\x5f\xab\x3e\x57\x80\x87\x7a\x34\xd8\x60\xe1\xcf\xd8\x35\x86\x0f\x3d\x95\x84\x28\x71\x03\x31\x96\x89\x1f\xc8\xbf\x0d\xdb\x0f\x7f\x68\x9f\xfa\x96\x7d\x89\xff\x3d\xdd\x7e\xf8\x01\xf2\x0a\x90\x22\x92\x0e\xc8\x21\x30\xd8\xab\x93\x7a\x7d\xce\x68\x38\x1b\x1d\x99\xa3\x81\xdf\x69\x55\xc6\x22\x38\x76\x92\xe9\x75\x2e\x7d\x4d\x47\x1c\x4a\xd4\xbf\x20\x43\x83\xec\x45\x39\xcc\x3e\x7f\x8b\x0c\x7d\x12\xd7\xd5\xbb\xc0\xe1\x68\x04\xd7\x36\xd9\x84\x54\x13\x61\x84\x4e\x35\x8d\xad\xbf\xbd\xbb\xf5\xc3\x87\x89\x27\x90\x19\xf1\x26\xdf\xab\x65\x8b\x1d\xf8\x5a\x41\xd7\x40\xfa\x15\x0a\xf6\x51\xb3\x56\xb0\xed\x72\x01\x95\x1e\xc4\xb5\x87\xcd\x01\x1f\x05\x49\x1a\xf1\x14\x9b\xb7\xdd\xac\xd5\xea\x86\x4d\x9a\x91\x66\xd4\xeb\x56\x5d\x39\x79\xc4\x42\x48\xa4\x55\xdc\x95\x6c\xb6\x17\x3a\xa7\xff\xdc\x3e\xf9\x7d\xc8\x66\x4c\x82\x28\xce\x9b\x1d\xa6\x1b\x49\xf0\x4d\x4a\x30\xf6\x69\xf0\xd5\xe9\x43\x03\x07\x87\x34\xbd\xc9\x76\x2e\x68\x3a\xff\x69\xbc\xa5\x57\x6a\x65\xa3\x8f\x9d\x85\xda\xd4\x9e\xa9\xa9\xa9\x3d\x35\xa6\xb9\x1c\xb3\xea\x25\xf8\x3c\xb5\x47\xdb\xcb\x64\x9c\x5e\x33\xb4\x3f\x34\xad\x06\xdb\xf3\xe6\x2c\x50\x9c\x09\xff\xaa\x26\x1e\x7c\x41\x41\x9a\x8c\xe3\x6d\x1e\xff\x33\x6e\x81\x0d\x14\x7c\xa7\xda\x27\x98\xbc\xbb\xd5\x7e\x70\x91\x4d\x70\xeb\xab\x9b\xa0\xc0\xf0\xc9\xa2\x64\x5f\x5e\x69\x7f\xf6\x5d\xfb\xfc\x49\x3c\x83\x3f\x05\x11\xe9\x3c\x09\xac\xb7\x8a\x9b\x08\x8f\x07\x38\x0c\xe8\x44\x39\xb7\xd9\xfa\x0c\x5e\x6f\xbd\xfb\x42\x66\x4a\x55\x16\x9d\xf9\x03\xd2\xc0\x85\x9c\x42\xb3\x8c\xcb\xc4\x4f\x5c\x46\xea\x24\x06\x5e\x50\xaa\x16\xe9\x07\xf4\x49\x89\xf6\xf9\xb5\xcd\xe5\x25\x1f\xe9\x88\xed\x64\x82\xc8\xa2\xcf\x43\x07\x95\xe6\x21\x21\x56\xb4\x6a\x8b\x05\x9b\xdd\x2f\xd8\x21\x32\x31\x7a\x78\x7c\x70\xa8\x30\x30\x36\xa6\x4d\x0e\x8c\x1f\x18\x9a\xc4\x8f\x6f\x16\x2c\xf1\xe7\xe8\xf8\x81\xdf\xb2\xbf\x6d\xf1\xf7\xc4\xd8\xc0\xe0\x10\x7c\x53\xa8\x5a\x05\xb6\xb3\x40\x19\xfb\xad\x92\x1c\xb1\xb8\xd0\x1e\xda\x6b\x55\xcc\x06\xb0\x63\x1d\xe8\x85\x27\x8d\x20\x11\x6c\x62\x7a\x88\x69\x4b\x46\x5d\x2f\x36\xd8\x21\xcc\x54\x94\x42\xc1\x81\x81\x3a\x77\xad\x6e\x55\x6a\x0d\x5c\xb3\x19\xab\x31\x9f\x68\x85\xf8\xe0\xed\x8d\x47\xdb\x5f\x7e\xd3\x7e\x70\x0e\xf5\x8d\x3b\xec\xf6\xc2\xf5\x2c\xdc\xf2\x0e\x57\xba\xf8\xc1\x01\xe5\xe0\xc7\x16\x63\xeb\x93\xd6\xd6\xc5\x2f\x82\x8b\x21\x23\xc9\xd8\x9d\xd8\xfa\xc9\xbd\x6b\x9d\x4b\xa8\x02\xbc\xf7\x45\xfb\xf4\xc7\xb0\x96\x8f\x8f\xc3\x50\xa0\x08\xdc\x41\xe9\x7b\x19\xa4\x2b\x63\x85\xf7\xef\x3b\x82\x20\xc9\xba\x72\x79\xc4\xc4\x8a\xa5\xed\xf5\x13\x87\x69\x33\x8c\xb0\x5a\xb3\x5e\x06\x8a\x5a\x33\x0d\x9d\x3d\xab\x6b\x56\xd5\x28\x34\x4c\x36\xa7\x00\xbd\x13\x08\x03\xcf\x80\x41\xca\x21\xfb\xde\x85\x53\x03\xbe\xfc\x0c\xaf\x34\x5e\xb6\x66\x73\x3c\x77\xa9\xfd\xe8\x32\x3d\xaf\x1d\x1e\x1f\x01\x15\x5c\xa6\x59\xe7\xdc\xf9\x27\x8f\x3e\x76\xc9\x90\x94\x08\xcd\xe0\xce\x2b\xd4\x32\xcb\xc5\xe4\xcc\x94\x6a\xe0\x5d\x15\x90\xc9\x19\x48\x35\x85\x1d\x93\x94\xe9\xc6\xdd\x7d\x81\x19\x89\x5f\x4d\xff\xb7\x7f\x3b\x66\x8d\xef\xd7\xf6\xda\x35\xa3\x68\xce\x2e\x2a\xe4\x18\xbb\xb9\x32\x1d\xac\x09\x06\x0c\xbb\x7b\xaa\xb8\xa3\x2a\xa5\x12\x9b\x7d\xe7\xe2\xd7\xce\xfd\xab\x73\xe6\x7d\xbc\x89\x64\x21\x40\xad\x69\xcf\x33\xc5\x65\x8c\xfe\x7a\xb3\x30\xa3\xbd\x72\x78\x78\x64\x3f\x3b\x0a\x5e\xc7\xaf\xe0\x3c\x28\x6a\x83\xa3\x07\x0f\x0e\x1c\xda\x0f\x7f\x94\xb4\xfd\xa3\x07\x07\x86\x0f\xc1\xe7\x59\x8d\x7d\x3b\xfc\xea\xd0\xc4\xe4\xf4\xd8\xc0\xe4\x6b\x78\x76\x94\xac\xe2\x51\xa3\x5e\x30\x2b\xfa\x9c\xc1\x1e\x1d\x7c\x7d\x68\x7c\x7a\xf8\xe0\xc0\x81\xa1\x2e\x8e\x12\x44\x32\x38\x5c\x7a\x80\xa3\x78\x0f\xd4\xcb\xec\x94\x71\x05\x67\xd9\xb4\x1b\x70\x0b\x44\x53\x43\xa1\x64\x94\x4d\x76\x64\xc1\x1d\x59\x9f\x03\xe5\x52\x6f\x90\xa4\x65\xd7\xea\x63\x75\xb3\xd1\x60\xf7\x44\x7e\x7b\x3e\x32\x38\x30\x36\xcd\x2f\x6a\x13\x9a\x64\xc6\xd2\x84\x19\x0b\xb7\x8f\x5e\x5d\x64\x07\x57\x93\x71\x8c\x74\xdd\xb6\x55\x97\x4c\xf6\xd5\xe6\xf2\x6d\xd8\xe8\xee\x5d\xf9\x16\x58\x73\x8e\x9f\x17\x36\x82\x53\x9d\x7b\x4c\x54\x3c\x56\xdf\xad\xd7\x7d\xa8\x6d\x5d\xf8\xba\x7d\xfd\x78\xfb\xc6\x29\xe4\x9a\xb5\xce\xc7\xf7\x36\x5b\x67\xb7\x1f\x3d\x00\xc9\x8b\xe2\x07\x8d\x22\x60\x17\x69\x9f\xb9\xdf\x3e\xf9\x3e\x18\xeb\x40\xb6\x7f\x8d\xb7\xd8\xdb\xdc\x7e\xc4\xf4\x65\xaf\xc8\x56\x5e\x44\xc3\x29\xcd\x6f\xd7\x05\xda\x4c\x66\x91\x11\xbc\x3a\x6b\xce\x35\xeb\x38\x77\xc6\xe0\x75\xc6\xeb\x4c\x11\x00\x33\x28\x5b\x16\x54\x9f\xc9\x4e\x6a\xcd\xfc\xde\x28\x36\xd8\xd7\x85\xb2\x59\x35\xfa\xa6\xaa\x12\x6f\x34\x6b\x4c\xc7\x66\x40\xb9\xb9\x8e\x31\x6b\x62\xa3\x21\x58\x38\x55\x4c\x31\x6b\xb2\xd5\x63\x08\xc2\x61\x8a\x36\xda\x2e\x91\xef\xd3\x70\xac\xc9\x79\x38\x8f\x99\x10\xe5\x2c\x24\xbd\x47\x23\xea\x55\x60\x34\xb0\x4d\xce\xd8\x56\x19\x2c\x3a\x8c\x83\xea\x06\xf0\xc7\x82\xfb\x2a\xe1\x17\x47\x08\xd8\x24\xd3\x93\xa3\xd3\xaf\x0e\x8f\x0c\xf1\xb9\x0e\x91\xac\x01\x76\x0f\xa0\xd8\x8f\x4f\xbc\x8d\xff\x65\xff\x37\xb5\xa7\x58\x6e\xda\x0c\xb5\xe9\xaa\x55\x32\x6c\x46\x3a\xf7\x37\xfa\x99\xf1\x74\x03\xbe\xfe\xb7\x5e\xcf\xf7\x15\xa3\x62\xd5\x17\xa7\x2b\x33\xf0\xdb\x4b\x2f\xbe\xfc\x2b\xf1\xeb\x3b\xf8\xe1\x9d\xb4\x8c\x2f\x99\x57\xda\x1f\xdf\xef\x7c\x02\x06\x55\xb0\x31\x9f\x3c\x0f\x47\x03\xdc\xe5\xae\x21\xfb\x3f\xe6\x97\xba\x4f\x4e\xa1\x59\xfa\xb6\xc6\xad\xd7\x0c\xe6\xa5\xcd\xe5\x7b\x9b\xcb\xb7\x36\x97\x37\xd0\x92\x2d\x2c\xa8\xec\x5d\xae\xd4\xdc\x0a\xb2\x76\xce\x5c\x96\xcb\xdc\xc4\x89\xc8\xb4\x86\x6b\x88\xfa\x5a\xa2\x09\x2b\xa7\xc7\xaf\xc4\xc1\xa1\x40\xa1\x93\x06\x69\xdd\xe3\x8f\x81\x85\x6b\x23\xf8\xd3\xd6\xdf\xbe\x67\xaa\xb6\x78\x80\xdf\x8b\xb7\x3e\xbe\x27\x7d\xb9\x2a\xae\xd9\x1f\xe0\xe7\x33\xe8\x0d\x38\x9b\x94\xda\x21\xac\x9c\x60\xda\xeb\x4f\x1e\xad\xec\x1a\x57\x3f\x03\x49\xd8\xcf\x49\x21\xe8\x36\x63\x56\x4b\x0e\xd5\x9c\x43\x9d\x1f\x03\xd3\xc3\x87\x26\x26\x07\x0e\x0d\x0e\xfd\x03\xcb\xc8\xe4\x04\xea\x56\x76\xd6\x8c\x7a\xc5\xb4\x6d\x38\xe9\x81\x61\xa6\xf6\xd4\x0d\xbd\x54\xb0\xaa\xe5\x45\x76\x41\xf8\x69\x89\xc1\x5d\x62\xb1\x7f\x0a\xc8\xe4\x02\xb2\x2b\x3e\xce\x2a\x38\x13\xb0\xf4\x73\x20\x03\x8b\xe0\xc2\x75\xcf\x0e\x4e\x13\x6d\x6c\x64\xe0\xd0\x4f\x48\x12\xe6\x2f\x08\xbb\xa5\xd3\x3f\x95\xc9\xcc\x52\x74\xb7\x59\xf4\x9f\x92\x54\x2d\x49\x77\x60\x1b\xfc\x54\x14\xd1\x31\x90\x07\xf6\xbc\xd5\x2c\x97\x50\x6c\x68\x7f\x34\x6b\x28\x1a\x7a\x5d\xeb\xb1\xfc\x25\x98\x2e\xb4\xb2\x55\xd4\xcb\x5a\xc9\xac\xb3\x3d\xcd\x86\xed\xd3\xc6\x2c\xdb\x44\x21\x66\xda\xec\xe7\x1a\xfe\xb5\x60\xa0\x09\x7f\xce\xa8\xf7\x82\x33\xd7\x66\x92\xd1\xb4\xea\x66\x63\xb1\x17\x0d\x65\xec\x49\xdb\xc2\xc0\x8e\xd9\xba\x55\x61\x20\x8f\x19\x76\x03\x46\x9b\x37\xe7\xe6\x0d\x75\x14\x0d\xfb\x0a\x65\x18\x18\x8e\x01\x2d\x0f\x33\x2c\xb5\x02\x5f\x21\x7f\x80\xa9\x19\x83\x5f\x38\x6b\xa0\xe5\x9d\xf1\xda\x1a\x3c\x01\xbc\xf6\xfe\xe6\xf2\xe7\x9b\xc7\xbf\x12\xdb\xf7\x36\xfc\x0a\x0c\x72\x7b\xb3\xf5\x67\x8c\x43\xf8\x1a\x3e\x43\xb8\x92\x1b\x8a\x50\x13\x93\x86\xa8\xa6\x3b\x9f\x77\x2e\x7e\x87\x96\x14\xd8\x57\xed\x77\x6f\xb7\xdf\x3b\xf9\xf4\xb3\x13\x4f\x1e\x9e\x05\xff\x3e\x8f\xdd\x40\x06\x5c\x5e\xc6\xf8\x27\x06\x7c\x19\x00\x2e\xb5\x9e\x3c\xfc\x13\x7a\x8f\xe9\x7b\xf6\xc0\xa9\xa7\x6b\x1f\x49\xdf\xc0\x04\x18\x28\xb0\x71\x2e\x3f\xc4\xcd\x71\x52\x0a\x3f\x89\x34\xb8\x8c\x81\x8d\xac\xd2\x2c\x37\x4c\x10\xc9\x7a\xad\xe6\x58\x6b\x2b\x7a\xd5\x9c\x65\x64\x56\x47\x0a\xc2\xf6\x84\x68\x8c\x15\x24\xe7\x2d\xc7\xde\x23\x5b\x56\xb7\x6f\xbc\x8f\x73\x96\x43\x3a\x2e\xe0\x87\xe3\x28\x69\xbe\x90\xc5\x9d\x12\x4b\x3c\xd2\xe8\xd8\x2c\xd1\xe2\x66\xd0\xe6\x87\x1b\x82\x8d\x29\x90\x4b\x83\x70\x21\x98\x74\xbd\xae\x2f\xd2\xac\xa5\x93\x08\xce\x58\x1b\x8e\x69\x8a\x04\x99\xa1\xd0\x22\x43\xab\x37\xcb\x46\x94\x15\x4e\xc8\x31\x6e\xa1\xdf\x79\xe5\x4e\x48\x48\x19\xfc\x46\xfb\xc4\x7b\x4f\x8f\xaf\xa2\xfb\x6a\x0d\x19\x62\x0d\x99\xec\xa3\xed\xc7\x5f\x73\xd7\x8a\x4a\xe8\x08\x11\xde\x3e\xfb\xd1\x93\x7b\x4b\xc0\x58\xef\x9d\x6d\x9f\xbc\x0c\x52\xfc\x0c\xdb\x1e\x37\x24\xee\x8c\x62\xfd\x1d\x5b\x4a\x82\x80\x8a\x8c\xb4\x9a\x48\x89\xae\x56\x94\xe0\xe2\xe3\xaf\xe8\xb6\xa1\x8d\x72\x75\xd1\xa6\xdb\x25\xf8\x23\x41\x14\x81\x60\x02\xdd\x15\xdf\xb4\xff\xd0\xd4\xeb\x86\x36\x53\xd7\x8b\x47\x41\x7e\xc1\x8f\x72\x70\xe0\xbc\xc9\xd0\xe3\x7a\x27\x3c\x58\x37\xfe\xd0\x64\x22\x11\x5d\x49\x0d\x3e\x0b\x36\x30\x3f\x10\x8e\xa0\x32\xf4\x7b\x9b\xc9\x0b\x9c\x1e\x37\xf0\xd3\x01\xf0\x26\x17\xd7\xae\xb0\x67\x9a\x75\xdd\x6a\x58\x45\xab\x4c\x6a\x75\xa3\x58\x83\xf3\xdd\xfd\x99\x4d\xb3\x61\x56\x91\x37\xe9\x89\x97\x5e\xec\x7b\xf9\x57\xbf\xea\x7b\xa9\xef\xa5\xff\xed\x7d\xb2\xc6\xc4\x2c\x57\xce\x7f\xf9\xcb\x17\xff\x9d\xeb\xe5\xe2\x68\xf8\xed\xf3\xc1\xec\xa1\x7c\x8e\x08\x3e\x73\x66\x47\xf0\xed\xab\x4c\x3b\xfa\x2a\xec\x18\x27\x2c\x85\x4f\x18\x69\xc5\x0e\x80\x1b\xb7\x3a\x2b\x5f\xb5\x1f\x30\xd0\xab\x14\xc9\xd9\xbe\x73\x3e\x54\x09\x00\x9b\x3d\xa3\x86\x34\x71\xee\x17\x7c\xfc\xde\xf6\xcd\x16\xd2\xca\x41\x48\xba\x7a\xbb\xfa\x05\xb2\x94\x97\x70\xae\x66\xf1\x4c\x19\x4b\x25\x24\x8e\x40\x08\x1e\xbb\x2c\x59\xc7\xd0\x1d\x02\x4e\x45\x5d\x04\xa5\x09\x15\x8c\xbe\x54\xc5\x97\xb1\xaf\xb6\x57\xbf\x69\xaf\xff\x20\x47\x7f\x3d\x7d\xff\x1c\x5b\xda\x00\x08\x26\x42\x6f\x89\x00\xbb\xb8\x30\x9b\x37\x0b\xa6\x76\xe8\xf0\x41\x47\xb9\x9b\x00\xef\xd5\x51\x6d\xff\xf0\xc4\xeb\xf0\xa9\xa2\x1d\x1c\x3a\x38\x3a\xfe\x06\xfa\xb4\xe6\x2d\xbb\x81\x8e\xb8\xd7\x46\x27\x26\xe1\x9b\x9a\x26\xfc\x5d\xb6\xc6\x5e\x1f\xc4\x57\x1a\xda\xe4\xf0\xc1\xa1\xd1\xc3\xf8\x44\x53\x7b\x6d\x68\x60\x84\xe9\x8a\x83\xaf\x0d\x0d\xbe\x3e\x3d\xf9\xc6\x18\x85\x56\xd4\x21\x4a\xb3\x80\xa2\x70\x9c\x3d\x3a\x14\xe3\xc9\x7a\x46\x88\x2a\x4f\x70\xbd\x04\xd2\x9e\x2d\xa1\x72\xb9\x78\xd0\x37\xdf\x6f\x42\x79\x78\xfc\xb0\x7d\xfa\x33\x5f\x24\x6d\xbf\xa6\x08\xdb\xd6\x4a\x96\x41\x71\xab\xc6\x5b\xe0\x9b\x03\xff\x2a\x13\xb9\x35\x4b\x35\x26\x0a\xaa\xdb\x18\x45\x7b\x4f\x52\xea\x44\xfc\xe0\x9d\x8f\x30\x1e\xf5\xb2\x2f\xc4\x54\x31\x38\xb8\xec\xd2\xf9\x15\x41\x13\x2e\x83\x31\x64\x51\x44\x30\x47\x20\xda\xb9\x7c\x9d\x09\x38\x6f\x68\xb1\x83\x96\x8a\x5d\x3d\x23\x58\x10\xc1\x1b\x3b\x42\xbb\xf5\x49\xe7\xce\xf5\x34\x23\x18\x95\x5a\x63\x31\x02\xee\xd6\x97\xf7\x29\x84\x5f\x0d\x02\xd6\x4c\x98\x33\xd8\x8d\xa2\x57\x63\xc7\x1e\x9c\xc1\x9e\x28\x95\x5e\xcd\xe8\x9b\xeb\xd3\xe6\x1b\x8d\x5a\xff\xbe\x7d\x8b\x56\xb3\x3e\x0d\x8b\x0b\xfe\xef\xa8\x59\x39\x52\x90\x62\x49\x6e\x61\xb0\xc4\x6d\x9c\xd7\x3a\xa9\xe2\xde\x47\xf6\x82\x64\x0c\x1d\xe5\x05\xcd\xeb\xcb\xf4\x38\xcd\x63\x26\xb7\xa0\x9b\x65\x14\x65\xec\xe4\x07\x78\xea\x8d\xe0\x26\x40\x84\xb0\xe6\x1a\xbf\x12\x08\x5e\x54\xef\x05\x3e\x70\xdd\xb0\x6b\x56\xb5\xc4\x54\x1d\x76\x05\x23\xa2\x56\xf4\xa3\x4c\x73\x69\x32\x75\xc4\x6c\xd0\x6d\x8c\x08\x5f\x2b\x37\xe7\x38\x76\x4a\xf5\x16\x34\xcb\xc7\x9f\x6c\xdd\xf9\x30\xb8\x2d\x20\x95\x43\x10\x92\x87\x30\x3b\xc1\x3f\x70\x7f\x0a\x4e\x86\xee\x37\x8c\x9b\x57\xb6\xae\xdf\xdf\xbe\x7d\x36\x48\x54\xb5\x1e\x09\x73\x9b\x05\xe7\x78\x04\xa6\xdb\x37\x57\xe0\x08\x87\xfb\x92\x74\x5a\xc3\xb0\x20\x46\x14\x80\xeb\xec\x9a\xbc\xe0\x5c\x39\xb9\x8b\x1f\x68\xc2\x6e\x72\xec\x6e\x6a\xd8\x29\x85\x89\xe4\x08\xc7\x8b\x5b\xfb\xd4\x69\x0c\x86\xf7\x88\x34\x45\x14\xec\x9e\x31\x5c\x12\x76\x80\x0a\x25\xd2\x99\xb6\xd0\x20\xf9\xfa\x32\x84\x4b\x7a\x43\x57\x46\xa0\x4b\x90\xc2\x54\x8c\x33\x7c\x51\xd9\x25\x97\xec\x2b\xad\xb5\x68\xe2\x29\x17\xa6\xc7\xdd\xce\x75\x63\xce\x04\x43\x05\x66\xc9\x60\x08\x70\x9f\x36\x61\x50\x44\xef\xbc\x51\xae\xa9\x76\x40\x0f\x0a\x8d\x2b\x3f\x3e\x3d\xf3\xad\x08\x58\x70\x53\x2f\xc4\x06\x5e\xf6\x69\x60\x0e\x50\x8c\x73\x39\xb7\xbc\xf5\xde\xad\xa4\x7b\xf4\x05\x47\x46\xe2\xb1\xa1\xbc\xdb\xbd\x20\x09\xc9\x90\xa3\x41\x7d\xcb\xfe\xc5\x2f\x06\x20\xfc\x03\xe0\xf4\x6b\x7c\x21\xf0\x3a\xc0\x6e\x20\x3a\xb0\x94\x13\x20\x32\xb3\xa8\xd5\x2c\x7c\x14\x0d\xc5\xcd\x6a\xa3\x0e\xb6\x9e\x12\x46\x8e\x5a\x75\x76\x49\x19\x86\xb4\xa2\x72\x19\x6f\x1a\x10\x6e\x55\x13\xe0\x1a\x1a\xc8\x2a\xcd\x3a\xc6\x76\xb0\x69\x1f\xed\xfb\xc5\x2f\x40\x0d\xdc\x6f\xc1\xd7\xda\x31\xbd\x8a\x86\x13\x93\xbf\x8d\x56\x61\xda\xee\x6f\xbf\xdd\x47\x28\xbd\xf3\xce\x7f\x68\x7b\x17\xe1\xe6\xa5\x0c\xf4\xfb\xc5\x2f\x3a\x77\x57\x3b\xef\x9e\xeb\xd7\xfc\x1b\x1c\xc4\x02\x53\x49\x31\x98\x68\x79\xf9\xc9\xe3\x6b\x4f\x3f\x7b\x20\xd4\x77\x90\xb5\x94\x65\xb4\x0d\xf9\x0d\x6b\x98\x05\xf2\x39\xc4\x1f\x41\x3c\xc9\x0a\xee\x83\xab\x22\x4c\xe5\xb4\x24\x1c\x50\xe9\xf7\x0f\xb4\xee\x66\x31\xc1\x26\x43\x65\xbf\xb5\x2a\x2c\x0e\x1b\xdb\xef\xdf\xa6\xd4\xa9\xed\x6f\xbf\x7a\xf2\xe3\x8f\xa8\xd8\x9d\xa1\xe1\x7c\x82\x85\x08\xe4\x83\x2f\x93\x43\xc3\x20\xba\xe0\x60\xc2\x40\xd9\x5a\x41\x82\xb9\xf1\xdc\x55\x45\x2c\xe2\x80\x93\x8d\x04\x8e\x07\xb6\x0e\x56\x99\x16\x83\xa2\x57\x49\xad\x1d\x2c\x5b\xcd\x92\xf6\x2a\xec\xed\xba\xea\x34\xf5\x3c\x03\xd1\x5d\x14\xa7\x2a\xae\x4d\x57\x37\x97\x5b\xbe\x4c\x25\x94\xbc\x5f\x4a\x52\xf8\x5d\x9a\x85\x02\xd1\xfd\xfb\xf7\x8d\x33\xad\xf0\x08\x18\x32\x0f\x1f\x18\x3e\xa4\xc0\x23\xb8\x28\xa4\xa8\xed\x23\xe1\x96\x10\xb8\x36\x3e\x34\x36\x3a\x31\x3c\xc9\x94\xd0\x84\xe3\x84\x1f\x23\xc9\x06\x3f\x02\x3a\xf0\x7e\xc5\x40\xdb\x5f\xde\xdd\xfa\xee\x6b\xc5\xab\x23\xc3\x03\x13\x8a\xf7\xda\x27\xbf\x68\x9f\x3f\xab\x78\x6f\x6c\xd8\xc9\xe9\x52\xbc\xae\x4c\xe6\x8a\x87\xa8\xed\x75\x94\x21\x9b\xe9\x29\x7a\xcd\xec\x93\xe2\x01\x55\x1b\x58\x39\xa0\xa4\xf5\x84\x82\x8b\xc5\xa7\x3f\xed\x88\xfd\x09\x60\x52\x2a\x9e\x39\xc4\xff\x7e\x47\xe5\xb5\x51\x0f\x12\x84\x90\x61\x54\x6d\x2f\xfc\xbe\x60\xd4\x6d\x94\xe0\xf4\xf3\x11\xfa\xf3\x9d\x77\x52\xd3\x5a\x35\x00\x88\x40\x38\x7d\xef\x91\xfb\x25\x64\xa0\x64\xb8\x77\x49\xae\x78\x5a\x8d\xa9\xb6\x83\x63\xe2\x55\xbc\x59\x2c\x42\xde\x0d\x86\x06\xbb\x29\x74\x35\x76\xf3\x31\x8b\xcd\xb2\x5e\xd7\x66\xea\xd6\x51\x43\x95\x8d\xe3\xe6\xcd\x31\xed\xc5\x35\xce\x83\x52\x0c\x36\x24\x6e\x39\xbf\x0e\x2a\xcd\xf2\x8f\x4c\x62\xc7\xe2\x20\x7c\x37\x78\xf1\xf5\xa3\x22\x7e\xb4\x66\x67\x0d\x48\xb6\x8e\x45\xca\x9f\x6a\x7b\x9b\xdb\x5b\x44\xfa\xb3\xef\x19\x26\x36\xd2\x22\x0e\xa6\x43\x30\x59\xf2\x6c\x73\x86\x62\xb1\x09\xce\x12\x0d\x73\x9e\x6d\xbc\x5d\xb3\xf5\x13\xd1\xbf\xef\x28\x33\xb4\x7d\x4f\x69\xee\x8d\x77\xfd\x2a\x9c\x96\x80\xc5\x1d\xb0\xcc\x03\xee\x27\xd0\xed\x81\xee\x36\x36\x09\x6e\x5f\x03\x03\xd9\xd6\xd9\x6f\x31\x4e\xff\x72\xfc\x2d\xd1\xc5\x9d\xe7\x6e\xfb\x70\x07\xd4\x3d\x38\x29\x10\xf7\x3c\xe3\xa2\x8d\x24\x3f\x21\xf6\x0e\x12\x1b\xb0\xcd\x7d\x16\x25\xa6\x87\x61\xbe\x9c\x74\x53\xc2\x5b\x81\xea\xbc\x76\xf3\xfe\x92\x1c\x64\xcb\x17\x84\xb9\x23\xd2\x06\x45\x68\x80\xdf\xad\x2e\x32\x77\xc1\x72\x5e\xab\xc5\x6d\x4a\xc6\x6f\x78\xc1\xe5\x09\xb7\xc9\x87\x43\xa6\xc3\xb1\xd8\x02\x30\x08\x8c\xf6\x30\xa8\x3f\x13\x9b\x51\xc4\xaa\xcf\xc1\x77\xa3\xf5\x39\xfe\xdd\x3e\x8a\xf9\x87\x2f\x27\xe0\x03\xff\x9a\xd6\xfb\xb0\xb3\x96\x7d\x7d\x2a\xa5\xdb\xf3\x98\xbb\xe4\x34\x07\x17\x1f\x58\x49\x4c\x4a\xf4\x0f\x2f\xa7\x06\xf8\xb1\x40\x2b\xea\xba\x32\xf1\x7b\x4d\xa2\x8f\xcb\x1b\x80\x6a\x38\xa1\xca\x26\x9b\x96\x2f\x33\x9c\xdf\xd2\x38\xc3\xcc\x18\x40\x4a\xae\x84\x53\x96\x35\x63\x28\xf2\x72\x0c\xbe\x2a\xb4\xc4\x7d\x3a\x40\xea\xd3\xb4\x71\x03\x45\x13\x00\xf0\x81\x15\xfa\x64\x0c\x78\x58\x90\x92\x51\x87\xd5\x62\xa0\xd0\xfa\x40\x4e\x10\x78\x80\x42\x4a\xf8\x3d\x42\x45\xfe\x70\xfd\x37\x2c\x8d\xdb\xc7\xe2\x44\x5b\xd2\x8f\x02\xe9\xf2\x70\x53\x3e\x8b\xcf\xd1\xbe\xbc\x04\xb3\x97\xd5\xd6\x7d\xf4\xa2\x7b\x0b\xc8\x8a\x46\xcc\x7d\x01\xae\x8a\x1b\xdb\xc7\x1f\x4a\x89\xab\xa4\x44\xf3\x9c\x4e\xca\xaa\x09\x9d\x5a\xb0\x06\x80\xa4\x75\x83\x5b\xe1\x6c\xfb\xd4\x59\x08\x9d\xff\xf8\xbb\x14\x76\x8d\x70\x26\x02\x36\xf1\x30\x07\xa6\x22\xd1\xa2\xf7\x38\x37\x16\x62\xdc\x1e\xc6\x38\x6f\xb0\x2b\x5f\x11\x5d\x63\x8d\x3a\xdc\x22\xf9\x8a\x03\x77\xa8\xde\x42\x46\x60\xbc\x54\x95\xee\x88\x6c\x5c\xfe\xb8\xcc\x49\x66\x75\x81\x9d\xd2\x11\x5c\xc9\x10\x78\xcd\x3a\x66\x2c\x80\x57\x1f\x2e\x9f\xdc\x4b\x37\x6b\xd6\xed\x86\x36\xdb\xa4\x8b\x2d\x03\x06\xf5\x31\x70\x4c\xcd\xac\xd4\xe0\x1e\xc4\xce\x60\x0f\xae\xf0\x13\x5e\xc9\xe1\x8f\x20\xc6\x84\x9b\x8a\x73\x23\x58\xcf\x7b\xe3\x0b\x02\x16\x72\x41\xcd\x8f\x31\x6b\xff\x67\xa6\x94\xdc\xc5\x5c\xbd\x2b\x2e\x43\x41\x2a\x46\xdc\xc8\x42\x1c\xdd\x0d\x61\x5a\x26\xaf\xbf\xbc\x89\xae\xa0\x9b\x64\x49\x72\x4b\x75\xf8\x78\x3e\xfc\xda\x1a\xed\x5a\xbb\x8a\xbc\x79\xd9\xe1\x79\xc6\xbc\x84\x74\xe7\xf2\xf5\xf6\x9d\x8f\x80\xe1\x43\xd0\x0d\x19\x58\x81\x3d\x5a\x8d\x44\xb6\xda\x7a\xfb\xe1\x37\x4f\xaf\x3e\x06\x52\x9d\x6d\xb5\x4f\x9e\xd8\x3a\x7f\x62\xfb\xd6\xe7\x62\x9b\x9c\x66\x3b\x45\xb8\xb6\xce\x48\x96\x1e\xb5\x81\x65\xa0\x2c\x15\x65\x40\xbf\x2c\xd7\xde\xc0\xc8\x22\x8c\x3b\x3a\x6a\x7e\xa6\x93\x5d\xc3\xde\x61\xc7\x95\xca\x9c\x27\x92\xbe\x3d\x25\x1a\x70\x3d\x7f\x40\x24\xe5\x2a\x0d\xdc\x28\x24\xff\xca\x33\xe4\x19\xfe\x92\x62\xc7\x89\x0e\xda\x1e\x49\xae\x35\x34\x8e\x7c\x9e\x40\xf5\xc8\x30\x41\xdc\xbf\xea\xcc\xfe\x4c\x13\xfc\xe0\x19\x4d\xcd\xac\x3e\x37\xab\x47\xae\x83\xdd\x99\xe5\xb3\x58\xc2\xcc\xf3\xb3\x8e\x69\x13\x13\xaf\x71\x2e\xe4\xe8\x1b\x91\x35\x32\x04\xfe\x52\xf2\xa6\x74\x25\x42\x68\x1e\x04\xc1\xa7\xff\x0d\x3b\xb0\xe3\x34\xd6\xb2\x6d\x69\x25\xa3\x6c\x34\x0c\xcc\xa1\xe3\xa5\x6b\x50\x83\x55\x33\xcc\x45\x34\x1b\x92\x98\xf6\x15\x98\xb9\xea\x68\xcc\xc2\x78\x1f\x3d\x3e\xe9\xc1\x95\x26\x3b\xee\x66\x0c\x5e\x67\xc3\x80\xd8\x39\x46\x14\xf1\x37\x2f\x16\x15\x45\x9d\x64\xb5\x42\x48\x50\xc7\x56\xe4\x08\x15\xa8\x0a\xfc\x99\x62\x1f\x77\x97\xd0\xd4\xaf\xa2\xce\x6a\x92\xeb\x95\x47\xbb\xcc\x9a\x46\x59\xe5\xa8\x71\x40\xe2\xf9\x0a\x66\xe4\xa7\x9f\x9d\xc4\xbb\xf3\xe7\xfc\xe8\xe0\x46\xff\x08\x6c\x3d\x8a\xbb\xd7\x09\xac\x56\x6c\x55\xe5\x9e\x54\x6e\x5f\xf5\xe9\x13\xb8\x08\xc1\xe4\x8f\x59\xf5\xa3\x18\xd7\x78\xd4\xac\xd5\xdc\x1b\x14\xc6\x8d\x02\x0e\x69\xd1\xe2\x89\xcc\xdc\xe4\xe1\xb8\xce\x50\xbb\x58\x6a\x11\x87\xf2\x5a\x5e\xc0\x05\x3f\xe0\xe5\xf7\xb8\x48\xfc\x8e\x5e\xed\x00\xf6\x5c\x20\x51\xf6\x29\xd3\xf9\xe0\xe2\x44\x02\x8b\x1e\x4a\x4f\x55\x12\x3f\x01\x40\x1a\x06\xed\xb8\x19\xaa\x41\xbf\x73\x14\xd9\x0d\x86\x1d\x18\xb3\x80\xd1\x20\x34\xb4\x64\xea\x73\x55\x8b\xe9\x8b\x45\x9b\x02\xc6\xca\xd6\x1c\x86\x52\x45\x18\xc2\xd8\xae\xe8\x7c\xb3\xbc\xbd\x7a\xbf\x73\xe9\x0e\x46\x26\xde\xe1\xf6\x03\x4f\xb8\xcc\xda\x93\x1f\x3f\x4a\x70\x57\x76\xf3\x74\xb5\x79\x43\x2f\x43\x6c\xdb\xbc\x51\x3c\xaa\x35\x16\x6b\x06\xb7\xd8\xf6\x40\x48\x0c\x95\xab\xa9\x5a\x55\xa3\x47\x65\x3e\x54\x66\xe9\x02\x6a\x1f\xa1\x42\x48\x25\xe1\x5a\xe0\xc7\x83\x60\xca\x0d\xb4\x6e\x50\x69\x85\xcb\xdc\xa0\xcb\x47\x93\x6a\xce\xf0\x41\x63\xf1\x77\xea\xd7\x99\x4c\x57\x7f\x2b\x03\x92\xc1\x62\x73\xec\xe0\xf9\xee\x7a\xfb\xc1\x45\xe5\xe0\xb6\xca\x8a\xec\x8c\xa3\xb2\x1a\x53\xe9\x2a\x9d\x02\x7a\xb8\x49\x44\x7d\x70\x8a\xf3\x6f\xcd\x53\x19\xca\x0d\xc2\x8d\x5e\x64\x31\x16\x59\x36\x68\xc4\x92\x31\x6b\x56\x29\xd4\x17\x19\x2f\xb1\x60\x6f\xad\xc9\x7f\xfa\x62\x95\x18\x32\x5b\x8f\xbe\xc4\x60\xb4\xf7\x53\x23\x06\x35\xb1\x08\x19\xb0\x99\x29\x3d\x2c\x37\x71\xe4\xef\x79\x74\x81\x07\xb5\xf5\xd4\x15\xb4\x04\x0a\x74\x02\x66\xc1\x40\x2c\x4d\xd6\xb1\xd9\x69\x73\x04\xd2\x1a\x54\xb7\x42\xcf\x82\x9f\xa2\xe3\xbd\xbd\xa4\xf2\x1a\x21\x48\x12\xde\x65\x34\x62\x8d\xb3\x7f\xc9\xfc\x05\x53\xd2\x02\x25\xc9\x5c\x1b\x18\x15\xed\x1a\xad\xcf\xb1\x6f\xd5\xe6\x2d\x9a\xa5\x04\xd9\x63\xc8\x92\x61\xf0\x4b\xa9\x44\xad\xe0\xe8\x7e\x8e\x96\xc4\xa8\xa6\xb6\x5b\x25\x98\x24\x21\x12\x39\x47\xc9\xd2\x47\x5f\xa3\xa5\xcd\xb1\xf5\x79\x10\x8d\x34\xf7\xf9\xa7\xe4\xa9\xe6\x96\x84\x52\x41\xa3\x9f\x17\xa1\x70\x4a\x7a\xa6\x18\x41\xc8\x9d\xa6\xe3\xae\x93\x6b\xc7\xc9\xe1\xb3\xf5\x33\xe0\xe2\x9b\x69\xfc\x86\x48\xe4\x70\x8f\xcd\x97\xc9\x25\x0f\xfb\x47\xaf\x9a\x7f\xc4\x59\x3b\x14\x6a\x26\x33\x1e\x87\xfb\x0b\xe2\x5d\x03\xa1\x68\x7a\x68\xe8\xc3\x4a\x18\x8d\xbc\x9c\x27\x26\xd3\x25\x05\xa5\x93\x86\x01\xfd\x2f\xf8\xc0\xf5\x27\x99\x72\xb9\x5a\xd8\x23\x8e\x25\x3f\x0e\x5c\xe1\x54\x99\xd9\x33\xcd\xbd\xd1\x80\xb0\x42\xb4\x02\xb2\xcb\x9c\x75\xac\x5a\xb6\xf4\x12\x05\xcc\x2c\x52\x74\x3c\x06\x68\x61\x0c\x45\xd5\x68\x40\x80\x29\x14\xf5\x53\x4f\x73\x78\x0c\x2f\x93\xe0\xf0\xfc\x0a\x4f\x37\x34\xa1\xf9\xa2\x4e\xfc\x6a\x1f\xdb\x16\x4b\x9b\xcb\x37\x51\xa3\xb9\xe3\x54\xa8\x92\xec\x70\xe9\xe6\x51\x31\xe7\xea\x3a\xb9\x51\xb8\x16\x3c\xcc\xb5\xac\xfd\x6e\xb5\xd1\x98\xb5\x8a\x7a\x11\xed\x87\xec\xf6\xca\xb0\x07\x56\xfe\xca\xa3\x92\xa5\xc6\x9b\x07\x2c\x61\xbe\x46\x99\x1d\xe9\xbf\x43\xfb\x9f\xce\xad\x7f\xbf\x03\x4b\x86\xb0\x62\xfc\xce\xaf\xd7\xff\x4e\x84\x81\xcd\xd6\x0d\x91\xb2\xe1\x68\x94\xbf\x0b\x4e\x43\xbc\x25\x15\x4b\xd6\x79\x6d\x65\x6d\x10\xf2\x63\x8b\x3c\xbe\x49\x2f\x55\x98\xa2\x65\x33\xba\x34\x98\x0a\x6d\xce\xa2\x85\xb9\x31\x6f\x56\x8f\x92\xb5\x04\x8b\x61\x53\x55\x47\x15\x11\x9d\x18\x26\xc9\x70\x12\x36\x03\xd9\x80\x12\x98\x3c\x84\xa8\xbd\x7b\xad\x73\xe9\x8a\x2a\x20\x2d\xa8\xff\x46\xcd\x1b\x40\x38\x05\x97\x99\x94\xe1\x05\x97\x2f\x02\x38\x39\xff\x01\xf4\x95\x33\xdb\xb7\x6f\x88\xb2\xd8\x74\x09\x5c\xed\x2c\x7d\xba\xb9\x7c\xce\x5f\x12\x8c\x5d\x0b\xd7\xaf\x81\x6d\x95\xc2\xae\x5a\xa7\xdb\x17\xcf\xb1\xa5\x87\x5f\xd9\xc3\x00\x39\x89\x47\xa2\x09\x5e\x81\x06\x5c\x0b\x0c\x3a\xc7\xd8\x0d\xa2\xe0\xa9\xbc\xa7\xa0\xf3\xd3\x4f\xff\xea\xad\xa3\x27\x29\x7a\x8c\x19\x6f\x9f\xdd\x5e\x7d\x10\xa7\xd2\xba\x83\x43\x04\xab\x72\x5f\x10\xb0\x27\xf7\xee\x90\xa5\x40\xcd\xd6\x12\x3c\xb8\xa3\x31\x29\x69\xbc\x55\x03\x1b\x05\x94\x4e\xa7\xf0\x58\xb8\x33\xce\xe8\xec\xd2\x66\xa2\x2e\x5f\x37\x0a\xba\x44\x82\x3e\x51\x3e\x1f\xab\xaa\xfe\x4e\xae\xf9\x39\xd5\x7c\xf1\xc5\x5f\x16\x45\x28\x06\xfe\x65\x40\xb1\x2e\xfa\x1e\x48\x27\xbe\xb3\xf8\x77\xec\x08\x11\x5f\xd9\xfc\x2b\x14\xe6\xf4\xe5\xef\x78\xe1\x3d\x07\x1b\x70\x97\xf8\xd1\x89\x24\x08\x64\xea\x62\x48\x6e\xe7\x93\xab\x4f\xaf\x9c\x87\x38\x4f\x28\xd2\xe4\xc6\x9d\x62\x80\x9d\x5c\xa4\xef\xf2\x96\x70\x57\xb5\x4f\x9c\x95\x96\xc8\xef\xbd\xf2\xf6\x08\xd0\x12\x00\xf1\xd4\x4a\xdd\x61\xba\xa5\xa8\x7d\x3c\x80\x81\x95\xfc\x18\x47\x79\xc6\x38\xbc\x64\x96\x78\xf0\x34\x25\xb0\x52\x84\x9e\x05\xb1\x7b\x50\x18\xb1\x68\x95\x54\xf7\x0b\x6e\xa0\xe4\x92\x05\xe3\x79\xb8\xe9\xc6\x5b\xf5\x10\x1c\x46\xfc\x34\xf1\x94\xa1\x83\x63\x68\x09\x1f\x13\x89\xa6\x7c\x06\x09\x42\x97\x5f\x19\x1e\x19\x19\x3e\x74\x00\x8a\x9d\x0d\x1c\x18\x1a\x57\x61\xb8\xb6\xd2\xf9\x66\xd9\x11\x0c\x0a\x50\xa2\x96\x9b\x32\xd2\x87\x49\x4d\x32\xcd\x41\x62\x36\x18\x1f\x14\x80\x4c\xc8\x88\xf3\xab\x80\x09\xae\xc8\x89\x82\x37\xfc\x37\x69\x8f\x21\x29\x52\xb0\x28\xf1\x02\x9b\xb5\x88\xfa\xf6\x07\xd8\xf0\x1a\xe9\x50\x0a\x12\xcc\xdb\x22\x0e\x47\xae\xce\xa6\xba\xe6\xf1\xc0\x1a\x65\x51\x73\xb4\x7a\x03\x07\xf8\xea\x3b\x26\x22\x84\x27\xc6\x7c\x2d\x29\xed\x76\x97\x58\x22\xf0\x27\x01\xb1\x14\xe1\x3c\x3f\x71\xda\xf9\xba\x42\xe0\x16\x40\x93\xb0\x92\x0a\xf1\xbd\x1b\x44\xe9\xfc\x4c\x9c\x1f\x82\x50\x74\x18\x51\x3c\x3e\x72\xa8\x51\x5a\x94\x8a\x80\x05\x84\xad\xa4\xca\xa1\x82\x57\x81\xad\x66\x8c\xc6\x31\xc3\xc0\x68\x76\xaf\x6a\x85\x87\xa6\xd7\x3f\xc0\x85\x3b\xba\x07\xd4\x7a\xb6\x0f\x0c\x94\xd2\xf4\xd9\xb4\xd7\x9f\x5e\xfa\xc0\x3b\x51\x2a\x11\x40\xd1\x7e\x67\x94\x7e\x84\x18\x29\xce\x67\x54\xd1\x17\x19\x4d\x20\xc4\x9f\x5b\xb7\xc9\xa7\x16\x8c\xc3\x82\xcc\xe9\x32\xa5\x59\xcc\x2c\x06\xd7\x55\xa5\x73\xf6\x69\xbe\xdc\x80\x5a\xdd\x2a\x1a\x46\xe9\x3f\x14\x24\x79\xe6\x78\x69\x7b\x17\xf7\xa9\x22\xec\x05\x72\x41\x2c\x12\x8f\x9b\x3e\x7c\x2d\xa1\x8d\x26\x1a\xe3\x64\xc6\x91\x92\x31\xab\x37\xcb\x82\xd4\xe2\xdc\xe9\x32\x68\x32\xbb\x11\x84\x8e\x33\x94\xb5\xeb\x98\x33\xc4\x24\xee\x97\xf8\xd6\xc9\xb0\x9d\x1f\xe7\x3c\x4e\x47\x0b\xe7\x24\x79\x66\xd3\x0f\x39\xa0\xba\x9a\x35\x71\xa8\x92\x31\x73\x89\xb5\xec\xda\xa0\xe8\xb9\x2d\x2b\x71\xdd\x91\x38\xcc\x08\xd2\x2a\x6f\x7a\x6a\xea\xe6\x49\xd5\xae\xec\x6b\xa1\xf4\x7c\x5e\xe9\x28\xcb\x54\x19\x6e\xf4\xbc\x45\x6c\x6e\x3e\xa8\x34\xcd\x72\xa9\x06\x77\x61\x06\xcd\xf9\x43\xac\x87\x27\x85\x2f\xf1\xad\x25\x0c\x54\x74\x96\x5f\x06\xdc\x12\x46\x24\x24\x45\x2e\x75\x80\xc2\x2b\x8b\x0d\xb0\x1e\xb3\xf3\x14\x84\xab\x88\x4b\xd1\xab\xa2\xf8\x92\x28\xf8\xd3\xac\x9a\xa8\xca\x57\x0c\x1d\xd2\x83\xb1\x22\x75\xd9\x3c\x6a\x68\x07\x7b\xb5\x83\xaf\xf4\x6a\x07\xb0\xb6\xd3\x81\x57\x94\x13\xa0\x35\x3d\x09\x55\x16\x5a\x1b\xda\x41\x76\xd1\x3f\xf8\x0a\xfb\xcf\x01\xf8\xdf\x2b\x1a\xc6\x12\x7d\x09\xae\xbd\xb3\x1f\x51\xd1\x23\xaa\xb1\xe1\x56\x45\x52\xd7\xd8\x08\x9f\x98\xd3\x57\xa3\x54\x2a\x50\x34\x68\x01\x73\xab\x21\xb1\x8c\x7e\x61\x1c\x08\xa6\x8a\xa1\xdf\x0c\x1c\x1c\x1b\x19\xa2\x82\x17\xd0\x75\xc5\xf7\xc2\x58\xdd\x5c\xd0\x1b\xc6\x38\x7c\xe6\x99\xdf\x95\xc5\x1a\x7d\x29\xb2\xbf\xf7\xc1\x87\x7d\xa9\x0e\x79\x07\x3f\x88\x8e\xe2\xad\x8a\x6c\x7b\x5e\xc3\x8e\x19\xf8\x53\x36\x70\x35\x53\x7b\x93\xcd\x4c\x55\x97\x25\xee\xed\x9a\x53\xfa\x31\x1b\x00\xe8\x62\x72\x78\x62\x68\x1c\xff\x1a\x1b\x98\x98\xf8\xf5\xe8\xf8\x7e\x20\x73\x26\x70\x58\x93\x92\xca\x5b\x08\x61\x4d\x95\xe2\x83\x75\xd4\xde\x2c\xcc\x06\xcb\x55\xb8\xd5\xe6\xc7\x06\xc6\xd9\xe7\xc9\xa1\xf1\x89\xe9\x81\x89\x69\xa8\xc9\xf2\x5b\x69\xf1\x27\xfa\x83\xa5\x30\xbd\xc3\xca\x05\xf5\x2b\x8b\x60\xa9\xa7\x92\xee\x75\x4d\x1a\xb2\xb2\xc8\x08\xd8\x05\xa4\x22\x15\xfd\x81\x92\x2c\x5d\x41\x81\xe2\x7e\x98\xb7\x8f\xa5\xfc\x10\x9c\x5b\xc9\x6f\xb8\xaa\xfd\x9a\xc1\xb3\x8e\xd9\xda\x98\x75\xcc\xa8\x4f\xcc\xb3\xab\x15\xe6\x0b\x97\xac\x26\xb4\x49\xc4\x2e\x0d\xa5\x5e\x8d\x1a\x5d\x50\x05\x46\x28\xd2\xf2\x36\x34\xa2\x20\xb0\x53\x00\x78\x8a\x83\x66\xff\xbe\xc3\x8b\xb7\x48\xb0\x79\x08\xb4\x36\x02\x69\xad\x00\x9d\xca\x2f\x29\xa0\xf7\x44\x01\x57\xe5\x2a\xed\x1a\x97\x38\xf5\x70\xfe\x21\x18\x24\x84\x3b\xb8\x23\xe3\xf8\x12\xe6\xd7\xad\x61\xd8\x25\xf6\xbb\xe2\xaa\xae\xeb\x47\x0a\xd8\x56\x5b\x61\xbd\x46\xae\xa6\xe0\x29\x81\x8e\x37\x75\xd9\x29\x8c\xb9\x81\xa3\xdf\xe5\xba\x39\x20\x76\xbb\x7b\xc4\x62\xd8\x31\x81\xcc\xe2\x5d\x5f\xc5\x15\x81\xf7\x1e\x9d\x18\x1a\x3c\x3c\x3e\x3c\xf9\xc6\xf4\x81\xf1\xd1\xc3\x63\xd9\x45\x62\x24\x58\x6d\x74\xfc\x00\x1d\x23\xdd\x0c\x10\x57\x07\x58\xb1\x5d\xba\x18\x92\xb7\x6e\xdd\x01\x92\x09\x3d\x49\xa5\xfb\x45\xbf\x8e\x61\x7a\xb4\xbb\x50\x5c\x08\xe1\xc2\xc4\x08\xd6\x5c\xe2\xd5\x96\x54\x87\x89\xfc\x7a\x65\x11\x44\x81\x67\x6f\x4a\xff\xf7\x2f\xf2\x0f\x69\x60\x70\x44\x66\x2d\x8b\xc1\xa0\xdf\xe5\x14\xed\x7d\xec\x87\x18\x11\xaa\x98\x63\x0c\x61\xb0\x00\x31\xd0\x41\xb7\x17\xab\x45\xec\x0c\xc5\x20\x88\x4a\x50\x8c\x57\xa6\x0f\x0e\x1f\x3a\x3c\x49\xe5\xa5\x0a\x6c\x68\xc6\x51\x7b\x1b\xf5\xa6\xa1\xfd\xb7\x36\xab\x97\x6d\xf8\x17\x30\xdf\xd7\xb0\xf6\x81\x60\x7b\x01\x9f\x2b\x5a\x65\xa6\x4a\x7a\x9e\xa3\x1f\xb0\x6e\x28\x83\x30\x32\x3a\x38\x30\x32\xc4\x7e\x1b\x1c\x19\x1a\x18\x7f\x21\x1b\xcf\xf1\x22\xad\x4c\x1e\x17\x44\x31\x4b\xb9\x67\x4d\x4d\xdb\x27\x30\x23\x27\x12\x3c\x88\xd5\x71\xd1\x8f\xe4\xbc\xd3\xb7\x58\x29\x2b\x8b\xe0\x25\xc2\xc0\xe1\x4e\xb7\x4b\x0e\xb2\x94\x86\x05\x10\x86\x47\x91\xd1\x28\x45\xef\xbf\x0b\x85\x92\x69\xc3\xa7\xae\x46\x2c\x59\x15\x68\xe7\x05\x62\x82\x2f\x73\x17\xc0\xe0\x52\xcc\x20\x75\x03\x82\x82\x57\xfe\xeb\xf0\xe8\xe4\x00\x16\x1f\x9b\x64\x1f\x46\xa6\xdd\x12\x64\xa6\x26\xa4\x8e\xf4\x65\x9d\x6a\x9d\x4d\xf0\x3a\x64\x3e\xf1\x44\x1c\x47\xba\x75\x4d\x37\x1d\x81\x56\xc0\x44\x8b\xae\xa8\x47\x9b\x04\xe5\xab\x24\x09\x42\x15\x8a\x64\xf2\x41\x06\x5b\x59\xa4\xab\x80\x4a\x44\x04\xfe\x2f\x42\x66\xc4\xc2\xf5\x2b\x26\x5e\xb8\xf8\x55\x5f\x8e\xd0\x7d\x52\xca\x07\x3d\x89\x90\xea\x76\x01\x02\x7a\x5c\x36\xda\x77\x45\xf3\xea\x8e\xd0\xba\x9a\x9c\xc6\x49\x78\x3c\x5a\xbf\x10\xf5\xaa\xe1\xc0\x9f\x1e\x3f\xcc\x38\x1a\x4b\x57\x77\xb3\xa9\x92\xd5\xca\x56\xe8\x1c\x54\x7e\x70\xe0\xc0\x44\x57\xfb\x5a\x48\x08\xb8\xc2\x16\x1a\xd6\x51\xa3\xaa\x8d\x0c\xbc\x32\x34\xa2\x8d\x8d\x8f\x1e\x19\xde\x3f\x34\xce\xe4\xd2\xeb\x43\x5d\xc9\x4a\x31\x04\xd5\xb2\x70\xe6\xf7\xca\x38\x03\x3c\x1e\xbc\x36\x63\x46\x3e\x63\x62\x6e\x1c\x28\x5a\xec\xbe\x94\xcb\x14\x8f\x1a\x8b\x41\xe2\x8a\x2f\x5e\x1f\x7a\x23\xea\x2e\xa4\xed\x62\x1f\xae\xb4\x68\x3f\xb7\xad\x17\x76\xb2\xff\x4c\x06\x22\x75\xd5\x77\x21\x49\xd3\x8e\x80\x5d\x2d\x02\xd9\xca\x62\x69\x86\xfd\x07\x3e\xf2\xf5\xf3\xc2\xf7\x80\x87\x75\x4b\x03\xee\x7f\xf6\x41\xae\x15\x6e\xa0\x7d\x8d\x4a\x6d\x9f\x70\xf5\x4d\xd3\x0a\xe2\x4d\xba\xab\x1d\x35\xaf\xd7\x8d\x92\xd0\xa8\xba\xd7\xa6\x48\xb4\xd3\xd9\x06\x6d\x75\x79\x3f\xdd\x3f\xd0\x57\x05\xd4\x91\xba\x13\x01\x28\x4b\xbc\x1a\x57\xa8\x7e\x25\xd7\x80\x7d\x66\xba\x16\xc6\x14\x06\xe4\x62\xb7\x10\x0b\xa2\xc4\xb8\xff\xd8\x91\x4f\x9a\x9a\x36\x38\x3e\xb4\x7f\xe8\xd0\xe4\xf0\xc0\x08\xce\xb0\xac\x4d\xbc\x31\x31\x32\x7a\x60\x7a\xff\x38\x5b\xe4\x69\xb0\xb1\xba\xa4\x11\x7d\x11\xf1\x6b\xbe\xa5\xc6\x74\xdb\xa6\xba\x07\x4c\x80\xc0\x86\xc7\xb2\xdf\x8c\x5d\xa8\x86\x9f\x2b\x03\x30\x2d\xd2\x96\x2b\x71\xb8\x11\x94\x5a\xc5\x2a\x19\xa1\x7b\x28\xe1\x4c\xb0\x27\x2a\x62\xd1\xeb\xa2\xd1\xeb\x0e\xde\x4b\xa3\xc3\xce\x95\xb0\x0e\xc1\x12\x8b\x08\xa1\x54\x60\x88\x12\x0e\x52\xac\x48\x20\xf0\xb3\x4b\x9c\x41\x0e\xb0\x3d\xfc\x92\x2b\xb4\x5f\x42\x41\xce\xbe\x7b\xd9\xfd\xee\x65\x49\x92\x4f\xf0\x7e\xaa\xba\x4f\x5a\xca\x82\x1c\xad\x3b\xdd\x21\xe6\x97\x9d\x51\x62\x2e\x1c\x2a\xd3\xe0\x4a\x33\x85\x0a\xd8\x45\x71\x71\x84\x0b\xba\x57\xea\x5b\x9b\x15\x9a\x73\x69\x75\x57\xd0\x0e\x9a\x0b\x63\x01\xd6\x19\xbd\xdc\x56\x79\x65\xcd\x5e\xb4\xcb\xd6\x5c\xff\xbe\x7d\x31\x2a\xaa\x12\xa2\xd7\x36\xc9\x76\x8d\xa8\x26\xe7\x01\x88\x20\x47\xcc\x6a\xf3\xad\x7d\x07\xf5\x62\x66\x92\x02\xef\x08\xa2\x22\xaf\x60\x60\x38\xb2\x8f\x4b\xe1\x7e\xf8\x83\xba\xe2\x86\xd8\x3e\x65\xeb\x75\xf6\x95\x45\x2b\xa2\x83\x89\x30\x24\x12\x36\x53\x80\x8f\xaf\xcb\x73\x3f\x7d\xc1\xb1\x12\x36\x50\x85\x51\xb6\x0b\xea\x74\x8b\x55\x9c\x41\x7e\xf7\x65\x6d\x48\xb3\xd9\xd6\xfa\xf6\xdd\xf7\x3b\x9f\x3d\xe8\x1c\x7f\xaf\xfd\xd9\x37\xc1\x26\x41\x90\x53\xbe\x7c\xa1\x73\xef\x1a\x0f\x47\xa6\x72\x99\xc7\xaf\x3b\xc1\xb7\xa2\x62\xf1\x9a\xdc\x85\x64\xd7\xe4\x70\x34\xf2\x0c\x3d\x90\x65\x6e\xbb\x66\x31\x0d\x4f\x28\xde\xf2\x05\x5f\x9c\x3d\x4f\x02\xcf\x69\x3e\xe9\x65\x34\xe2\x1c\xda\x07\xca\xe9\xcf\x14\x48\x68\xcd\x59\x5e\xab\x6c\x00\xff\x94\xd5\x3f\x55\x59\x1d\xea\x18\xfa\xa7\xd0\x0e\x0a\xed\x68\xfd\x18\xaa\x06\xa2\xdd\x99\x5d\x08\x16\x40\xdc\xfe\x86\xdd\x00\x26\x5f\x1b\xc5\x0e\xed\xaf\x41\x47\x87\xfd\x43\xe3\xbc\x5b\xfb\x00\xbb\x85\x80\xd2\xcf\x38\xa5\xd6\x6c\x68\xb0\xb7\x84\x24\x7e\x65\x51\x44\x24\xba\xad\x34\x00\x76\x0f\xe5\x6f\xb1\xbb\xdd\xac\x55\xaf\x30\xdd\xec\xc0\xd0\xa4\xb8\x0d\xf3\x7b\x35\x53\x8f\x01\x81\x3e\x6d\x78\x16\x2b\x96\x23\x3c\x28\x34\x26\x3a\x02\x2d\x98\xba\x56\x28\x41\x6b\xb1\x31\xf0\x51\x88\x16\xea\x1c\x26\x56\xb5\xb3\x1b\xec\xb2\xd8\x2b\x2a\x96\x61\x7e\x18\xdb\x5a\x85\xc9\xc5\x1a\x9d\xe3\xe2\x1d\xdb\x68\xf0\x30\x2f\x11\x72\xbe\x0f\xb6\x5e\x1f\xd6\x47\x83\x38\x56\x6b\xc1\xa8\xd7\xc1\x1c\x30\xcf\x00\x82\xf6\x8b\x81\x30\x8c\x10\x1c\x34\x42\x13\xc5\x25\x98\x04\x9f\xb7\x4a\xfc\x91\xdf\xf4\x71\x52\xbc\xca\xae\xf0\x50\x46\xa2\x64\x15\xb1\x91\x3f\x0e\xe3\xf4\x2f\x58\x30\x6d\xb3\x21\x22\x4a\xf4\x9a\xc9\x9e\xb2\xfb\x8a\x50\xc5\x79\x96\x8a\x38\x43\x16\x69\x5f\xd0\x6e\x5c\x9c\xa5\xb5\x9a\xda\xb3\x6f\xe1\xe5\x7d\xd0\x94\x6b\x6a\x0f\x1b\x14\xe9\xc9\x16\xba\x1a\x6a\xb2\x04\xc4\xa7\xf6\xc8\xd4\xe8\xf7\xcc\xfd\xad\xc2\xb1\x63\xc7\x0a\x40\xc5\x02\x83\x6d\x54\x21\x8d\x85\x6d\xbc\x28\x80\x25\xad\xe7\x0f\xff\x07\xb8\xb1\x1f\xed\x8c\x62\x57\x86\xa3\x57\xd2\xfe\x73\x9f\xec\xe9\x89\x53\x20\x72\x62\xc6\x40\x00\x2a\xb8\xb1\xbd\x6c\x09\x11\x5d\xee\x81\x73\x55\xf4\x1b\x72\x33\x07\x18\x5d\x9d\xb0\x56\x39\x67\x08\xdb\x91\x5c\x2e\x94\xc0\xb7\xfc\xe3\x8a\xc8\xd1\x71\x8a\xe4\x9f\xc1\x23\x99\x17\x09\xe2\x79\x77\x4b\x2d\x79\x05\xd8\xc8\x7e\xf6\x83\x04\x3e\x5e\x67\x82\x77\x02\x02\x46\x77\x13\xb7\x57\x2e\xb2\x13\xdc\x83\x04\x94\xfb\x38\x8e\x8e\x79\xc8\x26\x2a\xbc\x26\x1a\xfb\xdf\x46\x57\xf8\xaa\xa8\xb3\x76\x0d\x7b\xbf\x1d\xc7\x88\xba\x8d\xc2\x6f\xd8\x53\x4f\xee\x9d\xa6\x9e\xfd\x10\x8e\xce\x0b\x1d\xde\xf2\xf4\x08\x62\xac\x0b\x4a\x08\xa4\x31\xae\x61\xb9\xff\x77\x31\xa8\x0c\x72\xb4\x62\xb8\x16\xb3\x25\xe4\xea\x51\xfe\x2c\x31\xcf\x41\xfc\xf3\x60\xe8\x48\xe1\xca\x2b\x4e\x49\xfe\xc5\x59\x76\xb0\x66\x33\x8d\x10\xac\x50\xb7\x21\x44\xb7\x74\x03\xd3\x63\xc6\xea\x1a\x1a\xf7\x0c\xe6\x00\xa7\x36\xaf\x57\x0d\x1e\xe0\x62\x77\x0d\xcf\x6b\xfc\xea\x0e\x16\xf9\x64\x92\x7b\xa1\x70\x40\xb5\x2f\xd0\x03\x35\xa9\x0b\x30\xc2\x1f\xa5\x84\xe7\x71\xce\x61\x3c\x81\x07\x5e\x30\x86\x20\x2b\xd8\xee\x43\x13\xd2\x50\x7a\x56\xd1\x35\xcc\x07\x2b\xda\xbd\xd5\x2d\x4f\x44\x5c\x74\x73\x01\x1c\xe1\xa1\xca\x6b\x84\x70\x07\x55\x5e\xd0\x13\xb8\x9f\x3c\x9b\x24\x74\x8f\x84\xdb\xfc\x93\xf1\x52\x6a\x44\x02\x97\xc6\x68\x24\x12\x11\x23\xc4\x73\xd0\x3d\x85\x3d\xee\x83\x1c\x60\x71\x61\x29\x79\x1f\x0a\xe2\x00\xeb\x0a\xb8\xd7\xb0\x9f\x1d\x1a\x45\xc3\x14\x66\xd9\x45\xaa\x59\x67\xff\x96\xf5\x39\xed\xd5\xa1\x81\xc9\xc3\xe3\x5d\xc4\x50\x0b\xa8\x10\x8e\xdd\x55\x34\x34\x00\xca\x37\xbc\x9b\x1c\x04\x39\xcf\x97\x03\xed\x7a\xba\x46\x75\xa1\x4b\x00\x0b\x4c\x99\xb3\xbb\x83\x91\x2f\x69\x64\x68\xd9\xa2\x07\x41\x39\xb4\x25\xcd\x4f\xa8\x01\xae\xd3\x0d\x24\x4c\x03\xff\x1f\x8b\x47\x80\x9c\x99\xb4\x28\x77\x9a\xea\xb8\xc3\xf5\xb8\xc1\x01\x41\x2f\x0a\x4c\xc5\x75\x52\xfd\x2c\xaa\xf3\xbe\xdf\x34\xe6\x2c\x2c\x07\x61\x54\xd9\x05\x18\x22\xae\x9d\x8b\x0e\x5b\xd9\x38\x93\xed\xb3\x44\x93\x69\xd8\x88\x61\x24\x1d\xe7\x8c\x46\x81\xea\x26\x16\xa8\x6e\x62\x57\x5c\x02\xed\xc0\xb4\x37\x07\x47\x0f\x1e\x1c\x38\xb4\x3f\x9b\xec\xe1\xc5\xc8\x79\xae\x08\x8f\x4a\x2c\x00\xdd\xf6\x4d\x8e\xee\xe3\x6d\x8c\xfe\x1b\x63\x38\xfe\x1b\xac\x68\x6e\xe2\x09\xfd\x86\x9f\x5f\x70\x8e\x18\x36\xc0\x58\xdd\xaa\xd4\x78\x22\x27\xfa\xa7\xeb\x15\x0a\x30\x68\x56\xcb\x50\x37\xb7\xa7\x30\xdb\x23\xdb\x43\xc2\x8d\x03\x3e\xbc\xfe\x67\xdf\x7e\x5e\x21\xc9\xde\xc7\xd3\x5a\x98\xce\x35\xa3\xd7\x15\xcf\x87\x18\xfb\xbc\xef\x4d\x97\xc1\xe8\x37\xad\x57\x4a\xff\xfe\x2b\x05\x0c\x36\xdb\x83\x8b\x05\xcc\x98\xe1\xaf\x1a\xc5\xf9\x38\x3d\x2f\x7f\x7a\x02\xbd\xe0\x22\xce\xaf\xf7\xde\xbb\xf8\xf2\x05\xac\xd6\x7b\x96\xb7\x17\x84\xac\xb8\x3b\x68\x43\xbc\x4c\x65\x76\x78\xcd\x73\xb9\x6f\xae\x7c\x63\x7d\x7e\xa9\x1c\xc9\xb4\xb0\x5d\xe5\xec\xa6\x6c\x32\x8d\xca\xb3\xbc\x59\xd0\xc1\x46\x20\xbc\x33\x4d\xe7\x3c\x17\x4d\x62\xc9\x5b\xff\x5b\x39\x90\xc1\xa6\x03\xf0\xb7\x99\x33\x82\xd8\xd0\xec\x22\x90\xf5\xd5\x2e\xcf\x96\x8a\x5e\xe3\xf7\x10\x47\x50\xe6\x11\x01\xea\x82\xad\x2c\x42\x40\x72\x1e\x37\xbf\x48\x98\xdd\xdd\xfe\x52\x82\xee\xfe\x06\x98\x92\xec\x31\x6b\x48\x75\xd6\x1c\xd5\x5d\x44\x04\xd9\xda\xc2\x4b\xc2\xb3\x08\x1f\x9d\x3b\x15\x7c\x86\x68\xc4\x85\x97\xdd\x9f\x5f\xc6\xaf\x32\x33\xb1\xe5\xde\xe0\xb2\xbd\xdf\x45\xcc\x35\x7b\x17\xb5\x6f\x3b\x33\x04\x74\x33\xa4\x2b\xc5\xe1\xbc\x4a\x1d\x29\xb3\xbd\xdb\xac\xcf\x05\x97\x2d\x70\x7f\xcb\x01\xb6\xe8\xeb\xe5\x44\xa3\xa2\x38\xe3\xfc\x90\x4d\x59\x90\x6c\x4e\xd9\xdf\xcf\x46\x37\x6a\x5a\x1b\x9e\x03\x1b\x96\xff\x1a\xf2\xbc\x94\x02\x9b\x91\xe3\xeb\xd4\xae\xc8\xd9\xbf\x87\x86\x7e\x3d\xdd\x95\x28\x26\x80\x61\x56\x50\x77\x00\xef\x57\xdd\x0c\x23\x4c\x99\x00\x35\xeb\xb6\xe1\xa0\x94\xd6\x21\x80\x9d\x0b\x33\x7b\x07\x52\xd8\x72\xe4\xd1\xe8\xab\xae\xc6\x92\xec\x0e\x08\x39\x73\xf6\x19\xf0\x5b\x41\x34\xae\x7d\x53\x56\xf3\x82\x16\xa1\xe2\xac\xf7\x71\xf6\xb4\xc4\xa9\x31\x87\x4a\xcc\x40\xb2\xae\x17\x35\x48\xcc\x64\x20\xa9\xcd\xe8\x4e\xe9\x40\x20\xf5\x46\x2e\x40\x30\xdd\xc9\x11\x9d\xce\x6e\x1c\x3e\xb4\x7f\xe8\x37\xd9\xe0\xf2\x3c\x47\x76\xf5\x37\xeb\x56\x15\xbc\x9c\x85\x05\xbd\x6e\xa2\x41\x01\xad\xab\x99\xc0\xda\x98\xe8\x25\xb9\x4b\xdc\x6b\x28\xc6\x07\x1d\xd5\xf6\x0f\x4f\xbc\xee\x0f\x53\xcd\x68\x44\xca\x3f\xe1\x50\xb5\xc7\xbb\x01\x26\x59\x7d\xb3\x9d\x03\x49\x8d\x9e\x4a\xc3\x6b\x26\x8b\x6b\x9a\x51\x03\x56\xd6\x2c\xe6\x55\xe9\x9d\x60\xa8\x72\x92\xb9\xd9\x38\x54\xf2\x69\x85\x8f\x12\x35\x17\x3e\x42\xcc\x34\x1a\x05\xd9\x9e\xa6\x0d\x1d\x3a\x32\x7d\x64\x60\xdc\xfb\xc7\x91\x81\x91\xc3\x59\xb9\x4a\x61\x4e\xe1\x6d\x21\xfe\x9b\x9a\x41\x64\x86\x0d\x6a\x26\xd6\x3a\x77\x8c\xbc\x70\x7e\x8e\x8f\x52\x10\x56\x66\xb0\xa4\x47\x01\x28\xd4\xa5\xba\x82\x15\x2f\xbb\x92\x67\x93\x64\x46\x22\x68\x65\xc7\x9f\xfc\x06\xf7\x2e\xe1\x07\x57\x82\xce\xea\xae\xd7\x43\x24\x6d\x3f\x3b\x1a\x82\x1b\xa5\xc0\xcb\xb1\xe4\x94\xd9\x2a\x69\x33\xd9\xdf\x97\xd7\x74\x1a\x17\x32\xfb\xe9\x2d\x01\xcc\x28\xfb\x85\xff\x81\xd2\x34\x8c\x52\xb7\x7e\x08\x02\xe8\xdc\x23\xbb\x25\x56\xc6\x59\x49\x0e\x0b\xd4\x11\x64\xed\xa6\x80\xbd\x69\xa8\xac\x07\x6f\x3e\x09\x7f\x8c\x68\x6f\x42\xb5\x81\x69\x5e\x13\xbe\xff\xb7\x20\xed\xfa\xc1\x88\x80\xff\x81\xbf\xd0\x6e\x03\xad\x99\xd0\xb6\x50\xc0\x74\x28\xc4\xc8\xfd\x01\xee\x48\x8c\xdd\x8c\xb7\x98\xea\xe0\xfc\xc2\x83\xc1\x0a\x35\xdb\x68\x96\xac\x42\xa3\xb1\x88\x5f\xcf\x5a\x75\xc8\x85\xf1\x7e\x29\x5c\x4c\xd2\xd7\x59\x49\x50\x88\x28\x39\x1c\xff\x32\xf9\x7e\x4a\xdd\x69\x97\x8c\xe2\xec\x04\x61\x87\x5f\x37\x57\x2d\x04\x92\x91\x11\x62\xa5\x50\x56\xb0\xdd\xea\xdd\x76\xc3\xea\xb2\xa2\x12\xb5\x84\x0b\xb3\xa1\x66\x02\xd7\xac\xa6\xaa\x96\xa3\x0a\xb3\x50\x2a\x52\xa1\xf0\x93\xd7\xc6\x89\x51\xbb\x72\xc4\x3e\xa0\xa0\x75\x8b\x79\x22\xb2\xef\x58\x59\x18\x3e\xc0\x4e\x16\x86\x71\x86\x88\x29\x0d\xd3\x15\xf0\x1d\x2b\x02\xe3\x74\x0f\x16\xee\x13\xf2\x1a\x65\xd7\xae\x9a\xd5\x1d\x72\x07\xc8\x80\xf3\x73\x08\xc4\x40\xed\xce\x25\x90\x1a\x78\xf7\x4e\x81\xd4\xe4\x8f\x5b\xcd\xc8\x1b\x57\x46\x0e\xd9\xa1\x9b\x10\x01\x0e\xa8\x99\x5d\xde\x89\x64\xa8\x3b\x72\x61\x60\x03\xec\x80\xb6\xde\xac\x95\x54\x65\x74\xde\xe4\xf9\x3f\x14\xc8\x20\xea\xe9\xfc\x36\xb4\xa0\x0e\x2f\x30\x74\x94\x7d\xd5\xac\xc2\x87\x8c\xe7\x2b\x61\x93\xbe\xa4\xcd\x9b\x85\x2a\x9a\x4e\x85\xa8\xe8\x26\xe7\x1a\x1c\xe4\x05\x27\xf8\x28\xaf\x9c\x6c\x3e\xb5\xdd\xab\x0d\xe2\x0c\x18\x91\x38\x08\x24\x03\x5f\x9c\xb2\x7e\x5f\x97\xc5\x41\xbc\x38\xec\x48\x71\x10\xdf\x10\x29\x8a\x83\x74\x35\x5c\x74\x78\x9f\xa9\x1d\x1c\xf8\x4d\x41\x90\xba\x10\x5e\x17\x20\x01\xc7\x3e\x43\x46\xfd\x19\xa4\xfa\xa7\x9b\xc9\xf3\x91\xea\x9f\x1a\xe7\xdd\x4a\xf5\x4f\x8d\x58\xa2\x54\xff\x48\xa8\x79\xe4\x3a\x66\x1b\x2b\x59\x72\x69\x2c\xc0\xd4\xc9\xa5\x71\x10\x93\x24\x97\xc6\x69\x7e\xbb\xbe\xbd\x9d\xec\xf2\xcd\xd6\x2d\x91\x60\xce\xfb\xc3\xc6\xa6\x69\x77\x91\x60\xbe\xb3\xbb\x7f\xf7\x13\xcc\x77\x41\x32\xa8\x13\xcc\x43\xb2\xcb\x3d\x29\x69\x39\xcb\x8a\xa0\x79\xe1\x9f\x72\x22\x77\x39\xa1\xd2\x02\x26\xc7\xe1\xae\x32\x34\x3e\x3e\x3a\x0e\x7b\x7f\x60\x12\x5a\x9f\xb1\x0d\x8f\xb9\xa1\x50\x39\x7f\x8c\x4d\xfa\x9d\x77\xd8\x02\xb1\xcf\x43\xf5\xba\xb2\x41\x88\x62\x04\xbd\x8a\x25\xfb\x11\x6f\x28\x53\xa5\xb9\x41\x64\xd6\xac\x06\x6a\x8c\x73\x58\xa2\x1a\xa3\x80\xce\xf6\x3f\x64\x57\xfa\x9a\x27\x89\xb6\x92\xd8\xae\x21\xac\x91\x12\x0f\x55\xfd\x00\x3b\x8c\x50\x9f\xab\x5b\x98\xc7\x19\x5d\x0f\x9f\x21\xfd\x1c\x22\xac\xe8\x99\x90\x0a\x5b\x6d\xef\x7e\xca\x38\xef\x77\x32\x2e\x8c\x92\xaa\x77\xfe\x4e\xcc\x41\xdb\xeb\x4b\x34\xee\xd7\x9e\xdc\x3b\x4b\xfd\xfe\x14\x5d\x89\xd8\x04\x81\x85\x78\x62\xa8\xed\xeb\x44\xd4\xeb\x7c\x83\xee\x62\x88\xaf\x9f\xa1\x66\x1b\x36\xf5\x68\x98\x35\xeb\xd4\xa9\x81\x00\xa8\xa2\xf1\x92\x34\xe6\x6a\x9f\x3a\x8d\x91\xd0\x1e\x1e\xda\x5c\x6a\xb5\xdf\xa3\xae\x67\x3e\x08\xd8\xea\x96\x9d\x0a\x7e\x02\x86\x35\xba\x72\x81\x5f\x4e\xdf\xbf\x81\x08\x84\xf9\x05\x15\xbd\x7e\xd4\x68\xb0\xb5\x2e\x3a\xa4\xa2\x7c\x7c\xa8\x36\xac\x73\x13\x39\xd3\xb8\xa3\xdb\x06\xd2\xb1\xf6\x2d\xa6\x41\xe3\xd4\x44\x44\xb8\xb7\x55\xe0\x19\x0f\xaa\x50\x58\xe2\x01\xd6\x08\xc7\xb7\x80\x0d\xbe\xc2\x1e\xba\x44\x0d\xcf\x59\x28\x75\x8b\x4b\xb6\x21\x9d\x09\x62\x0f\x5d\xb3\x0a\xe9\xca\x14\xf1\x0f\x29\x00\x81\xc6\x2f\xbb\x32\xe3\x90\x7e\x33\x52\xaf\x5b\xae\x2e\x64\x9c\xeb\x73\x28\x7f\x62\x71\xb6\xf9\x5d\x63\xc6\x62\x37\x0d\xb0\x0b\xe1\x6e\x24\x13\x91\x66\x61\xf5\x48\x5b\xdd\xb6\xe5\x0e\x75\x6b\x41\x5e\xb9\x8d\x0d\x02\x9d\xde\x84\xab\xd8\x8c\xe7\x6e\xe4\x33\xeb\x4f\xee\x5d\xeb\x5c\x92\xd5\x16\x6a\x95\xfa\x01\xea\x65\x1b\x81\x4d\xab\x68\xf2\x12\x36\x15\x38\xf9\xc8\xf7\xe7\x36\xc2\xdb\x4f\xb6\x30\xf6\x4d\x44\xe3\x1e\xf7\x2d\xde\xf7\xce\x7d\x4b\xdb\x31\x8c\x1d\xe3\xde\x8c\xd9\x20\x79\x08\xf4\xdf\x47\xcb\x90\xbc\x6b\x0e\xb2\xcb\x07\x62\x3f\xac\x3a\xb4\xdf\xe7\x5f\x8b\x6e\xd1\x9f\xd7\xab\x73\x58\xc2\x73\xc1\x34\x8e\x61\xe2\x93\x13\x75\x57\xb4\x9a\xd5\x46\x2f\x9c\x54\x47\x79\xa4\x01\xba\x94\xa8\x66\x49\xc5\xa8\x58\xf5\x45\xfa\x06\x85\x40\x64\xdf\xc5\xad\x53\x3f\x20\x8e\xeb\x9e\xe6\x8a\x4e\xa9\x86\xe0\x66\x00\x16\x5b\x13\x4d\xcb\x4f\x62\xa1\x08\x14\xd7\xf0\x0c\x31\xa0\xd4\xd8\xfd\xe4\xf7\xd0\x17\x98\x3d\xd3\x3a\xbd\xb9\xcc\xc8\x75\x17\xef\x07\xd7\xa9\x1d\x3a\xff\x95\x49\xf8\x1b\xa7\x3a\xd0\xd2\xf7\x11\x88\x95\xd6\xc6\xf6\xb5\xd5\xad\x1b\xf7\x63\x9a\x3a\x72\xf2\xc8\x5b\x9e\x26\x1b\x38\x08\x33\x9f\x6b\x40\x13\x85\x98\x70\x71\x4e\x82\x24\x66\xaa\x0a\xb5\x5b\xc9\x68\x52\xfb\x6a\x18\x0a\xef\x1a\xd0\xd9\x97\xdf\xf4\x92\x0f\x08\xa6\x0b\x31\x9a\xba\x7f\x56\xe4\x08\x09\xda\x65\x0d\x42\xc8\x17\x0c\xe5\xb4\x67\x54\x8f\xc5\x1b\x89\x2e\x5f\xe0\x99\x52\x49\x87\x80\x9a\x20\xda\xab\x54\x14\x04\xcb\xe0\x2c\x18\x75\x94\xfd\xd8\xef\xcb\x3c\x82\x2d\xe4\x20\x66\xc2\xac\xb3\x63\x60\x70\xc4\xf3\xc0\x60\xd9\x3c\x68\x42\xbb\x7b\x0d\x0b\xf2\xe8\x75\x03\x8a\x70\x40\xef\xb9\xf2\x22\xa4\x12\x7a\x1f\x45\x58\x7d\x90\x8e\xd8\xac\xcd\xd5\xf5\x92\x41\xfd\xe0\x19\x4c\x6f\xb5\x9d\x7e\xe7\x16\x31\xc7\x8e\xd2\xe6\x0c\xba\x9a\xe4\xe2\x25\xec\x0f\xf3\x5f\x4a\x22\x93\x4b\x65\x87\x08\xcc\x8c\x77\x73\x16\xc7\x8b\x67\x86\xd4\xd7\x1a\xe7\x17\xf2\x98\x98\xa7\x06\x55\x58\x1e\xbf\xb7\x7d\xb3\xe5\x54\x61\xd9\x3a\xf7\x08\x5b\x79\xad\xfb\x5e\x03\x68\xd2\xb4\x35\xe7\x05\x1c\x82\x37\x5a\x3d\x8e\xe7\x88\xe8\xf3\x0f\x55\x5f\xdc\x1e\xdb\x9d\xaf\xae\xc5\x16\x68\x49\x4b\xa9\x70\x16\xe0\x45\x14\x5f\x33\xca\xea\xce\xb1\x72\xed\xae\x1f\xb1\x9c\x0d\x93\xd8\x97\xa3\x01\x82\x62\x92\x00\x60\xfb\xfc\xd9\x68\x38\xd0\x74\x9f\x7f\x86\x46\xfb\x26\xa5\xa8\x72\xff\xf0\x8c\x01\x1b\x84\x3b\x8d\xa1\xb6\x14\x3b\x77\xb4\xaa\x8e\x96\xda\xc1\x57\x45\x4c\xd1\x3e\xbd\x6c\xea\x36\x63\xd3\x71\xca\x70\x00\x00\x3e\xb0\xfc\xc9\x38\xf0\xd0\x5f\xb0\xc4\x64\x8d\x64\x1b\x6e\xd8\xe2\x01\xd2\x0a\x51\xf3\xb0\x95\x8d\xdd\x5d\x31\x08\x9a\xea\x03\x2c\xab\x77\x19\x45\xf7\x09\xb7\xb5\x20\xdb\xb8\x8c\x11\x48\x18\x8a\xb6\xec\xa2\x39\xa0\x4b\x3a\xff\x1c\xb0\xfb\xcf\x59\x7c\x9a\xfa\x61\x5e\x02\x1a\xc8\x6f\xec\x6b\x9f\xfc\x02\x4a\x2a\x0a\x6e\xcc\x8c\x8c\x47\x8d\x73\xdf\x5d\xe5\x0d\x7c\x98\xa8\xe3\xd5\x8a\xd6\x04\x53\x33\x75\xb6\xe5\xb4\x8f\xdf\x6c\x7d\xea\x2a\xac\xde\x09\x06\x26\x25\x33\x1f\x18\x8d\xce\xb6\x4f\x9d\xf5\x0a\x52\x4f\x63\xfb\x74\xcc\x04\xec\xe2\x61\x12\x58\x62\xbe\xf8\x3d\x60\x83\xc0\x8f\xa4\x63\xf7\x70\x39\xc7\x74\x83\x72\x49\x6b\x30\xb1\xe2\x84\x2b\xe0\x81\xa0\x78\x4b\xd4\x22\xab\x0a\x36\x61\x7f\x40\x7e\x30\x3d\x2e\x73\x94\x59\x5d\xb0\x8e\x46\x71\x27\x43\xe0\x35\x76\x6d\x5e\x00\x3b\x21\x74\xd8\xb5\xe7\x11\x15\xba\x67\xce\x36\xa1\x3e\x3a\xdb\xf7\x4c\xea\x36\x44\x69\x35\xb3\xc2\x94\x17\xec\x09\xe8\xc1\x15\x7e\xc2\x5e\x86\xf0\x47\x10\x63\xc2\x4d\xcd\xc1\x31\x2c\xe8\x59\xd5\x10\xf0\x41\x4e\xf6\xf3\x65\x0c\x0f\xfc\x99\x5d\x6e\xef\xb6\xdf\xbf\x0f\x0f\x3b\x8c\x05\x7a\x52\xdc\xc8\x42\x0b\xbb\x1b\xc2\xbc\xcb\x17\xb6\xbf\x64\xcc\xf4\x18\x59\x6a\x05\x6c\xc7\xc0\xa7\x1f\x04\xf9\x14\xc5\x77\x90\xf7\x65\x1d\xf4\x8c\x6c\x78\x80\x7d\x06\x6a\x17\xa6\x2a\x0b\xde\x67\x4c\x4c\x48\x77\x2e\x5f\x6f\xdf\xf9\x08\x18\x3f\x04\xdd\x90\x81\x15\xd8\x63\x5d\x34\x9e\x35\xcd\xa0\x3f\xfc\xe6\xe9\xd5\xc7\x40\xaa\xb3\xad\xf6\xc9\x13\x5b\xe7\x4f\x6c\xdf\xfa\x5c\x6c\x17\x76\xa9\x3f\x27\x8e\x31\x86\xe8\xb2\xb8\xe6\x5f\x89\xdd\x3d\x8c\x47\xeb\xcd\x2a\x14\xca\x67\x0c\x8c\xb5\x1b\x78\x49\xfc\x92\x31\x6b\x56\x99\x7c\x64\x7a\x31\xf0\x2f\xfb\xd2\x62\x7a\xa1\x8a\x81\x44\x99\x36\xa4\x98\xbc\xb4\x40\x28\x22\xf8\x45\x3e\xef\xd6\xc6\x93\x87\x17\xdb\xf7\x6f\x02\x3d\x97\x97\x99\x1e\xbd\xf5\xe8\x4b\x1f\x6d\x95\x28\xd7\x20\xea\x04\xd0\x66\xdb\x84\xd4\x7b\x7b\x5e\x7f\x49\x43\x73\x34\xec\x08\x59\xce\x9b\x55\x9d\xed\xe7\x88\xa2\x77\xfe\xa5\x70\xad\x29\xa7\x49\xd7\xc6\x6f\x3c\xb5\x52\x69\xb8\xf6\xd2\x0d\x60\xad\xd5\x93\x5b\xeb\xd4\xbd\xec\x66\x32\xed\x1b\xf1\xc7\xbe\x06\x00\x05\x54\x40\xf7\x18\xe2\x69\x4e\xbd\x24\x49\xa0\x10\x62\x43\x3f\x0a\xde\xbf\x63\xf3\xe0\x60\x8b\x50\x49\x03\x8c\xd3\xb9\x77\x12\x78\x3e\x20\xdd\x69\x58\x1f\xe6\x8e\x42\x89\x6c\x7c\x19\x4c\x2f\x6c\x9b\xb4\xce\x75\xae\x2c\x63\x2b\xf5\x33\xb0\x71\x60\xef\xc8\x1b\xc1\xe5\x2f\x4d\xad\x87\x5a\xd5\xaa\x51\x44\x57\x48\xa9\x59\xa9\x61\x27\x70\xa3\x88\xed\x4b\x21\x1f\x1c\xaf\x1d\xf9\xf6\xfa\x55\x46\xc7\x74\xfe\xf4\xc5\xd6\xf7\x4e\x21\x82\x47\xbc\xe0\xe0\x52\x4b\xd1\x05\x38\xf7\x26\xbf\xeb\x9d\x4f\x96\xb6\x1f\xff\x19\x77\xc1\x1d\xb2\xcf\x61\xe5\xc0\xbb\xa2\xfb\x9d\x47\xad\x67\xd3\x88\x23\x68\x43\x37\x51\xe6\xff\xe3\x51\xd2\x21\xe0\xf6\xe3\x87\xed\xaf\x1f\xa5\xa1\x5e\x6d\x11\xb7\x1e\xbb\xa0\x30\x1a\xcc\xd6\xad\x8a\xa0\xda\x04\x7e\xc5\x86\xa1\x4e\xca\x3c\xf0\x97\xff\x38\x89\x7f\xd1\x8f\xbb\xdb\x8a\xfa\x21\x37\x13\xf2\x13\x42\x90\x43\xc6\x96\x0e\xb5\xec\x54\xf6\xda\x29\xe1\x3e\x2f\x0d\x24\xcf\x1c\xef\x2d\x8c\x5d\x3f\x44\x23\x74\xc2\x8b\x28\x2a\x32\x60\x4d\x02\x13\xba\xdc\xf7\xdf\x6f\xe9\x9c\xaa\x0e\xd5\xeb\x56\xbd\x5f\x8b\xf1\x0a\xc5\xb4\xe7\xf6\x77\xb0\xf6\x9a\x8c\xe0\x4f\xe0\xd6\xa9\x2a\x94\xe7\x04\x8b\xc4\x03\x69\xc0\x98\x19\x14\x19\xf7\x78\x0f\x96\x7e\x4d\x38\xb1\xac\x08\x84\x63\x4f\x18\x58\x5c\x87\xae\xe1\x08\xfb\x46\x8a\xc1\xb4\x04\x2e\x67\x74\x32\xc2\x59\xc8\xef\xee\x1a\x34\x63\x01\xee\x2f\xb1\x3b\x7f\xb1\x61\xd5\x17\xff\x97\xca\xe8\x70\xee\x11\x3b\xc7\xc1\x9b\xfc\xc5\x1d\xe1\x52\xf8\x0a\x6d\x54\x27\x1d\x8c\xb7\xae\xdf\x47\xeb\x57\x38\xba\xff\x2b\x0e\xc3\x59\xe0\x06\xdd\x29\x56\x4c\xc1\x88\x4a\x02\x7a\xeb\xc8\x02\x01\x4f\x61\x55\x55\x3a\xd3\xce\x6c\xdf\x5c\x41\xbb\xdb\x8a\xec\xd8\x70\x70\x49\x86\x0a\xdb\xe8\xb0\xfb\x4a\xa8\xad\x39\xd2\xa6\x07\xb6\xbb\xe8\x36\xa8\x40\xcf\xf7\x02\x6e\x5e\xb6\x2d\x4e\xd0\x8d\xc6\x6b\x1f\xdc\x40\x9d\x68\x05\xa7\x73\x4b\x98\xf0\xd7\x72\xc0\x9f\x77\x67\x04\x5c\x0e\x57\xed\x66\x0d\x52\x69\x8c\xd2\x08\x7e\x8b\x37\x1c\xe8\x81\x74\xb4\x6a\x1d\xab\xf2\x47\x6d\x30\xeb\xf4\x2b\x65\xbc\x0a\x90\x3b\x3d\x14\xc2\xdf\x08\x2d\x75\x23\x7a\x0e\x4c\x9d\x63\xfa\xf0\xd6\xd5\x2f\x84\xf4\x76\x5f\xec\x57\x0b\x6b\xcf\x0c\xd1\x4e\x89\x35\x9e\xf1\xaa\xef\xee\xfc\x31\xf6\x03\x11\x5f\x2d\x5c\x03\x8f\x86\x2d\x93\xeb\xca\x88\x99\x4d\x22\x7c\x55\x72\x0e\x64\xa0\x90\x85\x32\xe7\xa8\x91\x8f\xe8\xcf\x4f\x9a\x76\xb4\x40\xcc\x63\x7b\x78\x8f\x37\xe7\x14\x64\x1b\xe3\x8f\x64\x1c\xa1\x73\x27\x42\x68\x87\x9c\x43\xd4\x34\xdf\x73\x70\x89\x63\xa9\xcb\x2d\xc1\x68\x6f\xb2\x5b\xff\x1f\x0d\xd9\xad\xa7\xd2\x66\x84\x53\x6d\xeb\xe3\xef\xda\x27\x2f\xb7\xcf\x5c\x52\x09\xb5\xe4\xa3\x52\x7c\x85\xd2\x33\xd5\xf9\xf8\xbb\xce\xa5\xaf\x93\x0c\xc9\xf6\x8d\x16\x37\x2c\x57\x55\xa8\x5e\x39\x19\x3f\xa3\xce\x4f\xa2\x37\x9e\x39\x41\x0f\xa5\xea\xae\xeb\x47\xca\x3b\x90\x1a\xc1\x6a\x4f\x43\x84\x30\x36\x8c\x4a\x8d\xe2\x04\x41\x57\x6d\xd6\xc0\x74\xa9\xe4\x16\x61\x44\x3d\x7e\x87\x2c\xa8\xd8\x3c\x7a\xfd\xc9\xbd\x25\x76\x23\xf1\xdc\xc6\xa0\xb5\x34\x05\x3d\xa5\x5e\x33\xc0\xcd\xaa\x19\x55\xc9\xbf\x15\x79\x4f\x0c\x75\x67\x79\x50\x79\x7a\x69\x05\x3c\xb9\x69\x91\x38\x56\x37\x19\x7d\xfe\x68\xd6\xa2\xc6\x87\x9f\x7d\xc3\x51\x05\xf1\xed\x47\x0f\xd0\x50\x92\x70\x50\x11\x4f\xea\x4c\x3a\xf9\x7c\x5d\x5a\x47\xdf\x70\xc5\x10\x3c\xc3\x00\xba\xf2\x91\xce\x0c\x0b\xcf\x46\x30\xea\x60\x47\x55\xd9\x10\x1e\x01\xdf\x89\x7e\xe1\x1e\x13\x23\x71\x2e\xc9\x07\x8f\x06\x90\x11\xb1\xc6\xbc\xde\x10\x86\x0e\x86\x50\x49\x9b\x59\xd4\xc0\x8c\xc7\x50\xb5\xb5\xbd\x18\xf6\x85\x8d\xef\x54\xc1\x2c\x68\xa5\xfa\x01\xd5\xe0\x75\x2e\xc5\xf6\x6e\xad\x5f\x03\xa3\xcc\x12\xaa\xd6\xad\xc7\x2f\x80\xfc\x15\x93\x41\x0e\x05\x8b\x6b\x17\xa8\x57\x8d\x63\xe8\x14\x53\x49\x16\x26\x56\x00\xd2\xbb\x1e\xa7\x58\xda\x41\x18\x4c\x46\x22\x72\x4d\xe1\xa2\xa1\x39\x42\xed\x09\xe5\xc6\x1d\x57\xcd\x59\xe7\x07\x29\xdc\x6f\x3f\x73\x5c\x58\xe9\x90\x10\x99\x0e\x5a\x54\x0a\x29\x7a\x50\x98\x8c\xf8\x02\xf5\x52\x32\x8e\xa3\xc5\x86\x1a\xd2\x53\x6b\xf9\xf4\x23\xd3\xc9\x0d\xe9\x06\x5a\x54\x9d\x30\xf9\xe4\xdd\xbe\x7d\x76\x7b\xf5\x01\x37\xbf\x80\x70\x48\xbf\xb6\x62\x5c\xca\x41\x48\xe8\x7c\x3d\x7e\x89\x0b\xc9\xe5\xb5\x2c\x4b\x9d\x9b\xcb\x37\xf5\xc0\x91\xb1\x33\x52\x80\x4c\x5a\xc0\xd0\x2d\x80\x38\x17\xdb\x81\x92\xe6\xd2\xa5\xe4\xf1\x78\xe6\x51\xfe\x60\x25\xcc\x6c\x9c\x4d\x95\x59\x9d\xb6\xe7\x6e\x9c\x01\x09\xa4\x79\xdd\x66\x02\x89\x1d\x4b\xb5\xa6\x3d\x0f\x41\x46\xcd\x62\xd1\xb0\x6d\xf4\x02\xa8\x76\xfd\x9d\xcf\xdb\xf7\xee\xa1\x54\xbc\x8c\xb2\xfa\xef\xb0\x23\xdc\x70\x23\x69\x5f\x3a\x9f\x81\x75\x02\x57\x91\xd4\x33\x61\xa2\x32\x4e\xcd\x48\x07\xb1\x04\x84\x81\xaa\x4d\xd0\xea\x81\x8c\xbc\x3c\xe4\xac\x97\xff\x65\x90\xc1\x0b\xfe\x80\xd2\x50\xf5\x86\xad\xbc\xc4\x48\x33\x5f\xf5\x45\x8b\x49\x58\xdd\x24\x99\xcd\x8d\xf8\x64\x5a\x82\xe8\x94\xaf\x36\x8f\x7f\x8a\xaf\x00\x5d\x7c\xb6\x5d\xe5\x9d\x25\x30\x0f\xb8\x80\xcf\x98\xe4\x9d\xd1\x8b\x18\x7e\x82\x3f\xd7\xf4\x45\xc8\x94\x47\x05\x55\x39\x81\xed\xb5\x95\xce\x37\xcb\xe8\x2c\x96\x02\x47\x44\x44\x48\xe7\xc3\x8d\xce\xa9\x8b\x8e\xfe\x1a\x3e\xa5\x24\xe8\x42\x85\x9f\x1d\x88\x00\xb9\x93\x56\x20\x21\x8d\xfc\xdb\x03\x6c\x74\xc2\x82\x61\x1b\x8d\x06\x86\x61\x42\x85\x63\xf6\x54\xfc\xba\xaf\x3b\x8e\x7c\xd1\xda\x05\x3d\x40\x29\xb6\x81\x6b\xe4\x8a\xc3\x3c\x5f\xf3\x6b\x5a\x4b\x61\xb8\xb1\x94\xdd\x31\xb2\x19\x06\xd7\x42\x49\xa0\xb6\xf3\x09\x2a\xb8\xca\x34\x83\xfa\x8a\xf8\xe3\x50\xcc\xac\x82\xda\x66\xc8\xeb\x9a\x6a\x61\xe2\xb1\xe2\x1a\x1f\xc4\xcb\xe1\x27\x0e\x10\x98\x3e\xb0\x44\x5d\xaf\x45\x18\xc5\x51\x27\x72\xf5\xbe\x00\x26\xd9\xa7\xb6\x4b\xf8\x67\xc6\x8f\x92\x1c\x19\xb0\xff\x82\x0f\x79\xe1\xd8\x3e\xf5\xed\xe6\xf2\xe9\xf6\x43\xa6\x78\xde\x7c\xfa\xfe\x39\x3f\xfc\xec\xe8\x92\xea\xc0\xc0\xbd\xc6\x73\xd8\xa3\x90\x23\x05\xc0\xfb\x74\x1e\x63\x33\xe5\x42\xc5\x9d\x5d\x0b\x90\x18\x1c\xbc\x6a\x37\x00\x15\xdf\x4c\xe3\x37\xce\x58\x4d\x67\x2c\xf5\xca\x35\x43\x25\x55\xbc\xca\x1e\x3a\x6c\x46\xb1\x1c\xd4\xe6\xf9\x04\x06\xe9\x50\x01\x9a\xc5\x30\xa0\xe7\x49\x79\x26\xc9\xd5\xff\x34\x6c\xe0\xbd\x07\x00\xaa\xf9\x9d\x12\x51\x97\x07\x69\xa4\x1d\x40\xde\x73\x1a\x86\x30\x72\xbe\x4c\xec\x55\x63\x82\x66\xd1\xd4\x67\x73\xae\xdc\x12\xaa\x33\x85\xd8\x6e\x77\xfd\xf4\x96\x12\x5f\x24\x74\x5e\x37\x16\xa5\x03\x33\x82\xb8\xc3\xfc\xab\x67\x47\x39\x1f\x06\x21\x91\xc8\xa8\x96\x86\x4e\xae\x0b\xa6\xc7\x76\x42\x2a\x2d\xa3\xfb\xc3\xee\xbd\x6f\x3a\x9f\x9c\xda\x21\xfd\x81\x78\x3e\xf4\x94\xde\x5d\xf5\x48\xbe\x63\xef\xd4\xe9\x1e\xba\xc1\xc3\x64\x41\x6e\xac\xab\xde\xa8\x8a\xdd\xdd\xd5\xfe\xa5\x78\x79\xd1\xb1\x55\xe9\x82\x7a\x06\xd2\x4f\xb2\x47\x76\xce\x9d\x7f\xf2\xe8\xe3\x18\xb7\xd5\xae\x8b\x3e\x24\x9d\x13\xf1\x10\x37\x53\x79\x3e\xfe\xb7\x32\xf1\xa7\x48\xff\xd5\x8e\x19\x75\x43\xab\x1b\xbf\xe7\x51\x3e\x3c\x82\x1e\xa2\x52\xf5\x39\x5d\x1d\xbc\xe9\x49\x28\x6f\x9d\xe9\xac\x5c\x68\x9f\xbf\x19\x8c\xd1\xd9\x5c\x7e\x97\xed\xac\xad\x74\x31\xb6\x2e\x76\xbd\x2e\x73\x99\xd5\x32\x04\x18\x60\xfc\x1a\xaf\x00\xd1\x8b\xbe\x4d\x88\x40\xad\x59\xb6\xe1\xc4\x5c\x1f\x19\x1c\x18\x13\x89\xfd\x13\x9a\x54\x26\x50\x13\x65\x02\x51\xd2\xcc\x40\x6c\xbb\xdc\x46\x54\x95\x02\x20\xfc\x9f\x5f\x8a\x93\x60\x19\x27\x73\x8e\x87\x20\x7b\x82\xf5\x6e\x71\x66\x13\xc6\x30\x0f\x99\x20\x02\xcb\xf5\xa6\xf2\x88\x39\xd9\x48\x46\x6e\x6a\x29\x23\xcc\xb1\x08\x7a\xe6\xb4\x75\xe1\xeb\xf6\xf5\xe3\x64\x5a\x68\x9f\x5b\xde\x7a\xef\x96\x6b\xec\xe7\x31\xd7\x6b\x71\xf6\x0f\x6e\xe1\x18\x8b\xce\x75\x91\xd2\x12\x3c\x39\x28\xd1\x40\x45\x4a\x8b\x56\x32\xc9\x65\x58\xd1\x1b\xc5\xf9\x94\x43\x40\xc8\xe6\xbd\xa5\xed\xf7\x9d\x44\x9a\x24\xde\xa6\xa6\xdd\xb0\x2a\x72\x02\xd9\x22\x79\xef\xf7\x1a\x7d\x73\x7d\x90\x69\xee\xfc\xf4\x02\x70\xd2\x01\xb3\x81\x86\x55\xfa\xb9\x27\x2e\x0b\xe2\xf7\xfa\x82\xee\x42\xe8\x63\x8f\xf5\x78\xc0\x60\xb4\x80\xce\x54\x51\xa6\x11\xcc\xc3\x0f\x0d\x7d\x2e\x3b\xec\x7f\x59\xf8\x65\xdf\x2f\xfb\x5e\xec\x41\x66\xed\x11\x7f\x30\x90\x2f\x50\xf2\x0b\xdb\xa5\xf0\x7c\xa3\x60\x4a\x2e\x45\x5b\x03\x0f\x52\xaf\x93\x4b\xd7\xc3\x23\x5e\x7a\x00\x9d\x9e\x6a\xb3\x5c\x56\x55\xde\x45\x93\x1f\xe9\x38\x9f\x89\xcc\x39\xaf\x3f\xae\xb5\x4e\xb1\x0b\xff\xef\xc1\xc9\x27\x8f\x56\x3c\xd4\xfc\x7f\x0f\x4e\xc9\xdb\x82\x11\x84\x3d\xcd\x48\xc2\x1f\xcd\x42\x59\x1f\x48\xbc\x3b\x90\x93\xa7\x25\x6a\x3e\xb0\x8d\x71\xd5\x19\x0a\x85\x8d\xf4\x3c\x9b\xc8\xf2\xd7\x7c\x7c\xfa\x43\xd0\xd0\xc9\xf7\xeb\x66\x55\x00\x3d\xe8\xc8\xfc\x01\x0f\x12\x72\x63\xad\x82\x74\xfb\x0c\xf3\x6d\x2f\xb4\x4f\x7e\x19\x62\xea\x47\x21\xe2\x2c\x93\x3c\x05\x5a\xae\x88\x2a\x16\x91\x9b\x40\x74\x32\xc7\x7c\x80\x62\xb9\x59\x32\x84\x7c\xe4\xa5\x6b\x7b\x3d\x91\xd7\x6e\x57\xf6\x0a\xc3\xc3\x64\xc7\x80\xd6\x30\x2b\xca\x5a\xbd\xdb\x37\x5b\x60\x29\x46\x27\x29\x93\x62\xe8\x14\x5e\x0a\xb0\x90\xd4\xae\x9a\x04\x65\x58\x30\xb6\x98\x5d\x5c\x95\x00\xaa\x1a\x37\xa1\x3c\x20\x5d\x6d\x55\xf1\xbe\x6e\xcf\xcf\x58\x7a\xbd\xd4\xef\x98\x3c\x94\xb0\x96\x5c\xb7\xc6\xf1\x4f\x48\x1e\x49\x6f\x85\x83\xc7\xd0\x75\xee\x32\xad\x1b\x3c\xe4\x13\xf5\xdc\x78\xe7\xe9\x6d\x27\xf2\xd2\xa7\x8a\x62\x33\x72\x0a\x56\x8f\x94\xe7\x9e\xd1\x49\xb1\x4a\x89\x83\xec\x03\x83\xb5\xcb\x01\x25\xac\x76\x90\xd1\xf5\x2f\xd5\x12\x48\x30\x44\x4c\x3c\x9f\xc7\x01\x9e\x0e\x72\x14\xf1\x42\x08\x93\x0a\x36\xda\xdf\xe2\x12\x31\xd3\x81\xcc\xcf\x97\x9c\x6d\xdc\xee\x7c\xc9\xd9\xc6\xcc\xc1\x97\x9c\x6d\x60\x75\x43\x8c\xf0\x42\x1a\xa9\xc7\x91\xaf\xf9\x2a\x1e\x0c\xdc\xd5\xd3\x0f\x93\xdc\x35\x9e\x01\x30\xbf\xea\x63\x66\x8f\xe9\x26\x36\x56\x99\x8e\x68\xce\xd1\x81\x24\x3f\x47\x31\xf2\xe5\x72\x74\xa9\xf8\x88\xcb\x3b\x97\x4d\x32\xae\x90\x64\xe2\x86\xce\x78\xcb\x61\x90\x7b\x4e\x09\x0d\xe1\xb8\xdf\x6c\xdf\xfa\x3c\xc5\xfc\x23\x02\x67\x7c\xf1\x32\xa9\xe8\x8a\x21\x43\xd4\x25\x5f\xe3\x5d\xf2\xf7\x9a\x7d\x46\x1f\xa3\xa5\x65\x1b\xe4\xd5\x87\x1c\x6a\xd2\xbc\x6b\x35\x03\x63\x3f\xc9\xd1\x99\x24\xb6\xa8\x7d\xe7\xc6\xd6\xda\x0a\xe9\xd9\xdc\xe3\xb0\x17\x83\x23\x1f\x41\x70\x24\xa8\x59\x52\xfd\x01\xf0\x66\x62\xe8\x1c\xbf\xf1\xd0\xed\x93\xfd\xf4\x2e\xbd\xfa\x82\x96\x76\x7a\x51\x35\x10\xa4\xab\x52\x5a\xa0\x09\x42\x07\xd2\x40\x2c\x82\xc4\x81\x24\x2a\xe5\xd9\x40\xb0\xce\xb4\xcf\x5d\x62\x64\xeb\x7c\x7f\xd2\x77\x39\x8e\x82\x6e\xe7\x1c\x8f\x94\x7c\x62\xcf\xdc\xb1\x9c\x77\xf6\x8e\x67\xf2\x09\x4c\x23\x0e\x15\x76\xd8\xb1\x9c\x11\xab\x9d\x32\xf9\xc6\x19\x7b\x33\xa2\xfb\xb3\xb2\xeb\x47\x19\xf2\x33\xd2\x67\xd7\x9c\xe9\x19\xf1\x7b\x56\xce\xf4\x8c\xe8\x3a\x0e\xed\x71\xf8\x90\xcc\x93\xce\x1f\xcd\x63\x54\xbc\x1d\x26\x19\x93\xfc\xed\xd9\x47\x7c\xae\x9d\xe6\xa1\x73\x8a\x9d\x50\x12\xa7\x79\xfe\x1e\xf3\x6e\x70\x7d\xb6\xee\xf2\xcc\x9c\xf3\xdc\xb8\x68\xb2\x9f\xf4\x31\x8e\x9c\xac\xa4\x51\x3b\x26\x73\x58\xd9\x34\xce\xc6\xae\x26\xe0\x38\x87\xbc\xa9\x53\xee\xf7\x14\x0e\x91\xfb\x22\xca\xc0\xc5\x42\x79\x97\xd2\x8b\x56\xf6\x79\x86\x79\xce\x76\xc2\x6f\x18\xe6\x67\x4b\x8b\xb2\x5d\xac\x9b\x58\x36\xb0\x5f\x62\x55\xe9\x6b\xa5\x50\xdb\xbe\xfd\x55\xe7\xa3\x3f\xa9\xdf\x0a\x1f\x8f\x8a\xf3\x41\xe0\xaf\x61\xdb\x22\xc6\xd6\xb1\xec\xca\x19\x74\x71\x45\xe6\xf8\xa5\xa8\xb5\xd6\xde\x78\x24\xf2\xfe\xa4\x1a\x52\xcb\x17\xb6\xde\xbd\xe6\xab\x67\x9d\x08\x27\x2c\xdf\x2e\xa4\x90\xa4\x05\x3a\x65\xe1\x2c\x72\xf2\x89\xc4\x18\x05\x9e\x2f\x69\xfc\x46\x8a\x75\xe8\x82\x99\x31\x02\xf1\x80\x58\x75\x5e\x51\xd6\x95\xbc\xc7\x6f\x13\x79\xcd\xd5\x21\xbf\x3c\xd5\xf8\x1a\x7f\x3b\x88\x9e\xdb\x87\x0e\xc8\x6c\x15\xa3\x18\x42\x7a\x96\x04\x57\xe7\xcc\x06\x98\x01\xd2\x8f\x0a\x0d\xfc\x28\xb9\xc7\x90\xbd\xae\x09\x73\x7c\xfc\xae\x51\x77\x79\xb5\x89\x89\xd7\xb4\x0c\xf8\x60\xa4\xbc\x9b\x8a\x07\x76\x27\x2a\xd3\x85\xb9\x59\x78\x43\xa1\xfe\x54\xd1\x18\x86\x19\xaf\x71\xd1\x4e\x88\x3a\x6e\x58\x1d\x17\xe2\x04\xa4\xb4\x2c\xb4\x90\x24\x75\xd6\xca\x18\x83\xdb\x0f\xa2\xd1\xb5\x59\x43\x6f\x34\xeb\x8c\xac\x16\x59\x7c\xa8\x3d\xe3\xbc\xbe\xe0\x61\xbf\x6a\x09\x1d\x3c\x4d\x9b\xde\xe6\x2f\x29\x2f\xaf\x17\x85\xa6\xd7\xda\x3c\x8e\x1f\x5a\xeb\x4e\x25\x2e\x89\xbe\xe4\xc1\x5a\x45\xa7\x8e\x64\xc7\x82\x8d\xf8\x29\x2f\xbb\xe3\x87\x13\x2c\x41\x77\x95\xb1\x91\xa0\x09\xff\x33\xcc\x8d\xed\x54\x0f\x8e\x24\x0e\x4f\x77\x80\x69\x43\x8d\x59\x10\x26\x6f\x43\x15\x24\xbd\x1a\x72\xe3\x0c\x28\x0d\xb9\x6a\x6e\x21\x3a\x89\x94\xec\xed\x43\x2b\xc1\x7e\x4e\x72\xce\xf8\x69\x00\x4b\xcf\x04\x28\x15\xcc\x66\x04\x51\xce\x7c\x56\x12\xb5\x12\x19\xe2\xcc\x1c\x9e\xc7\x24\x32\x24\x96\xc3\xe1\x44\x92\xad\xb4\x29\x24\xde\x8e\x53\x08\xb6\xce\x6e\x05\xa6\x3d\xbf\xf4\x0a\xd9\x55\x71\x84\x7b\x1e\x89\xb6\x4b\x3b\x11\x8e\x3b\x5e\xcf\x82\x22\x38\xfe\xd5\xee\x51\xcf\x16\x7e\xd5\x64\x6d\x8b\x9f\x6a\x7f\x93\x93\xc2\x72\xc4\x86\xee\x0a\xd1\x38\x79\xf4\xf7\x9d\x43\x10\x2a\xf8\x23\x30\x49\x6b\x75\xbc\x42\x31\xda\x81\xec\xc9\x09\xa0\xe6\x59\x49\xa7\x44\x7f\xa2\xe3\xf6\x28\x2f\xca\x4c\xc1\x3b\x2f\xff\xdb\xbf\x1f\xec\xd5\x5e\x7a\xf1\xe5\x5f\xc1\x3f\x07\x94\x3e\x14\xa9\xbc\x32\x55\x4c\xd6\xf6\x42\x67\x10\x7c\x9f\x9d\x95\x08\x00\xfe\x3d\xa0\x68\x13\xc0\x06\x66\x7b\x6c\x51\xa3\x56\xed\x94\x7f\xd8\x60\x07\xb6\x53\x6e\x2b\x41\xfe\x19\xe5\x66\x76\x96\xd8\x41\xba\xba\x75\xfa\xfb\xce\xdd\x56\x30\x9b\x50\x31\xba\xc5\xab\x0e\x95\xad\x3a\x14\x95\xb0\x9a\x8d\x5a\x53\x55\x84\xa6\xfd\xfe\xfd\xf6\xe9\x8f\xa1\x70\x06\x28\x85\x17\x9e\xfc\xf8\x91\x5c\x89\x20\x72\x00\xea\xa3\x8c\xfe\x6f\x6c\xac\x2c\x8a\x52\x2a\xa9\x7a\x5b\xb4\xd1\xa1\x6a\x51\xde\x12\x8e\xbc\x04\xe0\xe5\x64\x63\x57\xf4\x9a\xf0\xbb\x63\xd5\x2d\x9e\x67\xce\xb3\x3b\x2b\x16\x53\x9e\xb8\x47\x0d\xf5\xc1\x5a\xdd\x58\x30\x2d\x46\x7f\xcc\x8d\xb5\xa9\xd8\x5f\xba\xd4\xf4\x35\xc7\x91\x2f\xb9\xca\x18\xe1\xfe\xc2\x4b\x4d\x06\x52\xd9\xa1\x2a\xe9\xc7\x7f\xc5\xe9\xdc\x12\xe2\xca\x49\xb1\xa5\xca\x5b\xa9\x22\x03\x68\xe2\xd4\xdd\x98\x27\x3b\xea\xb3\x90\x99\x0c\x73\x8a\xd0\x6e\xa5\x71\x31\x53\x79\x4d\xf6\xbd\x3d\xbd\xb4\xd2\xbe\xb5\x92\x84\xec\xc5\xa3\x46\xbd\x60\x56\x30\x35\xd5\x72\x2a\x1f\xd0\xbe\x02\x95\x75\x5f\x49\x7a\xa4\x00\xd2\x5e\xb5\xbd\x84\xae\x88\x5e\x34\xb6\xc9\xe5\x17\xf9\x46\x53\x01\x54\xe1\xd6\x84\xa8\x50\x1c\x00\xd2\xb8\x63\xe3\x82\x20\x98\xf3\xd2\x15\x08\xf5\x8b\x0d\x06\x22\x37\x0d\x4d\x53\x6a\x62\xa3\x16\x1d\x92\xfb\x85\xe6\xe2\x79\x2b\x62\x10\xbb\x3f\x01\xcc\x7e\x15\x04\x2a\xe9\xac\xe9\x0d\x28\x97\xc2\x8e\x06\xdd\x2c\x1b\x25\x51\xa2\x0c\x4a\x7f\x41\x7b\xa3\xc3\x54\xa1\x18\x23\xc9\xb0\x74\x64\xaf\x53\x75\xd6\x46\xee\xd2\x17\xd8\x7b\x14\x58\x0b\xdb\x06\xa4\xf7\x9c\xb9\x60\x20\x55\xd5\x9e\xb2\x25\x91\x62\x7c\xc7\x29\x6c\x2e\x2a\xa7\x5e\x05\xc7\xe9\x8d\x6f\x3a\x17\x2f\x0b\x1e\xbb\x8c\x45\xc9\xbc\x78\x85\x95\x2f\xf5\x37\x36\x11\xd1\x65\x3c\x1e\x17\xe3\x34\xb9\xd7\x3f\x50\x14\xb5\x7d\xee\x52\xfb\xd1\xe5\x98\xaa\x34\xaa\xa8\x65\x41\x4b\xa7\xac\x26\xaf\xd9\xd6\x63\x6b\x45\x28\xc0\x6e\x37\x2b\x8c\x65\x0d\xdb\x0d\x88\xc5\x7c\x72\xad\x62\x34\xf4\x92\xae\x8c\x31\x0a\x21\x93\x93\x68\x1f\x5b\xe8\x0d\xc4\x47\x0b\xf2\x8c\xf9\xc5\xf4\x6f\x10\x98\x07\xb1\x94\xb7\xe1\xd4\x86\xbb\xe9\x49\xa9\xe8\xe8\x35\x74\x84\xbd\x8f\xe7\xe9\x63\xa8\xc1\x1c\x08\xbf\x55\xcc\xbc\x59\xa9\x79\xca\x6c\x02\x97\x18\x8c\xab\x40\x5c\x52\xd1\x48\x55\xf4\x59\xa0\x44\xa5\xa8\xb0\x78\x0b\x2f\x93\xb7\x21\xda\xd1\x53\xb4\x52\x2d\xe8\x86\x0e\x1d\x19\x1e\x1f\x3d\x74\x70\xe8\xd0\xa4\x76\x64\x60\x7c\x78\xe0\x95\x91\x21\x0d\xdb\x94\xaa\x42\x06\x29\x8c\x1a\x4a\x40\x5f\xfc\x5a\x76\x6c\x24\x87\x3f\xa1\xda\x7b\x32\x68\xc5\xde\x73\xfb\x0b\xaa\xe4\x1d\x36\x15\x8b\x7b\x59\x0b\x74\xd9\xb2\x9d\xbe\x5a\xa5\x19\x68\xfa\x35\x67\x95\x4b\xf1\xcf\x15\xb1\x11\x59\x5d\xaf\x4c\xcf\xcd\x4c\xed\xe9\xff\x55\x78\x93\x31\xff\x3b\xff\xb3\x0f\x8a\xfc\xa1\xa6\xb6\xaf\x51\xa9\xed\x13\xbe\xdc\xe9\xa2\x55\x9d\x35\xe7\x94\xbd\xc5\xbc\x70\x1a\xda\xd4\x1e\xe8\x8c\xd3\x6b\xcd\x42\x99\xd1\x39\x7b\x6a\x4f\x24\x4d\x7e\xae\x73\x8e\x5f\xea\x11\xb3\xda\x7c\x6b\xdf\x41\xbd\x48\x7f\x4a\x83\x78\xba\xb5\x63\x8f\x7a\xcf\x24\x6b\x50\x9f\xd1\x86\x2e\x0a\x36\x76\x93\xab\xb3\xfd\x89\xc5\x86\xa4\x76\x7a\xbf\x66\x20\xac\x63\xb6\x26\xaa\x34\xb3\xc1\x8c\x34\xe3\x4c\xed\x79\x7b\x6a\xca\x3b\xd4\x14\x0c\x36\x25\x0f\xc7\xfe\x78\xc7\xe9\x4a\x28\x46\x1c\xb3\x8e\x19\xf5\x89\x79\xa3\x5c\x4e\x39\xaf\x44\xc3\xc1\xfc\x1a\x9e\x15\x89\x00\x9a\x64\x75\xe3\x98\x73\x57\x56\x29\xd0\x4c\x81\xa7\xa7\xfc\x73\xc5\xc2\x56\xac\x9b\xad\x45\x05\xe5\x9c\xd1\x4b\x33\xce\x47\xdb\x2c\x2f\x30\x4d\x5a\x2d\x4d\x92\xef\xab\xc4\x83\xf0\x35\xe3\xe3\x4c\xe1\x48\x69\x96\x27\xcd\x6c\xfc\xe3\x88\x19\xa5\x86\x95\x4c\x66\x66\x81\xed\xc8\x51\x2d\xf9\xe1\xb1\xf3\x4b\x9d\x78\x73\xfe\x73\xd9\x73\x5c\xf6\xf0\x4d\x4e\x97\x17\xa7\x51\x28\x99\x35\x1c\xc3\x37\x4f\x86\x11\x05\x9e\xec\x1a\x93\x4a\xea\xb0\x63\xc9\xe0\x2a\x32\x60\x56\xdb\x8f\x3f\xd9\xba\xe3\x31\x74\xbb\x83\x71\x33\x49\x58\xf7\xdf\x48\x6c\x5f\x9b\x9c\x1c\x83\xd4\xc7\xb7\x16\x45\xdf\x26\xe8\x3c\x24\x70\x55\x60\x07\x8f\x38\x79\x39\x2e\x32\x08\x8b\x17\xb7\x5c\xbe\x83\x37\x7a\xde\xaf\x31\x25\x52\xbb\xe1\x55\xce\x86\xd2\x4f\xd2\xa9\xdc\xcd\x54\x77\xde\xa7\x9c\x12\x3b\x46\xdc\x12\xf7\x52\xa2\x01\x51\x65\x41\x41\x6b\xa1\x80\xcd\xa9\x96\xd4\x71\xcb\x87\xda\x69\x3f\x72\xca\x99\x7b\xdd\xc8\x92\x8d\x6b\x87\x3d\xc8\xc9\x73\x7d\x25\x44\x9f\x9d\xf7\x58\xa2\xea\xf3\xe4\x3d\x46\xda\xfc\xac\x9c\xc7\x5e\xf6\x4d\xe0\x83\xf1\x93\xa0\x5b\xdf\x71\x56\x2a\xec\x96\xef\x78\x77\x09\xf4\x93\x77\x1d\xe7\x41\xae\x7f\x40\xcf\x71\x76\xb2\xed\x80\xe3\x38\x3f\x64\x76\xc6\x6f\x9c\x01\xbf\x05\xb7\x98\x07\x5b\x8d\x23\xba\x88\x45\x39\xa6\xdb\xbc\x38\x7e\x43\x19\x87\x2f\x19\x67\xbd\x2f\x43\xf3\x02\x5e\xb6\x53\xce\x66\x8b\x33\xfd\xa3\x4b\x82\xb3\x7b\x68\x56\x07\x50\xee\xc0\xe1\xe1\xfd\x3d\xfd\xaa\x12\xa2\xd8\xa6\x73\x1d\xb3\xff\xd7\x03\x9e\x08\x4f\x3d\xf2\x00\x03\x87\x1c\x8d\xc0\xf2\x67\x9d\x8e\x33\x6c\x56\x5b\x57\xee\x6f\x7d\x78\xd5\xeb\x4b\x11\x08\x45\x4c\x09\xf5\x1a\x6a\xa2\x85\x37\x8f\x98\x62\x00\xeb\x54\x85\x06\x6a\xe6\x03\x5a\x51\xc3\x47\x8d\x5a\x14\x25\x72\xdc\xa2\xac\x66\xd9\x50\x92\x2e\xa4\xa0\x6a\xa0\x85\x5a\x72\xc4\xa2\x09\xe2\xa0\xc6\x09\xd2\x2f\xba\xe4\xa8\x7d\x86\xe9\x69\x23\x03\x4d\x82\x4b\x83\x37\x3a\x88\x6d\x65\x14\xd2\xcf\x20\x1d\x69\x52\xa1\x95\xb2\xe5\x42\xfe\xec\x13\x5a\x61\x29\x51\x03\xa5\xa8\x18\xf0\x34\x68\x8a\xce\x15\x91\x6d\x94\x08\xeb\x52\x68\xde\x21\xed\xf2\x44\x38\x87\xe5\x1d\xba\x67\x17\xc5\x0a\x24\xc1\x39\x35\xc2\xe1\x29\x89\x49\x5a\x83\x44\x27\x1d\xa6\x46\x3a\xba\x3f\x08\xc7\x5a\x19\x11\x95\x44\x30\xa7\x09\x7f\xf2\x34\xbf\x4d\x28\x92\xb3\x61\x4e\x67\x72\x0c\xfe\x91\x91\x52\xbb\x38\x0b\xa7\x2b\x23\xca\x4f\x57\xd2\xa9\x6b\x92\x0b\x01\xea\x38\x82\xd3\x70\x31\x02\x4e\x84\x0f\x59\xfe\x12\x20\x24\xec\x7d\x3b\x83\x90\xa1\xd2\xbc\x72\xe0\x4f\x8f\x9a\x95\xf7\xca\x2a\x11\xcf\x99\x3d\x77\x74\x12\xd0\x7c\x0a\xaf\x2e\x4e\x40\x0b\x5c\x6e\x93\xc8\x32\xb2\x45\x88\x6e\xd5\xb7\xc5\x0d\x76\xbd\x73\xe3\x93\xad\xef\xae\xe7\x2a\xc3\x82\x48\x52\xad\x8c\x58\x5d\xc4\x87\xa3\x97\xea\x69\x31\x4d\x8c\xe6\xce\x9d\x0f\x3b\x48\xdb\x98\x1e\x7c\x61\x6d\xf5\x52\xa0\x93\x04\x03\xff\x25\xc2\x3d\x97\x93\xa4\x8f\x29\x8a\x9e\xa6\x5f\x63\xff\x70\x5d\x60\xbe\xf3\xc8\x26\xc3\x2f\x2c\xa9\x35\x16\xc7\xc8\xca\xaa\x3b\x80\xab\x55\x3f\xa6\xd7\x11\x5d\x10\xa4\x11\x97\x1f\x21\x19\x5b\xeb\xdb\x3f\x5e\x7f\xba\xd4\xea\xfe\x92\x33\x47\x5d\x2f\x50\xf8\x16\xad\x92\xfa\xe6\x95\x14\x08\xf4\x1c\x51\x45\x4a\xc1\xef\xa2\x8a\xe8\x3a\x5d\x7b\x13\xcd\x20\xc9\xd8\x92\x77\x80\x9d\x48\x95\x0a\x76\x50\x8d\xaf\x2c\xe3\xf5\x10\x40\xc8\xf1\xdf\x70\xbf\xf3\x90\xba\x14\x48\x26\x22\x33\x0f\x7f\xd6\xc0\x9d\xc9\xc3\x8e\x29\x7e\x90\xf1\xc9\xab\xec\x5a\x37\xa6\x37\xe6\x93\x36\x7b\xf5\xbe\x23\x02\x1d\xfd\xce\xe8\xdb\x4e\xdf\x11\x61\x67\xc8\x72\x92\x26\x99\x1b\xf6\xdf\x83\xe5\x8f\xf2\x19\xf0\xbb\x68\x06\x2e\x48\x82\x02\x8c\x4e\x64\x5d\x78\x79\x1f\x72\xa2\x8a\x05\xf8\xef\x9c\x6a\x4e\xcd\xd6\x6e\x68\x94\x8c\x03\xc0\x3b\x09\xc5\x16\xa9\xfc\x41\xe4\x96\xc3\xf2\xa8\x77\xb1\x9e\x25\xa3\xd9\x67\xbc\xa8\x01\x2c\x30\xbf\x43\xe7\xcd\x9d\x9c\x17\x45\x94\x2a\x51\x12\x02\x57\x23\x50\x0c\x44\x97\x86\xc6\xdb\x06\x43\x4e\x77\x83\xd6\x54\x00\x93\x5a\x12\x1b\xd4\xc7\xd6\x49\xcf\x8e\xbe\x62\x47\x41\xc7\xd2\x66\xd0\x8b\x13\x86\x18\x1f\x1b\x14\xb6\x6d\x25\x91\xe0\x19\xaf\x0b\x79\xbd\x7d\xf2\xd3\xce\x27\x57\xdb\x67\x2e\x75\xbf\x78\x4c\xd2\xd9\xf3\x3a\x6a\xe3\xff\x77\x62\xf4\x90\x02\x07\xf8\x89\xec\xda\x7f\x15\x12\xef\x73\xd8\x87\x5d\x6e\x3c\xe8\x71\xe9\x1e\x1f\xd8\x3e\x1e\x09\x1c\x75\x00\x50\x87\x77\xde\xd1\xf2\x83\x7c\x57\x5e\xe0\x93\x6f\xdb\xcd\xd4\x48\x46\xa1\x58\x63\xeb\x95\x70\xb1\xb6\x6f\x7d\xde\xf9\xeb\xf9\x27\xf7\xee\x74\xb5\x46\x62\x40\x5e\x24\x56\x49\x0c\xa9\x80\x6b\x6e\x43\x1b\x75\x68\x91\x9b\xc2\xaa\x4c\x39\x3e\xdd\xb2\x65\xad\x6e\x09\xfb\x3c\x44\x0f\x02\x0f\x40\xa4\x3a\xb6\xb0\xa6\xe3\xb2\xa7\x4b\x21\x10\x36\x42\x7e\x20\x5d\xe9\x0b\xb2\xc5\xa8\x47\x68\x32\x24\x56\xce\xbb\x92\x17\xf6\xb8\x24\x64\xdf\xbf\x29\x9a\xb5\xa1\x7f\x83\xbc\xf1\xdd\x6d\x32\x88\xdf\x0c\x9a\xec\xe3\xb5\xea\x04\xb6\xfb\xed\xdb\x8c\xe1\x1e\xf3\x32\x7a\xf9\x99\xcf\x05\xc6\xc2\xf2\x13\x67\xed\x49\x8b\x46\x9a\xb1\x71\x5d\x13\x19\x78\xb0\xe4\x3b\xa1\xb4\x7c\xc1\x45\xa9\xf5\x79\xba\xb5\x4c\x8d\x5c\x7a\xa6\xcb\x01\xcb\x18\x8e\x9b\x65\x18\xce\xa3\xfe\xe4\x96\x8d\x52\x22\x48\xcf\x78\xca\x3f\xb1\x5b\x1b\x36\xc6\xee\xfe\xbc\xad\x1b\x55\xbd\xb2\x83\xc6\x7b\x2c\xbb\x0e\x0e\x4b\x86\x6f\x8e\x26\x7c\x2e\x7f\x51\x51\x4f\xc3\x80\x42\x32\x9f\xd9\x6c\x2d\xe3\xa2\xe6\x70\x4a\x4b\xb8\x38\xea\x30\x68\xc2\x5e\xee\xeb\x4a\x98\x42\x41\xec\xf2\x82\x53\xb1\x2d\x5e\x3a\xf1\x4c\x4b\x3a\xf9\xbe\xb9\x9f\xab\xf0\x69\xd4\x4d\x03\x71\xb1\x1b\x8c\x5d\x32\x5d\xb1\xfd\x40\xba\x3d\x6c\x6c\x7d\x41\x16\xe1\x5d\x42\xc3\xac\x97\x9d\xdb\x13\xc9\xb7\x6e\xd2\xdd\xe0\x20\x4c\xe9\xd7\xd3\x98\xb5\x37\xdd\x58\xac\x19\xc9\xed\xef\xeb\x21\x2f\x63\xe7\xf4\xef\x44\xa1\xf5\xdc\xe4\x1f\xb9\x57\x7d\x66\x8e\x44\x1d\xf9\xa3\xfa\x8d\x04\xdc\xb2\x69\xdc\x9c\x49\x0c\xac\x2e\xda\x3b\xc3\x17\xd9\x66\x90\x94\x47\xa0\x75\x3e\xde\x22\xad\xee\xbc\xee\xf7\x90\x83\x45\x3b\xfd\xd6\xe3\xfc\xdc\xef\x7f\x34\x6b\x35\x1f\x53\xa4\x67\x03\x80\xa2\x75\xab\xe8\x87\xda\x8f\x21\x63\x98\xaa\x2c\x41\x93\x18\xea\xd9\xa3\xdb\x14\xcb\x5b\x9f\xc3\x7c\x6c\x0a\x7a\x1a\xb3\x6c\xac\x16\xde\xc3\xf8\xa4\x21\xff\x09\x07\x05\xbb\xbd\x43\xc0\x3e\x7b\xb9\x61\xcc\x19\xf5\x3e\x4d\x7b\x15\x6e\xbd\x16\x04\xb4\x2e\x56\x1b\xfa\x5b\x6c\x1b\x96\x6b\xbd\xd8\xbd\xf9\x77\xc5\x59\x91\x54\xe0\x72\x5c\x61\xfe\x77\xea\xe8\x25\x3e\x61\xc5\x04\x18\x1d\x64\x74\xe0\x78\x7e\x70\x11\x32\x48\x45\x9c\x59\xe7\xde\x35\x91\xa4\x2e\xdb\x30\xdc\xa8\x26\x38\x38\x97\x5a\x1e\x18\x1b\x9d\x8b\xdf\x61\x16\xea\x85\xf6\xe3\xf7\xd8\xf1\x1a\xf2\xd2\xd2\x32\x42\x3d\x85\x8e\x9b\x95\xce\xad\x95\xce\xa5\xf7\xf1\x82\x86\x5d\xb8\xc1\x1d\x76\x03\x1f\xbe\x49\x1d\x45\x54\xd3\xc6\x22\x76\xbc\x67\xd0\xe5\xa4\x1d\x99\x90\x0c\x11\xba\x1f\xa7\x58\xa4\xc0\xea\xd7\x0e\x59\xd4\x8c\x07\x9b\xab\xc4\x96\xb4\x70\x60\x7a\x8a\x23\xa0\x26\x04\x61\x5a\x37\x57\x70\xc2\x2b\x22\xbe\x37\x41\x77\x20\x8e\x06\xa8\x16\x25\x48\x03\xd1\x8e\xe9\xb4\x9b\x11\x15\xc6\x38\x45\xed\xf7\xd6\x0c\x5e\x08\xd9\xa3\x98\xdd\xdf\x03\x3b\x1d\x0a\xd7\xdb\xaa\xf6\x45\x12\xa2\x4f\x3f\xfd\x6b\xfb\xfc\x99\xce\x27\x57\xd1\xf6\xc5\xb6\xd2\x25\x1f\x2c\xd8\x42\x7f\x5b\x7e\x72\xff\x84\x08\xec\xc2\x50\xaf\x47\xef\x85\x29\xc6\xdc\xc0\x87\xc1\x5d\x37\xd1\xbe\x2f\x47\x33\xc7\x4e\x32\xd6\x9b\xe1\x60\x1d\x23\x54\xa8\x58\x87\x8d\xd5\x3a\x50\x43\xa3\xba\x19\x4c\x43\xc3\xa8\x18\x46\x49\x48\x3b\x31\xaa\xa5\x9a\xc5\x76\xa3\x72\xb8\xc7\x28\x61\xbe\x45\xd1\x0c\xbe\x0a\xf6\x12\xe2\x40\x36\xe9\x4f\x85\x49\xf0\xa4\x27\x20\x13\x44\xd3\x06\x3c\xe6\x98\xab\x3d\xd5\x3e\x54\x21\xdd\x6f\xd5\xc8\xb6\x27\x9b\xff\x29\x2e\x5f\x27\x23\xbb\x35\x0b\x85\xa9\xf7\x2d\xe8\xe5\xa6\xc1\xe4\x90\x59\xb7\xa7\xaa\xdc\x56\x54\xc4\xd6\xdf\x28\x96\x9c\xab\x6c\xd5\xd0\xeb\x4c\xaf\x83\xb5\x7c\xa3\x52\x9e\xa8\x32\x09\x6b\x34\xd8\x7a\xa6\x96\xab\x1b\x54\x43\x7a\x5f\x7b\xe9\x06\xf8\x92\xd8\x73\x70\x31\x17\xd6\x78\x60\xde\x65\xb9\xf2\xc0\x93\xfb\x27\x81\x99\xfc\xa1\x88\x74\x5e\x61\xde\xfc\x39\x61\xbd\xf3\xb9\x22\x6f\xc5\x2a\xa9\xc1\xc9\x24\xa6\xa5\xed\x21\x66\x06\x22\x64\x9a\x71\x0c\x7e\xae\x0e\x20\x90\xb3\x0d\xb1\xd0\xda\xff\x99\x6a\xbe\xf8\xe2\x2f\x0d\x0d\x17\xbc\x17\x0f\x14\xb3\x81\x91\xa2\x58\xe9\x75\x92\x69\x69\xef\xbc\x13\x11\x4d\xec\x68\x17\x7c\x01\x1d\x80\xb0\x90\xb0\x89\x7f\x14\x7c\xed\x4c\x68\x35\x62\x2a\x24\xff\x9d\x81\x35\x47\x6c\xa9\xe5\xaf\x34\xcd\xb1\xba\x55\x33\xea\x8d\x45\xdf\x74\x67\x2c\xab\x6c\xe8\xca\x76\x7d\xc1\x17\x45\x4f\x2d\x28\x9b\x81\xf3\x48\x86\x7b\x17\x28\x8a\xbd\x67\xb3\x6b\x4b\x75\xce\x4e\x87\x2a\x37\x0e\xdd\x16\xc9\x30\xa1\x1b\x67\xa7\x30\xaf\x36\x2b\x33\x46\x3d\xc8\x39\xe2\xf1\x58\x0e\x0a\x4e\x88\x9d\xf6\x29\xa8\x2e\x38\xc6\x3b\x60\x02\xce\x79\x75\x60\x78\x64\x68\xbf\xca\xb6\x85\x15\x56\x14\x2f\x0e\x0d\x4c\x1e\x1e\x1f\xd2\x5e\x1d\x19\x38\xa0\xee\xb9\x15\xc8\xd4\x21\xeb\x1d\xba\x79\x14\x70\xb1\xc2\x8c\x46\xdd\x5f\x44\xb4\x40\xdd\xa2\xf2\x32\x10\xb1\xa9\x54\x33\x9c\x90\x9a\xf6\x43\xaa\xa1\x7c\xc1\x9b\x3e\xb4\x26\x17\x56\x8e\xaa\xe0\x22\x88\xa6\x52\x57\x38\x8a\xb3\x46\xa3\x38\xef\xb9\xa8\xd8\xc9\xa2\x47\xc3\xba\x59\xa1\xd9\xb0\xfd\xfe\x7d\xac\xfd\xe4\x47\x24\x51\x98\xa8\x1f\x2b\x0a\xab\x49\x88\x92\xb7\x3b\x50\xfe\xc8\x18\x0b\x4c\x71\xb7\x13\xde\x3e\x19\x1a\x57\xf8\x69\x9f\x14\x99\xe8\x9b\xa5\x1f\x1b\xc6\x52\x05\x4a\x68\x03\xcd\x0e\x99\x8b\x62\x4b\xc6\xd9\xc7\x49\x8b\x97\x59\xe3\x35\x2e\x13\xd0\x8f\x18\x4e\x0d\x43\x73\x53\x96\x7c\x6d\x7d\xf2\xa7\x34\xc4\xa3\x25\xa2\xb3\xdb\xd5\x66\x07\x28\x8c\x06\xb4\x3a\xb5\x1f\x70\x59\x30\x82\x01\xd7\xb8\xf7\xe1\x78\x58\x77\x9a\xa4\x54\x4a\x85\x5d\x02\xb4\xdc\x4a\x6a\x79\x63\x80\x21\x46\x21\x3c\x88\x51\x43\x5d\x73\xa1\x0a\x8a\xbf\xad\x35\x4a\xe3\x9d\x66\x48\x8a\x3d\xec\x4b\x17\x9e\xe6\x6f\x2b\x96\x1c\xad\x04\xd1\x68\x1c\x43\x76\x9e\xd0\x05\x58\x83\x32\x03\xb4\x0c\xbc\x25\xe2\xb4\xa8\xbf\x15\xe5\x7f\xf4\x3d\xec\xb8\x23\x09\x9c\xd4\x73\x39\xfc\x74\x49\x88\x9b\xb8\x65\xf4\x42\x4b\x34\x5e\x65\x0d\xbc\xb3\x46\x68\xe3\x62\xf5\x1d\x3c\x78\x0b\x88\x43\x90\x69\x14\xde\x0a\x58\x17\xc8\xc1\xeb\x7b\x3e\xe6\x94\x64\xe8\xf2\x68\x83\x78\xef\x35\xaf\x81\xe8\x86\x1a\x64\xa5\x1d\x55\x33\x24\x97\x4e\xf4\x22\xd2\x33\x7c\xed\xdc\xba\x85\xa9\x86\xe5\xa9\xd2\x10\x5a\x45\x1f\x5f\x2d\xeb\xd0\xe5\x80\x97\xe5\x2e\xa9\x2b\xdc\xf9\xd5\xa3\x20\x0c\xb8\x9f\x61\xbc\x7d\xfb\xcc\xa5\x40\xf7\x6c\x95\x4e\xa7\x42\x88\x12\xbd\xbb\xc5\x87\x02\xac\xd3\xe3\xa3\x8e\x22\xf0\x0f\xab\x00\x03\xb1\x62\x90\xba\x47\xf6\x21\x88\xcc\x29\x43\x2b\xe3\x8a\x7e\xd4\xd0\x6c\x98\x30\xe6\xa0\xc3\x53\xc6\x5b\x26\x96\xec\x68\xf0\x32\x83\x35\x9d\x2d\x32\x9b\x0b\xfc\x58\x8b\x0e\x97\x93\xad\xb0\x67\xa4\xf6\x2a\xc0\x8b\xd1\x46\xa5\x60\x31\x41\xea\x58\xed\x1d\x18\x33\xf2\x78\x5e\xbf\x67\xac\xf6\x9d\x8f\xb0\xcf\xb5\xec\x03\x58\xd9\xba\x7e\x7f\xfb\xf6\xd9\xa0\x25\x4e\x41\x21\x0b\xda\xb9\xce\xf0\x30\x56\xe8\x36\x0d\x56\x2c\xac\xa5\x52\xaf\x44\xd6\xdf\xa0\x61\x96\x2f\xe0\x2e\x68\xf1\xea\xa3\x52\x2f\x72\x90\xc1\x0f\xfe\xde\x3e\xf9\x7d\x8c\x6d\x85\x30\x28\x51\x0b\xbc\xbd\x25\xaa\x2d\x5a\xab\x5b\x58\x3b\x12\x72\xaf\x24\x5c\x54\xb5\x2e\x79\xd9\xd2\xc0\x88\xda\x5e\x3f\x9a\x8c\x44\xdc\x8e\x8f\xf5\xff\xe0\xaa\xb7\x81\x87\xc4\x65\x67\x75\x14\xa5\x31\x25\x3c\xc1\xfa\xd3\x2d\xa9\x54\x28\x47\x0d\xce\x4b\x65\x52\x45\x01\x8c\xa1\xeb\x7e\xc1\xbc\x01\x74\x70\xd8\x07\x0a\x60\xa6\xc2\xb1\x62\xce\xd5\xf5\x5c\x28\x04\x82\x9d\x21\x03\x8a\xdd\x57\x1e\x7b\x4f\x2a\x7c\xf2\x69\x4c\x91\x62\x40\x26\xb5\xe8\x28\x99\xc5\x90\x1d\x41\x05\xe2\xe8\xa8\x90\x5b\x89\x27\x21\xa0\xe6\x3e\x6e\xdb\xbf\x78\xaa\xe4\xb2\x8b\xea\x89\xb3\xec\xb4\x69\xaf\x5c\x4c\x87\x54\xb3\x9a\xdb\x16\x07\x64\xee\x66\xd9\xe8\x07\x86\x26\x27\x87\x0f\x1d\xd0\x26\x26\x07\xc6\x27\x95\x06\x04\x3a\x4e\x15\x10\x46\x46\x5f\x19\x18\xd1\x46\xc7\x26\x87\x47\x0f\x29\x0b\x65\x22\xc7\xdc\x11\xa1\x23\x6b\x78\x39\xb8\x8d\xd7\x02\xce\x40\x8a\x50\x95\x03\x46\x43\xd3\xdd\x48\x01\x70\x26\x1d\xb3\xea\xbc\xe8\x8a\x3d\xaf\x15\xcb\x26\xdc\x48\x23\x62\x0e\x31\x08\x04\xcb\x72\x71\x22\x9d\xc4\x5a\x22\xeb\xbe\x08\x5b\xd4\xa1\xff\x8c\x5b\x6c\x83\x07\xd9\xca\x61\xaa\x51\x24\x64\x28\xc2\x89\x15\xf4\x08\x93\xe1\x19\x78\x2e\x59\xaf\xd3\x50\xb7\x32\x58\x8f\x92\x63\x42\xf1\xf0\xd0\x56\x97\x02\x53\x79\x81\x6b\xa6\xba\x1d\x35\x1a\xec\x06\x51\x34\xa2\x7a\x5a\x92\xd2\xf6\x0d\xb7\x72\x02\x52\x5f\x21\xe1\x44\xff\x5c\x4f\x77\x5d\x29\xa8\xd5\x83\x5f\x82\xb4\xfe\x03\x6e\xe0\xbe\xfd\xd3\xea\x3a\x9a\x79\xaa\x92\x71\xa9\xaf\x4f\x99\x73\xa8\x32\x2a\x85\x0e\xa8\x4a\x30\x14\x43\x72\xcb\x51\x28\x81\x77\x84\x92\x9c\x56\x01\x2b\x54\x06\x72\x19\x52\xe1\x07\xa7\x2c\xbe\xf6\xf6\xcf\xa5\x5b\x6d\x6b\xdd\x77\x25\xcb\x48\x25\x34\xc7\xed\x04\x79\x94\x1c\xba\x6b\x04\x0a\xda\x0f\x33\x6d\x02\x8a\xff\xfd\x19\x32\x90\x2f\x58\x3d\x1b\x03\xa9\xce\xac\xae\x02\xa1\x02\x27\x96\x8b\x90\xca\xc8\x70\xc0\x93\xc4\xb3\x8b\x65\x81\xd6\x43\xd2\x7f\xd2\x10\xd0\x41\xf8\x39\x6e\xd5\x1a\x37\xc9\xa4\x33\x8c\x6b\x3b\xe9\x5f\xac\x1d\xe9\x1c\x9a\xa8\xe5\x64\xd7\xcb\xfa\x8f\xd3\xcf\x3a\x2b\x79\xec\x9f\x2e\x2d\x32\x4f\x5b\x55\x00\x2f\xdb\x61\xd9\xc5\xa1\x46\x86\x06\xae\xdb\x53\x75\xdb\x1a\x44\x99\x59\x75\x93\x1d\x76\x0c\x80\xd2\x7c\xec\x29\x07\x97\x2c\x7f\x4f\x81\x26\x0d\x93\x1c\x4d\x07\xc5\x45\x4d\x15\x51\xc3\x8f\x96\xee\xf0\xea\xd7\x14\x31\x2e\x02\xab\xd0\xce\xbf\x28\xe5\x76\xba\xe1\x79\x97\x42\x09\x11\xcf\xa1\x02\xa3\x0f\xcb\xcc\xf8\x78\x9c\x83\x01\xb4\xb4\x0c\x1b\x23\xd6\x7f\x98\x69\xb7\xf0\x4e\x4f\x79\x20\x28\x7b\x12\xbb\xc1\x25\x54\xc5\x49\xa8\x7b\x46\xe2\x9d\x7d\xf4\x54\xc3\x24\x01\xa8\x82\x18\x8d\x61\x53\xa8\xeb\xd8\x1a\xce\xab\x54\x69\xbc\x4d\x32\x7d\x79\x00\xbe\x3b\x14\xb3\x05\x92\x6a\x4d\x21\x40\x49\xc9\x5e\x73\xed\xad\x99\x36\x89\x77\x0a\xf6\x2e\x28\x81\xd9\xd4\x3c\x71\x92\xf3\x62\x9e\xb9\xf7\xb8\xf7\x56\xcd\xcc\x4a\x4b\x0f\x8e\xc0\x25\x6e\x73\xfe\x57\xf0\x13\x30\x72\xd5\x5b\xab\x9c\x73\xa5\xf3\x77\x2e\xa5\x7c\x83\x2d\xfb\x9d\xf1\xa1\x21\x9f\xac\xb8\xca\x03\x7b\x2b\xa2\x3f\x4b\x0a\x05\x8b\xb2\x3e\x1f\xa4\x53\x54\x67\xfd\x89\xd3\xf5\x19\x12\xed\xb9\x20\xcc\xce\xce\x7f\xd7\xa7\xb8\xd3\x7b\xe4\x79\xe2\xf3\x67\x27\x28\x7e\x2a\x92\x60\x87\xb6\xfc\xb3\xdf\xd3\x4e\xb6\xb5\xbd\x13\xd7\x77\x5e\xd3\x46\xce\xd4\xee\x16\x63\x12\x3d\xb9\xdc\xd1\x03\x4d\x34\x3c\x02\xa8\x8b\x1b\x80\xa7\x67\x09\x5c\x3b\xb9\xbf\x37\x49\xf3\x81\x5c\xe9\x1f\x1c\x24\xa2\x77\x48\x97\x57\xd7\x4c\x93\x8e\xd2\xea\x9f\xe9\x34\x82\x4e\xd5\xf4\xbe\x84\x1d\x31\x8e\x26\xf2\x28\xc4\x7a\x79\xf3\xf0\xec\x3a\x94\xfa\x09\x11\x26\x97\x79\xe3\xc4\xbc\x26\xa6\xdc\xcc\x4b\xf2\x1c\x54\xa6\xa6\xee\xcd\x4c\xd2\x14\x72\xb9\x07\x2a\x71\xee\x0e\x43\x99\xb5\xc8\xfc\x1f\xe7\x7f\x88\x3a\x02\x62\x79\xc9\x3f\x44\xd0\x0f\xd1\xcd\x99\x00\x65\x1d\x30\x89\x74\x02\x3e\x41\x0e\xa9\x67\xdf\x38\x0a\xce\x6e\x7a\x29\x83\x83\x26\xd9\x43\x64\x89\xc7\x7c\x7d\xcf\x7c\xb2\x2f\x36\x96\xbc\xf8\x19\xd0\x23\x33\x05\x28\xbd\x20\x84\xdb\xbd\x33\xf7\xfa\xc0\x42\xb6\x40\x1e\xdc\x1f\x3a\x6f\xef\xc8\xe2\x98\xf1\x27\x24\xa4\xb5\x48\x45\x4d\x3b\xf7\xa3\x42\x06\x9e\x7c\x02\xca\xa5\xc3\x5e\x7c\x58\xc9\x0b\x9b\xa9\x17\xcb\xcd\x12\xea\x08\x54\x95\x90\xf2\xab\x67\xac\xd2\x62\x2f\x34\x54\xeb\xf9\xcf\x1e\xa6\x07\x95\xcb\xd6\x31\xa3\xa4\xcd\x2c\x42\xd7\x2e\x0c\x91\x66\x8c\x04\xaf\x43\x9d\x26\x7c\xd1\xa9\x0c\x16\x51\x90\x51\xce\xa3\x3e\xfe\x09\x54\x03\x5b\xfe\x1c\xee\x0b\xe7\xd7\x00\x63\x6c\xa8\x0f\xb8\xb9\x65\xc2\x96\x5a\xe8\xca\xbf\x8c\x51\xc9\x1b\x0c\x15\x68\x40\xf2\xfd\x5f\x36\x5b\x7f\xc6\xc0\x67\x37\xc6\xa0\x7d\xfe\xac\xf0\xc3\xb8\x25\xc6\xe4\x62\x59\x51\x6b\x8a\xf4\xa8\x18\x8d\x79\xab\xa4\xed\x3d\x30\x34\xd9\x3b\x36\x3a\xc1\xfe\x73\x78\xb2\x77\xff\xd0\xc8\xd0\xe4\x50\xaf\xd1\x28\xaa\xe2\x88\x79\x5f\x43\x86\xc6\x43\x54\x59\x4e\x21\x04\x86\x38\xc0\x80\x7f\x0e\xc3\x7f\x09\x8e\x86\xbd\xc4\xbf\x54\x44\x0b\xbf\x66\xd9\x0d\xa4\x2a\xf5\xeb\xaf\x2c\x16\xec\xe6\x0c\x45\x49\xa9\x1b\xf6\x7f\x4c\xd4\x64\xd3\xe7\x0d\xfb\xbd\xaf\x45\x0f\x24\x0c\xd9\x68\x27\xd7\xf6\xf2\x9a\x16\x3c\x7c\x71\x5e\x87\x8f\x3c\x4a\x4b\x39\xfb\x50\x50\x31\xc3\x36\x79\xc5\x8d\xa2\x55\x81\xe6\xf4\x4e\xe4\xaf\xb6\x7f\xf4\xe0\xc0\xf0\x21\x4c\xad\xc0\xd6\x82\x8b\x12\x76\x90\x04\x6b\x56\x95\x8d\x3c\x24\x42\x40\x2f\x3f\xe1\x08\xf1\x04\x9d\x7a\xfb\xd8\x78\x02\xc1\xe0\xca\x7e\xbe\x7d\xfe\x24\xed\x20\xa9\xa3\x5b\x04\xd3\x74\x3b\x1d\x0a\xb0\x4d\x3b\xa1\x60\x2c\xed\x4e\x4e\x0b\xe4\x43\x89\x89\x26\x0f\xf2\x39\xf0\xc2\xf0\xa1\x89\xc9\x81\x91\x91\xa1\xfd\xda\xd8\xc8\xe1\x03\x8c\x48\x83\xa3\x07\x0f\x0e\x1c\xda\xaf\xcc\xf1\x0d\x84\x98\x77\xee\xb1\x59\x3d\x0e\xa9\xe6\x2a\x95\x19\x56\x8c\x3d\x57\x85\x12\x2d\x9e\x1a\x81\x99\x0b\x03\x62\xa3\x8a\xed\x9b\x97\x62\xa8\x3a\xcc\x85\xac\x53\xcd\x8e\x97\xbc\x14\x52\x97\xda\xc1\x46\x17\xff\x93\xcb\x60\x62\xb4\x37\xf4\x74\xc5\x7e\x4c\x8c\x10\x54\xc0\x27\x06\x05\xab\x0e\xf5\x66\xb5\xc3\xb6\x3e\x67\x40\xc3\x5b\x55\xc9\xcb\xdb\x37\xa8\x9e\x1a\x31\x4c\xe7\xee\x45\x7c\x38\x09\xd4\xbe\x54\x60\x31\xa5\x2e\x29\x64\x6d\xa0\xea\x16\xe7\x31\x6d\x0d\x9b\x77\x63\xd8\x03\xa6\x7f\xf0\x87\xcb\x8b\x9a\xc1\x68\x6d\x31\xe6\x4d\x8d\x4b\xe7\xab\xcf\xb6\xcf\x3f\x94\x73\x63\x44\x4d\x9d\x47\xd4\x22\xb4\x73\xe7\x73\x3a\x8b\xda\x1f\x7f\xcb\x0f\x2c\x7e\xdc\x32\xb1\xfe\xae\x78\x18\xeb\xd1\x89\x03\x27\xdd\x14\x07\x9d\x22\xdc\x55\xb6\x8d\xca\xfa\x9c\xcd\x0e\x83\xb7\x8a\x46\xad\xa1\x15\x66\x5f\x80\x2e\x98\x30\xd5\x19\xde\x71\x94\xed\xcf\x63\xf3\x90\x77\xd4\xa4\x02\x84\x95\x66\xb9\x61\xd6\xca\x06\x05\x2e\x53\xf4\x85\x97\xcd\x55\x3a\x48\x28\x39\x54\xdd\xa3\xe5\xec\x7a\x6d\x6f\x61\x56\x7b\xf2\xe3\x17\xed\x1b\x97\x5e\xd0\xa8\xe4\x4f\x82\x62\x9a\x58\xbd\xef\xc6\xfb\x48\x2d\x4f\xf0\x32\x7e\x38\x8e\x51\xf7\x5f\xb8\x1d\x3a\x21\x49\x6e\xe3\x69\xeb\x4b\x14\x5e\x4e\x32\x58\x64\x2f\xb4\x00\x65\x5f\x1b\x1a\x18\x99\x7c\x6d\x7a\xf0\xb5\xa1\xc1\xd7\xa7\x27\xdf\x18\x1b\x62\xd4\xb2\x91\x94\x53\x7b\xa0\xb4\xfd\xd4\x1e\x60\xa4\xa9\x3d\x55\xab\x6a\x4c\xed\x99\x62\x6b\x96\x8e\x77\x82\xf0\x19\xce\x2e\x6c\x87\x85\x9c\x21\xa8\x6a\xc2\x6d\xd0\x64\x60\x42\x5f\x4b\x65\x75\x60\x66\x1c\x83\x64\x93\x3b\x64\xb9\x3b\x43\x1c\xe2\x69\x99\x5f\x54\x7c\xba\x1d\xc6\xc6\x88\x51\x72\x36\x56\xe1\x83\xf7\x18\xf6\x44\xca\x4a\x7e\x01\xf8\xe3\xa2\xf8\x56\x0f\xe3\xf4\x02\x9e\x39\x46\x75\xc1\xfd\x80\x51\xa2\x3d\xa0\x86\x0b\x34\xec\xd4\xe4\xf0\x56\xd3\x8a\x19\x09\x12\xeb\x38\xfd\xd8\xa2\x5e\x49\x41\xaa\x88\xa9\xec\xf4\x04\xf2\x41\x5b\xc4\x01\x38\xc9\x2f\x39\xa3\x1d\x02\x3f\x07\xb4\x07\xc6\xc6\xb4\x89\xa1\xf1\x23\xc3\x83\x43\xd3\xa8\x8b\x1c\x1a\x1c\xca\x15\xef\xd0\x01\xf2\x41\x9c\x3a\xd4\xc3\x31\xc1\x15\xcc\x9c\xf1\x26\xf8\xec\x2b\x01\x3f\x6f\xb4\x83\xb2\x72\xc7\x66\x10\x26\x96\xf3\x9d\xcc\x4e\x73\x91\x3b\x97\x9d\x65\x27\x17\xeb\x9c\x10\xf6\xe0\x96\x07\x5e\x39\x12\xb3\x6b\xba\xbd\x72\x78\x78\x64\xff\xd8\x00\x63\x2a\x80\xd8\xab\x1d\x1a\xfa\xf5\xb4\xf7\xbb\x5c\xf9\xc0\x0b\x9a\x29\x59\x21\xe3\xe5\x30\x2b\x21\x4f\xba\x60\xeb\xac\x43\x62\x21\xcd\x04\x2b\x9d\x16\xfe\xc8\xc0\x2b\x43\x23\xbd\xda\xd8\xf8\xe8\x91\xe1\xfd\x43\xe3\x38\xb7\xc9\xd1\xd7\x87\xf2\x95\x9a\x38\x0a\x18\x7b\xf8\x30\xa0\x06\xb7\x4e\x63\xe5\xcd\xbb\x7c\xb8\x1c\x96\x27\x30\x97\x1d\x9c\x41\x1e\xf8\x8e\x8e\x1f\xf0\x1c\x53\x79\xe1\x0a\x70\xf3\x3d\x9e\xfc\x98\xe6\x48\xd8\x1d\x41\x96\x4b\x9d\xff\x3a\x3c\x3a\x39\x90\x37\xb6\x42\xc4\x10\xf0\x1c\xf0\x1d\x1f\x1a\x1b\x75\xcf\xcb\xc3\xe3\x23\x3b\x25\x4b\x26\x86\x06\x0f\x8f\x0f\x4f\xbe\x31\x7d\x60\x7c\xf4\xf0\x18\x8e\x36\x36\xc0\x4e\xff\xc9\xd1\x69\xa8\xfc\x32\x3d\x7e\x78\x64\x68\x62\xfa\xd5\xe1\x91\x7c\x85\xb3\x6f\x58\x58\x6c\xd5\xb0\x39\x50\xd3\x3b\x5a\xaf\xc3\xba\x13\xec\x24\xd8\xc9\x79\x31\x8e\x60\x43\x79\x04\x1b\x0d\x99\xcb\x9c\xe8\xb0\x79\x65\x9c\x89\xca\x71\x3a\x4d\xbd\xdf\xe5\x3c\x31\x19\x34\x3f\x4d\x7d\xe3\xed\xc0\xac\x0e\xb3\x2f\x68\xdf\x8e\x0d\x4c\x4c\xfc\x7a\x74\x7c\x7f\x6f\x9a\xdd\x90\x6d\x6a\x62\x50\x10\xed\x7c\x54\xf8\x96\x0d\x9b\xe3\x0c\x1d\x25\x41\x7c\xf1\xfa\xd0\x1b\x3b\x32\xad\xd0\x81\x76\x62\x22\xb0\xa3\x64\xae\xd8\x11\xed\x3e\x44\xa1\x5f\x0d\x1f\x75\xa7\xa6\xb8\x6b\xeb\x25\xdf\x5f\xf2\x5a\xb3\xd1\xc3\xe3\x83\x43\x05\xb8\x68\x4f\x0e\x8c\x1f\x18\x9a\xc4\x8f\xb9\xce\x22\x74\x84\x3c\x50\x27\x59\xbd\x33\x0a\x87\x90\xca\x79\xaa\x1c\x2e\xc2\xf9\xab\x1c\x2e\xbe\xb9\x69\x1c\x08\xb2\xe0\x5e\xd1\xf1\x4f\x84\x5e\xc8\xfd\x6a\x26\x8d\x85\x4c\xee\x1f\x2b\xaf\xe9\x90\x06\x85\xd2\xc1\xfd\x33\xf7\x89\x84\x8e\x92\xef\x14\x72\xbc\xd1\xe7\x8b\xa3\x7b\x3e\x33\x45\xa7\x57\x1b\x1f\xcd\x59\x4f\x94\x8e\x62\xd2\xa4\x70\x84\xfc\x11\x47\xaa\xec\x06\xfe\x38\x50\x8e\xf3\x48\x66\x01\x08\xc5\xf5\x25\xad\xbd\xb4\x22\x35\xc1\xe8\x1e\x97\x5a\x8d\x42\x5c\xf2\x63\x57\xc7\xd1\x85\x2e\xfd\x3c\x30\x9c\x06\x0c\x7b\x79\x8c\xc6\xb4\x1f\xdd\xae\x17\x5c\x8c\xc0\x96\x58\x1e\x22\x0f\xdc\xb3\xa2\x88\xce\xd6\x73\xbc\x3c\x62\x8e\xcb\xed\xd4\x3f\xe2\x24\xc5\x52\x8e\x70\x76\xd4\x78\x7b\x94\x5c\x09\xeb\x1d\x8d\x91\x17\x86\xf3\x5c\xad\x9c\x61\x73\x98\xdb\xbc\x65\x37\x70\x2e\xbc\x05\x7e\x8e\x33\x71\xa2\x54\xe0\x1b\x4f\xe0\x49\xd7\x58\x5b\xe5\x92\xb4\x09\x19\xf6\x55\xe3\x58\xe8\xae\xec\x76\x0e\xed\x73\xd8\xb1\xc6\xb3\x39\x57\x45\x9f\xac\x77\x73\xde\xb4\x30\x2b\x08\x18\x24\x2e\x83\x29\x89\xbf\xf2\x9f\x12\x85\x0f\x02\xde\x4b\x2d\x67\x3e\xee\x97\x39\x4c\xa6\x3e\xb7\xc3\x12\x48\x8c\x90\xbf\x04\xe2\x19\x00\xbd\x9e\xdc\x8f\xde\x60\xc5\x90\x3c\x37\x8b\x1c\xc1\x0f\x81\x8d\xe1\x49\x20\x21\x3f\x05\xca\x88\xe4\x41\x00\x0c\xea\xce\xfd\x88\x73\x03\x8a\xf3\xe1\xb1\x85\x97\xc4\x6d\x18\x3e\x3a\xd6\x69\xf8\x3c\x32\x70\x48\x5b\x78\xd9\xfd\xf9\x65\xfa\x2a\x4f\xfe\x4b\x3f\x7a\xa6\xf9\xaa\xca\x52\x06\x71\x54\xd4\xa1\x74\xe1\x89\x22\xe3\x15\xbd\xd1\xef\x36\x86\x03\x3b\x24\x14\x36\x86\xde\x76\x53\x0d\xf6\xff\xd5\x23\x7a\xd9\x2c\xf1\xa7\xa9\x96\xb1\x5e\xa9\x61\xaf\xdc\x37\xa7\xaa\x0c\x3a\xfc\x47\x83\xf8\x95\xba\xd5\xb0\x8a\x56\x79\x8a\x0d\x33\xb5\xa7\x51\xac\x4d\xed\xe9\x15\xbf\x95\xb0\x53\x26\x62\x4b\x3f\xbf\xf4\x62\xdf\xcb\xbf\xfa\x55\xdf\x4b\x7d\x2f\xfd\x6f\xe9\x31\x08\x81\xb1\xe9\x81\x5f\xfe\xf2\xc5\x7f\x9f\xda\x03\x3f\x30\x44\x7e\x1b\x37\x6b\x42\xaf\xfd\xf0\x7a\xfb\xc1\xb9\xc8\xc9\x50\xad\xe8\xcd\xd6\x6d\x5e\x14\xdd\xdb\xb9\x17\xc2\x62\x77\x75\x5a\x8a\x25\xa2\x42\xbc\x83\x23\xc3\xbc\xf2\x8c\x62\xfa\xec\x81\x60\x2d\x99\x90\x12\xbb\x71\x01\x87\x38\x9c\xd4\x3b\x9f\x51\x6e\x0c\x3f\x51\x9b\xe9\xa8\x42\x9b\x9e\xd1\xfd\x2f\x6a\x6a\x74\x12\x84\x9e\x8b\xaa\x47\xb1\x71\x9e\x42\xd4\x45\x83\xd1\x0e\x1a\x15\xab\xbe\x98\x18\x1a\x6f\xf7\x7f\xfc\x3a\x95\xee\x89\x01\x2e\x42\xc4\x74\xad\x6a\x55\x0b\x55\x63\x8e\x41\x5e\x30\x44\xbf\xbf\xe4\x83\xb6\x36\xb6\xbf\xfd\x4c\xc4\x7b\xbd\xcb\x9b\xec\x45\x86\x7f\xa9\x10\x5b\xc0\x6d\x8b\x75\xec\xc3\x1a\x23\xc7\x24\x24\x7a\x7a\x71\x53\xc1\x77\xd8\x34\x08\x8e\x82\x4c\xa3\xc7\x1d\xe7\xfd\x23\xe0\x5f\x75\x3b\x0b\x01\xd7\xed\x14\xc1\x9f\x8f\x84\x3d\x31\x31\xa2\x0d\x1a\x75\x2a\xe0\x0d\x81\x62\xd0\xac\x0e\x43\xc6\x26\xcd\xda\x41\xc3\x8e\x8c\x1b\x13\xcf\x6b\x9e\x79\x01\xc8\xed\xd5\x07\x9d\x8f\xfe\xd4\xf9\xf8\x5e\x10\x54\x24\x3a\xd4\x88\x2f\x37\x1a\x3b\x4d\xf9\x92\x90\x39\x41\x1f\x69\x07\x70\x30\x4d\xb9\x5f\x51\xf6\x4a\x40\xc7\x2a\xce\x73\x4d\x5e\x71\x9b\x09\xc2\x05\xb3\xc4\x63\xfe\x0b\x45\x0c\x3a\xed\xd3\xc6\xca\x86\xce\x66\xcd\x7f\x64\xfc\x2f\xf1\x9d\x35\xf3\x7b\x38\x68\xb0\x7d\x3f\xe2\x29\x32\x42\x18\xe0\x06\x53\xd1\xb0\x72\x6e\xf0\x05\x95\xb4\x61\x63\x3a\xd1\xa4\x9b\xad\x35\x5f\x6d\x7b\x67\x9e\xd0\x69\xf2\xe4\x79\x08\xd2\x75\x64\x3d\xef\xe6\x70\x1b\x92\x9f\x97\xef\x61\xb4\xe9\x06\x5e\x45\x44\xb4\x6e\xec\x93\xcb\x17\x20\xf3\x64\x79\x29\xd8\x15\x95\x17\x5b\x5e\xbe\x20\xf0\x21\xe9\x96\xa0\x49\xa5\x20\xb3\xdb\x28\x1f\x12\xcd\xa0\xbc\x18\xa5\x5e\xf5\x68\x05\x21\x91\xf1\x91\x92\xc5\xb4\x1c\x88\xea\xc5\x6e\x02\x0a\x22\xf9\x41\x04\x19\xcc\x49\x7b\x61\xe0\x43\x82\xe2\x9d\xa4\x98\x60\x07\x80\x64\x22\xa7\x64\xda\x47\x29\xeb\x12\xcf\xe0\xfd\xec\x4f\x9e\xd0\x99\xae\xe5\x8a\x07\xe1\xe5\xcf\x91\xc8\x1b\xbe\xcc\xcb\xa4\x23\x74\x89\xf0\x8e\xe0\x18\x87\x16\xd5\x23\x2d\x60\x3d\xd2\x02\xd6\x23\xad\xe9\x75\xbd\x82\xe0\xe8\xb7\x41\xf8\x89\x3a\xab\xc5\xe1\x17\x02\x0d\x2b\x33\x7f\x89\x67\x1c\xaf\x54\xa6\x00\x1d\x89\xa5\x73\xfd\x29\x5a\xcd\x2a\xb5\xe0\x16\x87\xa2\x3d\x08\x5f\xc1\x84\x87\x3d\x0f\x49\x87\x25\x19\x2f\x62\x0f\x4a\x97\xcc\xa1\xc7\xf4\xf2\x1a\xb6\x1c\x85\x02\xbb\x0a\x04\x62\xdf\xa3\x90\xfd\xee\xcf\x5b\x87\x1c\x15\xd4\x36\xb4\xb2\x59\x31\x89\x2a\xa4\x7e\x8c\xc0\xdf\xa9\x18\x2b\x4e\x31\x69\x9f\xfc\xfe\xe9\x95\xf3\x91\x43\x24\xc2\xd8\x43\x39\xcf\xa2\xe5\xb9\x5c\x81\x51\x42\x75\xa0\x5c\x97\x22\x7e\x62\x65\x28\x80\xd2\x98\xd7\xab\xf2\x93\x9c\x77\x76\x6a\x8a\x21\x43\x69\x9d\x4f\x6e\x77\xee\x2f\x75\x33\x67\xbc\xd4\xc4\xa5\x57\x7a\x0b\x1f\x07\x74\x3c\x7e\x31\xe2\xc7\x80\xf2\x1a\x49\x03\x8a\x9c\x91\x3e\xcd\xed\xbc\xca\xbe\x54\xb5\x08\x90\xe4\x65\x20\xf5\x63\x69\x19\xbf\x3c\x4e\x95\xdf\x44\x73\x49\xf9\xec\xb9\xac\x6c\x79\xe4\xa0\x13\xb2\xeb\xd2\x6f\x39\xe5\xee\x4a\xb9\xb5\x72\x93\x01\x39\x6e\x77\x05\x4e\x5d\x1c\xce\x11\xb8\x65\x3c\x90\xe5\x7a\x9c\xda\x5c\xd3\x2c\x21\xc8\x03\xec\x43\xea\x74\x10\x02\x08\x2d\x37\xb0\x4d\x8a\x73\x80\x4e\xd2\x37\x69\x56\xc1\x81\xa2\x38\x38\xc3\x40\x46\x62\xe5\x56\x28\x07\xa5\xcd\xdb\x71\xb5\x87\x2a\x44\x62\xe3\xd9\x23\x7a\x59\x26\xa4\x12\xd3\x10\x28\x9e\x5b\x4e\x7b\xe9\x46\x24\x54\x15\xb2\x66\x83\xcc\xea\x6c\xaf\xb3\xeb\x10\xa5\xb3\xf7\xe2\x37\x06\x75\x80\x9b\xe5\xfd\xb4\xa8\x3a\x3d\x6f\x71\x85\xe9\xfc\x11\xfd\x21\xe4\x4e\xa8\xeb\x9d\x95\x8f\xb1\xad\xf8\xea\xd6\xfa\xb5\xad\xf3\x27\x20\x21\x1b\xda\x66\xbf\x0b\x2d\xdf\x4e\xfd\x80\x6a\xb5\xb7\x44\x85\xa7\xeb\x76\xa0\xa9\x2b\x53\xc6\xb9\x46\xef\x1a\x3f\xd4\x06\x36\xc5\x04\x6d\xa3\x0c\xb7\x17\xf8\xa1\xc8\xce\x86\x39\x32\xfc\xf2\x99\x43\xb3\x66\xbb\x66\x50\xd7\x1b\xdc\x4c\x76\xd6\xb9\x42\x1e\x9c\x30\xe8\xb6\xd6\x9f\xb6\xee\x75\x4e\xff\x95\xfd\x0a\x1d\x15\x3e\xfe\x4e\x76\xf5\x74\x3e\xdc\xe8\x9c\xba\xf8\xe4\xde\x69\xb6\xc9\xd8\x93\xdb\xab\x77\x80\x30\x0e\xa9\x22\x67\x39\xa2\xb3\xa3\x6e\x94\xb1\x06\x61\xa5\x38\x18\x3e\x59\x6a\x3f\x3a\x03\x28\x7e\x70\xf6\xc9\xc3\x4f\x14\x90\xa0\x29\x32\x98\xa7\x44\xcf\x13\xb7\xb7\x3a\xad\xb9\xf2\xd6\xeb\x6d\xa9\x7e\xfc\x47\x4f\x45\x15\x2a\x55\xe0\xe9\xcb\x22\x27\xfb\x39\xad\x93\x23\x4d\x59\x2e\x6e\x0b\xba\x59\x46\xde\xe4\x17\xa8\x22\xa5\x4b\xaa\xfa\xeb\x90\xd5\xb4\x7d\x6e\x63\xfb\xf8\x43\x14\x6a\x51\xb9\xc2\x80\x90\x83\x68\xb7\x98\x21\x09\x29\xe9\x1b\xb2\x34\xa5\xe2\xd2\x6c\x2f\x81\x0b\x0e\xde\x29\x95\xe4\x9f\x4c\x65\xe7\x3a\xe9\x0a\x7a\x35\xac\xfa\x34\xbf\xee\x6e\x3f\x7e\xd8\x3e\xfd\x99\xdb\x15\x2e\xb2\x96\x36\xae\xcc\x9a\x68\xfa\x2c\x3f\x19\xb0\x3c\x06\x68\xa1\xb0\x2f\x38\xc4\x70\x7b\xc9\x24\x2a\xf3\x1d\xd2\x52\x26\x35\xfd\xa1\xf4\x79\x82\xc1\x9c\xca\xe6\xa9\x07\xe0\x95\x84\xf9\xc6\x28\x52\xbd\x0e\x5e\xdc\x84\x67\xbb\x8b\x2f\xe5\xc2\x83\xaa\xd3\xe7\xdc\x23\xd8\xde\x1e\xd1\xc7\x57\x91\x7e\xe2\x5e\xba\xc0\xf6\x91\xea\x1a\xa4\x9c\x80\xaf\xd0\x6f\x92\x95\x49\x56\xcc\x37\x03\x26\x5e\x17\xdb\xce\x8a\x9b\x38\x47\x5a\x96\x09\x38\xf5\x9d\x74\xac\xfe\xa2\xc0\xf5\x25\x0d\xc3\x14\xd6\x55\x6b\xe9\x2b\xce\x94\x1e\x0d\xaa\x3c\xb4\x57\xe7\xae\x3c\x13\xba\xc1\xd7\xea\x46\x01\xf6\x1f\xa5\x7b\x6b\xf6\xa2\xdd\x30\x2a\xbd\xbc\xc6\x0b\x5a\xe6\x18\xca\x74\x60\x40\xf1\x22\xfe\x33\xbb\x25\x35\x20\xb9\x5c\xab\x37\xb1\x15\x98\xb2\xdc\x87\x1f\x7f\xa9\x78\x50\x88\x9c\xd8\xeb\x79\x04\xba\xe7\xdf\xc6\x19\x63\x6b\x3e\xce\x51\xd8\x46\x1f\x56\xe6\xef\xf8\xf6\x09\xe8\x75\x26\xcc\x72\x4f\xee\xaf\xb4\x4f\x9d\x75\x25\x84\xdb\xf0\x52\x32\xd7\xf9\xde\xe5\x9d\xec\x4f\xe3\x11\x1b\xe8\x7f\xe9\x7f\x78\xc3\xd3\x39\x6b\xfd\x2a\x1e\xba\x4e\x57\xd6\x2b\x8a\xfa\x29\xce\x12\x00\xd7\x92\x18\xe7\x07\x52\x02\x69\xee\x17\xd3\x21\xb6\xba\x80\x88\xef\xe6\x68\x72\x0a\x71\x70\x45\xce\x65\x60\x6b\x36\xbd\xcc\x4a\xc4\xcc\x79\xc9\x2c\xa7\xc4\x12\x56\xc8\x50\x6e\x34\x5a\x67\x25\x66\xde\x42\x49\xe9\x90\x70\x8e\x75\x6b\x76\xd6\x00\xfd\xda\x41\x47\xaa\xae\x18\x89\x56\x44\x3d\x43\xc2\xd5\xaf\xa4\xc0\x1e\x41\x8e\x85\xa5\xc7\xdd\x91\x19\x69\x3a\x9e\x44\x03\x69\x5e\x33\x2f\xa1\xae\xe4\xef\xdf\x7d\x1b\xeb\x1b\x85\x97\xc9\xcb\x88\x5e\x13\xfc\x30\xa9\xb0\xa2\x3f\x61\xd0\xd6\x7a\x97\x68\x48\xdd\xe7\xa4\xb3\x27\x82\xc9\xbc\x27\x8f\x87\xdb\xbc\x1d\xe5\x52\xa1\xe1\xb4\xaa\xd1\x03\xe7\x62\x82\xe2\xa2\x8a\xd8\x10\xb7\x91\x4c\x2a\x5c\x3c\x0d\x33\x94\xb7\x9e\xa8\x16\x18\xa9\x86\xf3\xb7\x1e\xe0\x2b\x01\x77\x30\x26\x99\xfc\xbf\x62\xdf\xf4\x66\xb5\xca\xfb\x32\x96\x4d\xea\xca\xaa\xc2\x93\x64\xf9\x93\x7b\x77\xbc\x77\x8e\x6f\x3c\x4d\x61\x3d\x85\x8a\x13\x28\x3b\xa4\x13\xe1\xfa\x7b\xf4\xe7\x1d\x50\x94\x54\xc4\x69\xe8\x73\x54\xbf\xb4\x21\x9a\xc6\xc5\x51\x42\x9c\x76\x0f\xf0\x44\x01\x81\x12\x47\x95\xdd\x9c\xa5\xa7\x5a\xb5\x4d\xa5\xf5\xd4\x33\x51\x16\x93\x76\x6e\xcd\xd9\x86\x77\x2b\x49\x27\x18\x3a\xb4\x30\x74\xa6\x71\x79\x3d\xe8\x84\xd3\x0d\x94\x78\x4e\x33\x26\x30\x0d\x0f\x09\x61\xda\x0a\x85\x73\xd8\x51\x15\x8c\x93\x95\xdb\xf2\x23\x91\x20\x00\x64\x04\x1a\xaa\x6b\x10\x3c\x03\x1c\x7c\x4c\xaf\x97\xc4\x45\x99\xf8\xb8\x4f\x9b\x9c\x67\xaa\x2c\xf8\xa1\x51\x25\x9d\x81\x06\xda\xb3\x66\x95\xa1\x5d\xb1\xb0\xfb\x3a\xa8\xb0\x4c\x3e\xaa\xc3\x57\xa4\x6e\xea\x40\xb7\x4f\x71\x06\x27\xb7\x7f\xbc\xfe\xd4\xe9\x9d\x0e\x91\xc4\x42\x3b\xe4\xae\xe7\x8d\x27\x0f\x2f\xb6\xef\xdf\x04\xfd\x6f\x79\x99\x3d\xb3\xf5\xe8\x4b\x59\x17\x54\x3a\x7c\xd9\x84\x8e\xe2\xe6\x74\xee\xbd\xe0\x13\x67\x8a\x38\x74\xbf\xd4\x9a\xb5\x92\xde\x50\x5f\xed\x3f\xfe\x0e\x22\x33\x97\x2f\x3c\xfd\xe8\xdb\xce\x9d\xeb\x81\x52\x6e\xa1\x77\xe3\x3b\x42\xa1\x8e\x5e\x75\x8b\x6a\x54\x6a\xca\x40\xa3\x80\x66\x74\x47\x6a\xea\x9d\x0c\xb6\xa5\xac\x59\xa6\x00\x7e\x1d\x7d\x73\xb1\x1c\x6b\xcd\xcd\xb1\xf5\x36\xc0\x84\x69\x2b\x7b\x36\x13\xc8\xd6\xda\xf6\xea\x47\x4f\xcf\x7c\xeb\x6a\xd4\xcb\xab\x68\x77\x7b\xa0\x70\x72\x00\x70\xac\x1b\xd6\x6c\x44\xc5\x40\x05\xf1\x4d\xc4\xdc\x73\x73\x75\x08\x13\x62\xb2\xd9\xa8\x96\x6a\x96\x09\x8e\x51\x5e\xa8\x0c\x83\x01\x28\xfa\x22\xaa\xe6\x9c\x0c\x03\xe7\x42\xf5\xb7\x3e\x15\x17\x04\x86\xcc\x19\x1e\x0d\xe1\x09\x5b\x58\xf3\xd5\x6b\x52\x61\x68\x1d\xc5\xf2\xa5\x35\xb4\x4f\x03\x1e\x14\xd6\xd5\x13\xec\x83\xe6\x0d\x3a\x88\x28\xeb\xe9\xbd\xae\x04\x02\x1e\xc8\x1d\x15\x18\x0f\x0c\xba\x37\x3e\xd9\xfa\xee\x7a\xa2\xba\xab\x07\xf5\xa3\xe0\xac\x2c\x5a\xb5\x45\xd1\x27\x9d\xeb\xb5\x45\xab\xc4\x03\x74\xa0\x11\xb7\x74\x24\x62\x6c\x4a\xd5\x62\x7b\xb3\xde\xa7\x69\x87\xab\xe8\x11\xb4\x16\x18\x5b\x99\xec\xd2\x56\xed\x25\xb3\x0d\x03\x58\x70\x20\x51\xf9\xb5\x63\x26\x36\xad\xa3\xa6\xec\x78\xc9\x73\x81\x2a\x39\x86\x9f\x92\xaa\x53\x15\x48\xf0\xe4\xc7\x4b\xd1\xfa\x88\xfb\x13\x9c\x6f\x0f\x5d\xfd\x1b\x0c\x95\xbc\xeb\x37\x7e\xfe\x10\x2d\x7f\x97\x1d\xd1\x84\xd7\x06\x11\x7d\xc4\x0b\xb5\x39\x17\x66\x08\x3a\x03\xeb\x32\xde\x8a\xe5\xf9\x7a\xec\x9f\xec\x32\xdc\xfa\x34\x0a\x3d\x76\x43\x76\x3a\xc9\x4b\x43\x47\x2e\x17\x48\x89\x82\x13\x63\x14\x8c\xae\x76\x2e\x03\x6c\xa9\x06\x5f\x45\xdb\x43\x02\x81\xd2\x39\x77\xfe\xc9\xa3\x8f\x13\xda\x77\x00\xae\xd4\xc4\xfc\x8c\xa8\x82\x89\xa2\x1d\x56\x8c\x6d\xa8\x13\xb2\x4f\x21\x62\x42\x28\xe6\xf1\xd4\xee\xb1\x3d\x91\xe3\x8c\xaf\xaa\xe5\x45\x6d\xc1\xb4\x4d\x98\x0d\x94\xff\xf4\xdc\x2c\x60\xf2\x11\x76\x2d\xd5\x90\x52\xe9\x3e\xad\x58\x37\x74\x84\xd3\x44\x6d\x69\xb6\x59\x66\x03\xea\x8d\xe8\x46\xb8\xed\xcf\xbe\xeb\x9c\x5a\xc2\xb3\x24\xb6\x2a\xdf\x99\xce\x9d\xcf\xdb\xf7\xee\xb1\x87\x9f\x3c\xfc\x04\xc4\x8b\x5b\x6b\x0f\x4c\xcf\xaa\xb8\x32\x2f\x96\x26\x05\x33\xcd\x5a\xcd\x6a\xc9\x6f\x2e\x2d\x99\x10\xa2\xcc\x44\x4b\x2f\xa3\x99\x27\xc0\xcc\x30\x61\x93\xf2\x46\xf4\x14\x94\xce\xa4\x9f\x70\x43\x47\x5b\x51\x29\x46\x07\x2e\xd5\x1b\x92\x51\x3c\xd1\x84\xb7\x6f\xae\xf0\x54\x22\x49\x6e\x62\xfc\xbd\x9c\xf4\xc1\x2d\xb3\x21\x00\xc1\xd2\xc0\x84\xd6\x5f\x90\x4c\x2b\x11\xd1\x62\x2a\xca\xd5\xb8\x79\xc6\x12\x17\x52\xd8\x07\x0d\xd0\x7f\x22\x1a\xf2\x73\x6d\x9b\xe6\xe3\xbd\x7a\x92\x4e\xe3\x32\xfb\x9a\xeb\x7c\x8f\xe3\xee\xb7\xb4\x63\xba\xd9\x40\x77\xa8\xd3\x8f\xda\xd9\xa7\x28\x09\x9b\x35\x30\x24\xb2\xe3\xac\xda\x54\x6b\x34\x5e\x09\xe6\xdf\x8e\xdb\x7f\xfb\x3b\x4a\x8f\x75\x70\x4a\xdd\xb8\x85\x1e\xb3\x6b\x9d\x2b\xcb\x4f\x2f\x7d\xa0\xed\x6d\x9f\x3c\xa1\x30\xb8\x05\xb1\x73\x75\x2d\x7e\x25\x4a\x82\x5a\x50\x9d\xe2\xf6\x63\xcf\xf5\x28\x0b\x76\x66\xa5\x59\xd1\xf4\x0a\xc6\x41\xb1\xc3\x89\xbb\xe3\x89\x9d\x9d\xd3\xc8\x0d\xaa\x62\x3f\xcc\xeb\x0b\xa2\xd0\xf3\x4b\x2f\xbe\xfc\xab\x83\xbd\xda\x4b\x07\xd8\xff\x5e\x3c\xa0\x32\xbd\x0a\x73\xb2\x52\x3c\xab\xf2\x44\xce\x7e\xd6\xf9\xe4\x94\x23\xee\x68\x6a\xb2\x7f\x1f\xda\x33\x50\xe9\x68\x44\x84\xb1\xff\x4b\x90\xdc\x89\xa8\xec\xc6\x7c\xfb\xb4\xc2\x4b\xa0\x76\xb0\xf3\x16\xdb\xc5\xb3\x87\x9b\x55\x74\xbe\x42\xd8\x09\x8e\xa1\x3a\x73\x9f\x05\x4d\xd8\x89\x57\x80\x71\x37\xd0\x0c\xb5\x46\xd1\x11\x58\x2d\xf3\x36\x0a\x83\x0f\xb0\xe1\xd9\x85\xed\x6b\xab\x49\x0e\xc9\x5d\xa7\xa4\xb6\x77\xbf\x31\xab\x37\xcb\x8d\x7e\xf7\xb7\xe7\x89\xe5\xb2\x91\x77\x2f\x46\x36\x31\xc9\xfc\x25\xee\xf0\x93\xfd\x9a\x78\x91\xbd\x75\x39\x86\x8f\x51\xa8\xec\x05\x87\xad\xc1\xb4\xf3\x92\xfd\x02\x4a\x18\xc8\xd3\x60\xc2\x18\xc5\x8e\xcf\xd4\x42\xe2\xb0\x57\x43\xcd\x92\x47\x85\x6b\x36\x9c\x63\x3c\x98\xc4\x66\x47\xd7\x22\xbe\xa1\xca\x4c\x00\xe8\x30\x2b\xb5\x11\xe6\xe9\xa5\x15\xa6\x6b\x81\xd2\x05\x62\xe8\x06\x11\x51\x08\xa3\xad\x5b\x17\x18\xa5\x5a\x42\x9f\x94\x22\xcf\x61\x49\xfe\xc6\xd5\x3f\xf8\xfc\x18\x3f\x7f\x26\xdd\x64\xce\x78\x2a\xe9\xc2\x75\x93\x68\xba\x2c\x97\x2d\x56\x50\x4c\x0a\x33\xe2\x2c\xf8\xf2\xbf\xfd\x3b\x70\xa0\x60\x44\x75\xa1\x7a\x7f\x40\x11\x67\x00\x78\x1f\x97\x5e\xf0\x81\x6a\xb1\x28\x6c\x9f\x87\x21\x45\x67\x03\xe0\x60\xc7\xd1\x8a\x05\x62\xdd\xf7\x4e\x38\x78\x73\xae\xce\xb4\xab\x10\xe7\xa4\x73\xb1\xf0\x34\x89\x72\x6f\x16\x31\xd7\x01\x49\x3f\xf5\x5c\x01\xe4\xef\xd7\x92\xb9\x29\xff\x8a\x6e\x83\xaf\xb9\xff\xcc\x65\x95\xc8\x83\x1d\x12\xf6\x55\x36\xd2\xf3\x67\xdb\xa7\xce\xaa\x5f\x53\x5d\xbc\xe9\x3d\xc5\xed\x1a\xee\x7c\x59\xc6\x43\x95\x8f\x5d\xeb\x98\xfc\x9a\x33\xed\x86\x51\xf7\x84\x4d\xa8\x34\xc0\x2b\x3f\xb2\x9b\xbf\x30\x4d\x79\xee\xa1\x6c\xb0\x4c\x23\x41\x45\xed\x3a\x29\xfa\x6e\xfc\x06\xf7\xee\x31\xb5\xac\x6c\x15\x41\x09\x4f\x96\x39\x85\x0a\x1a\x15\xea\x3f\x2d\xf4\xd2\x33\x5b\x0f\x29\x3c\xf3\x8c\x53\x64\x3c\x24\x3a\x43\x89\xbc\x71\x4c\x1b\xe3\x75\x70\x55\x7a\xbf\x93\xb9\x4c\x29\x0c\xc7\x37\xe8\xe6\xa8\x06\x58\x55\x2f\x99\x03\x2c\x72\xed\x2c\xed\x5f\x6d\xd2\xf8\x15\x60\xd8\xcf\x4a\x6d\x1b\x4e\x09\x75\x08\x28\x83\x3d\x30\x36\xec\xda\x52\x6c\x83\x1d\x61\x87\xd9\xcd\x01\x8c\x09\x23\x16\x5b\x95\x49\xb3\x06\xc6\x04\x1e\x6f\xc7\x1e\xe6\x5f\x80\x22\x4d\x4e\x1d\xb6\x5d\xc5\xfb\x2a\x45\x02\xc6\x50\xd9\x5a\xb8\x6d\x99\x5f\x86\x3c\x29\x13\xec\xe4\xf1\xe3\xe1\x16\xfa\xf6\xa2\x03\xc1\xaf\x6e\xfb\x85\x9b\x9a\x7b\xb6\x86\x8d\x0a\xb7\x7c\x6f\xa4\x43\x6b\x2d\x45\x0e\x0a\xd4\xdf\x2e\x92\x05\x84\xdd\x5a\xab\x7d\x9a\xf6\x86\xd5\xa4\xc0\xe8\x92\x69\xe3\x7d\x9b\x9b\xdc\x41\x8e\x95\xcb\xe2\x0a\x3b\x1b\xec\x56\x27\xa4\x9e\xf0\x1d\x43\xa4\x0d\xc6\xca\x35\xa0\xf2\x3c\x13\x9a\x6c\x51\xa4\x66\x93\xce\x23\xbc\x6a\x3d\xec\x23\x4f\xab\x33\xf6\xa3\x6a\x11\x9e\x3c\x84\x9b\x41\xfb\xfd\x9b\xb0\x45\x96\x97\xb1\x6d\xcb\x29\x4f\xb5\x77\xc1\x2b\x68\xbe\x0d\x84\xf5\x00\x89\x30\x95\x9f\x91\x37\xd8\x75\xcf\x23\x71\xd7\x43\x62\x9e\x40\x94\xde\xe3\xda\x8e\xd4\xa4\x52\x04\x5a\x3a\xf4\xc7\xd0\xea\xa5\x96\x67\x56\x84\x01\xd5\xc1\x0f\xb8\xbf\x39\x72\x6e\x68\xa3\x77\x80\xed\xd5\x6f\xda\xe7\x36\xc8\xf4\x2b\xb2\x87\xfd\x2d\x04\x72\x58\x66\xbe\x12\x63\x6c\xa5\x39\xd2\x78\x90\xfd\x03\xad\xb9\x6f\xfa\x3f\xe9\x65\xaf\x99\x0a\x99\x28\x6c\xae\xd0\x74\xc6\x2b\xfb\x76\x44\xf4\x39\x26\xde\x94\xe2\x4d\x40\x4e\x66\x28\xc1\x19\xd7\xd0\xc0\x64\xbb\xa6\x25\x8c\x8c\x26\x5b\x72\x2a\xb3\x1a\x41\x8b\x3e\xb1\x64\x83\x61\xc6\x73\xcb\x0d\x83\x8c\x1e\x29\x68\x95\xc8\x3c\x24\x45\x34\xdb\xda\x31\x03\xfb\xdb\x94\x94\x9a\x18\x45\x21\xb7\x36\x30\x0a\xf1\x5c\xe8\x7e\x53\x0e\x22\x22\x27\xa2\x27\xe5\xa9\x05\x93\x71\x3a\xe8\x41\xb3\x1d\x6b\x14\x9c\xa7\xb5\x1a\x71\x5c\xdc\xb2\x79\x1e\xa6\x96\xab\x0c\x97\x2b\x4e\x5a\x58\x22\x5f\x09\x43\x81\x7a\xb0\x38\x9a\x20\xb6\xb6\x08\x50\x59\xed\x44\x72\x9c\x8b\x67\xbc\x79\xad\xfe\xad\x94\x64\x41\xa2\xe4\x01\x14\x91\xc1\x00\x76\x8c\xf8\x11\x26\xe7\x5e\x30\xbf\xe3\x36\xe1\x7d\x65\x02\x7a\x91\xe7\x3d\x95\x92\xcd\x83\x66\x97\xbd\x01\x8b\xcb\x61\x1a\xca\x6d\x2c\xdc\xe0\x9b\x5d\xcb\x87\x81\x4f\x56\x08\x49\xb9\xea\x0f\x88\x4c\xa0\x01\x45\x12\x04\x9a\x98\xa9\xe8\xf1\x2a\x75\xd4\x73\xb1\x8a\x9e\xbc\x63\x03\xf6\x84\xb9\x9d\x49\x49\x82\xc0\xa0\x7e\x52\x24\x9e\x5a\x0e\x33\x7a\xae\x90\x57\xb3\xa7\x6a\x6f\x65\x9d\x46\x1c\x1b\x76\xcf\x77\xd1\x92\xd1\xc1\x3b\xa3\x4c\xf4\x04\x69\xc5\xc8\x60\x75\xa8\x56\x77\xc3\xc7\xcd\x10\xe3\x3d\xb3\x0f\xc1\xa3\xbc\x8c\xea\x82\xb6\xa0\xd7\x4d\xd0\x63\x6d\xb2\x7a\xce\x18\x90\x82\x64\x28\xfb\xa4\x61\xd0\xd7\xd6\x85\xaf\xdb\xd7\x8f\x83\x44\xc5\xca\x70\x11\x3a\x4c\x2c\x0a\xfe\x28\xac\xb8\xa1\x93\x45\x91\x65\x42\xc9\x86\xf9\x63\xc1\x85\x79\xdd\x8e\x23\x84\x1a\x4a\xb2\x2c\x80\x64\xd3\x48\x7a\x86\xfa\xdb\xdf\x47\xeb\x5d\x91\x41\x4f\x99\x99\x4a\xe0\x70\xd4\x58\xf4\x34\x75\x77\x2c\xeb\xee\xe5\x41\xe4\xef\xc6\x28\x1a\x31\x16\x3b\x25\xc0\xb0\xfe\xef\x14\xae\x99\x9e\xa2\x30\x1b\x77\x9c\xd7\x0d\x9e\x20\xc8\x55\xe4\xe7\x74\x9e\xa1\x18\x83\xea\xd3\xdd\xca\xba\x11\xda\x69\xf8\x2b\x18\x6d\xdd\x2d\x8b\xa5\x18\x3f\xfb\x50\xdd\xaa\x35\xcf\x83\x1e\x93\x4e\x57\x8d\x49\x0b\xea\x66\x3a\xea\x69\xe4\xa8\x90\xf2\x9c\x0b\xdd\xb6\xcd\xb9\xaa\xda\x80\xec\x9d\x88\x1c\xe3\x2e\xec\x22\x09\x8f\x0b\x1a\x2e\x9a\x15\x3d\x63\x65\x65\x45\x1e\x91\x9c\xfe\xb4\x0e\x0d\x4c\xce\xe1\xf0\x76\x63\xa4\xe5\xb3\x2e\x15\x22\x28\x19\x76\xee\x28\xc7\xac\x2b\x37\x2a\x2a\x0b\xe9\xdc\x24\x26\x27\x16\x2a\x07\xd2\x61\xb4\x96\x88\xb6\xcd\x80\x96\x14\xa2\x25\x02\x68\x73\x40\xab\xa1\x95\x29\x1e\xd4\xac\xba\x76\xae\xc1\x57\xd1\xea\xee\x15\x16\xec\x39\x78\x28\x26\xa6\xd3\x09\x70\x0d\x33\x68\x05\xe1\xfa\x85\x42\x08\x94\x44\x26\xf9\x86\xd1\x4f\xa1\x3d\xe0\x1b\x06\x83\xad\x66\x5b\x15\x72\x19\xab\xbc\x2f\x77\x57\xfb\x35\x70\xcf\x02\xa9\xd6\xd0\x6a\x71\x19\x6a\x87\x40\x69\x8f\x73\xe4\x0a\x46\xa5\x61\x05\x77\xad\x70\xe4\x7a\xad\x88\x0a\x6c\x9a\x95\x19\x08\xdf\x9d\x75\x1d\x9d\x29\xaa\xd9\xad\xb3\xa5\x0c\x87\x3b\xfa\x7a\x2a\x8d\x74\x74\x6c\x72\x78\xf4\x90\xba\xe7\x33\xa6\x6c\x0b\x47\xa7\x02\xc4\xf8\x01\x6d\x60\xff\xc1\xe1\x43\x91\xf7\x2d\x4a\xca\xdf\x5e\x7a\x2f\x02\xc8\xe1\xfd\xc3\x93\xa3\xe3\xd1\x60\x3e\xfe\xbc\x73\xf5\xc7\xf6\x07\xd7\xd4\x60\x0e\x0e\x1c\x1a\x38\x30\x14\x0d\x06\x83\xb2\xce\x0a\x81\x03\x82\x45\x09\x4f\x45\x1b\x02\xa4\x78\x4d\x99\xc4\x14\xf3\x16\xcf\x03\xa5\x32\x6e\xb6\x9c\x17\x25\x05\x3f\x44\x67\xbb\x85\xe4\xe7\xaa\xa3\x49\x31\xc9\x33\x0e\x27\x8f\xc1\x5d\x2f\xd7\x0d\xbd\xb4\x48\xb5\xd2\x54\x2c\x4b\x10\xbd\x2f\x42\xf9\xa1\xcb\xd7\xc1\x1c\x1f\x52\xfd\x4c\xb1\x49\x02\xa3\x7b\x4b\xb5\x61\x2a\x3f\xfd\x4d\xce\x10\x88\xfc\x4c\x85\x52\xb0\x14\x1b\xc5\xb8\xac\x60\xf2\xaa\x30\x39\x49\xd9\x8d\x3c\x42\xd8\xf1\x22\xb8\xe9\x09\x6a\xf9\x19\x33\x8b\x68\xfb\x4a\x80\x88\xaa\xe2\x71\x4a\xb9\xc7\xde\x56\xc5\x11\xd0\x10\x8a\x38\x82\xd1\x04\x19\xa9\x51\x9c\x43\x51\xde\x86\x53\xa3\xb0\x44\x51\x4f\x22\xfe\xde\x09\x45\x55\x9e\x15\x9e\x78\x22\x90\x79\x3c\xe4\x3e\x34\xda\xd4\x53\x32\x50\x11\x8b\x1d\x19\xa6\xa1\xc4\xd7\xa9\x74\x91\x11\x6d\x5f\x48\xc2\x2e\xcd\x42\xc4\xce\xb3\x03\xc6\x17\x3e\x8f\x31\xc1\x24\x54\x98\x82\x61\xd6\xad\x2a\x76\x89\xd6\x67\xc1\xaa\xe5\x8b\xc5\xaf\x95\x0d\x75\x34\xa7\x27\x8e\x9d\x6d\xa5\xf5\x33\x4f\xee\x9f\x20\x65\x15\xca\x9d\x40\x10\xaf\x37\x63\x93\xf4\x10\xc8\x68\xbb\xe5\x8f\x93\x0d\x04\x5f\xb9\x81\xee\xd9\x08\x31\xa6\x9b\x25\x6f\x7c\xb8\xb2\x38\xcb\xa9\xce\xa5\x2b\xaa\x52\xe0\x2a\xe0\xb6\x4d\x45\x8f\x18\x79\xea\x70\xa7\xa0\x02\x97\x8c\x6b\x28\x46\x1c\x62\x5b\x5c\x23\x9a\x43\x63\xa1\xcc\x91\x42\xac\xe4\x20\x7f\x19\x24\x08\xa1\xa7\x02\x9a\xa2\x2c\x76\xe7\xde\x35\x5e\x67\x3e\x68\x70\xf3\x66\x03\x8a\x40\xf2\x18\x62\xc5\xcf\x47\xba\x66\xec\xe0\x7c\x82\x37\x81\x3c\xe6\x16\x11\xac\x93\x28\x46\x47\xc0\xd0\xd8\xee\x72\xd2\xe4\x5c\x31\x5e\xd1\x1b\xc5\xf9\x64\xf0\xe1\x20\xb9\x7e\x7f\xfb\x36\x14\x66\x7f\x72\x6f\x69\xfb\xfd\xef\x04\xfa\xea\xf3\x03\x3c\xac\x68\x4a\x72\x0a\x09\xa4\x52\xf1\xc6\x44\x8d\xd8\x5a\xcd\x95\x5e\x58\x32\x05\xea\xc6\xfe\xd1\x24\xaf\xae\x10\x14\xa0\x7b\xa0\xcf\xcf\x15\x1c\xf1\x32\x4f\x8e\x38\x0f\x17\x6c\x8e\xf7\x26\xf6\x49\xb6\xf3\xdf\x6b\xaf\x63\xb4\x00\xe0\xa6\x2a\x0c\x1b\x3d\x57\xcf\x3c\xc5\x14\x23\x24\xb6\x1a\xe3\x2e\x90\x88\x49\x9e\x08\xcb\x66\x48\x04\x9a\xdd\x11\x4b\x00\x9f\x89\xf9\x6a\xc3\x9c\x5d\xcc\xca\x17\x46\x1d\xaa\xd4\xc3\xd6\x36\x41\xd0\x6b\x58\xc3\x94\x4e\x3e\x26\x05\x2a\xec\x0a\x0a\xa1\x78\x94\x16\x42\xf0\x45\x1e\x49\x59\xe8\x7f\x40\x5e\xb6\x03\xe2\xfc\x10\x5b\xe7\x1e\x31\x9d\xc5\xaf\xb9\x2c\xe3\xad\xa9\xf5\x25\x26\xff\x40\x9c\xed\xf6\xed\xc7\x10\xbd\xb1\xbc\xb2\xf5\xf5\xb5\xf6\xd9\x8f\xb0\x60\x54\x0b\xa8\x23\x32\x2f\xe5\x8a\x5c\x8a\x49\x41\x44\x8d\x4f\x4b\x14\x5b\x47\x15\x65\xa3\xc0\x3e\x36\x80\xc9\x8d\x5e\x51\x2a\x65\x11\x48\xba\xe0\xa5\x88\x98\xa2\x5e\x05\xbc\x67\x8c\x18\xbf\x12\x1f\x39\x1c\x88\xca\x94\x94\x16\x19\x70\x73\x54\xad\x90\x80\x5c\xe0\x6d\x8a\xd6\xcd\x8a\xe0\x1a\xcf\xe6\x09\x0f\xa7\xbd\xe2\x8f\xdb\x55\x44\xb9\x27\x32\xd6\xc3\xb8\xfd\xa1\x78\xc4\x21\xaf\x78\x4b\x39\x8a\x2d\xdd\x42\xb4\x99\x45\xa8\x05\xc4\x34\x30\xb3\xd8\x2c\xeb\xf5\x44\xf5\x5d\x44\x45\x3e\xc9\xb3\x1a\xb8\x6a\x40\xb0\x6a\xb4\x6e\x42\x79\x5d\xc5\x79\xcb\xb2\xdd\xb4\xae\x72\xd9\x82\x46\x37\x18\x95\x06\x9f\xfb\xb4\x57\x2c\x38\x55\x30\xb8\x42\xaf\x1b\xb8\x5d\x6a\xb0\xeb\x1b\x0d\x92\x2e\x33\xa0\x09\xdb\xb6\xe1\xe4\x90\xd9\x10\xb6\xcb\xf3\x33\x55\x77\x16\x1a\xc7\x15\x9e\x62\x38\x2d\x98\xa8\xf5\x94\x09\x3b\x6e\xde\xf4\x18\x6f\x9e\xdc\xbb\xd6\xb9\xf4\x83\x27\x31\x1c\x2e\xaa\xec\xad\x8f\xbc\xc9\x92\xb7\x50\x69\xb8\x22\x6c\x2e\x1b\xbe\xbb\x98\xf2\x3e\xc4\x09\x44\x96\x2a\x4d\x9f\xd3\x23\xd2\xb3\x3d\x86\xa6\xad\x8f\xbf\x4b\x6a\x6e\xf6\x55\x6f\xa7\x58\x66\x30\xb6\x4b\x69\x89\x32\x47\xc8\x95\xdb\x33\x5d\xfa\x23\xcd\xe4\x11\x36\x00\xa6\xb6\x9f\x5f\x03\x9a\x49\xd1\xd0\x52\x65\x95\x35\x61\xdb\x4c\x3a\x6d\xbc\x2a\x45\x44\xa0\xfb\x2e\x43\xca\x30\x6b\x0e\xc9\xa4\x82\x09\x9c\x46\x20\x7d\xa0\x7a\x42\xc2\xd8\x6f\x1e\x72\xe4\x6b\x92\xb1\x81\x11\x8e\xa7\x3b\xdf\x9f\xf4\x65\x57\x46\x22\x82\x09\x91\x4e\x1b\x8e\xd0\x7b\x7c\xe2\x19\x07\xe0\xa4\x2e\x09\x1f\x85\x14\x64\x2e\x72\x1b\x0d\xc6\xa4\x76\x83\x16\xb7\xd8\x08\xe3\xab\xcf\x62\xac\x3c\x82\x9d\x42\x5c\x88\x61\x49\x9b\xda\xe3\x49\x47\x9f\xda\xe3\xb3\x22\x39\xc9\xa8\xe0\x80\xe2\x49\x1d\xf8\xaa\x4a\xcc\x04\x01\xa2\x08\x60\x68\x9d\xa0\x30\xf9\x90\x3a\x8a\xa1\x65\xbd\x22\x6d\x52\xec\x06\xdb\x3e\xf9\x05\x68\xa4\x04\x53\xed\x61\x8b\x90\x35\x9c\x16\x7f\x68\x32\x45\x90\x91\x82\x9f\xa9\x33\x66\x55\x87\x24\x33\x27\xf9\x1a\x74\x94\x45\x76\x95\xd6\x46\x27\xfa\x55\xf9\xc4\xdb\x37\x5b\x9d\x6f\x96\x95\x75\xcb\x40\x02\x7e\x28\x30\x5c\x67\x80\x34\x8a\x7d\x6d\x3f\xfe\x84\x1f\xa9\x81\x4c\x08\xdf\x01\xda\xaf\xc8\x2f\x1e\xf3\xb5\xaf\x11\xea\x93\x9c\x06\xdd\xac\x9a\xa2\xb8\x49\xea\xae\x36\x12\xbf\x89\xfc\x67\x14\x58\x77\xc3\xf6\xaf\x67\xcf\xc6\x11\xde\x3f\xc4\x02\xfb\xe2\x08\xbb\xe1\x9a\x50\x2c\xd9\x3b\x81\xae\xd1\xf7\xc2\xf6\x4e\x26\xf3\x34\xea\x10\x5e\x0c\x01\xc2\x9c\x85\xd8\x89\xaa\xcf\x55\x2d\x9b\xa9\x15\xa8\x87\xd9\x8d\x92\xba\x02\x08\xbc\x47\x4c\xb3\xbd\x7a\xbf\x73\xe9\x0e\xdc\xbb\xe9\x05\x64\x8d\xf7\xef\xb7\x4f\x7f\x1c\x77\x7b\x46\x04\xe0\x0d\x5d\x2b\xa3\xc9\x75\x96\x07\x01\xc3\xd9\xe9\xbb\x4f\xfa\xae\x8f\xba\x53\x56\xc6\xb9\x61\xf2\xf4\x72\x61\x1b\xb1\xe8\x24\xdc\x3f\x34\xa0\xcd\xe8\x45\x26\xac\xd4\xa2\x3d\xe4\x8e\x26\x6a\x7f\x79\x5a\x4d\x49\xd5\x70\x44\x3d\x4f\xa7\xd0\xb1\xf7\x49\x7e\xcf\x64\xca\x45\x72\x42\x00\xb6\x0b\xb4\xc6\x4a\x4c\xcf\x0b\xeb\x85\x30\xb2\x67\x02\x0f\xd4\x3a\x40\x39\x03\x90\xa9\x78\x4c\xa7\x0e\x99\x0d\x52\x58\x94\xa7\x0d\x65\x35\xae\x0b\xcb\x88\x4f\x74\x5f\x05\x90\x48\x89\x8c\x48\x5a\x4c\x56\x41\x85\x92\x0a\xd3\x6b\xd8\xfa\x95\xac\x63\xd5\xb2\xa5\x83\x0b\x95\x4b\x34\xd0\x6d\x8c\x8a\x64\x32\x50\x4a\xb3\x27\xf7\x96\x3a\x57\x96\x23\x17\x76\x49\xb4\x91\xb8\x43\xc6\x13\x91\x66\xe6\x15\x63\x0c\xf9\x53\xa7\x9f\x5e\xb9\x01\xc8\xf3\x4a\x12\xab\x7c\x5b\xc1\x87\xb3\xed\x8b\xe7\x9e\xc2\xbd\xf1\xcc\xd6\x95\xfb\x5b\x1f\x5e\x15\x73\x8c\x2a\xa8\xc0\x26\x4a\x49\x1b\x78\x0d\xc6\x9a\x0f\x4c\x9f\x87\xb8\x01\xbd\xdc\xaf\xfd\xab\x0d\x55\xf9\x31\xa5\x17\xd4\xb9\x68\xcd\x0c\x84\xc6\x1d\xa1\xc1\x6f\x88\x16\x01\x7f\xc7\x6b\xcf\x69\x5e\x35\x06\xb0\xfe\x1c\x03\x20\x97\x85\x05\xd5\x41\xf0\x5f\x6d\xe8\xb8\xe3\xe9\x2c\x70\x2b\xe4\x39\xe5\x3c\xb0\x6a\x79\x58\x21\x74\x37\x8a\xdf\xed\x35\x40\x75\x9f\xa8\xea\x38\x79\x56\x98\x9a\x5c\x9d\x83\xdc\xda\x66\x0d\x0a\x46\x41\xfc\x35\xd7\x6d\x91\x09\xd8\x53\x54\xc9\xbb\x01\xa7\x19\x70\x66\xa4\xf4\xbc\x83\xb6\x40\xee\xca\x0f\x45\x0a\x0e\xa5\x10\xbb\xc8\xad\xc0\x85\xd6\x49\x48\x71\x2a\x8c\x7a\x4b\x95\x83\xad\xe9\x6f\x4e\xe5\x29\xa9\x0e\xcb\x39\xa9\xf1\x83\x04\x04\x12\x71\x25\x46\x62\xe7\x3b\xd8\xaf\x99\x3a\x7c\x3a\x54\xed\x8f\x90\xd8\xa8\xf2\x2b\x93\x52\x39\x19\x88\x85\x97\x94\x8e\xc7\xb1\x66\x9d\x87\x50\xd0\xe5\x5b\xea\x6a\x41\xa4\x8a\xaa\x1c\xe6\xde\x9c\x83\xef\x61\xef\x38\x58\x05\xdc\xfe\x09\x8b\x2a\x85\x60\xe3\x31\x8d\x24\x47\xc6\x6f\x51\xc9\x82\x8b\x3d\x0f\xed\xe0\x78\x2f\x5a\x88\xb0\x83\x3e\x61\x22\x25\x00\xd3\x82\x49\xaf\xe4\x85\x0a\x63\xb3\x34\x9d\xbb\x91\xe4\xf3\x63\x6a\x21\xd3\x09\x7d\xa5\x3c\x9c\x5a\x85\xbc\x91\x18\xa5\x0c\xc0\x1c\x2e\xa3\x89\xea\xef\x10\xac\x12\x23\x42\x09\x7b\xa8\x46\x55\x26\xe3\xea\x5e\x90\x21\x30\x0d\xf8\x97\x0e\x5a\xb1\x21\x5f\xe8\x57\xd6\xbe\x6f\x9f\xfd\x88\x09\xd0\x40\x39\xf7\x10\x3c\xb4\xbd\x21\x1b\xca\x55\x65\x71\x3a\x9f\x7d\xd7\x3e\xcf\xbe\x5c\x96\xf4\x5b\xf0\x83\x3a\xdf\xcb\xe1\x0c\x88\x54\xe8\xdc\xb0\x0f\x93\xb6\x1f\x82\x57\xa8\x73\x32\x5b\x6f\xfc\x2e\x8d\xeb\xd8\x57\x54\x94\x82\x58\xfc\x90\xb2\xf8\x92\x09\x3b\x60\x0f\x0c\x00\x13\x09\x79\x8c\x8f\x98\xf2\x27\x2a\xfb\x40\x70\xfc\x5e\xe3\x2d\x51\xaa\x19\x83\x45\x2c\xec\xad\x01\x0e\xb5\x66\xb9\x41\x7a\x0f\x42\x40\x0f\x08\x3b\xa5\x85\x9f\x10\xcb\xa8\xaa\xb2\xef\x05\xb7\x9d\xf3\x16\xf6\xb9\xea\x26\xa9\x79\x02\xcd\x56\x7c\x64\x60\x8b\xc8\x2f\xfa\x9e\x80\x0c\x30\xa3\x5c\xb9\x81\xa9\x6f\x54\xb6\x6e\x35\xe8\x7e\xf4\x57\x69\x0d\x8f\x69\x8b\xa8\xb5\x9c\x88\x70\x64\xdd\xd8\x55\xd2\x79\xa3\xe7\x9e\x7b\x02\xfa\x58\x38\x91\xed\xc0\x3f\x89\xc0\x36\x48\x69\x37\x18\x1f\xfa\xaf\xc3\x43\x13\x93\xca\x66\xb7\x78\x57\x50\xe8\x12\xe3\x43\x13\x63\xa3\x87\x26\xd4\x35\x09\xb0\xad\xa2\xea\xe5\xd1\x91\xa1\x89\x08\x69\x86\x7d\x2a\x95\x82\x65\x7c\xf4\xf0\xe4\x90\x3a\x0e\x07\x9c\x0c\x8a\x17\x99\xbc\x29\x60\x59\x30\x37\x0b\x17\xb6\xb8\x59\x9d\xb5\x50\x6d\x01\x1b\x42\x3d\xa2\xc5\x88\xd8\x9e\xeb\x9d\xe3\xef\xb5\x3f\xfb\xc6\x69\x19\x82\x26\x6b\x47\xb7\x70\x0f\x86\xed\xdb\x77\x98\x86\x4a\x16\xa6\xf6\xd7\xcb\x20\x4c\x25\x13\xae\x72\x7e\x86\x0e\x37\xd0\x92\x01\xde\x76\x86\x60\x8d\x9d\x65\x06\x6f\xd7\x63\xff\x07\x69\x49\x95\x9a\xba\x69\x56\xfb\xce\x8d\xad\xb5\x15\x52\x67\x9c\x5a\xdf\x92\x2e\x83\xc8\xb5\x56\x3c\x90\x12\x20\xc2\x7d\x26\x07\x2d\xf6\x37\xb5\xac\x73\xfe\x14\x12\x1d\x7a\xd5\xb0\x0b\xcb\x22\x18\x35\xe7\x60\x73\x5b\x45\x53\x17\x8a\x31\xd3\x0d\xff\x43\xed\x5b\x89\x00\x8b\x7a\xfb\xa7\x14\x73\xf7\xf4\xd2\xf5\xa7\x4b\x9f\x3f\xf9\xf1\x23\x6c\xdc\x75\xca\x53\xb5\xc1\x53\xfd\x1c\x75\xe3\xd0\x69\xe7\x32\xd7\x8c\x33\x49\x8f\x10\xf7\xac\x84\x44\xf5\x7b\x3a\x3d\x51\x55\x94\x1a\x77\xde\x8c\x96\x4b\x41\x37\x0b\x63\x76\xc8\x0f\x36\x8e\x05\x7e\xfa\x8f\xa9\xe6\x8b\x2f\xfe\x32\xde\xf1\x15\x3e\xb2\xd0\x34\x84\x83\x27\x74\x70\x5e\x71\x52\x81\x80\xc6\x0b\xa3\x45\x96\x53\x01\x52\x71\x44\xa3\x08\x56\x63\xca\x69\xb0\x6c\x4c\x88\xe6\x8b\x14\x1b\x2c\x5b\xcd\x92\xf6\x2a\xdc\x7d\xea\x8b\xaa\x45\x4d\x94\x73\x11\xd4\xab\xbd\xc0\x45\x8b\x50\x8f\x82\x9b\x88\x05\xbc\x33\x12\x69\x15\x41\xf5\xb9\x8b\x09\xf9\x93\x2e\x42\x75\xf3\x1c\xe6\x53\x34\xcc\x05\x74\x21\xb9\x2d\x86\x8b\xec\xbe\x47\x41\x14\xbc\x66\x68\x64\xf9\x44\xb9\x9d\x9e\xa2\xaf\x30\x6c\xb2\x73\x0c\x97\x3f\x93\xdc\x8d\xbd\xdd\x8f\x43\x58\xba\xcd\xf0\x62\xa4\xe6\xb7\x58\xb7\xf6\x3b\xb5\xa5\x32\xcb\x25\xde\x34\xd7\x0e\xa1\x32\x76\x02\x9c\x81\x4b\xb0\xd0\xd9\x2b\x3a\x96\x74\xe5\x46\x3a\xba\x85\xf8\xb2\xae\x32\xa6\x5b\xad\xb1\x43\x79\x7b\x6d\x45\xe8\x27\xe4\xeb\x82\x6b\xac\x7f\x71\x9c\xfe\xb2\x90\x63\xfd\xc0\xa9\x76\xe4\x75\x5a\xaf\xb6\xef\x9c\x0f\xef\xc2\x7b\xe2\x6c\xfb\xde\xd7\x5b\x7f\x79\x17\x35\x29\x8f\xc4\xca\x40\x44\xb7\xba\xe8\xcf\x99\x9a\xe1\x5e\xe9\x3c\x49\xcc\xc9\xea\x6f\x6d\xa2\x8e\x3d\x4c\xd4\xc9\x24\xdd\xe0\xbc\x85\x05\xf4\x1d\xc7\xb5\xa3\x8a\xb2\x09\xf2\x0f\x04\xc5\x3c\x6d\x49\x48\xd3\x4b\x8d\x44\xb3\xce\x1b\x40\x71\x1c\xaa\x51\xd5\x39\xdd\x1b\x3b\x1e\x41\x87\xc7\x47\x34\x95\x56\x14\x3d\x2c\x36\x63\x93\xca\x7c\x90\x57\x96\xb1\x66\xea\x42\x1e\x54\x07\x4e\xf6\xc9\x4a\x0d\x65\x52\xe1\x54\xf5\x64\x85\xa8\xd4\x56\x4f\xcc\x5c\xba\x49\x53\x49\x82\xcc\xeb\xed\x68\xcc\x19\x56\xda\x9f\xc5\x04\x87\xd2\x11\xbd\x2e\x9f\x76\xfe\x2a\x14\x70\xa7\xb4\xfc\xf1\xd5\xfb\x38\xd3\xc2\x99\x06\x1f\x84\xb6\x6a\xc3\x37\x83\x14\xc2\x74\x98\x4d\x2a\xca\x70\xe5\x7f\xd2\x8d\x55\x0c\x8b\xcb\xde\xa7\xc9\x7c\xee\x1f\x98\xdb\xb3\x55\x95\x31\x90\x6c\xd2\x8a\x79\xa7\xed\x37\x4b\xc6\x1a\xc8\x1c\x52\xe2\x1a\xbe\x2d\x7a\xff\x13\xfd\xb0\x66\x3c\x34\xd5\x44\x56\xe6\x53\x73\x69\x48\x5f\xb3\x79\x79\xa9\x48\x5f\xe3\x94\x76\x82\x8e\xde\x51\xfd\x94\xf4\x0e\x2e\x7c\x03\x2e\xdf\x05\xa6\x43\x14\x25\xfe\x93\xe6\xff\xcc\x08\xb9\xa3\xf4\x7a\x36\xf4\x68\xd2\x05\x85\x89\xd6\xfc\x36\x26\x60\x5b\x8d\x31\x27\x7b\x1e\xdb\xe9\x2d\x89\x67\x86\x3b\xcd\xbc\xe8\xa5\x9e\x5d\x0e\x23\x62\x48\x88\xee\x56\x3e\x4a\x5e\xf2\x08\x82\xac\x20\xcc\x41\x14\xc2\x89\x11\xd7\x7c\xa0\x3c\xb4\xb2\xee\x46\xee\xba\x59\x53\xc6\xe1\x93\x26\x43\x67\x02\x9f\x4c\xbf\xc9\x08\x5a\xdd\x62\xcb\xa9\xc0\x92\x16\x2e\x77\xb5\x78\xb7\x91\x63\x7f\xf8\x19\x48\x04\x76\x19\xf6\xcc\x05\x74\x78\x3f\x8d\x92\x6e\x50\x20\x96\x5b\x3d\x9d\x0c\x28\xaf\x88\xbf\xfd\xb4\xf3\xfd\x10\xd5\x2f\xc5\xbf\xa5\x15\xa0\xdd\xb9\x04\x7e\xe9\x72\x52\x81\xd5\xf5\x73\xc0\x8e\x2c\x6b\xee\x6b\xe3\x95\x69\x9c\x8a\x09\x67\x94\x6e\x3a\xd1\x82\xd1\x3b\x72\xca\x69\x26\x9c\x63\xc0\xec\xe3\x37\x1a\xfe\x04\xd5\xec\x18\x8f\x73\xe8\xfc\xba\xe6\x19\x41\x09\x30\x86\x4a\x38\xb9\xe4\x94\xbe\x0c\x23\xe6\x0e\x52\x4d\xd0\xc5\x4b\x39\x1f\xa2\x12\x61\xe4\x6f\xb3\x92\xa5\x66\x45\x47\x01\x27\xae\xb7\x3c\x4e\x1e\x1a\x27\x13\x65\x62\xe2\x35\x0a\x71\x2d\x5b\xc7\x28\x36\x3d\xf9\x59\x4c\xa9\x87\x08\x02\xeb\x20\x50\xf9\xcf\x8b\x5e\x9f\x82\x27\x23\xa5\xfd\xd9\x37\xed\x3f\x9f\x8e\x3d\x01\x43\x51\xa4\x26\xfe\x25\x08\x72\xf3\x35\x13\xe0\xc1\xde\xd8\x19\x2c\x46\x79\x89\x28\xfb\x7f\x17\x3f\x9c\xc0\x30\xa2\x07\x0a\x63\x94\x98\xec\x9a\xd4\xb7\x5f\xaa\xc3\x92\x7d\xbe\x64\x87\x52\x06\x77\x05\x17\x58\x6d\x8c\xa5\xb8\xc6\x9a\x6d\x34\x4b\x56\xa1\xd1\x58\xc4\xb5\x8d\x0c\x7a\x97\x9e\x25\x0f\x69\xe7\xcc\x06\x18\x7e\x97\x2f\x88\x10\xd9\x18\xfc\x21\x97\x31\x8d\x96\x75\xe2\x6c\x58\x93\x92\x04\x83\x84\xea\x45\x3f\x25\x59\xaa\xd2\x86\xd4\x24\x49\x24\x1e\x28\x37\x39\xcd\x02\xf8\xba\x5e\x45\x02\x06\xaa\x87\xf9\x81\x18\xea\xd4\xb7\xcc\xd9\x89\x9e\x69\x75\x7b\x96\x87\xef\x55\xff\xd5\x72\x3d\xda\x9b\xe4\x90\x57\x9a\x70\xfc\xa9\xde\xa8\x9b\x06\x19\xef\xcc\x6a\xc9\x5c\x30\x4b\x4d\xbd\xec\x04\xf2\x61\x23\x47\x74\xc8\xb2\x21\x1a\x4d\x65\x22\x34\xfa\x5b\xb6\x4e\x7f\xdf\xb9\xdb\xc2\x46\x4a\xad\xcd\xd6\x8d\xf6\xd2\x0a\xc5\xc0\x87\x84\xd8\x51\x33\x27\x27\x45\xe7\xdc\xa5\xf6\xa3\xcb\xce\x02\xa9\x02\x01\x5c\x54\x4b\x90\x1d\x54\x2b\xeb\x94\xbf\x38\x3a\xe0\xb4\x00\x75\x12\xf6\x9c\x26\xff\x90\x54\xa5\x4e\x9b\xe2\xad\xfc\x7f\x14\xb1\x4f\x3c\x83\x9c\x83\xf4\xb5\x09\x95\xd0\xbc\xb9\x7d\x6d\x75\xeb\xc6\xfd\x58\x9e\x52\x60\x3c\x67\x2e\x18\xc8\xc0\x3d\xb6\x36\xd7\x34\x4b\x7d\x9a\x36\x00\x75\xb8\xf1\x0c\x98\x37\xf4\x32\x1b\x1c\x2b\xbb\x22\xd1\x21\x86\xba\xd6\x74\x93\x11\xb1\xb9\x93\x8d\x71\x95\x75\x03\xd2\xac\x54\xbb\xda\x5b\xb6\xf6\xaa\x64\xdd\x5e\xd7\x0e\x1c\x1e\xde\xaf\x45\x4f\xca\x8d\x91\x94\x5e\xa4\x16\x18\x14\x9f\xde\x59\xba\xe5\x84\x35\xd0\xe2\x8b\x58\xe0\x0d\xc7\x42\xdd\x39\xfd\xe7\xf6\xc9\xef\xa5\xa0\x75\x75\x69\xec\x18\x72\x31\xc1\x17\x46\x2e\x1f\x71\x30\x46\x23\x03\x71\x1c\xe3\x73\x2a\xca\x38\x6f\x11\x59\x76\x72\xfa\x5c\xed\x4e\x40\x02\xc7\xbc\x91\x89\x47\xbc\x55\xd7\xd3\xb1\x89\xe7\xdd\x5d\x23\x49\xe1\xa8\xb1\xb8\x9b\x64\x71\x6b\x3e\x3e\xef\xf4\x81\x53\x39\x09\x65\x50\x7f\xc8\x46\x17\x8f\x8b\x2e\x25\x39\x3c\xef\xee\x02\x39\x1a\x7a\xf1\xa8\x43\x0e\x35\x35\xe0\xb1\xcc\xd4\x80\x83\x99\xea\xc0\xa7\xa7\x86\xf4\x6e\x9e\xd4\x70\x92\x6f\xa4\x43\xdd\x96\x4f\x75\xf8\xd1\xd0\x8b\x94\xd3\x5b\xa0\xa4\x32\x7a\x56\x75\x6e\xd2\x49\x0f\x59\x60\x14\x6b\xf5\x57\xf6\x5f\xe9\xed\xb0\xa0\xfa\x5b\xbc\xa9\x52\xb4\x32\x20\x67\xe1\x04\x14\x83\x98\x79\x86\xd5\xa0\xc8\x5c\x4a\x25\xa6\x3a\x8a\x9c\x03\xd4\x35\x92\xd9\xeb\xa3\x24\x2f\x79\xd2\x15\xc2\xf5\x26\xf5\x6e\xa0\x76\x21\x24\x4c\xbd\xc5\x95\xfd\xf1\x7b\x8e\x58\x49\x9e\x7c\x9c\x22\x60\x2f\x59\xbb\x7f\xfe\x79\x2d\xe5\x94\xd1\x26\xe3\xec\x0b\x98\x30\x30\x36\x94\x30\xe4\x9b\xc2\xee\xde\x18\xe9\xed\x60\xc3\x99\x1f\x27\x7e\x36\x6c\xef\xb8\xaa\xb5\x2c\x4a\x92\xdc\x96\x42\x66\xc4\x50\x7a\x95\x26\xf2\x2a\x9b\x57\x1e\xa6\xd5\x20\xc8\x5c\x50\xce\xb6\x9f\xbb\x9f\x4e\xa6\xad\xdf\xfd\xd4\xe2\xa5\x40\x0e\x7c\xd7\xad\xc0\x48\x32\x4d\xe1\xb2\x7c\xcd\xb2\x1b\xdc\xf5\xc0\xfe\xda\x8f\x9d\x47\xf8\x5d\x96\xfd\x3d\x04\xc1\xeb\x06\x5e\x5b\x53\xd5\x9e\x49\x00\x7e\xdf\xdb\xa2\xb7\x4c\x2e\x03\xe1\x07\x06\xeb\x98\x4e\x61\xf7\x33\x98\xfd\xd6\x08\x96\x37\x09\x09\xbc\x65\xc8\x65\x1b\x94\xdc\xb8\x09\x4b\x26\xfa\x7c\xbf\x19\x52\x5c\x7c\xe3\x4a\x95\x00\xd2\xcc\x96\x2f\x47\xfa\x19\xf3\x9e\x08\x0e\xb5\xeb\x07\xe0\x4f\x86\x88\xd3\x8e\x3a\x3d\xcc\x68\x72\xa9\x5f\x84\x3d\x08\xe1\x58\x87\xc7\x87\x45\xf7\x7f\x27\x73\x51\xae\xfc\x21\xba\x34\xc1\xde\x85\x67\xf5\x66\x83\xf1\x60\xc3\x2c\x42\x20\xae\xda\xd5\x46\xfb\x8b\x4e\x2d\x0c\x9f\x15\x63\x05\x93\xea\x41\x39\x4c\x50\x47\x04\x75\xc8\x4f\xd1\x10\x2b\x32\x51\x20\x1d\x0d\x0e\x58\x01\x78\xfb\xfd\xdb\xed\x95\x8b\x14\x40\xe8\x2d\xe2\x1b\xad\x42\xc2\xb9\x1f\x33\x93\x35\xd5\xab\x24\xa8\x87\x24\x69\x76\x44\x48\x33\x5c\x5d\x5b\x99\x0e\x12\x29\x7f\x15\xd6\xa1\x89\xa1\x41\x36\xd7\xc9\x37\xb4\x03\xe3\xa3\x87\xc7\x94\xfa\x52\xbc\xe6\xa0\x02\x3f\x7e\x64\x78\x70\x28\xb2\x5a\xad\x7c\xbf\x8b\xa9\x59\xcb\xc1\xa9\x8b\xe7\xba\x90\x14\x00\xc6\x06\x62\xb1\x71\x75\xab\x38\x6c\x08\x58\x64\x0d\x5d\x0f\xb8\xe8\x4a\xba\x04\x6e\xff\xd0\x91\xa1\x91\xd1\x31\x65\x35\x5d\x19\xe0\xd3\x4b\x2b\x5b\x57\xee\xc7\xe0\x17\x5d\x9c\xd7\xa3\x4a\xc2\x8d\x22\x59\x95\x5e\x04\xad\x5e\x06\x17\xa6\xe2\xf5\x89\xd7\x78\xda\x68\x26\x27\x0d\xbc\xce\xc4\xd1\xd6\x87\xdf\xc0\xfd\xa8\x5b\x8f\xcd\x5a\xe7\x4f\x5f\x6c\x7d\xff\x97\x18\x2d\x77\x82\xc9\xa7\x9f\xad\x6f\x01\x09\x82\xd4\x73\x5b\x42\x24\xd3\x5a\x26\xc4\x85\x26\x5a\x36\x25\x91\x20\x2a\x09\xe5\x2d\x69\xcf\x50\x17\x97\xa8\xe9\x39\x7e\xda\x25\xab\x0a\x94\x00\x85\x50\xe8\xa9\x73\xfe\x12\x60\xcc\xbe\x33\xea\x75\xab\x3e\x5d\x89\x6b\xeb\x9c\x15\xeb\x90\x11\x14\xc8\x96\x8d\xa2\xd3\x6b\x42\xdb\xcb\x2e\xab\x68\xbd\x61\xfa\x34\xe8\x17\x70\x58\x1f\x35\x6b\x2f\xa8\x17\xd6\x13\x78\xf5\xb4\x75\xaf\x73\xfa\xaf\x72\x26\xb4\x53\x98\x6c\x08\xe1\x71\x13\xe0\xf2\x85\xce\xe9\x07\xae\x6e\x0d\x5f\x1e\x47\xed\xf9\xb2\x48\x79\x8e\xc6\x96\xf6\x5c\x5a\x64\x9d\x60\xab\x9d\x47\x13\xdb\xa3\xe3\x02\xf4\xd2\x3f\x4c\xba\x95\x0c\xe8\xfd\xfe\xe2\xcb\xbd\x5a\x45\x34\xf6\xe6\xd5\x07\x41\x1f\x92\xa2\xfe\x67\x8c\xa2\xde\xa4\xe2\x4c\x4e\xb9\xed\x9a\x54\x5a\x58\x1d\x4e\x96\x04\x1d\x7e\xa5\x25\x7c\x7e\xf5\xe2\x2f\x03\x08\xc2\x57\x0e\x86\xd0\x5d\x55\x54\xab\x63\xaa\xda\xbc\x55\x37\xff\x48\xe5\xea\x6a\xbc\x9a\x25\xde\x2f\x9d\x72\x4b\xd4\x9c\x35\xe6\x80\x76\xba\xb6\xaf\x62\x4e\xdb\x03\xa6\x78\x89\x7b\xef\x5d\x2a\x3c\x82\x98\x61\x41\x08\xf1\x08\x17\xe7\xf4\x23\x62\x09\x3f\xfb\xbb\x9e\x4b\xee\xe8\xab\x22\x11\x54\x2a\x71\x4c\x1d\xab\x5a\x1b\x21\x91\x08\x71\x7b\x3a\x8a\x84\xfd\xda\x00\x65\xbb\xb2\xc5\x2a\x19\x55\x6c\x9a\x88\x94\x2b\x59\x48\x38\x6c\x24\x51\xab\x9b\x0b\x66\xd9\xe0\x25\x13\x8c\xb7\xd8\x8e\xc5\x34\x48\xd3\x8e\xab\xf1\x97\x92\x6c\xfd\x9a\xb7\x8a\xe1\x46\x67\xe5\x42\xfb\xfc\xcd\x60\x05\x24\x61\x4d\x92\x6a\xfc\xb1\x5b\x2b\xa7\x11\xe8\xc4\x5b\xa7\x7e\xe8\xac\x7e\x19\xaa\x61\xa7\x26\x13\x5c\x29\xeb\xf5\x09\xfc\x6a\x90\x7d\xf3\xce\x3b\x5e\xc6\xa3\xdf\x07\x6a\xe6\x10\x7c\x29\x9e\xa8\x48\x2d\xf0\xd9\x0f\x9e\xb4\xc8\x1c\xa8\x15\x44\x4a\xcd\x73\x61\x08\x86\xb1\x60\x18\xa6\x4a\x62\xc1\xcd\x10\x9d\xa6\x93\xe8\x87\x65\xef\x8e\xe8\x33\x46\x99\x04\xb8\xa8\x6c\x12\x38\xe2\x92\xd4\xfe\xd8\xbe\x7d\x76\x7b\xf5\x81\xec\x8b\x55\x43\x8f\x38\xe2\x22\x97\x1a\xb0\x7f\xc5\x89\xd9\x0b\xcd\xb3\x4f\x82\x6a\x78\x20\x5e\x7c\xca\x7d\x2c\x6e\xe2\x82\x2d\x84\x28\x0a\x54\xd1\x83\x26\xc6\xc4\x1a\x9b\x76\xb6\x21\xa7\x00\x88\xaa\x8d\xb7\x92\xf6\x59\x9d\x88\xcf\x9e\x8d\xbb\xc4\x67\xca\x99\xcd\xd6\xf4\x28\x0c\xdb\xf0\x0e\x68\xd9\x56\x3f\x55\x8b\xb5\xec\xfc\x20\xd0\xef\x0f\x84\x29\x66\xc5\x33\x04\x52\x24\x06\xaa\xee\x75\x21\x05\x94\xbb\x36\x1c\xed\x5e\x1f\xbb\xec\x2b\xe2\xa4\x5a\x7b\x09\x30\x55\x9d\x1c\x1e\xeb\xd7\x86\x67\xa1\x44\x23\xea\x1f\x8d\xfa\x22\x5a\x80\x2d\x9e\xab\xad\x6b\x0b\x2f\x05\x12\xb6\x7b\xf1\x71\x6c\x06\x2f\x4c\x4c\x85\x1a\xfa\x21\x12\xd3\x28\xa4\x37\x9e\x6a\x72\x53\xd5\xcd\xe3\x17\x28\xdd\xb0\x1f\xb0\x89\x87\xe5\x2b\xbe\xe4\xa9\x9d\xc6\x3d\x36\xbc\x02\x10\x93\x22\x4b\xad\x02\xd5\x41\x17\xf1\x3e\xc2\x02\x95\xbe\x7b\x7a\x80\xda\xa9\x45\x4b\x4e\x2d\x03\x27\x54\x41\xd0\xe9\xc5\x46\x48\xa4\x71\x76\x3e\x94\xb7\x71\x1a\x1d\xe3\x03\x9f\x08\x48\x7e\xea\xab\x7b\x4f\xc5\xda\xb0\x38\x00\xf5\x95\x4c\xc2\x4d\x05\xa2\xe1\xcf\x6b\x25\x37\x65\xc2\x2c\xdf\x75\x5f\xba\xab\xd4\xd9\x3e\xc2\x82\xc2\x06\x15\xe5\x87\x20\xdc\xb4\x6c\xf4\xc1\x06\x1f\x19\x1d\x1c\x18\x19\x82\x13\xba\x67\x70\x64\x68\x60\xbc\xa7\x17\xee\x74\x0b\xa6\xc5\x34\x47\x7a\x8c\xb4\x6a\x28\x1a\x12\x51\x29\xd4\x5b\x43\x08\x14\x8a\x3b\xc2\xa4\xb1\x16\xc4\x90\xf1\x03\x1f\x97\x31\x8d\x18\x18\xa4\x9e\xbc\xfd\x44\x55\x5b\x09\x10\x54\x22\xa2\xf4\xb0\x04\x66\x60\x98\x30\x45\xa5\x4d\x63\xa1\xff\xe9\xc6\x62\x8d\xc7\x06\xc2\x05\x80\xea\x84\xf7\x40\x24\x73\x0f\x54\x23\xeb\xa9\x5a\x55\x43\xd5\xbc\x32\x08\x47\x96\x0c\x02\x8a\x7b\x8d\x25\x60\x81\x22\xe0\xae\x19\x3b\x76\xa9\x18\x46\x0b\xa6\x71\xcc\x2d\x8c\x6d\x42\x4e\xb8\x92\x37\x7c\x6d\x22\xd7\xb9\x7d\x7e\x44\x93\x88\xcf\x91\x4b\x14\x04\xe8\x41\x61\xde\xed\x99\xe9\xe9\x72\x9e\x14\x9b\xb5\x40\xbc\xda\xa3\x90\xde\xe6\x99\x11\xe5\x75\xef\xe4\xbc\x75\x4c\x42\x18\xe2\x7f\x46\x99\xf9\xd4\x19\xec\x94\x1e\xe0\xc2\xd0\xbc\xab\x97\xc8\x38\x47\xa8\x79\xf6\x39\xd4\x80\x74\x72\x9d\xb1\x83\x20\xff\xe6\x88\x5e\x6e\x1a\x54\xa6\xb2\xfe\x73\x34\x73\x7a\xa5\x96\x9f\x0e\xb8\x8b\x7c\x84\xc8\x4c\xf0\x3f\x84\xd5\x1f\xe3\x95\xb0\xfe\x7f\xf6\xbe\xb7\x39\xaa\xe3\xca\xfb\xfd\xf3\x29\xee\xb3\xb5\x29\xd8\x5a\x49\x31\xae\xbc\x22\x2f\xb6\x14\xf1\x27\x6c\x19\x41\x81\x70\x6a\x63\x5c\x64\xa4\xb9\x92\x66\x19\xcd\x9d\x9d\x3b\x83\xac\x4d\xb9\x4a\x23\x8c\x03\x48\xb2\x31\x31\xd8\xda\x60\xe3\x60\x40\x80\x0c\x22\xc6\x49\x08\x18\xfb\xc3\x44\x33\x42\xaf\xf6\x2b\x6c\x9f\x73\xba\xfb\x76\xdf\xdb\xa7\xef\x9d\x91\x70\x08\xbb\xb5\xb5\x29\xa3\xb9\xdd\x7d\xba\x6f\xdf\xd3\xe7\x9c\xfe\x9d\xdf\x71\xe4\xa0\x6c\xe7\xd2\x3d\x87\xaf\x6c\xe1\xb2\xbb\xa8\x59\x9f\x13\xfb\xdb\xc1\x21\xfa\x93\xf7\xe5\xc7\x42\xec\xdc\xbc\x5e\x5e\x20\x44\x8f\x73\x9c\x06\x7b\xbf\x84\xf1\x32\x60\x2c\x2a\x23\x44\x81\xf0\x51\xde\x5c\x5a\x45\xc6\x72\x53\x52\xc8\x48\x3b\xe0\x02\x44\x68\xa4\xef\x73\x59\xe9\xff\x3b\x9d\x73\x7f\xe8\x5e\xcb\x2b\x69\x06\xa2\x90\x73\x82\x22\xa4\xe1\x18\x92\x47\x74\xa7\xbf\x69\x53\xe4\xcc\x98\xec\x17\x6d\xce\xa8\xd0\x2a\x47\xb3\x09\x2d\xaa\x8d\x4b\xcb\x67\x40\x2d\x80\x24\x83\xda\x41\x45\x8e\x4f\x94\xa3\x5a\x4d\x95\xde\xdd\x8e\x35\xaa\x51\x62\xc5\x05\x98\x0e\xab\x7c\x31\xb5\x4f\x71\x52\xbd\xcd\x08\xf8\x0e\x1b\x33\x74\xaf\x89\x73\x91\xf8\xd8\xdd\xa5\x04\x28\x0b\x5b\x3c\x1c\x24\x8e\x71\xa4\x6b\xa7\x22\xc9\x03\xa2\xb1\xe2\xf4\x84\xfd\x5e\x0f\x1b\x25\x52\xbe\xf2\x67\xaa\x58\x2a\x7e\x12\x9a\x0c\x56\x28\xe6\x78\x3c\x53\xe0\x58\xc9\xa8\x98\x99\x46\xb0\xdb\x7e\x70\x1d\xdd\xbd\xff\x92\x24\x71\x06\xe6\x02\x5f\x71\x52\x85\x59\x97\x33\xdd\x78\xb2\x08\xb6\xb2\x4e\x87\x4e\xea\x25\x18\xf4\xef\xa9\xb6\x12\xd8\x7a\x51\x63\x2e\xbc\x0f\xaf\x5b\xb9\x49\x32\x42\xad\x8b\xcf\x70\x34\xa0\xf8\x26\x14\xfb\x64\x41\xbe\xc9\x5e\x5e\x32\x74\x0d\x21\xc5\x18\xb8\xca\xe1\xe6\x26\x6f\x0c\x8b\xbc\x47\x4c\x04\x09\x42\x30\xdb\x67\xad\xf8\xa8\xc8\x40\x58\x0e\x9b\xa5\x4a\x55\x7e\x27\x66\xd5\xa3\x74\x48\x84\x13\x49\x53\xf4\xe7\x7b\xfa\x66\xdd\xad\x07\xcf\xef\x3e\xda\xfc\xe6\x61\x4f\xcb\x44\xd6\x90\xe7\x1d\x64\xf8\x5e\xfb\x79\x19\x8d\x70\x02\x8b\x6a\x0a\xc3\x35\x3c\x03\xe7\x22\x07\x3e\xbf\x36\xff\xfc\xfb\x8f\xac\xf4\x1c\x19\x1b\x5b\xd1\x86\x77\xf1\x51\x33\x41\x3a\xcf\x34\x0b\xc4\x94\xfb\x99\x78\x6c\x84\x16\x7b\x19\x5d\xe6\x62\xf4\x33\x22\x25\x3e\xf8\xc6\xb2\x72\x14\xfa\x1e\x22\x77\xe7\x58\xb9\xc6\x3b\xb1\x8b\x68\xdc\x22\x1f\x75\x6a\x8e\x3b\xf1\x69\x83\x92\xd7\x19\x78\x18\xf9\xa0\xe4\xc9\x57\xd0\x13\xc3\xf2\x84\x2a\x7f\xc3\x08\xd3\x24\x4b\x55\xd0\x86\x81\x35\xcb\xa6\xfe\xed\x8c\x0b\xfb\x12\xb1\xa1\x58\xb9\x83\x77\x12\xaf\xa8\xb7\xf5\x3a\x5d\xa9\x4b\x3e\x70\x45\x1e\x82\x78\x03\xe1\x99\x16\x66\x9c\x5b\x73\xd1\xcd\x59\x3c\xe0\xea\xd8\x3e\x4b\x36\x93\x13\x38\xe1\x91\x6f\x3a\x8a\x9b\xa8\xcb\x90\xbf\xd4\x97\x94\xfe\xd7\xb3\xbf\x93\x29\x2f\xa6\x3a\xbb\x79\x0d\xae\x3d\x7b\x1f\xd7\x2a\x34\x2b\x5d\x2a\x08\xce\xa8\x98\xce\x50\x30\x1a\x35\xe1\x94\x89\x66\x84\x6b\x55\x0e\xcb\xff\x9f\x8f\xe8\xb8\x03\x3a\x79\xc2\xfd\x75\x7e\x61\xeb\xb3\xcf\xbb\x1f\xdc\xe9\xdc\xba\xf3\xdf\xdf\xb6\x19\x59\x0b\x32\x2f\x78\x5a\x07\x3b\x52\x36\xc0\xa3\x7a\x77\xae\x84\x80\x21\x6f\x11\x04\x52\x4a\x0e\x2e\xfa\x8d\x9d\xfe\x2d\xea\xfe\x17\x7d\x41\x69\x6d\xd4\xeb\xfb\x48\x77\xd0\xf7\xd2\x17\x59\x74\x76\x95\xa1\x12\x15\xd5\xe4\x94\xd5\x94\xd1\xc9\xc1\xfa\x05\xa2\x1b\x0c\xfe\xe3\x4f\x88\x80\xa2\xba\x55\x61\x79\x40\xd7\xe2\xa0\xc7\x01\x1d\x23\x2b\x1e\x40\x49\x78\x79\x3a\xce\x46\x0d\x24\xac\xd5\x45\x8f\xf8\x8b\x81\xc4\xab\x50\xd5\x0c\x92\x7a\xef\x2a\x11\xd1\xc8\x2a\xa4\x9f\xda\x4b\x76\x8e\xe2\x3d\x5c\x2c\x04\x88\x67\x4b\x7b\x50\x22\x5e\x52\xe7\x6a\x9d\xf2\xe3\x61\xb8\x5b\xf7\x99\x5a\xc7\x6b\x76\x69\x05\xff\x3d\x02\x3a\x8c\xa4\xa4\x7f\x58\x07\xd2\x2c\x59\x62\xfa\x88\xaf\xae\xc7\x28\x63\x68\x7d\xc0\xef\x8b\x87\xc6\xb8\x0f\xa6\x37\x86\x8e\xad\xab\x8b\x9d\xd5\xc5\xbc\x93\x8d\xfa\x14\x96\x50\xb3\x32\x13\x46\xad\xe6\xc9\x9a\xbc\x5a\x1f\x36\x80\xd7\x78\x61\x3e\x4e\x19\xaf\xa1\x59\x26\xae\x51\x99\x9a\x6e\x06\x70\xb7\x34\x84\x58\x1a\xa1\x85\xe0\x68\x9c\x2e\x35\xca\x80\xda\x52\x91\x48\x78\x60\x00\x77\x27\xfc\xeb\x1f\x8f\x1e\x39\x36\xe6\x8c\x42\xf2\xd7\xba\x72\x5a\x72\x4e\x62\x63\xc1\x4b\xfd\x02\x61\x6c\xc2\xf8\x38\x0f\x52\x1b\x77\xed\x7c\x6d\x55\xa8\x00\x88\x4b\xf2\x9e\x51\x2c\x62\x55\x4e\x2c\x30\xf4\xde\x3d\xcc\x95\x14\x5b\xe2\xa1\x51\x9c\x4a\x25\x8f\xc8\xdd\xa5\x3a\x80\x5b\xfb\x0f\x09\x05\xa6\xe0\x60\xbf\x49\x76\x38\xf4\x49\xea\x61\x55\xec\x4c\x9a\x7c\x2a\x20\xd5\x73\x11\x4b\x7a\x6d\xad\x5a\x52\x2e\x51\xbf\x37\x58\x65\xb8\xa7\x18\x21\xc8\xa0\xba\xaf\x99\x89\x1a\xa1\x19\x74\x62\x56\x5a\x6d\x9a\xf5\xce\xcd\x3f\x74\xaf\x68\xd3\x03\x2e\xec\x53\x6b\x2c\xfc\x7c\xfc\xfb\x87\x78\x9b\x68\x0f\xe8\x99\x92\x67\x3e\x61\x99\x6e\xca\xe9\xbf\xd9\xab\x75\x25\xa2\x05\x56\x4c\xb5\xe4\x07\x79\x65\x21\xfa\xc6\xe7\x5e\xc4\xd2\x87\xb5\x68\xd5\x15\xb0\x74\x80\xe0\x30\x51\x50\x6b\x41\x22\x72\x04\xf5\x81\xe8\x0f\xea\x42\x9e\xe8\x81\xe4\xe3\x5c\x98\x86\xf8\x71\x4c\xb8\x28\x9c\x87\x4b\x54\x53\xcf\x44\xa7\x38\xab\xfa\xa8\x8f\xdb\xac\x28\xbd\x86\x1f\xf1\x53\x75\x4f\x9b\x1c\x86\xec\xb4\xd8\x0a\xe8\xe0\x13\x9d\x5b\xe4\xdb\xb5\x62\xb5\x89\x9a\x3c\xde\x8b\x1c\x2b\xeb\x41\xa6\xc3\xa8\xde\x03\x99\x52\xfb\x5a\xf7\xfe\x8d\x5c\x55\x1d\xd5\xeb\xaf\xec\xf6\x35\x96\xa0\xc8\xf6\x45\x43\x65\x50\x22\x54\xcb\xfc\x91\x9b\x9c\xf8\x04\xc0\x64\x8e\x56\xd0\x9c\x6c\xc5\xa1\x44\xe9\x71\xd5\x82\xa8\xb9\xf8\xf7\x09\x50\xbe\x23\x07\x4e\x8d\x0e\x1f\xde\x2f\xcd\xd2\x41\xf0\x9c\x07\x15\xa6\x74\x50\xd1\xcd\x60\xc5\xfe\xd2\x69\x0a\x25\xe9\x9f\x55\xac\x2e\x36\xea\x10\x8b\x07\x47\x0e\xa0\x15\x56\x40\x3e\xf1\xb3\x0b\x75\x6a\x47\x71\xa1\x8c\xc8\x01\xe3\x90\x6c\x2f\x29\x6d\xad\xea\xd9\x4b\xe0\xd9\x9a\xfa\x5a\xd7\x08\xf0\x52\x70\x6a\xb6\xfa\xe7\x77\x34\x9e\x57\x23\xb2\x4a\xe0\x6c\x45\x68\x1e\x4c\x22\x10\x86\xc7\x1c\x21\xe0\x65\xc5\x40\x75\x21\x6b\x38\x5e\xb1\x38\xfc\x9a\x15\xe4\x4c\x98\x43\xf8\x5f\x83\x78\xc6\x7c\x08\x20\x7d\x74\x29\xe6\xc4\x75\x69\x29\x82\x4e\x59\xda\x6a\xdf\x4d\xca\xb2\x2e\x2c\xea\x6a\x83\xd2\x34\xf4\x54\x6b\x4f\x88\xc1\x64\x5b\x9c\x33\x00\x7d\xad\x3e\x73\xa1\x66\x69\x44\xe3\x78\x38\x5d\xa9\x95\x85\x11\x3f\x29\x9c\x98\x59\x2c\x7d\x80\xf5\xb1\xfe\xa3\x55\x69\x20\xb1\xd8\xcf\xc7\xc6\x8e\x02\x5a\xf9\x9d\xb9\x01\x8a\x4e\x10\x2b\xcb\x74\xb3\x59\x8f\x4f\xe1\xdf\xdd\x77\xbd\x98\x50\xd0\x00\xc7\x48\x2c\xb4\xd0\xf3\x43\xc1\xfe\x6a\x1c\x0e\x04\x08\x1e\xa2\x9a\xd7\xb5\xb0\x09\x2e\x14\xf8\xbf\xb5\x10\x33\x36\x0a\xac\x6b\x62\x6f\x93\x5d\xb6\x70\x57\xa1\xa2\xd6\x3a\x0f\xce\xa7\x98\x27\x3a\x6d\xf1\x06\x56\x61\x0a\xaa\x20\xeb\x7d\x58\x55\xb1\x9e\x12\xb9\x78\x4f\x42\xad\xe6\xdb\xc6\x84\x2c\xc3\x49\x38\x61\xf7\xbf\xdc\xbc\xf1\x24\x93\x7c\xab\xc9\x2d\xb0\x9a\xc8\xc2\x65\xf1\xcc\xf3\x7b\xcb\x7c\x86\x2f\xd2\xc2\xc0\x51\xb5\xac\x5c\xf5\x75\x02\xc5\xcb\xcc\x3f\x6f\x0f\x9e\x97\x39\x1a\x49\x2d\xac\xc0\x49\x03\x89\x79\x36\x49\x84\xf0\x86\xd5\x04\x55\xfc\x64\x84\xc1\x8f\x5e\x32\x0d\x5d\x33\xc6\xbc\xe4\xc2\x35\x19\xdc\x92\xc9\x0e\x6c\x33\x22\xa4\x0d\x37\x1b\xfd\xe4\xea\xbe\x98\x7d\x87\xab\x71\x42\x4e\x7d\xb8\x5e\xb1\x67\x0d\x41\x96\x4a\xad\x15\xea\x2b\xfc\x4a\x0d\xef\x9b\xed\xf8\x5a\xfe\x6a\x6c\x7d\xf6\x79\x72\xf3\x2c\xb6\x60\xfb\x5e\xc0\xa3\xa7\x88\x50\xfe\x4f\x2b\x98\xd9\x69\x6b\xb9\x8c\x8c\x3d\x29\x34\x35\xcd\x91\x03\xba\x07\xeb\xb4\xc3\x29\x87\xc2\x74\x17\xf3\xc3\x6f\xcd\x42\x5f\xe9\xa2\xa9\x70\x36\x84\x93\x93\xe2\xe3\xcb\x9f\xb8\xd8\x9d\x42\x4d\x41\xec\xd5\xfa\x3c\x1e\x28\x45\xb7\x64\x71\x8d\x7a\xf4\xbb\x57\xec\x3e\x57\x41\x72\x7b\xa6\xfc\x91\x52\x4d\x51\x20\xc0\xc9\xf6\x02\x96\xa4\xe0\x4a\x28\x15\xa1\xea\xff\x3e\x4a\x8a\x5a\x9b\xe7\xe3\xf7\x9f\x41\x5c\x56\xc6\x39\x7c\x8b\x97\x9d\x6d\x7f\xcb\x66\x7d\x20\x2f\xf1\x6e\xe9\x73\x9e\x89\x1a\x3c\x51\x2f\x0b\x53\x42\xf3\x9e\xdb\x13\x6f\xe1\x8f\x94\x03\x97\x5f\x40\x21\x51\x8b\xd2\x41\x77\x54\x54\x10\x33\xc4\xea\xa5\xd9\x99\x78\x24\x29\x3c\xb5\xd2\x14\x39\x11\xf0\x1f\x1e\x6c\xb8\xd8\x5b\x0f\xcd\xe7\x98\xce\x84\x7d\x03\x40\x56\xe3\xf2\xba\x1a\x4d\xf5\x08\x7d\x49\x6e\xb3\x25\xe3\xc5\xe5\xe7\xdf\x3f\xeb\x3c\xfc\xae\x37\x0c\xeb\x98\x09\xae\x35\xad\xfe\x9c\x32\x9d\x29\x0c\x12\x7b\x84\xe8\x10\x43\xce\xf0\x2e\x9f\x86\xb7\xdb\x7d\x01\xef\xbe\x45\x51\xf5\xe7\x2d\xa8\xa0\xc9\x52\xa0\x73\xca\x4a\x4d\x83\x24\x4f\x58\x72\xe1\x3b\x68\xc0\x11\x12\xa0\x09\xa4\x5e\xb2\x68\xb6\xc6\x06\xc8\x5b\x25\xb3\xb7\x84\xf5\x4b\x08\x4e\xbd\x78\x2f\x1d\x72\xcc\x55\xa6\xdc\x46\x9a\xb4\xf3\x9b\x1b\x9d\x6f\xaf\x58\x65\xed\xe7\xdb\x9d\x4b\xe2\xa7\x4f\xf5\x4f\x64\x38\xf1\x76\xf1\x03\xa3\x9a\xb7\x63\xc4\xec\x1f\x3b\x4b\x57\xf3\x76\xa1\x58\x06\x0c\x63\x43\x72\x22\x16\x60\xdb\x8f\x49\xb2\xa0\x0a\x9d\x37\x21\xc2\x49\x28\x87\xc4\x3e\x28\x0b\xb6\x25\xf7\x01\x1e\x77\x2f\x89\x1a\x7b\x46\xd2\x57\x26\xae\x12\x6f\xce\x90\xfe\x83\x8d\xc7\x8b\xdc\x15\x8b\xb0\x23\xd9\x1d\x87\x09\xdd\x65\x64\xbd\x08\x66\xa7\x2b\x13\xb4\x1f\xb4\x3a\x8c\xd1\x59\x40\xdb\x5d\x7c\x21\xe5\x56\xc3\x2e\x66\x01\xf4\x39\x83\x65\xf1\xf5\x78\xf3\xae\xb3\xaa\xb2\xfd\x80\xc8\x6d\xba\x37\xaf\x75\x7e\xf3\xa4\xbb\xb2\x80\x1f\xc8\x45\x0c\x8b\x2e\x3a\x9f\x17\x4f\x76\xaf\x3f\x85\x40\xce\x17\xef\x77\x9e\x7c\xc8\xcf\x06\x01\x4a\x06\x15\x12\x55\x02\xae\xe8\x24\x13\x60\x90\x6c\x4c\xb1\xee\xae\x54\xee\x1a\x72\xa4\xde\x83\xc1\xfd\xa6\xee\xa0\x97\xec\x44\xe7\xac\x7b\x9b\xb2\x8e\x3d\x1b\x2f\x47\x68\x2a\xae\xcd\x43\x4f\x59\xa1\x7f\xfb\xc3\x88\x2b\x74\xd6\x0f\xba\xca\x14\xf2\x7e\x21\x92\xbf\xb0\xa5\xee\x5f\xe6\x06\x4b\xf3\x25\xbe\x59\x61\xeb\x0c\xc9\xe0\x3c\x05\x3b\xc8\x4b\x8f\xe2\x26\x80\x42\x48\xc3\x0f\x0a\x6f\xfe\xc8\xf1\x31\x0c\xae\x88\x29\x82\x79\x34\x38\x28\xe6\x55\x8e\x66\x06\xa9\x73\x61\x0d\x4d\x85\xb5\xb0\x91\x1c\x1b\xf4\x77\x38\x52\x44\x7f\xb5\xa0\xde\x8a\xa7\x89\x41\xab\x68\x31\x2b\x5a\x17\x65\xd9\xa4\xa8\x0e\x48\x25\x19\x46\x95\x29\x62\xda\x4f\x54\x40\x8b\xce\xa5\x65\x88\xe5\x49\x43\x72\x45\x56\x33\x80\x28\x8b\xca\x3b\x4a\xcd\x2a\xd5\x91\x3e\x33\x74\x75\xc8\xcd\x8f\xaf\xe3\x35\x28\x69\x4b\x2c\x5f\x29\x8e\xa2\xf7\x97\x3b\x4f\x6e\xe3\x2b\x26\x7e\xf1\x5b\xe6\x15\x2d\xff\x9a\x74\x8e\x90\xe9\x57\x0a\xf7\xb3\x55\x2d\x13\x03\x1d\xc4\x91\x4a\x42\x95\xb2\x51\x24\xb6\x6f\x88\xc8\x20\x0b\x86\xb6\x09\xd4\xa9\x2e\xf1\xf7\xb0\x27\xea\x75\x36\x8a\x92\x21\x04\x57\x07\xb9\x2b\xaf\xbc\x20\xd9\x42\x22\x56\x33\x82\x68\xa3\x70\xb9\xa8\xfc\x3f\xfa\x5b\x92\xc8\x77\x40\x7c\x70\xc8\xc1\x86\x49\x63\x15\xba\xd7\x83\x8d\xc9\x89\xaa\x0c\x46\xf2\x85\xec\xda\xfd\xed\xa5\xce\x4d\x74\xa7\xdb\x1f\xe8\xd7\x41\xd5\x4a\x60\x5b\x9c\xbb\x85\xac\xbb\xc5\x63\x28\x28\x3f\x2c\x5c\x4d\x32\x41\x48\x4a\x11\xa3\x14\x2d\xdc\x44\x82\xf9\x0e\x15\x30\x4e\x34\xaa\xc2\x5a\xdf\xcb\x55\xc0\x80\xc7\x1a\xfa\x31\x71\x80\xaf\x4a\x32\x90\xe4\xfe\x17\x79\x2f\x20\xc8\xbd\x9c\x70\x3c\xb4\x97\x36\x57\x9e\x88\x6d\x68\x5a\x87\x7b\x99\xd2\x19\xfd\x4a\x4c\x94\x10\x51\x03\xac\x59\x70\x0b\x2a\x75\xd6\x7b\xe8\x65\x88\x86\x73\x88\x1f\xc5\x9c\xf0\x90\x47\x49\x99\x0c\x40\xd3\x0c\x69\x16\xc0\xd7\xd2\x88\xe2\x58\x1f\x17\x42\x93\xed\x83\x54\x4b\xdc\xe1\x4d\x8a\xda\x36\x8c\xe2\xac\x09\x5f\x2d\xd5\xca\x1f\x40\x05\x85\x8f\x61\xb8\x1b\x36\x21\x5c\x60\x48\xbb\x36\x19\xb1\x55\xc3\x4f\x0f\xaf\x81\x4f\xd6\x86\xc9\xdd\x0d\x94\xdf\x1b\xcc\x96\x6a\xf2\x3e\x4a\x17\x87\x77\x27\x5d\xfc\x0b\x5b\x00\x45\x9e\x0b\x46\xba\x87\x41\x00\x6d\x1c\x0d\xab\x2a\x51\xc2\xad\x11\x29\x60\x9c\xd4\x01\x4c\xb8\x01\x89\x67\x57\xfd\xc5\xec\x18\x95\x59\x7b\x49\x3c\xdf\xf9\xe0\xa9\x11\x27\x7e\x40\x97\xc2\x0e\xd1\x54\xb5\x07\x43\x25\x80\xb3\xda\x39\xff\x70\xab\xfd\xb1\x71\x5e\x7d\x68\x5c\x4f\x2b\x95\xed\xcf\x0e\x71\x54\xbf\x67\x77\x33\x6c\x03\x89\x1e\x86\x04\xec\xda\xae\x26\xb2\x77\x47\x70\x15\x28\x61\x3a\xa0\xdd\x4e\x87\x73\x71\x9e\x66\x33\x39\xda\xd7\x35\x1a\x4f\xa2\x5c\xc0\x1f\xf8\xa3\x71\x23\xff\x49\x11\xe5\x06\xc2\xa1\x3f\xa8\xce\xda\xe9\x12\x7e\x15\x04\x60\xd4\xde\x22\x62\x84\xf3\xa4\xb3\xf8\x92\x13\x93\xc1\x87\x1e\x5e\xb2\x61\x8d\x17\xb2\x9b\xc5\x23\x38\x7e\x10\x44\xe2\xa4\x4a\x4f\xd0\xad\x2b\x5c\x62\x0c\x05\xec\xf6\x27\xd4\xaf\x19\x97\x63\xeb\xcb\xd3\xcc\x80\xe5\xa8\x9d\x6c\xb1\x64\x37\xad\xa7\xef\x2d\x94\xd4\xe9\x9b\x39\x86\xfb\x4d\xed\x1d\x66\x92\x84\x26\x21\x4b\x33\x9e\xab\x4d\xd0\x65\x85\xaa\x1f\xce\x5d\xed\x7f\xf6\xb9\xf0\x32\xbb\xd7\xae\xd3\xd3\x8a\xab\xe9\x41\x16\xf0\xc1\x8d\x5a\x97\xa1\xa5\x52\xb9\x3c\x48\x2e\xdf\x20\x28\xc1\x5d\xb4\xba\x53\x00\xf3\x68\x48\x42\xaa\x3a\x8b\x19\xcf\x06\x92\x1c\x25\xbb\x37\x57\x9e\x6e\x2d\x7d\x6d\x06\x92\x1c\xa3\x16\x0e\x1c\x89\x2d\x5a\x0d\x0e\x0b\x3d\xca\x56\x12\xef\x5c\x3a\xff\xfc\xce\x79\x24\x13\xba\x41\x42\xf8\xba\x2a\xcd\x44\xad\x1a\xf2\x81\xcd\x60\xa7\xc1\xee\x70\x68\x6a\x28\xd8\xf3\xda\xeb\x3f\x39\x3c\x10\xec\x39\x28\xfe\xff\xb5\x83\x1c\xaa\x2b\x3b\x14\x64\x8e\xee\xde\xf8\x6e\x71\x2f\xf5\x20\xf6\xd3\x9e\x83\xf0\x3f\xd0\x47\x2f\x52\x28\x16\x39\xc0\x96\x21\xe7\x55\x2f\x62\xed\x09\x90\x4e\x22\xf5\xb5\x2e\x75\x96\xbf\x40\x6d\x2d\xbd\xa5\x1d\x13\xbe\xd6\x9a\x19\x87\x2a\x06\x93\xf2\x24\xf3\x1a\xd5\x60\xb0\xe1\xc0\xdd\x2b\x0f\x8b\x75\x9a\x4e\x0c\x29\xc2\xf7\xc0\x25\x85\xe4\x0d\xdd\x80\x35\x2f\xf2\x01\x9a\x9f\x1d\xc4\xc4\xcf\x4b\xc4\x1e\x8c\xe2\xdd\xc0\x27\x86\x87\x13\x83\x5a\xb2\xfb\x52\x15\xe2\x89\xa8\x36\x59\x99\xc2\xb8\x0d\x33\x28\xb4\x65\xee\x68\x96\xba\xab\x8b\x70\x3e\x58\xf0\xc9\xb5\x42\xfc\x49\x40\x2d\x20\x3e\x7a\x0a\x98\xe8\xb8\xa9\xbe\x72\x48\x2e\x92\x51\x15\x8f\x43\x7a\xac\x38\x45\x66\x78\xda\x27\xcf\x05\x41\x26\xf6\x25\x83\xad\xe0\x65\xfe\x25\x51\x1a\x67\xaf\x2b\xfd\x29\x0d\x00\x21\x63\x01\xe1\xd5\x3b\x33\x26\x40\x3b\x52\x8b\x2e\x7e\x98\x2d\x35\xca\xc0\x2a\x77\x5c\x78\x2f\x33\x86\x9f\x0c\x3d\x29\xf8\x1e\xde\xa3\x16\x9f\x9e\x84\x23\x9e\x57\xc5\x23\xd6\xe1\x25\xd1\x7c\xda\x4b\xcf\x9f\x0a\x5b\xa7\x6d\xce\x44\x1c\x1d\xf0\xbf\x32\x65\x03\xcf\x77\xc4\x59\xe2\xa8\xf8\x79\xb2\x98\x3a\x66\x11\x8e\x0f\x1f\xdc\xef\x05\x9e\x76\x1f\x5d\xf1\x34\xe5\x50\x21\xba\x2d\x03\x06\x39\x71\x7c\xff\x31\x3f\x05\xb0\x81\xb0\xc8\xa1\x00\x86\xbe\x58\x1a\x5c\xa3\x1b\xa6\x75\x4d\x21\x40\x28\x04\xe2\x8c\x7f\x0f\xa1\xcb\x40\xb4\x73\x9e\x3b\x07\x1f\xf8\x7b\xcd\x15\x0c\x49\x0c\x30\x7b\x80\x5c\x49\x09\x9f\x10\xd5\x42\xc4\x94\x22\x7b\x9f\x2c\x48\x2e\xe9\x21\xc9\x6e\x14\xc6\x4e\x5d\x7c\x7f\x9c\x56\x20\x06\xc6\xce\xf7\xd7\x36\xef\x7f\x2c\x1d\xff\xb3\x54\x30\x4c\xd9\x02\x06\xf9\x1e\x9c\xc7\xcb\x5f\x23\x99\xbe\x25\x7c\xae\xb0\x2d\x08\x9d\x00\xb7\x78\x93\xf7\x77\x89\x27\x2f\xb3\x2a\x79\x7d\x93\xa7\x32\x20\xc3\x34\xbb\x54\xd4\x65\x57\x41\x2a\x23\x65\xa6\xa7\x87\x95\x41\x1c\xa3\xbf\x7e\x68\x8d\x4c\x31\x9b\x78\xa5\x11\x06\x23\x23\x18\x17\x79\x33\x6c\xc4\x08\xbf\x77\x70\xb3\xf7\x16\x16\x49\x06\x89\xc6\x21\x8b\x42\x05\xe1\x31\xec\x05\x1a\x2a\xd4\x41\x75\x2a\x28\xa0\xfe\xc5\x6e\x63\xf2\xd3\xc5\xbe\x78\x7e\xf6\x59\x3a\x4e\x6f\x36\x0f\x92\x08\xa0\x8a\xcb\xcb\xd0\x94\x2c\xb9\xd0\xd3\x2e\xa9\x97\x1a\x71\x7a\x79\x08\xc9\x70\xf4\x90\xfc\xa7\x78\x0f\xbd\x2e\x0d\x7a\x29\xc2\x22\xa2\x1c\x46\xfa\x40\x8a\xd7\x30\xc7\x2f\x22\xed\x93\xd8\xa9\x56\xcf\x57\xbf\x34\x1d\x3d\xbf\x20\x49\xc5\x5c\x27\x37\x09\x8a\xf7\x62\x32\xe1\xfc\xaa\x09\x3f\x7c\xde\x0d\x73\xf0\x99\x30\x4b\x50\x00\x55\x78\xa2\x36\x4e\x80\x2b\x9b\xed\xa0\xbf\x77\x53\x90\x03\x01\x8d\x88\x47\xe6\xe9\x9b\xfb\xc2\x3c\x42\x52\x09\xa1\x26\xd9\x97\x76\x25\x21\xf8\xde\x5c\x40\x3a\xef\x97\xe6\x33\x71\x0a\x56\x0b\x4a\xc0\xbb\x2f\xeb\xaa\x18\x55\x61\xf3\x56\x25\x9b\xc3\xe1\xcb\xea\x7a\x89\x17\x29\x95\x94\x2e\x77\x38\x1e\x55\x39\x7e\x0e\x09\x98\xe7\x93\xbc\x00\xe9\x0a\x22\x1e\x5e\xb4\x7c\x13\x20\x52\xb5\xca\xfa\x09\xbe\xc6\x4e\xf4\x36\xa9\x56\x8e\xf7\xf0\xef\x09\xdb\xed\xe7\x5e\xa4\x17\xc3\x57\x18\x70\xbe\x8e\xc2\x5a\x1b\x96\x76\xa6\x34\x17\x08\x9b\xe5\x4c\x48\x98\xb2\x19\xf1\xbf\xc4\x44\x9e\xba\x9e\x3b\xd3\xaa\xc2\x45\x9a\x38\xdd\x7f\x1a\x60\xfc\xa1\x92\x75\xc7\x79\xea\x53\x89\x77\x8e\x4d\xe3\x11\xed\xa5\x7d\x91\x15\xaa\x13\xcf\x4d\x84\x61\x99\x8b\xcf\xbd\xec\x62\x07\xbb\xe7\x7e\x5c\x63\x02\x24\x89\xec\x29\x11\xad\xbd\x9c\x2f\xd3\x8b\xda\xdc\x79\x52\xc7\xf9\x05\x18\x70\x26\x32\xf9\x25\x75\x78\xa2\x24\xad\x02\x35\xa9\x5b\x3c\xf1\xd7\xc7\xc8\x6d\x90\x4e\x81\x29\xaa\xfc\x9d\x12\x17\xf9\x88\x5e\xc8\xc2\xe8\xf3\x73\x5b\x0b\xe3\x48\x8f\xfc\x3b\x5f\x24\xf1\x83\xd8\xdd\xa5\x9a\x74\x78\xa9\x7e\x1a\x6e\x6e\xbd\x9f\xfb\x5d\x2c\x7f\xdf\x7f\xc3\x35\x0a\xdf\xa9\x87\x13\x70\xfb\x47\x57\x93\x70\x23\x13\x4d\x60\x52\x76\x79\x2f\x86\x11\xe4\x1d\x24\x17\x9a\x79\x72\xbe\x7b\xed\x7a\x92\x32\xe9\xbf\x84\xb5\x3a\x64\x04\x42\x25\x24\x8b\x6b\x2a\x0c\x18\xf0\x1a\xc8\x74\x71\xc2\x78\x06\xa5\xc6\x54\x0b\x72\x24\x58\xf3\x22\xc9\x49\xeb\x7c\x7b\x05\xe1\xb2\xab\x44\x62\x60\x64\x26\xdb\x30\x30\xbd\x88\xda\xf8\x20\xa6\xfd\xb3\x6b\xb9\x76\x86\x94\x19\xf6\x9a\x14\x59\xc3\xd0\x46\x73\x7c\xac\x94\x14\xe9\x86\x41\x9e\x58\x85\xce\xdb\x6a\x04\xe9\xe6\x26\x06\x8d\x40\xca\xe8\x2f\x13\x64\x37\x0f\x56\xe4\x40\xe6\xaa\x3d\x77\x5f\x01\xca\x10\x10\x42\x70\xdd\x85\xcb\x06\x26\x39\x67\xf5\x62\x07\xdf\x6a\x7f\xf4\xaa\x94\x54\xd2\xab\x0f\x19\xff\x20\xf4\x84\x70\x55\x26\xaf\xa9\x0b\x2c\x89\x9f\xa6\x10\xb5\xd5\xce\xd3\x14\xba\x69\x08\x29\x92\x97\x73\x45\x8d\x33\xeb\x71\xe1\x09\x2a\x5e\x2a\x80\x13\xf7\xc0\xc2\xfd\x0b\xa9\x86\x28\xc4\x86\xe8\xd6\xbf\xbd\x0f\x45\xc6\x14\x58\x6d\xe2\x2b\x3b\x1d\xe6\x95\xce\x71\x97\xf6\xe8\x7b\xdc\x71\xac\xde\x51\xf0\x6e\xca\xae\xd1\xd1\xf7\x98\x39\xd5\xdd\x8a\x78\x77\x3d\x0d\x5c\x33\x52\x0d\xc3\x38\x6a\x35\x54\x14\x8c\x63\x88\x53\xb9\x81\xe8\xf3\x3f\x73\xe3\x03\xfa\x97\xc1\x08\xc3\xe5\x0a\xe0\x01\x28\xf4\x26\x80\x33\x0d\x35\xf7\x4d\xa8\x1b\x0c\x77\x9e\xe9\xf6\xdf\x0d\x31\x02\xc8\xff\x66\xad\x06\xbb\x43\x4d\x07\x90\x34\xe3\x47\x80\xf5\xfe\x51\xec\x60\x61\x07\xda\xeb\x1f\xc5\x5c\x50\xd7\xd9\x04\x19\xa2\x45\x1b\xb8\x50\x31\x44\xca\x35\x9a\x94\x1c\x25\x82\xbe\xca\x04\xcf\x18\xa3\xcd\x67\x10\x28\x86\x7f\x28\x8f\x8c\x98\xf1\x66\x80\x89\xd6\xc2\xd9\xb0\x31\x04\x85\xa4\x1a\x9a\xf9\x46\xa6\x10\x56\x62\x6c\x2b\x1d\x26\xbb\x69\x8e\xf1\x40\xe8\x7d\x39\x01\x04\x36\xe4\x48\xb2\xf1\xf4\xd6\xd6\xca\xb2\x91\xba\xb9\x4a\x48\x12\x83\xc4\x2d\x95\x6a\xb1\xce\x0b\x17\xe8\xe6\x79\xcb\xf5\x2a\xd1\xb7\x59\x5f\x45\xd1\xd3\xce\x06\xfa\x8b\x0e\x75\xee\x52\xbe\x99\x98\x3e\x03\x1d\xcd\xb7\x21\x95\xf3\x0e\xe1\x07\xe0\x32\xef\x53\xdc\x02\x1e\xdd\x76\x9d\xdb\xfe\x7d\xb1\x7e\x54\x49\xd6\x6a\xd8\xa9\xe8\x60\x2f\x66\x46\x6f\xaf\xc0\xb4\x37\x40\xd4\x9d\xbb\x5f\x2a\x5a\x48\x6c\xdb\xc2\x3b\x22\x5e\x99\x59\xe4\x7d\x9a\xd6\x63\xfc\x2c\x7c\xb5\x9a\xb6\x3f\x1f\xc7\x45\xe0\x4e\x5f\xf5\x71\x1f\xf3\xb6\x04\xb7\xea\xb7\xbd\x12\x41\xf5\x2c\x99\x87\x3f\xcc\xde\xfb\xd2\x55\xa3\x92\xbe\x98\x00\x94\x56\x8c\xfe\x20\x5a\x50\x54\xec\x9f\xb3\xba\xbe\xfa\x7d\x42\x95\x67\x47\xf7\xd3\x8c\x77\xd2\xb9\x3f\x2b\x99\x1e\x08\xb2\x61\x0b\x68\x8e\x97\x23\xe8\x0b\x3e\xf2\x72\x45\x2d\xb0\x96\xe6\xe1\xee\xdd\x2e\xd9\x3b\x90\xed\x8f\xfc\xcb\x4a\xfd\x80\x78\x8f\x3f\x9b\x6b\x86\x31\x94\xc8\x14\x7f\x82\x7f\x8f\x00\x16\x13\xbc\xfd\x0a\x5f\x7c\x3e\xd3\xfa\xaf\xf3\xed\x54\xf3\xce\xfc\x62\x9a\x5a\xaf\x80\xe4\x8c\xd8\x6c\xbd\x20\x1e\x19\xb7\x2d\x7a\xb3\x1d\x25\x2d\x53\xa2\x18\xb4\x0e\x58\x8d\x08\x4b\xf3\x35\x29\x5b\x5f\x5a\xe3\xa0\x6d\x90\x7d\xb8\x97\xa2\x44\x3a\x21\xe1\x4e\x8a\x87\x43\x65\xe0\xa8\x0c\x6e\x8b\x58\x6b\x4d\x4d\xcd\x4d\xdb\x50\x70\x5e\x25\xc0\x6f\x0d\x22\x7e\xab\x5e\x8a\xe3\xd9\xa8\x81\x37\x52\xd5\x68\xaa\xc2\xe7\x90\x66\xe0\x59\xa4\x1b\x88\x4c\x05\x41\x5a\x76\xd2\xd8\xfd\x24\x5a\x9a\xe3\x0c\x5a\x6a\xbd\x59\xe2\xb3\x16\xdd\xdc\x47\x90\x6f\xef\xe9\x19\x32\x6e\xf0\x3d\x49\xad\x5d\xb0\xd6\x9c\x31\x56\xa6\x0b\xc0\xd7\xf7\x8c\xc9\x02\x17\x3c\x97\xd2\x2a\x33\x43\x0e\xc5\x28\x7a\x2b\xd2\x89\xa7\x39\x1c\xdf\x05\x7a\xe8\x5c\x5a\xe6\xfa\xa0\xeb\x4d\x93\xae\x55\x6b\x79\x4f\xfe\x75\x0e\x81\x6a\xd2\x47\x76\x6f\x4b\x75\xc3\xe5\x52\x93\x44\xfa\xd2\xf2\x18\xfc\x07\xde\x5c\xe6\x66\x4c\x26\x8f\xb2\x83\xfa\x86\x24\x4a\xd6\x5f\x23\x6b\x5c\x81\xb3\xca\xa4\x52\xb5\x1b\xb1\xa3\xb3\x67\xc3\x9b\xfb\x8f\x1d\x3f\x74\x64\x94\xdf\x0b\x97\xd4\xa5\x1b\x80\x56\x98\xed\xf0\x26\x70\x6d\x07\xff\x7a\xfc\xc8\x68\x10\x8d\xff\x3b\x94\x58\x97\xcc\xc8\x86\xf9\x3b\x28\x39\x7a\x27\x24\xe6\xbb\xd5\x20\xa0\x67\xbd\xd4\x10\xa2\x37\x85\x83\x3f\x90\x7c\xc4\xb2\xba\x5d\xa5\x36\x58\x05\xec\x61\x84\xd9\xed\x25\xdc\x23\x43\xc1\x01\x2c\x5a\x01\xa4\x9c\x88\xd9\xa1\x8c\xa3\xb0\xec\xe9\x37\x0e\x21\xd0\x3e\x81\x97\x38\xf4\x2b\x21\xa0\x43\x5f\xe9\x0b\x7e\xf9\xe9\x0e\xe0\xae\x52\x4e\x52\xd1\xda\x30\xf4\x54\xe1\xbc\x55\xa5\x6f\x54\x72\x97\x61\xa7\x75\x7e\xf7\x04\x23\xf5\x0f\x14\x9c\xfd\x23\x8c\xb3\xfc\x1e\x17\x9e\xb4\xbe\xe4\xbd\x55\xd7\x1c\xf7\x68\xad\x31\xbf\xf2\x2a\xbc\x1c\xf8\x16\x90\x4c\x60\x7e\xc1\x4e\x95\xb2\x18\xaf\xd8\xfe\x65\xac\xf2\x2f\x8a\xe8\xe2\x26\x0a\x7f\x5b\xd6\x31\x7c\xf6\xdb\xe7\x77\xbf\x2e\x52\xe8\xe3\xf9\xa3\xdf\x74\xaf\xae\x20\x8e\x72\x61\xf3\xdc\x6a\xd1\x13\x65\xc7\x77\x4f\xa5\xf6\x7f\xbb\xe6\x7f\xc3\xae\x69\x11\x4e\x18\x4b\x62\xee\x12\x0e\xca\xa0\xf2\xb0\x07\x91\x09\x65\x17\xa0\xb1\x64\xe2\x76\x2d\x9c\x12\xaf\xe2\x0c\x7f\x60\xc9\x6a\x98\xee\x7e\x20\x89\x66\xfe\x26\x18\x53\x5f\x7f\xa1\x72\x15\xde\xc3\xbf\xf4\x9e\xb7\xa0\xf9\xa0\x47\xf9\xf3\x93\x48\x97\xd8\x93\xf3\x4d\x62\xf3\x3b\x2a\x4d\x2f\xee\x74\x22\x52\x3a\xdb\xca\x62\x3b\x8c\x7d\xf4\x1f\xd6\x19\xc0\x74\x01\xb6\x2d\x24\xd2\x0c\x60\xf2\x5c\xa3\x29\x73\x7b\xe5\x7d\x6b\x4c\x9c\xd0\x2a\x29\x93\x3f\xde\x5d\x19\x97\x5b\x57\x6f\x48\xfb\x95\x8c\x42\xe0\xe2\xfb\x2a\xd9\xae\x90\x68\x72\x11\x89\x19\x1e\x49\x63\x37\x53\xb2\x85\x3b\xf1\x7f\x31\x7c\x6c\xf4\xd0\xe8\x41\xa2\xc6\x24\xe3\x0a\x94\x0e\x1a\xe7\xda\xb2\x85\xbc\x51\x8d\x05\x20\xcd\x82\x79\xf2\x10\x45\x9f\xae\x4c\x4d\x57\xe7\x20\x5b\x7e\x42\xb4\x29\x4d\x85\x65\xec\xea\xdf\xac\x0e\x00\xc2\x25\xf6\xe0\x99\x0a\xb1\x54\x00\xe2\x1d\x8e\xb7\x18\x17\x48\xfe\x08\x95\x21\x1a\xa4\xbc\x68\xf8\x78\x3a\xac\x56\x45\xff\x31\xf0\xd1\x00\xbb\x32\xe7\xb4\xdc\xbf\xdd\xf9\xe8\xa2\x22\xf7\x4c\x9b\xd4\x16\x5f\x2e\x18\x4a\x77\x13\x1e\x9a\x74\x76\xbe\x62\x59\x90\x3a\x47\x13\x53\x4b\x0e\xb4\xce\xb7\x7f\xc6\xaf\xf2\x62\x67\x71\x15\xb2\x46\x93\xb5\x75\x8e\xbc\xf1\xf4\xea\xc6\x13\x24\x5f\xbc\xbd\xa8\xf2\x5f\xaf\x4b\xfe\xf5\xd4\xc3\x90\x08\xf5\x67\xd0\x46\x44\xc4\x7e\xf6\xb2\x95\x17\x05\xf4\x8d\x9f\x62\x32\xe5\x95\xa4\x13\xdc\x0e\xdd\xf6\x25\x62\xe7\x34\xab\x58\xe3\x52\x79\x5f\x76\x80\x39\xb6\x92\xd7\x3e\xc2\x8c\x60\xa1\xe3\x63\xe2\xb5\x27\x34\xb0\x15\x6d\x94\xa9\x28\x36\xc3\x48\xb6\x72\x13\x38\x05\xe2\x0b\xa8\x4d\x89\x26\x09\x3f\x2b\x1c\x42\xe4\x2e\x50\x37\xb8\xbf\xe8\xb6\x3f\x78\xfd\xb5\xd7\xe0\xf7\x9f\xec\x79\x6d\x40\x11\x75\x64\xfb\x05\x90\xcc\x78\x18\xd6\x54\x0d\xe3\x01\x44\x03\x52\x01\x96\xfa\x34\xde\x08\xc1\xce\x89\x61\xe3\x8c\x54\xa3\x56\x59\x9c\x74\xad\x5a\xb9\x31\xb7\x2b\x0e\xca\xa5\x66\x69\xbc\x14\x8b\xd3\x6f\x58\xec\xa5\xd3\xb5\x68\xb6\x1a\x96\xa7\x34\x93\x54\x66\x2c\x95\x31\x46\x29\xfb\x65\xba\xfa\xb7\x3a\x35\x8b\x03\xe8\x65\x22\xe4\x53\x2c\xbf\x77\x5d\x4e\x8a\x4d\xfa\x96\x5b\x56\xe6\xcf\x76\x7f\xbb\xbc\xf1\xec\x1a\x51\xa2\x1a\xa9\xc8\x05\x6e\x0a\x17\xcf\x61\x80\xf0\x93\x84\xd2\xd3\x7f\xe3\x0c\xfb\x6c\x01\xf3\xcb\xdf\x53\x67\xe2\xaa\xda\xe4\x36\x0f\x09\xbc\x19\xdc\x54\x8b\xf8\xe3\x3a\xbc\x23\xb8\x7a\x52\x09\x47\x26\x11\xbc\xfa\x42\xa0\xfd\x67\xea\xa7\xcf\x0a\xcd\x21\x5d\x0f\xfa\xfa\xe6\x1f\x2f\x75\x3f\xbf\x06\xc7\xe7\xfd\x9b\x9b\x6b\x8b\x48\x12\xf5\x48\x7f\x25\xf6\xab\x08\x14\xfc\x8d\xce\xe3\x15\xad\x2e\xbb\x1f\x7f\xb7\xf9\xec\x01\xc7\x76\xda\xb9\xb0\x2c\xbe\x70\xab\x6c\xbc\xe6\xe2\xb0\x85\x29\x20\x7f\xa2\x9a\xa9\x58\x16\x54\x76\x48\xbd\x02\x0d\x12\x33\x48\xef\x17\xde\x63\xca\x89\x89\xe5\xbc\xfb\x4f\x81\xc9\xbc\x90\x99\x33\x28\x13\x8b\x29\xc1\x9f\x4f\xff\x42\x3e\x7a\x5d\x08\xdf\xfd\xd1\xd3\xd7\x0c\xb8\xb2\x4c\x1a\x2f\xe5\x35\xbf\xe0\xef\xb9\xbf\xcf\x38\x91\xd1\xfc\x8e\xd5\xc7\x0d\xf5\x8b\x82\x52\xb3\x19\xce\xd4\x9b\x7a\x80\x99\x52\x39\x54\x14\xad\xa5\x09\xd7\x3a\xfe\x54\x03\x63\x71\x01\xd5\x29\x0a\x0a\x10\x08\x00\xca\xc2\xf3\x6f\x44\x73\xaa\x12\x44\xea\x1d\x18\x34\x08\x72\x6d\x32\xb2\x8a\x95\x98\x84\xa4\x7d\xe7\x28\x00\x5c\x86\xe3\x55\x81\x97\xa1\x5e\x89\xf4\x2c\x69\xf1\x15\x29\xf5\x20\xdc\x84\x0d\xd2\x4d\x58\x94\xf9\x51\x4a\x83\xf3\x9c\xa9\x6b\x82\x91\x09\xf1\xde\x6a\x2d\x96\xb3\xa7\x1f\x25\x97\xb1\x8e\x77\x58\xc9\x65\xf5\x54\x42\x43\xf2\x4a\x69\xab\x02\x8a\xc9\x71\xa2\x64\xb4\x92\x53\x79\x6d\x4b\x49\xe5\xbd\xbc\xc7\x12\x05\x90\xa4\xdb\xae\x3f\xbf\x7b\x1b\xd3\xc9\x2f\x18\xa5\x84\x14\x33\x4c\x1e\xc2\x6a\xf3\x8b\x6f\xba\x5f\xbe\x67\x15\x19\x91\x3b\xcf\x30\x0b\x13\x82\x23\x49\x56\x23\x5f\x27\xf1\x1d\x15\xd8\x16\x36\xf8\x76\x45\xf3\x66\x67\xe8\x45\x9c\x83\xc2\x28\x9d\xef\x96\xc4\x63\xfc\x47\x99\x9c\xcc\xee\x6f\x33\xed\x39\x5b\xbd\xdf\x46\x2f\x97\x72\xec\x1f\x25\x77\x11\xf0\xcc\x12\xf2\x57\xae\x58\x54\xbf\x19\x03\xb7\xe7\xb3\xa5\x02\xca\xbb\x09\x11\x52\xac\x96\x61\x6d\x8e\x9f\xa6\x94\x9c\x41\x6d\x3f\x1e\x2a\x45\x0a\xc4\x4a\x48\xe6\x4e\x70\x33\x09\xa4\xcf\xe8\x69\xb3\x65\xa9\x2a\x06\x84\x14\x7f\x24\xc9\x6b\x54\x66\x4a\x62\x23\x82\xe6\x9c\x80\x2c\xdd\x84\x18\xcf\x14\x12\x59\x4f\xea\x55\x24\xc9\xc9\xe8\x5e\x24\x17\xa8\x80\xbe\x9b\xc1\x32\xe1\xa0\xf2\xce\xec\x09\xe4\x85\x62\xf0\x33\x7a\x0c\xb0\x3f\xd2\x9a\xf5\x36\x7c\x1d\x9f\x84\x92\x98\x21\x64\xb0\xb8\xcf\x1d\x3c\xa7\xc4\x18\x00\x74\x42\xe9\x44\x33\xfc\xef\xa1\x20\xf8\x45\x98\x14\xcf\x03\xae\x28\x75\x64\xc8\xc7\x35\x9e\x16\x29\x71\x5b\x84\xf1\x2d\x47\xb3\x35\xf5\x50\xa2\xc4\xeb\x0d\x2c\xf0\x1a\x94\xca\x65\x2c\x5f\x27\x5e\x52\x4a\x84\xf1\x10\x4b\x69\x52\xdd\xb0\xa1\xe0\x08\x98\xc6\xbe\x93\x7c\xa6\x32\x05\xc4\x7b\xe5\x01\x35\x58\x52\xa7\x41\x08\x4b\xb3\x01\x4e\x13\xef\x91\xdc\xdb\x39\xb2\x9e\x52\x39\x9d\xf7\xcf\x6d\x9d\x85\x12\x0d\x98\x96\xf9\xa1\x0a\x17\x21\x3d\x0e\x7c\xfa\xc5\x14\x06\x78\x52\xe6\x28\xa0\x45\x37\x1e\x7f\x60\x7d\x21\xa0\xf6\x90\x59\x2a\xdb\x9b\x8b\x7c\xc4\x04\x41\x62\xe1\x20\x22\xff\x4b\xd7\x3c\xb0\xc7\x7d\xd0\xb9\xfe\xa4\x7b\xed\x2b\x75\x8d\xa0\x18\x86\x88\x1c\xaa\xc8\xb8\x0b\x97\xe1\x35\x18\x88\x35\x50\xc8\xb0\x9d\x8c\x3f\xad\x75\xde\x5f\x46\x7d\xa4\xab\x28\xde\x16\x7d\xbb\xb7\xb8\x54\x28\x5f\x9e\x53\xc4\x76\x39\x7a\x17\x3a\x7a\xdd\xd9\x32\xbd\xe2\xab\x78\xf8\x89\x43\x4e\x78\xdc\xe7\x8d\x55\x96\x28\xb7\x8d\x67\x2b\x9d\xf3\xef\x63\x60\xc9\xa1\x78\xed\x2a\x70\x29\x7e\x4a\x7a\x67\x52\x03\x5b\xab\x01\xdc\x2d\x19\x30\x79\xba\x04\x8f\xed\x10\x61\xfb\xcc\x2c\x21\x76\xf0\xa5\x2a\x8a\x30\x8f\xdc\x4b\x8f\x8a\xa8\xd3\x22\x87\x0a\xbc\x1a\xa8\x15\xf1\x50\x91\xcc\xe8\x38\x85\x3a\xf0\x61\x51\x2e\x40\xd8\x8d\xa6\x67\x9d\xff\x32\x1e\x64\xce\xd9\x79\x48\xdb\x34\x6d\xb4\xf4\x56\xa5\x37\x5e\xf9\x97\x1a\x60\x71\xee\x05\x46\x67\x2a\x47\x00\x54\x26\x36\x77\x24\x11\xeb\x02\x4e\xd5\x78\x24\xb6\x9e\x89\x65\x7d\x12\x5d\x17\x34\x2f\xd0\xe3\xaa\x63\x80\xc4\x3c\x9e\x62\x06\x4b\x44\xd3\x9b\xa9\x8a\xe5\xea\xe7\xb8\xbf\x23\x2c\x2f\x6a\x1a\x35\x6c\xb4\x45\xad\x8f\xe4\x67\x05\xc6\x1f\xa1\x50\x61\x15\x28\x60\x1b\x87\xcd\x53\x50\x3f\x36\x3e\x35\x3e\x77\x4a\xc1\xe2\x38\x48\xad\xd6\x82\x60\x20\x13\x3c\xae\x8d\x7b\xef\x5b\x79\xfd\x27\xa3\xb7\xee\x4e\xb3\x24\x26\x05\xae\xe6\xf4\x04\x28\x59\x09\x0a\xa6\xc3\x24\x20\xc6\x99\x2b\x64\x8a\x4c\xdd\x30\xde\x89\x3e\x12\xc4\xf1\x25\x2f\x31\x12\x35\x2a\xe2\x84\x13\x1b\x49\x38\x5f\x51\x19\xab\xe0\x1c\x38\xf4\xc6\x7e\x3c\x93\x64\x6d\xbd\xb8\x59\x16\x7e\x15\x23\x1f\xb6\x14\x7a\x75\x43\x38\x14\xe2\x7b\xa0\x67\x03\xe9\x94\xa0\x52\xa7\xfe\x10\xa1\x2c\x2c\xd1\xe5\xe7\xdf\x7d\x0b\xa6\xa7\x6f\x91\x50\x24\x55\x06\xec\x0c\xc4\xe4\xf1\xe4\x46\x07\x09\x6f\x56\xd8\xa0\xb2\x95\xb8\x07\xc1\x74\xe1\xec\xd0\x55\x43\xf1\xe1\x7f\x09\x15\x89\x1b\x13\xd3\x95\x33\x61\x72\x2f\x2f\x6f\x8f\x0a\x24\x7b\xfc\xa7\x68\x8e\x06\x21\xea\x34\xd8\xe6\x57\x91\xb2\x3b\x4b\x5f\xbd\x04\x57\x29\x42\x10\x8b\xc5\x8f\x0f\xf2\xbf\x75\xf8\xc4\x1b\x63\x87\x8e\x0e\x1f\x1b\xfb\xf1\x81\x23\xc7\x0e\x0f\xee\x1b\x1e\x1b\x0e\x46\x8e\x8c\x8e\xed\x1f\x1d\x0b\x7e\x7e\x68\xdf\xbe\xfd\xa3\x6f\xf7\x94\x9d\xfa\xd6\xd1\x63\x87\xde\x1c\x1e\xdb\x1f\x60\x4f\x7d\xf5\xe0\x2a\xf6\x13\x73\x7d\xbc\x65\x56\x7f\x78\x9b\xe9\x71\xaa\x1a\x8d\x0b\xeb\x49\xb2\xc6\xbe\xad\xfd\xee\xb7\x54\xc2\x5c\x3c\x34\x34\xf4\x76\xf0\x96\xfa\xbb\x7a\x90\x1b\x13\x95\x3d\x21\x84\x2e\xa9\xa2\x9c\x56\x8c\xfa\xed\xc0\xf4\x21\x82\xb7\x28\xdb\x8e\x06\x49\x47\xba\x53\x2d\xdd\x53\x20\xdd\xe4\xa1\x0d\x50\x1a\x83\x6b\xde\x8c\xf8\xec\x17\x6a\x0d\x57\x65\x4c\xeb\x2a\x87\x6f\xd2\x8e\x25\xdb\x30\x9a\x65\x29\x06\x88\x1a\x29\xa5\xeb\xb9\x8e\x0a\x54\x06\xee\xb9\xf4\x6f\x01\x22\x06\xb6\xa1\xb0\xba\x4b\xf1\x34\x4f\xb3\x66\x54\x5d\xd9\xbc\xf2\xb0\xf3\xf8\x31\xd5\x20\x60\xfb\xf3\xbd\x5b\x9f\x24\x80\x8c\x56\x74\xb9\x93\x42\xf3\xf3\xab\x8d\x28\x67\xc5\x45\xb9\x94\x2d\x8c\xe9\x1e\x20\x29\x6e\xd3\x3b\xa1\x1c\xd3\x23\x5a\xab\x7b\x13\xc4\x32\xdb\xb1\x65\xc6\x99\x0d\xdc\xfd\x2a\x1d\xca\x43\x44\xd2\xea\x92\x41\x89\x8c\x03\x68\x10\x9d\x32\x80\x23\x7a\xa8\xf4\x94\x25\x99\xa0\x05\x75\x16\x2d\x2d\x0a\x4f\x66\x38\x51\x6f\x31\xdd\x8e\x1c\x3d\xc1\x34\xf1\xee\xb8\xfc\x5d\x86\xed\x85\x65\x50\xa0\x83\x8d\xc7\xf7\xdd\x7d\x94\xc3\x78\xa2\x51\xa9\xfb\xb0\x89\xf7\xbe\xea\x7e\xfa\x01\xd7\x1a\x8c\x13\xd6\x2a\xb9\xfb\x68\xf3\x1b\x66\xb9\xca\x95\xd8\xaf\x4c\x36\x1e\x2f\x93\x3e\x61\xdb\xf3\x89\x94\x18\x33\x03\xa3\xde\xd3\x98\xdf\x54\x49\x6b\x66\x3b\x15\xc4\xe1\xf5\x01\xb5\xa3\x44\x58\x56\xb2\x24\x3b\xd5\xd7\x3c\x93\xb9\x8a\x15\xb7\x25\x6d\x36\x3d\x32\x40\x15\x0d\x6b\x81\xf8\x24\xf4\x1f\x79\x40\xa1\x2f\x2b\x56\xcc\x92\xf2\x7d\x2d\x02\x6b\x2c\x79\x4d\x55\x0a\xe6\xdb\xdd\x0b\xf3\xae\x07\x1c\x7c\xf1\x76\x2d\xdf\x93\x35\x47\xd7\x69\x82\x6b\x59\x2a\xe9\x57\x13\x93\x3a\x42\x87\x33\x1d\xa4\x49\xfd\xca\xc1\x75\x9b\xb3\xfc\xce\xf5\xb3\x97\x4a\xae\x9f\xbd\xa8\xfd\xae\x1f\xb3\x3c\xc9\xfa\x31\x0b\x5c\x60\xfd\x1c\x5d\xe7\xaf\x5f\xdf\x0b\xc7\x97\x18\x37\x04\x60\xbf\xa9\x59\x7e\xdf\x4b\xb5\xec\x6e\x49\xf9\xfd\x9c\x1a\xa1\x9b\x08\xae\x25\x96\x2c\x43\x54\xf2\xd1\x06\x04\x28\x9b\x73\x0a\x9d\x1c\x4f\x9b\xd5\x17\xa0\xfc\x30\xa7\x65\x0d\x73\xd5\xd9\x13\x06\x3d\x96\x14\x43\x6c\x2a\x9e\x55\x80\xef\x0f\x63\x86\x3e\x6c\xd7\x0a\xbd\x6e\x77\x6b\x32\x21\x02\xe1\xfd\x52\x7d\xf4\xc9\x49\xf0\x52\x62\xe1\xa8\x06\xe1\xc4\x74\x84\xf1\x59\x0d\x17\x11\x03\x35\xe6\x0c\xfa\x8a\x7d\xc9\xe1\xe0\x39\xd5\x2d\x48\x85\x2a\xa6\x40\x31\xf7\x47\x32\x02\x27\x4d\xea\x3b\xf2\x96\x06\x02\x38\x78\xe3\x04\x2b\x62\x13\x49\xb6\x57\x33\x24\x1a\xb6\x14\xee\x59\x8a\x49\x7a\x51\xc1\x09\xd4\x8d\xc5\x36\x4d\x36\x42\x0c\xe2\xd6\x4b\x15\xf6\x48\x7e\xef\xf7\x00\x18\x53\xb1\x29\xb1\xb7\xc4\x3f\xdd\xbd\x65\xd3\x70\x85\x16\x61\xba\x75\xa4\xec\xb6\xd7\x19\xee\x7b\x67\xbf\xca\x9a\x8e\x43\x6e\xa3\x38\x87\x20\xfb\xda\x51\xa2\xd4\x63\x62\x3b\xc7\x87\xaf\x44\xd6\xe5\xee\x69\x7c\xca\xd4\x91\xb1\x62\x4e\x10\xd8\x16\x7b\xb9\xd5\x88\x62\xbe\xb0\xa0\xac\xfd\xe2\x6e\xa9\x91\x27\x92\x01\xbc\x5a\x99\xa9\x78\xbf\x32\x3b\x4a\x08\xa1\x9f\x84\xc9\xbb\x73\xfe\x4f\x5b\x2b\x97\xfc\x03\xa1\xb9\xab\x78\xa6\x0e\x01\xba\x0f\x72\x60\xc4\x7b\x8b\xa3\x1a\x55\xc1\x78\xa7\xd2\xb4\xb6\xfa\x00\xd8\x17\xcd\x53\x71\x52\x03\x1c\x1e\xa1\x92\xe0\x1e\x42\xdd\xb4\xac\xae\x81\x85\xc2\xdf\xbc\xf4\xfe\xe6\xc7\x7f\x70\x8f\x0c\x3f\xa3\xd9\x68\x94\x15\xb7\xc6\xf6\xce\x94\xf7\x7c\xd2\xa2\xe5\xf4\xc3\x97\xcf\xce\xcc\x91\xeb\xe9\x0c\x22\x7c\x2b\xb5\xe9\xb0\x51\x69\x8a\x4f\x5b\x38\x57\xe2\x80\x57\xd0\xff\xc2\x48\x7f\x4c\x7a\x5b\x13\x9f\x3f\xc1\x59\x37\xff\xb4\xd2\xbd\xf0\xbd\x4a\x31\xb3\x40\x60\x7e\x41\xce\x68\xe8\xa8\x3a\x7b\x46\x0e\x9c\x3a\x3e\x36\x7c\xf0\xd0\xe8\xc1\x53\x63\x87\x0e\xef\x3f\x72\x62\x4c\x29\x3e\x1e\xfc\x6f\x9e\x38\xd9\xf6\x1a\x33\xba\xa4\xe4\x5d\xc5\x60\xa9\xee\xb5\x2f\x09\x8f\x8d\x9d\x38\xba\x1d\x09\xcd\xf6\xfd\x49\x58\x2d\x8d\x87\x6c\xd8\x02\x02\x9a\xe2\x1c\x5c\xe3\x9a\x02\xf6\x5a\x5d\x40\xb2\x96\xc2\x3c\x5c\x06\xab\xbb\x20\x4f\x4f\xad\x3a\xb9\x91\xdc\xfe\x94\x3d\x65\x72\xcf\xba\x9f\xdc\xea\xae\x2c\x30\x7b\x15\x15\x10\x6b\xc6\xf8\x34\x0c\xd0\x1e\x79\x7c\x5a\xc9\x5b\x44\xae\xbc\xbb\x87\x19\x5f\x81\x87\xfc\xd2\x0e\xd4\x9c\x37\xfe\x92\xf6\xcc\xdc\x3d\x47\x37\x55\x69\x62\x9a\x45\xb5\x60\xbc\x14\x57\x26\xf4\xb5\x27\xd3\x09\x90\x12\xd1\xbd\x9e\x71\x55\xc3\xf6\xc9\x5a\x11\x10\xa8\xfe\x84\x6b\x86\x31\x68\xf1\x01\x29\xa4\xbe\x8c\xe1\x08\xdb\xcb\x73\x48\xa9\xe8\x8d\x8e\x32\xfc\xce\x40\xb5\xaf\x9b\x5f\x87\x7b\x58\x9e\xb4\x89\x72\xf4\xd8\x56\x7c\xd5\x08\x4f\x33\x70\x80\xb8\x2d\x8f\x8e\x86\xbb\x1d\x18\x54\xfa\x16\x1b\xef\xa4\x79\x5b\x1d\xf1\xf8\xa9\x2b\x4e\x79\x91\xc6\x75\xde\x9c\xee\x29\x1a\x0d\x02\xe4\xf1\x8c\xf0\x2d\xf9\xa0\x99\xbf\x69\x14\x57\x3c\xaa\x67\xe3\xd9\xf2\xe6\xb3\x07\x4c\x53\xca\x2d\x61\x83\xbd\x52\xbf\x50\x78\x6a\x9e\xfd\x46\x31\x69\x9e\xfb\x44\x53\x39\xef\xcc\x57\x0a\xe8\x7a\x59\x46\x86\x5b\x06\xae\xa1\xfa\x14\xc0\x96\x61\x89\xf5\xed\x6f\x01\x4c\x8f\x73\x8b\x85\x3a\xe4\xa6\xe5\xec\x91\x9d\x1c\x51\xc8\x00\xd2\xb0\x51\x19\x47\x6a\x7c\x08\x13\x9d\xc2\x85\xdb\xa5\x6a\x87\xf4\x3c\xef\x74\x9f\xda\xb8\xd9\xb9\x2e\x49\xfd\xee\x5c\x7f\x98\x13\xd8\x67\x77\xf9\x15\x69\x98\x86\x84\xa2\xe4\xf6\x27\x42\xaa\xdc\x2d\xb7\xc1\x79\x66\xf3\x9c\x70\xdd\xa3\xde\x62\xfb\xcd\x3b\x4f\x76\x88\x27\xcd\xdf\xf9\x76\x89\xc9\x8a\xf5\xde\x77\x25\x20\x7f\xf7\xa7\x43\xd6\xf2\x70\x41\xb5\xfd\x9d\xf9\xb4\x7b\x4f\xe7\x8a\x0d\xf3\x2b\xda\xa5\x75\xc1\xe1\xed\xb8\xc8\x62\x32\x1d\x60\xcc\x91\xfb\x52\x30\x54\xc8\x34\xac\xf0\x5b\x84\x5c\x71\x32\x50\x09\x9f\xc2\xf4\x51\xb0\xd6\x80\xa7\x35\xf1\xb7\x78\x9c\x3b\x96\x8b\x85\x51\xdd\xd8\x6b\xa1\xfe\xb8\x0e\xe2\x69\x5d\x3e\xd0\x88\xa6\xc0\x15\x85\x27\xb2\x78\xfc\xf8\xcf\x03\x3b\x79\x51\x06\x54\x94\xd9\x56\xb8\x52\x6f\xce\xf8\xe0\xb1\xd2\xca\xf9\x19\x4f\xcc\x85\x03\x7f\x75\x35\xe8\x47\x44\x2e\xd4\xc2\x08\xe9\x8f\xbe\xb2\x02\x18\xb4\xa9\xdb\x5a\x23\x39\xfc\x0b\x58\x22\x8f\x84\x05\x97\x48\xbf\xbf\x49\xf6\xaa\x3e\x15\x01\xeb\xac\x4b\xc8\x8e\x4b\x2c\xdf\x3b\xeb\x4d\x9e\x9d\x5c\xac\xed\xef\x24\xf5\x0a\x77\x66\x95\x7c\xaf\xad\x27\x71\x76\x74\x47\x6d\x7b\x2f\x81\x7f\x69\xee\xa7\x3c\xa9\xb6\xb7\xa1\x30\xe4\x5a\x58\x2e\xe3\x05\xee\x84\x58\xfc\x62\xf9\xc4\x6a\xfa\x70\x02\x06\x6d\x05\xdf\xbe\xd1\xe4\x0d\xd0\xad\xab\x8b\x9d\xd5\x45\xf6\x12\xdd\xe7\xd6\xf8\xfc\x18\x0a\xed\x7a\x1a\x3e\x6a\x73\x0d\x23\x28\xc6\xc0\x19\x01\xed\x6b\xdd\xfb\x37\x7c\x01\x1f\xd9\x3e\x28\x61\x0a\xd3\x9e\x40\x18\x14\xc2\x0b\x98\xe0\xc2\x14\x00\xc1\xbd\x87\xd7\x70\x37\x31\xd5\x06\x52\xf7\x31\x56\xb6\x46\x43\x99\xa8\x4c\xf7\x80\xc0\xd8\xc3\xed\x8d\x95\x85\xce\xf9\xa7\x4c\x33\x2c\x4e\x59\x20\x44\x9f\xad\xae\xe9\x8b\x98\xc1\x05\x04\xbb\x57\x88\x27\x88\x71\x07\x5a\x35\xc8\x7d\xab\xa9\x92\x71\x4d\xce\x74\xdd\x78\xbc\xdc\xfd\xf4\x03\xb1\x83\xc9\x94\xef\xde\xbd\xbe\x75\xf5\x06\xd7\x65\x91\xd0\x9f\x2f\xf8\xd4\xea\x9d\xae\x4a\x34\xe1\xf6\x9d\xb7\x0d\xf7\x89\x89\x46\xcc\x97\xd5\x8a\x4b\x53\xac\x87\x9e\x57\xf2\x10\x70\xb4\x6c\xe0\x23\xaf\x4a\xa1\x45\x1d\x5c\xa0\x17\x4a\x3f\x77\xf7\x75\x66\xfb\x3c\x05\x73\x1e\xf2\xf9\x75\x96\x6c\xe2\xd7\x54\xe1\x50\x62\xb6\xdf\x7d\x37\xd8\x8d\xa4\xb7\x24\xce\x5e\x22\x74\xab\x48\x16\x85\xe3\x4d\x48\x0d\x7d\xf7\x5d\xae\x50\xad\xbb\xaf\x34\xd1\x0e\xd7\x27\x27\xde\xc8\x01\x45\x49\x58\xaf\xf4\x14\x2c\x30\xdb\xfa\x08\xbc\xf2\x5b\xcf\x42\xa6\x7a\xab\x52\x6d\x52\x46\xd0\xc1\xc8\x5a\xa0\x83\x91\x26\xf1\xe5\x17\x46\xf7\x05\x57\xaf\xa2\x83\xd4\xaa\xa4\xfa\x01\xe8\xb2\x9d\x02\x71\x5d\x1d\x6e\x7c\xb0\x16\x69\xdd\x5a\xb5\xe6\x91\x49\x99\xe7\x11\x8b\x8e\x54\x06\x8f\x8f\xba\x31\xd3\xa8\x40\x92\x82\xc4\x00\xb2\x88\x0d\xe8\x97\xe0\x67\x8a\x40\xcf\x8f\x46\xcb\x3e\x9f\x02\x42\xe6\x23\x0f\x01\xfa\x52\x89\x4f\x9f\x00\x85\x00\x3c\xd1\x93\x81\xfc\x8b\xe4\xd7\xe4\x47\x36\x1e\x82\xbb\x23\x71\x0e\x8b\xff\x0d\xec\xfe\xf8\x31\x85\xbe\x56\x32\x7b\x50\x26\xa9\x27\x73\x40\x27\x4e\x6c\xc2\xc9\xda\xd8\xa1\xa3\x7b\x03\x4d\x05\x78\x40\xbd\x32\x83\xcd\x4f\x91\xf1\x19\x39\xda\x98\x70\x4d\x39\x72\x26\x1d\x9f\x67\x47\xb8\x86\xce\x54\x07\x77\xb2\xf4\xd1\x45\xa6\x22\x18\x60\x72\x70\x13\x12\x93\x14\x75\x9f\x73\x46\x3d\xc0\x84\xd4\x05\xdf\xc9\xda\xc9\x26\xfe\x1f\x2d\x98\x26\xbb\xa4\x94\x14\x95\xbb\x12\xcc\x4e\x87\x94\x45\x77\x12\x5a\x1e\x6d\xc5\xd3\x7a\xd8\x93\xff\x80\xb6\x3a\x96\xd6\x54\x49\x6d\xf0\xed\x57\xa8\x01\x59\x33\x60\x34\x60\x96\xbd\xc4\xe5\xc7\xba\xa6\xbd\x24\xd3\x87\x12\xb0\x43\x80\x99\x52\xaf\x4c\x4b\x62\xbf\x31\xe0\x63\x72\x31\x38\x69\x84\x6a\x6c\xf5\xe2\xe6\x80\x14\xf3\xaa\x37\xa7\x65\xd9\x52\x4d\x08\xe9\x7f\xcb\xe6\x52\x99\x2f\xd8\x24\x34\xd5\x39\x6e\x66\xdd\xd9\xf6\x52\xe7\xdc\xad\xc4\x7a\x86\xf4\x2f\x4a\x24\x96\xd6\x9b\xb4\x91\x60\x37\x60\x82\x9a\x73\x85\xa1\x17\x99\xcc\xaa\x68\xa0\x28\x8b\xdb\x95\xa6\x90\x49\xf4\x59\x51\x78\x34\x9e\xe0\xc9\xd5\x91\x41\xed\xe4\xda\x87\x62\x78\xee\x45\x39\x37\x22\x49\x20\xfa\xba\x48\x68\x54\xb0\xa3\x30\x49\x86\xb2\xb3\x0d\x72\xf8\x7b\x9d\x2f\xbe\x11\x66\x64\x6f\x0c\x9c\x45\xb6\x3a\x6d\xf2\xd6\xb6\x08\x42\xcd\xee\x8c\x8d\xb0\xa3\xbc\xa1\x40\xa8\x4a\x79\x52\xa0\x9d\x6b\xd5\xb9\x60\x36\x6a\x88\x6f\xb2\x55\xc7\x5c\xe2\x03\x81\x61\x79\x80\xf2\x3d\x5c\x7a\xa7\x32\xd3\x9a\x49\xe8\xfb\x89\x7c\x28\x21\xfa\xb7\x0c\x09\x9e\xde\xbf\x80\x34\xba\xf6\x40\x56\x0a\xc5\xfd\xaf\x87\xf9\xe7\x7e\xe5\xd0\x65\x01\x60\x94\x91\x37\x32\x96\x11\xf4\xa3\x3b\x81\xef\xd2\x6a\xe0\x30\xa5\xd2\x03\x43\x9b\xe4\x1d\x29\x7b\x23\x9b\x57\x96\xbc\x38\x6b\xdf\xab\x41\x16\x2e\x77\x1e\x7e\x24\x53\x61\x41\xbb\x2f\x38\x97\x41\x65\x9e\xc9\x94\x73\x65\x27\x80\x6e\x80\x5e\xd5\xae\x2f\x00\x5e\x81\x37\x51\xa5\xd4\x69\xcd\xd5\x4b\x29\x69\xfc\x66\x4d\x37\xc0\x04\xdc\x62\x09\x0a\xb0\xb3\xc2\x19\xdb\x4a\x10\x7f\xc8\x35\x12\x92\x67\x6c\x1b\x21\xe9\x8c\x1f\x4f\x9c\x03\xd5\x31\xe1\x14\x8a\xb6\xea\x9f\xca\xa8\x2d\x92\xa8\xe2\xef\x42\x87\x14\x7b\xc8\x64\x01\x42\x6e\x85\x57\x91\xbd\x7a\x93\x41\x1c\xcf\xf7\xb6\xe4\xe9\xd6\x50\x15\xbb\x11\x4d\x35\xf8\x24\x25\xf7\x90\x5b\xf3\x5f\x8b\x03\x03\x57\xdf\x6b\x09\xa7\x9b\xc6\xad\x09\x28\xef\xd8\xe3\x04\x85\x01\xde\xb9\x58\x20\x7f\x31\x03\xcb\x0d\x66\x5a\x31\xb1\x17\x04\x31\x7a\x38\x58\xb6\xa4\x25\x8c\x32\x04\x40\xf1\x42\xa4\xba\x41\xba\x13\x4d\x19\x06\x2c\x1d\x08\x6c\xd2\x14\x8b\x80\xfb\xed\x93\xae\xaf\x80\xcc\x3b\x22\xeb\x4e\x48\x56\x18\x2d\xed\x90\x6a\x9b\xf0\xe8\x5f\xdb\xc5\x36\x76\xd3\x17\x2f\x4c\xbf\x37\x20\xaa\xf2\xee\xbb\x87\xad\xf0\xd1\x80\x09\x86\xb4\x9e\x0b\x9c\x88\xd0\x01\xcd\xb1\x1b\xab\xe7\xe8\x8e\x7b\xc0\xe0\xb8\xd7\x3f\x29\x83\x7e\x20\x30\x31\x2f\x78\x00\x8d\x46\xb5\x9f\x01\x54\x49\x35\x19\xa6\xe4\x17\xaf\xb3\x9e\x33\xaf\x6c\xb4\x8b\x58\xd1\xdd\xd3\x2b\x08\x62\xa5\x2e\xec\x19\x13\xb5\xba\x2c\xb4\x8c\xbf\xa7\x27\x2e\xc9\xd7\x4d\x27\x62\xbe\x9d\x85\xf3\xe4\x2c\x04\xf7\x7e\x8f\x11\x38\x40\x9d\x25\x74\x24\x8c\x41\x68\x50\xfd\x29\xe1\xc6\xf0\x03\x09\xd2\xed\x48\xee\xe4\xac\x48\x8d\xa4\xa6\xe5\x22\x24\x42\xc3\x38\x5f\xcf\x1d\x97\x81\x65\xd5\x65\x4e\xa0\xd9\xd1\x02\x85\x58\xd2\x11\xe8\x3e\xc7\xc3\x0d\xb4\x8f\xd2\xb5\xbc\x9b\xae\xd0\xf0\xe9\xde\x3c\xd2\x34\x53\xa7\xc9\x90\xf6\x8f\x1d\xbe\x64\xd4\x30\x7f\xb1\x9d\x30\xc4\x8e\x1b\x34\x32\x14\x3c\xf7\xf8\x4f\x6a\xf0\xec\xa9\x24\xac\x76\x02\x79\x52\x8c\x1d\xe8\x8a\x88\xb2\x34\xed\xf0\xba\xdc\x5d\xcd\x4c\xe1\x96\xb4\x37\x77\x58\x99\x39\x60\x32\xa1\x0b\x20\xdc\x4a\xfa\x6e\xc5\x1f\xdf\x31\x95\x55\x66\xab\xf3\x13\xef\xbd\x53\x06\xb3\xf1\xff\xde\xfe\x9f\x00\x00\x00\xff\xff\x65\xe6\x29\x80\x01\x68\x03\x00") + +func cfI18nResourcesJaJpAllJsonBytes() ([]byte, error) { + return bindataRead( + _cfI18nResourcesJaJpAllJson, + "cf/i18n/resources/ja-jp.all.json", + ) +} + +func cfI18nResourcesJaJpAllJson() (*asset, error) { + bytes, err := cfI18nResourcesJaJpAllJsonBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "cf/i18n/resources/ja-jp.all.json", size: 223233, mode: os.FileMode(420), modTime: time.Unix(1456502789, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _cfI18nResourcesKoKrAllJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xbd\x7b\x53\x1c\x57\x96\x2f\xfa\xff\xfd\x14\x79\x34\x77\x02\xd4\x41\x21\xdb\xdd\x33\x71\x82\x13\x27\x7a\x30\x42\x32\xc7\x48\x30\x3c\xd4\xe3\x6b\x3a\xe8\xa4\x2a\x81\x6c\x55\x55\x56\x57\x56\x81\x69\x8f\x27\xb0\x55\xf2\xc5\x16\x3d\x96\xc7\xc2\x42\x36\xa8\xf1\x69\xb5\x65\xf7\xc1\xb7\xb1\x84\xdc\x38\x46\x3d\x1f\x88\x2a\xbe\xc3\x5d\x8f\xbd\x33\x77\x66\xe5\xce\x47\x3d\x24\xd9\xf3\x88\xb6\xa8\xaa\xcc\xbd\xd7\xda\x8f\xb5\xd7\x5e\x8f\xdf\x7a\xf3\xff\x32\x8c\xb7\xe1\x7f\x86\x71\xce\x2e\x9c\x1b\x31\xce\x2d\x94\x17\xca\x73\x13\xd3\x23\x0b\xe5\x73\x43\xfc\x7d\xad\x6a\x96\xdd\xa2\x59\xb3\x9d\xb2\x7c\xe0\x6c\xfb\x5d\x7c\x00\x7e\x7f\x67\x28\xaa\x81\x37\x9c\x7a\xd5\xf8\x5f\xb3\x53\x57\x0d\xb7\x56\xb5\xcb\x2b\x86\xbb\x51\xae\x99\x6f\x19\xb6\x6b\xd8\xe5\x35\xb3\x68\x17\x86\x0d\x63\xba\xea\x54\xac\xaa\xf2\x53\x6d\xd5\x76\x47\x0c\x23\xbf\x6c\xb8\x56\x2d\x57\xad\x97\xcb\xf0\x6a\xce\x2a\xaf\xd9\x55\xa7\x5c\xb2\xca\xb5\xdc\x9a\x59\xb5\xcd\xa5\xa2\x95\x5b\xa9\x3a\xf5\x8a\x31\xf0\xf6\xc2\xb9\xb2\x59\xb2\x16\xce\x8d\x2c\x9c\x83\x66\xeb\xf0\xd7\x50\xfb\x57\xef\x0c\xc4\xb0\x42\x54\x36\x0f\x4f\x5a\xf7\x6f\xb7\xee\x1e\x1b\xa7\x4f\x0e\xf1\xc3\xfe\xb1\xd1\xda\x3d\x6c\x1e\xdd\x69\xfe\xf1\xb8\xf5\x70\xd3\x68\xed\x7c\xd8\xfa\xf0\x49\xf3\xd6\x56\xf3\xd6\x83\x61\xef\xa7\x13\xef\xf1\x4d\x03\x7e\x68\xed\x6f\x9f\x3e\x7e\x6a\x9c\x1e\xdd\x53\x9e\xed\x07\x37\x7d\x1d\x77\xb7\x66\xae\xfc\x78\xc6\xbd\xa7\xdc\x68\xc6\xfd\x27\xc6\xdc\xaa\xe5\x5a\xd0\x5f\x75\xcd\xce\x5b\x46\xa5\x08\xdc\x1a\xab\xe6\x9a\x65\x98\x65\xc3\x74\x5d\x27\x6f\x9b\x35\xab\x60\xe4\x1d\xb7\x36\x6c\x8c\x55\x2d\x18\x09\x98\x1c\xd3\x7b\xc3\x2e\x03\x9d\x65\xf8\x63\xdd\x2e\x16\xe1\x53\x1e\xa6\x11\x67\x85\xdf\xd0\x8e\xe2\x4f\x8c\xb3\x9d\xe3\xe6\xad\xef\x8d\x56\x63\xaf\xf9\x7d\xa3\xf5\xe1\x03\xe3\xec\xce\x76\xf3\xfe\x5e\xeb\xee\x6d\xa3\x75\xf7\xe8\xf4\x78\xb3\x79\x7b\xcf\xc0\x9f\x3e\xfb\x9a\xc6\xf6\xfe\x96\x3a\x9c\xde\x5b\xad\xfd\x13\xf8\xe7\xac\x71\x0c\xff\x6d\xfe\xf1\x29\x3c\xf7\x71\xab\xf1\xed\xd9\xce\x6e\xf3\x6b\x78\x09\x5e\xf4\x9b\x68\x1e\xed\xb5\x6e\xec\x9f\xed\x7c\x2d\x5a\xd1\x0d\xca\x68\xa5\x02\x8b\xd0\xac\x02\xdf\x31\xa2\xa4\xb5\xf3\xad\xd1\xba\xb5\x07\xfd\x35\x6f\x7f\xa5\x97\x28\xd8\xd8\xdb\x6f\x0f\xc3\x3f\x57\x61\x56\xde\x79\xc7\x58\x37\x5d\xd9\xba\x51\x77\x71\x30\xc5\x70\x95\x4a\x66\xb9\x60\xfc\x0a\x1e\x1e\xe3\xbf\xdf\x79\xe7\x57\x31\xfd\x07\x1f\x34\x9a\x7f\xba\xd9\x3c\xf8\xbe\xb5\xdf\x30\x5a\xef\x1d\x02\xc3\x30\x02\xad\xbb\x87\xc1\xae\x81\x64\x1a\x4a\x41\x35\x3c\xa0\x8c\xa9\x9e\x85\xab\x8e\x61\x56\x6c\xc3\x2a\x17\x2a\x8e\x5d\xae\xe1\xe2\xd4\x4f\xec\xe8\xf4\x04\xcc\xdf\x9d\xe6\x27\x7b\x67\x1f\x1d\xc2\xe4\x9c\x7d\x78\x72\x7a\x04\xbb\xa1\xf1\xa0\x75\xb0\x83\x7d\x8a\xad\x01\xe4\x79\x5d\xeb\x3a\x9e\x71\xea\x35\xcb\xa8\x39\xc6\x92\x65\xd4\xcb\x25\xb3\x52\x81\x31\x83\xb1\x2a\x3b\x35\x03\xd6\x59\x15\x76\x44\x71\xc3\x10\xdf\xc3\x63\xb5\x55\x58\xb6\x95\x4a\xd1\xce\x13\x41\x7a\x22\x9b\x0f\x9f\x9c\xed\x7c\x8c\x4b\xb0\x75\xb0\x77\xb6\x73\x60\x34\xf7\x9f\xb6\x3e\x3b\x12\xb4\x9e\xed\x36\x5a\xf7\x0f\x81\xca\x03\x5c\x92\x5f\x1e\xb6\x9e\x6e\xc2\xb0\xb5\x6e\xee\xe2\xda\xe4\x57\x91\x91\x4f\x79\x51\x86\xb7\xba\x8e\x19\x3c\x99\x0c\x63\x1e\x36\xdb\x00\x6c\xf0\x92\x59\xbd\x6e\xd5\x60\xbb\xc1\xce\xc9\xb9\xc6\xec\xf8\xcc\xb5\x89\xb1\xf1\x01\xe4\x62\xcd\xb6\xd6\x8d\x82\xe5\xe6\xab\x76\x05\x49\x76\x0d\x67\x19\x36\x56\xc1\x5e\xb3\x0b\x75\xb3\x28\xf6\x28\x7c\x67\x1a\x2b\xf6\x9a\x55\x96\x5b\x51\xcf\x2e\x9e\x79\x46\xeb\x0f\x4f\x81\xe4\xd6\xc3\x86\xbf\x79\x5a\xfb\xbb\x20\x7a\xf6\x9a\x8f\x1b\xca\xe6\x6b\x6e\x6f\x9e\xed\xec\xe1\x84\xc1\x92\xc2\xf5\xd4\x7c\x7c\xdc\x3c\x78\x80\xdb\x29\x86\x70\xda\x7a\xde\xc2\xbb\xf5\x0d\xae\xb1\xdd\x84\xc1\x18\x75\x5d\x7b\xa5\x6c\x54\x9d\xa2\xe5\x82\xf8\xa8\xad\x82\x3c\x83\x35\xcd\x13\x0b\x03\x55\x85\x25\x8b\x82\xd0\xa9\xae\xe4\xf0\xa1\x01\x03\x37\x48\xf4\x33\x6e\x05\x08\xe2\xa7\xe2\x87\x21\xa1\x0b\x94\xc6\x89\x3d\xb4\xed\xb2\xd6\xdd\x6f\x60\x15\xd1\xd7\x0f\x37\x61\x9d\xa7\x1f\x03\x5a\x0f\xd8\xdf\xa5\x39\xb3\xba\x62\xd5\xbc\x1d\x4d\x4b\xa1\x46\xdf\x19\x65\x58\x10\xd4\x7d\xc2\x0c\xdf\xd8\x82\x73\xe6\x5d\x20\x86\xa6\x6d\x7b\xb3\x75\xe3\xdd\xd6\xde\xd3\xe6\x17\x7b\x3e\x59\x72\x26\x23\xbb\x84\xd7\x06\x61\x22\xcf\x67\x9e\x49\x8f\x0b\x1d\xf5\x30\xbe\x29\x68\xff\xe2\xa8\xf5\xf0\xdd\x74\xb4\x77\x4f\x73\x5d\xec\xc4\xa2\x03\xa7\xac\x91\x33\x0d\x94\x5c\xb9\x9c\x7b\xdd\xae\xe4\x5c\xb7\x98\x23\x9d\x83\xc8\x1c\x00\xf2\xe9\x51\x94\x82\x31\x4f\x01\xcb\x6e\xbd\x52\xa9\x5a\x2e\x2b\x26\x86\x55\xad\x3a\xd5\x04\xbe\x49\x6d\x80\x93\x6b\x97\x76\xd0\xa7\x4f\x48\x20\xed\x2a\x1b\x2e\x0d\x7d\xcd\xdd\xdb\xcd\x0f\xef\xa4\xa0\x31\xb8\x72\x13\x06\x0a\xfe\x1a\xbb\xb4\x78\x75\xf4\xca\xb8\x61\xd6\x61\x77\xa2\x5a\xf1\x0f\xd6\x5b\x66\xa9\x52\xb4\x86\xe1\xbc\x32\x16\xce\x2d\x2c\x2c\x9c\xab\x80\x9a\xb0\xee\x54\x0b\xf8\xf7\xc2\x39\x63\x10\x24\x97\x59\xb1\x8c\xdf\xd4\x9d\x1a\xec\x6b\x7b\x19\x47\x1a\xc4\x76\xd9\x90\x0f\x9e\xd7\x0c\x49\x47\xfd\x0d\x82\x28\x6b\x1e\x6d\x36\x1f\x6d\x9d\xed\x9e\x80\xfc\x02\xe1\x26\x38\x04\x19\x8d\x83\x72\xfa\xe8\xaf\x20\xda\x8d\xe6\x9d\xa3\xd6\xee\xf1\xd9\xc7\x7b\x38\xe4\x28\xfb\x48\xa8\x9f\xdd\x69\x9c\xef\x98\xf9\xd2\x86\xc7\x12\xf2\x8d\x0b\x4a\x30\xbd\x0c\x0b\x46\xfe\x24\x44\x9b\xc9\x3b\xf8\xbc\xf6\x44\xcf\xda\xe1\xe0\xe9\xe3\x27\xcd\xa3\x6f\x85\x6e\x84\x9c\x86\x46\x42\x65\x99\x06\xe4\xbc\xee\x88\x57\xba\xce\x3b\x95\x8d\x9c\x0b\xba\x38\x88\xf7\xd9\xa9\xf9\x99\xb1\xf1\xdc\xe8\xf4\xb4\x31\x37\x3a\x73\x79\x7c\x8e\xfe\x7c\x33\xe7\xc8\x8f\x53\x33\x97\x7f\x09\x9f\x5d\xf9\x79\x76\x7a\x74\x6c\x1c\xbf\xc9\x95\x9d\x1c\x6c\x03\xd4\x72\x7e\xa9\x65\x38\x91\x16\x5e\xf9\x83\x4e\xc9\xae\xe1\x1a\xaa\xe2\x88\xd0\x11\x20\x07\x01\x77\x1c\x3f\x04\x6a\x89\x55\x35\xf3\x35\x38\x0f\x41\x23\xc8\xe5\xbc\x36\x48\x2b\xad\x54\x9d\x52\xa5\x46\xb3\xb2\xe4\xd4\x56\x53\xcd\x01\xb5\x3b\x88\x87\xe1\xbd\x3b\xad\x5b\xfb\x42\x16\xc1\xff\x4e\xff\x72\x82\x6a\xcd\xce\xee\xe9\xc9\x91\xd1\xda\x6b\x80\x12\x21\xc6\x17\xee\x03\xb8\xb8\x9a\x5f\x36\xf0\x14\x51\x67\x03\xc4\xdb\x7e\xf3\xfe\x13\x85\x30\xd2\xff\x3f\xde\xc5\x3b\x00\x4c\x1f\xa8\x6e\x7f\xc4\x5d\xff\x51\xa3\xf9\xc5\x3e\x9c\xc5\xf0\xcf\x21\xfc\x17\xf4\x11\x94\x0a\x30\x83\xb0\x4f\xcf\x76\xbe\x4a\x33\x81\x42\x5c\xc0\xc6\x77\x8c\xc1\xf0\x28\x80\x06\x01\x23\x68\xd4\xab\x45\x1c\x3a\x67\xa9\x66\xc2\xb3\xa6\xe1\x94\xad\x5c\xcd\x86\xc1\x6d\x1b\xd8\x14\x5b\x55\xe9\x70\xd0\x63\xee\x58\x3b\x52\xfb\x4f\xcf\x3e\xdb\x06\x0d\x3d\x30\x3e\x2c\xfb\xfe\x1d\xa5\xd3\xfc\xcc\x24\x09\xa9\x83\x3d\x58\xdf\xc8\x73\x5a\x8e\xeb\xed\x3b\x26\x57\xe9\x58\x44\xa5\x5e\x22\x59\x3a\xee\x5e\x56\xa5\x5f\x00\x3a\xaa\xfa\x26\xb4\xb2\xf4\xdb\x1f\xd9\x15\x4b\x41\xc5\xfc\xbb\xbf\x5b\x77\x66\x2e\x1a\x83\x6e\xc5\xca\xdb\xcb\x1b\x1a\x91\x02\xb7\x33\x50\x5b\xea\x78\xdb\x76\xbb\xe7\x5b\xf6\x3a\x98\x24\x21\x68\x07\xc0\x55\x76\x6b\xd7\x57\x79\xd2\xf0\x5c\xa9\xbb\xab\x70\xde\x4f\xf3\xa7\x37\x73\x4b\xc6\xab\xf3\x13\x93\x17\x41\x10\xbf\x4e\x5f\xa1\x34\xce\x1b\x63\x53\x57\xae\x8c\x5e\xbd\x88\x1f\x0a\xc6\xc5\xa9\x2b\xa3\x13\x57\xf1\xef\x65\x03\xbe\x9d\xb8\x34\x3e\x3b\xb7\x38\x3d\x3a\xf7\x1a\x49\xee\x82\x93\xbf\x6e\x55\x73\x76\xc9\x5c\xb1\xe0\xd1\xb1\xd7\xc7\x67\x16\x27\xae\x8c\x5e\x1e\xef\x42\x90\x13\x91\xed\xdd\x65\x6f\x70\x8a\x2e\x44\x66\x11\x64\xbc\x2f\xcd\x8a\xb6\x5b\xc3\xeb\x10\xdd\xa0\x73\x05\xab\x68\xc3\x81\x81\x17\x42\x73\x05\xf5\x30\xb3\xc6\xe2\x0f\xee\x90\xeb\x55\xbb\x56\x83\x0b\x93\xb8\x2a\x5e\x1b\x1b\x9d\x5e\x14\x17\x98\x59\x43\x31\xb3\x18\xd2\xcc\x42\x7b\xc2\x2c\x6f\xc0\xb1\x51\x87\x45\xa2\xdc\x2d\x5d\xdd\x6d\x0b\xbe\x6a\x35\x0e\xce\x6e\xec\xb7\x0e\xa4\x02\xdb\x3c\xba\x03\x53\xdb\xbc\xf3\x35\x5a\x34\x22\x6e\x95\x70\x0b\x0b\x92\x72\x76\x6f\x17\x24\x01\x5c\xbc\x36\x61\x3d\xe0\x6e\x00\x01\x0a\x07\x03\x5e\x54\x5b\x1f\x3c\x85\x4d\x81\xad\xa2\x1d\xe9\xbb\x06\x36\x79\x76\x83\x45\x2d\x9c\x26\x7f\xfa\x1a\x9e\x53\xe5\x67\x1a\x25\x2f\x62\x54\xc5\x95\x32\xc7\x7b\xc5\xce\xc3\xe0\x96\x97\xed\x95\x7a\x95\xf8\x84\x65\x5d\x85\xc5\x0e\x47\x2e\x1a\xe7\x60\x0a\x48\xc3\x64\xeb\x9d\xb3\xf4\x6b\x2b\x5f\x83\xaf\x73\x45\xbb\x6c\x0d\x2f\x94\x95\x75\x50\xaf\x80\x1a\x0a\x8d\x0a\xd3\x11\x2c\xcc\xd4\x06\x2c\xb4\xbb\xe9\x16\xc0\xb2\x0d\x33\x05\x04\xe2\x69\x46\x96\xc3\x2e\x89\x1f\x36\xa8\xaf\xb9\x55\x3c\x10\x41\x0a\x8a\xe5\xa2\xbc\xc7\x3d\x9a\x65\x5c\x54\x68\x27\x5b\x72\x9d\x22\x9a\x2a\x60\xb5\x54\x2d\x5c\x0b\x6b\xfe\xab\x4c\x5f\xd2\x40\xe0\x86\x58\x9c\x9b\x5a\xbc\x34\x31\x39\x2e\x78\x1d\x67\x51\x82\x4b\xbb\x8d\xc4\x11\x7a\xe2\x6d\xfa\x2f\xfc\xdf\xc2\xb9\x7c\xb1\xee\x02\x69\x8b\x65\xa7\x60\xb9\x30\x74\xfe\x6f\xfc\x33\xac\xdf\x1a\x7e\xfd\x77\x43\x81\xef\x4b\x56\xc9\xa9\x6e\x2c\x96\x96\xf0\xb7\x97\x5f\x7a\xe5\x67\xf2\xd7\x77\xe8\x8f\x77\xd2\x2f\x72\xdf\xc0\x49\x64\xe2\x9d\xe6\x64\xbb\x75\xb0\x0f\x3a\x0c\x0a\x36\x34\xb0\xec\x93\x64\xf7\xac\x0f\x68\x76\x80\x45\x4c\xba\xc0\xc3\x07\x64\x87\xc0\xf5\x4e\x92\xb0\x7d\xf5\xf6\x78\x21\x65\x20\x3f\x2d\xd1\x67\x1f\x1d\x82\xbe\x82\x6a\x1c\x9c\x67\x67\xdb\xdb\x2d\x64\x39\x72\x27\xf2\xfa\x52\xdf\xf7\x9e\xdf\x45\x1d\x00\x08\x52\xdb\xd8\x85\x36\xb6\x40\x13\x95\xd7\x3c\xb8\x1a\xe3\x27\x7e\x10\x95\x47\x69\xc0\xcb\xba\xc2\xe2\x98\xc6\x5e\x77\xb7\x9e\xd9\x3a\x7b\x0e\xb2\x69\x44\x8c\x82\x1c\xb2\x25\xbb\x5c\xf0\x06\xcc\x3b\x52\x85\x50\x5e\x9c\xb8\x3a\x3b\x37\x7a\x75\x6c\xfc\x3f\xb1\xd4\x4a\x3f\x40\xdd\x4a\xb3\x8a\x55\x2d\xd9\xae\x8b\xe7\x2c\x2e\x98\x85\x73\x55\xcb\x2c\xe4\x9c\x72\x71\x03\xd4\xe8\x17\x4e\x30\x3d\xa3\x55\xf4\x63\x17\x59\xdd\x2c\xaf\x0e\x24\x59\x8a\x35\xf6\x02\x08\xa5\x3c\x7a\xdc\x7c\x39\x2e\x46\xc3\x98\x9e\x1c\xbd\xfa\x03\x12\x4d\xbd\x97\x4c\xdd\x8e\xd3\x7f\xe9\x5b\xd9\xc4\x5a\xbf\xd7\xe1\x73\x15\x6e\xe8\x10\xec\xb5\x60\xeb\xf5\xea\xfc\x01\xe8\x6a\xd3\xb8\x43\xdd\x55\xa7\x5e\x2c\xd0\x46\x36\x7e\x6b\x57\x68\xb3\x0e\xf9\x36\x47\xf5\x4b\xbc\x5b\x1b\x45\x27\x6f\x16\x8d\x82\x5d\x85\x5d\x06\xdd\x0e\x1b\xd3\x8e\x6b\x93\x58\xb1\x5d\xf8\xb9\x42\x9f\xd6\x2c\xb2\xf0\xae\x58\xd5\x21\xf4\xc5\xb9\x20\xab\x6c\x07\x2e\xf3\x1b\x43\x64\xbc\x81\x27\x5d\x87\x1c\xea\xcb\x55\xa7\x04\x4d\xae\x5b\x6e\x0d\x7b\x5b\xb5\x57\x56\x2d\x7d\x18\x02\x7c\xe5\xcf\x30\xd2\xc5\xb3\x3c\xa4\xfc\x8d\x63\x3b\x3f\x33\x29\xa7\x1b\x27\xf9\xdf\x0f\x8d\xe6\x9d\x3b\xcd\x83\x0f\xce\xde\x3f\xc0\x7b\xfc\xdd\xc3\xd6\x0e\xac\x36\x2f\xac\x00\x4d\x9d\xad\xef\x69\xd5\xb5\x3e\xfd\x98\x97\xcc\x0e\x5e\xe4\xf7\x8f\x9b\x5f\x1f\x19\xad\xcf\x8e\x60\xb1\xb7\xb6\xf6\xe0\x31\xda\x7b\xe4\x19\x47\x2b\xe9\xe3\x03\xa3\xf9\xde\xff\x87\x96\x61\xfe\x55\x58\x08\x9b\xef\xff\x9b\xf2\x1d\xfe\x97\x77\xc8\xc1\x4e\xf3\xe0\xb0\x79\x3b\x3e\x9a\x01\xa7\x05\xad\x2f\xa5\x7a\xb1\x66\xa3\x74\x33\x2b\x15\xcf\xb8\x57\x32\xcb\xf6\x32\x8c\x8f\x3e\x62\x0a\xbe\xba\x22\x1e\xa2\x3e\xef\x1e\x36\x7f\x8f\x9e\xf1\x6f\x8d\xb3\x8f\x4f\x60\xf7\x68\x43\xa9\xa4\xbc\xe7\x33\xa5\xc0\xd2\xbb\x03\xdd\x73\xa2\x26\x57\x14\x07\xa5\x18\x18\x31\x81\x6c\x54\xab\xe6\x06\xf3\xa1\x88\x69\x3c\x80\x5c\x3c\xc3\xd8\x7d\xbe\xc4\xd1\x15\x96\x51\xad\x17\xad\x58\x8b\x0d\xc9\x04\xb4\xa5\x74\xa7\xca\x88\x77\xee\xd2\x83\xa7\x7f\xd9\x6b\x7d\x7f\x8f\x44\x0e\xf9\xd2\x85\x24\x6a\xdb\xbe\x14\x72\x40\xb2\x8a\x8c\x39\xf0\xd4\x7b\x64\x13\x6a\x1e\x1d\xb5\xee\x1e\xcb\xd8\x97\x4f\x8f\x83\xab\xac\x6f\xc3\xce\x2d\xd0\x89\xac\x8c\x3c\xb1\xd7\xd5\xe8\x73\xbb\xf4\xf8\xab\xa6\x6b\x19\x53\x42\xef\x71\x59\xb5\x44\x2f\x0f\xee\x60\xdc\xcf\xa8\x84\xd1\x9b\xee\x6f\xea\x66\xd5\x32\x96\xaa\x66\xfe\x3a\x6e\x7b\xfc\x51\x0d\x4a\x5a\xb5\x81\x3c\xa1\x40\xe1\x83\x55\xeb\x37\x75\x90\x24\x64\xca\xaf\x09\x2e\xa0\x63\x21\x42\xaf\xd1\xa9\xfe\x6b\x17\x64\x0b\xb1\x27\x6c\xb5\x2c\x37\xdf\x14\x52\xce\x97\x91\xa0\x22\x56\x9d\x9a\x93\x77\x8a\xac\x1f\xd6\xf2\x15\x3c\xc3\xfc\x9f\x81\xcd\x9a\x5d\xa6\x75\xc4\x4f\xbc\xfc\xd2\xf0\x2b\x3f\xfb\xd9\xf0\xcb\xc3\x2f\xff\xf7\xe0\x93\x15\x90\x4e\x42\xcb\xfc\xe9\x4f\x5f\xfa\x7b\xa1\x60\x4a\x89\xfa\xcb\xbe\x2e\xcc\xc0\xa2\x84\xfe\xfa\xbb\x2c\xfd\xde\x50\x74\x51\xa3\x68\xbc\x7c\x7c\x12\x68\x1b\x3b\xe4\x53\x8d\xfc\x62\xe8\xfd\x00\xc9\x08\xd4\x9f\x1e\x37\xd0\x01\x70\x6f\x53\xc4\x80\x61\xbf\x20\xf5\x82\x2f\x3f\xdc\x86\xaf\x1b\xad\xcf\xee\x28\xdd\x46\x9f\x92\x4c\x8c\x7f\x38\x3e\xd7\x49\xd6\x6d\xd8\x6b\x18\xef\x03\x1a\xb8\xb3\x4e\x26\x67\xf4\xc6\x98\x32\x1e\x46\x2a\x10\xfc\xa5\x2e\xb4\x05\xbe\xf2\x9e\x3c\xdb\x39\x68\xde\xfa\xbe\xf9\xfb\x0f\x06\xc4\x1c\x9c\xdd\xdd\x6a\x7d\xf6\xb5\x01\xd3\xd9\xfc\xf0\x8f\x18\xd9\xe3\x3d\x81\x91\x3d\x30\x39\x5a\xc2\xde\xcc\xd9\xc6\xd5\xf9\x2b\x9e\x66\x32\x8b\x0e\x82\xeb\xc6\xc5\x89\xd9\xd7\xf1\xaf\x92\x71\x65\xfc\xca\xd4\xcc\x1b\xe4\x36\x58\x75\xdc\x1a\x39\x53\x5e\x9b\x9a\x9d\xc3\x6f\x2a\x86\x74\x29\xb8\x06\xbc\x3e\x46\xaf\xd4\x8c\xb9\x89\x2b\xe3\x53\xf3\xf4\x44\xdd\x78\x6d\x7c\x74\x12\x14\x9d\xb1\xd7\xc6\xc7\x5e\x5f\x9c\x7b\x63\x9a\x7d\xc7\x55\x8c\xfa\xca\x91\x54\x9a\x81\x47\xc7\x13\x9c\x05\xcf\x89\x50\xed\xc1\x67\x16\x50\xf0\xc2\x0c\x6a\x67\x0b\x16\x2c\xae\x50\x76\x04\xc9\xd3\xfc\xbb\x3b\x38\x43\xb7\xbf\x32\x34\xb1\x9a\x46\xc1\xb1\x38\xf2\xcd\x7a\x0b\x1d\x1e\xe8\xa7\x02\x79\x57\x71\x74\xbd\xb4\x0e\x36\x5b\xf7\xff\xd8\x7a\x7f\x9b\x9a\xff\xe2\xb8\x75\xff\x10\x37\x93\x08\x57\xdb\xdf\xd6\x74\x83\x1e\x0f\x2d\xe1\x14\x96\x63\x68\xde\x44\x7d\xad\x88\x97\xe8\x0d\x19\xdf\xa8\x25\x0d\x38\xff\xf3\x89\x1f\x3d\x99\xa6\x41\x07\x83\xfc\x92\x1a\x7c\xf0\x31\xf0\x17\xdb\xa0\x55\xaa\xd4\x36\xb4\xfc\xc1\x95\x42\x44\xf5\x69\xc7\x47\x84\x1f\xca\x5b\x2e\xa8\xb5\x43\x06\x1c\x22\x78\xa2\x05\x1c\xec\x43\x86\x35\xbc\x32\x6c\xac\xd6\x6a\x95\x91\x0b\x17\x36\x9c\x7a\x75\x11\x67\x0b\x1d\x83\x5a\x2e\x3c\xe1\x45\x4e\x70\x20\x64\xa7\xd1\xbc\x75\x4f\x8a\xb8\xa8\xa6\x64\xf0\x30\xe8\x87\x21\xc7\x79\xb2\xe3\x47\x72\xb2\x66\xda\x45\x92\x3c\x70\x68\x62\xbb\xfa\x85\xeb\x2d\xa9\x80\xef\x9a\xdc\x52\x70\x6d\x6a\xdd\x7d\x1f\x86\x4d\xbb\x7e\x45\x77\x55\xcb\xad\x38\xe5\x02\xe8\x06\xa0\xea\xf3\xb8\x95\xcc\xeb\x70\xd4\xd7\xe1\xfc\xb6\x6b\xac\xf5\xf3\xd8\x56\x8a\xf5\x15\x41\x93\x56\x77\x83\x61\x1a\x84\x8d\x73\x1e\xfe\xf8\xb8\x79\xeb\x89\xb2\xc2\xa3\x62\xaf\xd1\xf3\xf6\xfb\x43\x8e\x4b\x50\xb8\x81\x8b\x32\xbc\x74\x76\x6f\x87\xc3\x15\x12\x47\x0e\xf9\x58\x46\x8f\xa0\x96\xaa\xa3\xff\xa0\xb9\xf0\x46\x45\xd3\x50\x15\xae\x5a\x6b\xde\xb5\x45\xf8\x31\x91\x5f\xb8\xf4\xc0\xfd\xc6\x72\x13\x67\x42\xba\xfc\xc4\x84\xc0\xe4\x7f\x7b\xa4\xdd\x00\x0b\xe7\xa6\x69\x48\xe1\x94\x92\x5a\x93\xc7\x8a\x54\x99\xc4\xfc\x00\x51\x05\xb3\x66\x6a\x63\x4a\xcf\xa9\x43\xb9\x70\x2e\x78\x40\x93\x2f\x1b\xa7\xc3\x68\xfe\xee\x08\x23\x17\x1a\x47\x92\xc0\xe0\xc0\x24\x04\xcd\x0e\xf8\xbb\xad\x6a\xad\xd8\x78\x99\xa5\x50\x74\x8a\xfd\x1b\x36\x66\x2d\x8e\xe0\x5b\xb5\x8a\x15\xdd\x9a\x1d\xf0\x16\x48\xf3\x93\x6f\x61\xa0\x28\xa8\x5c\x84\x4a\x87\x37\x18\xb6\xd5\xfc\xa8\xd1\xfa\x7c\xb3\xf9\xf0\x36\x87\xca\x1d\x9d\xb4\xbe\x38\x4a\xb1\x24\xce\x7b\x92\x8a\xa4\xb3\xf6\xae\x71\x5e\x59\xaf\x2c\xb2\xd4\xb0\xf6\xe8\xb6\x7f\xf2\x93\x51\xf4\x5a\x63\x13\x23\x86\x98\x40\xd2\x76\x41\xc1\x36\x71\x91\x78\x7e\xed\xa5\x0d\xb8\x2f\xd3\xa3\x64\xd0\x83\xeb\x7d\x15\x2d\x00\x05\x0a\x28\x73\xaa\xa0\x83\x4f\x60\xb4\x7e\xb1\x48\x8a\x34\x86\x7e\x54\x64\x73\x35\x03\xe5\x8a\xe1\xac\xc3\x7e\xb3\xdd\xeb\xc3\x3f\xf9\x09\x6a\x54\x17\x1d\xfc\xda\x58\x37\xcb\x74\x9d\xb6\xc5\xdb\x64\xbd\xe3\xcd\xf9\xf6\xdb\xc3\x4c\xd2\x3b\xef\xfc\xdc\x18\xdc\xc0\x8b\x85\x36\x68\xe8\x27\x3f\xc1\x18\xe4\xfd\xdd\x91\xc0\x3e\xa4\xbb\xed\xfd\x03\x38\x9e\x14\xeb\xcf\xad\x83\xe6\xff\x3e\x52\x04\x0b\xe9\xb7\x14\xd9\xdf\xba\x7f\x9b\xe2\xc9\x3f\x39\x36\x5e\x69\x3d\x6c\xa8\x7a\x6e\x60\x73\xc3\xad\xfa\xfb\x5d\x52\x24\x39\xf2\x82\x63\x4a\xe8\xdc\xdd\x6b\x9c\xdd\xdd\xa5\x6e\x65\x50\x06\xfb\xce\xff\x8f\xdf\x18\xb3\xaf\x30\x17\x22\xb9\x21\x3a\xa0\xa5\xb1\x77\xfa\xe8\x80\x27\xf1\xf4\xfb\x6d\x1a\x05\xa1\x91\x97\x35\xc1\x4b\xa3\x5e\xb4\x3f\x9a\x7c\x61\x64\x9d\x22\x0f\x2f\x07\xb1\xb1\xee\x37\x56\x74\xea\x05\xe3\x12\xee\xcd\xaa\xee\xc4\x0a\x3c\x43\xcc\xde\x78\x17\xf5\x67\x18\x29\x96\xcb\xbc\xd4\xcf\x3e\xfd\x00\x17\xf6\xe9\x93\x43\x0d\x3d\x17\x2f\x5e\x98\x01\x15\xe9\x1a\x9a\xa4\xe6\x2f\x4f\x5c\xd5\x74\x17\x1c\x61\xd2\x58\x2e\xb0\xc8\x49\xd9\xae\x31\x33\x3e\x3d\x35\x3b\x31\x07\xca\x58\xaa\x2e\x3c\x29\x97\xaa\xb3\x6b\xa8\xfb\x5d\xd4\x34\x7c\xfa\xf8\xe0\xf4\xe4\x03\xcd\xab\x93\x13\xa3\xb3\x9a\xf7\x9a\x8f\x1b\x30\x88\x9a\xf7\xa6\x27\xbc\xac\x08\xcd\xeb\x11\xe9\x10\xc9\x6d\x19\x83\x9e\xee\xe0\xc2\x89\x6f\x56\xec\x61\x25\xae\x48\xb7\xbd\x22\xba\x1a\xc4\x9b\x8f\xbe\x9d\x44\x42\x46\xd2\x77\x35\x92\xa2\x35\xce\x46\xb1\xc7\xc5\xe7\x77\x74\xe6\xee\xa8\xe6\xdb\xdf\xed\xa0\x3f\x63\x10\x7f\x5f\xb3\xaa\x2e\x09\x53\xfe\xf9\x1a\x7f\x7c\xe7\x9d\x0c\x03\xdb\xde\x34\xb5\xdc\x7c\xd4\x68\x1d\x34\x22\x1a\x4e\x47\x6b\xc7\x03\x93\x3c\x2a\xd3\xba\xf5\xdd\xda\xf9\x56\xf3\x4e\x3e\x8f\x81\xec\x14\x15\xe8\x67\x9c\x54\x40\xb1\xb7\xf3\xf5\xa2\x59\x35\x96\xaa\xce\x75\x4b\x17\xde\x7e\xf6\xe1\xf7\xad\x83\x1d\x03\x74\x02\x32\x99\x52\xaa\x89\x92\xe0\xb5\xf3\x45\xab\x81\x79\x5b\x89\x5d\x4b\x93\x39\x5d\xd9\xc2\x14\xc8\x1f\x9d\xe5\x65\x0b\x73\x06\xe3\x69\x51\x72\xc6\x76\x1f\x9c\xfd\xee\x69\x13\x73\x0d\x76\x03\xa9\x64\x74\x21\x4b\x43\x1f\x9a\x99\xd0\xbc\x25\x72\x23\x81\x92\x7c\x1d\xed\xd1\x06\xe5\xe5\xb9\x74\xfd\x83\x79\x91\x21\x86\xef\x68\xf3\x09\x43\x4f\x0d\xc2\x01\x78\x9e\x4f\xc0\x07\x24\xb5\x1f\x1f\xb7\x76\xb6\x0c\x90\x87\xcd\x3f\x7c\x6f\x9c\x7d\xf6\xbb\xe6\x27\xfb\x49\x34\x89\xbc\xc1\x10\x4d\x48\x52\xa0\x2f\x0d\x41\x81\x67\x7c\x72\x3e\x7c\x70\x76\x73\x1b\xe3\xd5\x1e\xee\x64\x21\xaa\x00\xba\x07\x25\x80\x28\xba\x3c\xe9\xb6\xba\x13\x0d\xf3\x40\x62\xcf\x80\xb8\x8e\xd0\xc7\x50\x95\x39\x63\x68\xee\xac\x54\xf4\xab\x1e\xe7\x99\x2c\xfb\x32\xf5\x2b\xa9\x03\x9a\x6f\x6a\x1d\xc6\x08\xde\x04\x71\x82\xdd\x84\xf3\xfb\x80\x4b\xa7\xba\x82\xdf\x4d\x55\x57\xc4\x77\x17\x38\x8e\x16\xbf\x9c\xc5\x3f\xc4\xd7\x3c\x25\xf3\xde\x70\x0f\x0f\xeb\xf4\xc6\xc0\x63\xde\xac\x04\xfa\xe0\xec\x99\x0b\xa1\x2e\x64\x3e\xd0\x6e\x7b\x26\x20\xf0\xef\x31\x12\x1e\x04\xbc\x4a\x23\x35\xd1\x63\x51\xb4\x81\xf2\x50\xfe\xa1\xb8\x3e\x88\x79\x5e\xb2\x70\xb4\x84\xbe\xc8\x49\x7b\xb0\x0e\xd8\xde\x3c\x76\x49\xaa\x3f\x17\x4c\x6c\x69\xd8\x30\x66\x2c\xda\xdf\xd8\x40\xa8\x59\xa9\x28\x25\x34\x8f\x63\x5e\xb0\xaa\x38\x21\xd0\x14\x5d\x66\xd9\x1c\x8d\x0f\xb0\x97\x5a\xa8\xbc\xba\x11\x66\x7d\x8e\x4c\x08\xfb\x27\x21\x6d\x0f\x94\x43\xd2\x02\x42\xc4\x79\xba\xbc\xb0\x70\x02\x63\xac\x6f\x5d\xe0\xc7\x15\xdd\xb4\x4d\x1d\x05\x0d\x52\x5a\xe4\x76\x4f\x1f\x6d\x1b\x7e\xce\x4f\x3c\x21\x91\x59\x9f\x52\x72\x61\xe6\xd4\xd1\x9d\xd3\xff\x38\x49\xba\xae\x44\xcf\x20\xce\x51\x60\x66\x28\x22\x9e\x47\x7c\xc0\xd3\x85\x79\x05\x0d\xc0\xac\xbd\x01\x57\x83\x3c\x79\x08\x6a\x55\xbc\x6d\x88\xe1\xc6\xa9\xd1\xbd\x45\xb3\x00\x13\x59\x56\xee\x12\xd0\xaf\x78\x5c\x9d\x46\xbb\xbc\x06\xc7\x4b\xcc\x92\x00\x02\x5e\x73\xd6\xad\x35\xf4\x09\xe2\x25\x45\x38\x2b\x96\xed\x2a\x5c\xa3\x97\xeb\x7c\x01\x82\xc6\x30\x3d\x99\xfa\x34\xec\x52\x05\xb5\x6b\x38\x45\x02\xb4\xe2\x4f\x74\x6b\xc3\x0f\xed\x14\x33\x6d\xba\x65\x13\xbf\x30\xda\x5b\x6b\x5b\x58\x9a\x05\xa3\xcd\xee\x45\xf5\xfe\xbb\xbd\x60\x52\x45\x52\x37\x0d\x6f\x51\x91\xfe\x4c\x46\xe0\xcf\x1b\x94\x7b\xa6\xbb\xd6\x88\x9b\x57\x20\xe9\x1a\x05\xfe\xef\x0f\x9b\xef\xed\xe2\x82\x6f\x7d\x91\xd4\x6f\xb0\x53\x76\x52\xbf\x7b\xf6\xe9\x1f\xa9\x9b\x7b\xa8\x28\x9d\xdd\xdf\x42\x22\x80\x05\xe1\xfe\x4c\xef\xe8\x1a\x2d\x2a\x89\xb0\xe4\x2a\x12\xba\x00\x5e\x8c\xe5\x5d\xdc\x24\x3d\xc2\xf6\x02\xb9\xe1\x1d\x10\xcd\x3a\xa3\x8a\xb8\x91\x37\xff\xf4\x55\xf3\x93\x03\x2f\x19\xf1\x38\x98\x2e\x2b\x7e\x8d\x50\x65\xd4\x31\xd3\x19\x7c\x3a\xa1\x9a\x36\x88\x3e\x7f\x52\xda\x11\x90\xd0\xe7\x46\xb2\x5d\x7e\x3e\x43\x1d\x63\x5b\xeb\x8c\xee\x67\x31\xd8\xf1\x44\x3b\xeb\xc6\xec\xec\x6b\x62\x11\x08\x9a\xac\xd8\xec\x5f\x71\xc4\xfb\xa9\xdb\xf8\xbe\xd7\xad\xf0\xff\xe8\xfa\x73\x1d\xa3\x60\x15\xad\x9a\x45\x69\x0e\x22\x95\x9e\xb4\x1c\xdd\xdc\xc9\x04\xf8\x3d\x5f\x69\x68\x7e\x84\x59\xa5\xdf\xc0\x46\xd7\x74\xc3\x2a\x51\xa9\x0e\x92\x79\xc9\x12\x79\xc1\x16\x06\x89\x00\x7f\xf2\xb3\x80\x95\x48\x66\x54\x9b\x1f\x4c\x12\xf1\x80\x15\xf8\xf8\x54\x62\x21\x62\x34\x66\x52\x84\x6c\xd0\xeb\x8d\x1a\xf7\x07\xbe\x44\x4a\x8c\xcd\x8e\x19\xe1\x88\x5e\xb6\xad\xa2\xce\x4c\x4c\x08\x12\xe2\xe4\xde\x24\x97\x26\x06\x1f\xed\x34\xe0\x7a\xd7\xba\xdf\xd0\x77\x13\xd0\xe4\x82\x6e\xa1\x18\xfd\xb1\x1d\x06\x22\xd9\x00\xdb\xd6\x1b\x31\xb7\xee\x54\xaf\x53\x24\xce\x75\xbb\x52\xf1\xb5\x62\x0a\x72\xc2\xfe\xd2\x92\xb0\x49\x26\xbd\xbb\x37\xc9\x00\x47\xb1\x31\x8a\x1a\xca\xc6\x3e\x54\x93\xbe\x3d\x6e\x36\xb6\x9a\x7b\x3a\xc5\x3c\x8a\x44\xb1\xbd\x39\x6b\x07\x94\x09\x54\x8a\x79\xfb\xf3\x43\x99\x86\x89\xf7\x7c\xb8\x09\xda\x6f\x9c\xd8\xf3\xc9\x9e\x02\x07\x91\x3c\xa2\x70\xe5\xa7\x0c\x6d\x5c\x23\x18\xa7\x54\xb0\xcd\x95\xb2\x03\xea\x47\xde\xe5\x30\x8c\xa2\xb3\x42\x01\x0a\xba\x0d\x48\x99\x95\xbe\xa3\x9d\x1a\x6b\x7d\x76\xa7\xf5\xe8\x1b\x58\xe0\x8d\xe6\xad\xaf\xe2\x6f\x32\x7e\x12\x93\xb1\x6a\x99\x45\x0c\x10\x59\xb5\xf2\xd7\x8d\xda\x46\xc5\x12\x96\xa7\x01\xf4\x65\x73\xda\x7b\xd9\x29\x5b\x03\x3a\xcb\x48\x7b\x32\x13\x59\x20\x6f\x60\xb8\xc2\x26\x68\xba\xa0\xa0\x1c\x9c\xed\xee\xb0\x19\x0a\x83\x09\x60\x66\x65\xb4\x02\x89\x41\x9d\x65\x44\xa1\xd1\x03\x98\xb1\x41\x9b\x7b\x2b\x03\x21\x0a\x30\x0c\x50\xf5\x01\x7c\xd6\x76\xe6\xea\x0c\x5d\xb0\x06\x74\x86\x2d\x06\xaf\x30\xd9\x35\x2f\x2e\x9c\x31\x27\x07\x0b\x24\x98\x2d\xdf\xfd\xce\xd2\x28\xa1\x79\xbe\x38\x72\x27\x05\x6b\xd9\x2e\x73\x70\x1c\x2d\x94\x74\xa7\x02\xff\xa5\xf6\x7b\xb0\x43\xda\x58\xfa\xee\x11\xf5\x82\xbb\x44\xdb\x80\xae\x47\xcf\x9a\x7e\xf7\x36\x5e\x69\x44\xbf\x8c\x8d\x91\xaa\x37\x3e\x26\x3a\xeb\x8c\xc6\x37\x7d\x67\x20\x9a\xaf\x61\x08\xaa\xae\x79\x6a\x80\xe2\x6e\x8e\xfe\x2d\xae\x1d\x16\x7f\x45\xba\xda\xcf\xc0\xbf\x6c\x14\x40\xc2\x8d\x36\x14\x11\xdf\x32\xc0\xc0\x1b\x70\x77\x87\x6f\x63\x2f\xfd\xea\x83\xf2\x4c\xdb\x6d\x6f\x39\x3c\x1a\x3e\x31\x81\x01\x89\xbf\xd5\xa7\xe0\x87\xc9\x89\x65\x47\x31\x75\xf0\xd7\x64\x8d\xf0\x8c\x1d\x01\xba\x63\x59\x0f\x3c\xa9\x9a\x3c\xda\xc7\xe4\x42\x5b\x67\x01\xb3\x47\x80\x6a\xfd\x50\x29\x87\xcf\x33\x1b\xad\x3e\x0e\x4a\x36\xe6\x3b\x59\x27\x21\x03\x23\x34\x26\xbf\x59\xa4\x6f\x78\x34\xbc\xe5\xe0\x8a\xb9\xf1\x47\x02\xfe\x31\xcb\xf6\x6f\x89\x41\x6f\x30\xea\xe9\xcc\x61\x11\x46\xca\xf6\x16\x03\x23\xe1\x06\xd7\x06\x9e\xdf\x01\x43\x66\x14\xfd\xd9\xc6\x43\x11\xd5\xd0\xd8\x3f\xe2\x1f\x42\x97\x50\xc7\xa1\xc7\x16\xc0\x08\x6b\x5f\x94\xd0\x0f\x11\x94\x86\xb1\x5a\x0d\xa3\x65\xc8\x44\x02\xb7\x04\x67\xbd\x5c\x74\xcc\x02\x7b\x9d\x37\x38\x82\x92\xe2\x16\xc8\x6d\x59\xb6\x6a\x18\xf9\x84\xd8\x37\x7a\x1e\xd0\x63\xd1\x38\x6a\x36\xfe\x42\x60\x54\x5e\x18\x09\xfa\x71\x65\xa8\x1e\x62\xe2\x7d\x76\x8c\x91\x8e\x9f\xec\x65\xa0\xae\x64\xaf\x54\x4d\xb6\xcc\x0a\x2d\x6d\x42\xa8\x0d\x17\x7d\x20\xad\x84\xe1\x8d\x7b\xd1\x68\x3e\x84\x2b\xf2\x31\xae\x94\x83\x2d\xa9\x60\x24\x50\x27\x3c\xf6\x14\x8f\x0b\x17\x51\x32\xe9\x4c\xc3\x1f\x3c\x03\xbf\xc2\x7b\xa9\xbc\x93\xfe\x2a\xac\x5d\xfe\x4a\x46\x3e\x2c\x57\x2d\x19\x92\xeb\x29\x42\xbf\x6a\x27\x56\xbe\xa5\x80\xf0\x99\x02\xb3\xcf\x18\xc3\x44\x9e\xbc\x70\xf0\x9b\x85\x12\xa8\x10\x2e\x70\x5f\x03\xed\xce\x5e\x26\xd3\x19\xdc\x7a\xcb\xd7\xf9\xee\x4b\x70\x8b\x0c\x5c\xa4\x9d\x45\xe1\xc4\x8f\x20\x3a\x70\x15\x0e\xf3\x2b\xee\xc4\x08\x7c\x72\x78\xdc\xfc\xc3\x36\x99\x99\x03\x01\x18\x31\x8c\xb5\xc1\xfc\x49\x10\x23\x34\x99\xea\x21\xfe\x04\xb6\x12\x75\xc5\x40\x13\xa7\x8f\x6e\x88\xcb\xe0\xd9\xf6\x6d\xd0\x95\x29\xf6\xf4\xd8\x40\xbc\x41\xd0\x1e\x3d\xc9\x48\x10\x8d\xbb\x29\x22\x3f\x46\xeb\x68\xce\xac\xa1\xb6\x6a\xb1\xe4\x07\x8d\x39\x17\xc0\xa3\xd1\xe9\xf1\xdf\x37\xc2\xf0\x32\x2a\x4a\xc4\x49\xeb\x4b\x9d\x57\xc5\xef\x12\xc3\xa8\xe2\xb6\x1b\xb4\x11\xbf\x4e\x95\xa6\xf0\x3e\x00\xf2\xc8\x7a\xab\x82\x37\x57\x44\xdb\xe4\xf0\x2c\xbc\x8e\x2c\x99\x70\x41\xb0\x49\xed\xac\x5a\x39\x53\xe1\x79\x58\xa2\xae\x12\x08\xd8\xaf\x54\xc0\xaa\x85\xfa\x4b\x2f\xfd\x34\x2f\x3d\x9c\xf4\xc9\x42\xa0\x0c\xfe\x1e\xc7\x4a\x7e\xe7\x88\xef\x40\x7c\xcb\xaf\x5c\xf1\x15\x89\x4d\xfe\xf2\x57\x02\x96\xc6\xa3\x06\x0d\xbb\x61\x72\x62\xc7\x82\x96\xc8\xc3\x6d\x58\x7c\x61\xf4\x43\x03\xe3\x4f\xe8\x19\xdf\x12\x8f\xb2\xe8\x56\x10\xf3\x27\x98\x1f\x45\x08\x5e\x51\x4f\x21\x24\x5c\x7b\x7b\xfd\x1d\x9c\x4c\x08\x7c\xa3\x14\x10\x24\x0e\x4a\x12\x43\xb0\x70\x0b\x76\x41\x84\xe8\x71\x3a\x0e\xc7\xa1\x38\x18\xa1\x82\xe0\x40\x79\xa7\xa0\x53\x97\x4f\xbf\xdb\x66\xcc\xc0\xbd\xe6\xa3\x06\x6d\x36\x0f\xe6\xa7\xf5\x57\x74\x57\x07\x89\x83\xe1\x11\xe1\xec\x04\xd8\x79\xe8\x83\xe6\x25\x44\xa7\xbe\x3a\x31\x39\x39\x71\xf5\x32\xe2\x88\x8c\x5e\x1e\x9f\xd1\xcd\xf5\xa3\x6f\x4e\x9f\x1c\xfa\x5b\x5a\xd3\x96\xc4\x49\xd1\x46\x7e\x7c\xbf\x8d\x8e\xf6\x6d\x8d\xed\xec\x55\x1b\x93\x11\xc2\x4a\x50\x86\x7b\x59\x50\xfb\xf0\x6c\x09\x19\x7b\x43\xeb\xa0\x8c\x1c\x0c\x7b\xa1\x05\x72\x26\x62\x1b\xa1\x21\x51\x3a\xab\x55\x18\x13\x1d\x95\xec\x7e\x8e\x86\xc0\xf4\xc3\x3e\x03\x2c\x28\x00\x24\xcf\x83\x3b\xe9\xf6\x4e\xc3\x9d\xea\xcd\x7e\xe6\x3c\x86\x70\x73\x69\xc5\x90\x05\x2d\x13\x1a\x4e\x5c\x73\x29\x3c\xdf\xd1\x00\xba\xa9\x78\xc8\x63\x3f\xe8\x76\xcd\x4c\x2f\x4e\xcf\x92\x55\x5b\xb7\x2c\x0a\x1c\x0c\x9e\xf1\x24\xcd\x83\xa6\x4d\x21\x8f\xc8\xb2\xa9\xd7\xdb\x82\xcd\x9c\x3e\x7e\x3a\xd8\xba\xb7\x79\x3e\xd8\xd4\xe9\x51\xc3\x87\xe1\x91\xc6\x4f\xad\x94\x11\xa4\x96\xcc\x0d\x60\x16\xc3\x24\x85\xa9\x8e\xed\xf1\xed\x31\x00\x98\x5c\x55\xe4\xe0\xd4\xa5\x8d\xf6\x29\xd1\x69\x35\xc3\x46\x28\xbe\xb2\x52\x75\xf2\x96\x55\xf8\xb9\x86\xd7\xe7\x4e\x97\x31\xb8\x71\x41\x17\xd3\x28\x89\x6b\xa7\x22\x75\xbf\xd9\x43\x27\x52\x5e\x9c\xe3\x29\x4e\x77\x8d\x2d\x58\xcb\x66\xbd\x28\x87\x5a\x4a\xd2\xae\x62\x6a\x48\xc6\x06\x3d\xb9\x89\x37\x52\x0f\xee\x94\x63\x0e\x4e\x8f\xfe\x4d\x31\x44\xdf\x89\x39\xaa\x32\x5c\xd8\xa5\x20\xed\x86\xb9\xf4\x8c\xa8\xc2\x38\x13\x2f\xbc\xaa\xb4\x8b\xa9\x27\xb1\x39\x3d\xb0\xcc\x74\x1d\xa1\x13\xcd\x9e\x2f\xc0\x3d\x99\x1d\xab\xe9\xeb\xc7\xad\x97\xe3\xf5\x7c\x63\x99\x82\x0c\x75\x3a\x42\xaa\xec\x52\x3b\x8a\xe5\xc8\x7b\x2a\x18\x56\x95\xae\xe3\xba\x5d\x2c\x54\xf0\x4e\x03\x2f\x7a\x1f\xe4\xb8\x06\xf2\x0a\xf4\x04\x84\xdf\xf3\xb4\x57\xc5\x87\x15\xe7\xe7\x8f\x25\x22\xb5\x93\x31\x9e\x8a\x64\x87\xe3\xab\x1b\x35\xb4\xa0\xc1\xb9\x83\x62\x4a\x3a\x8c\xcd\xb2\x4c\xff\x97\x99\xeb\xf5\xb2\x4d\x3a\x61\x09\x6e\xa8\xf5\xaa\x45\xa0\x7d\x45\xfb\xba\x65\x5c\x19\x32\xae\xbc\x3a\x64\x5c\x26\x74\x81\xcb\xaf\xea\x54\x7b\x9c\x97\x63\x32\xf5\x62\x86\xfe\xa6\xf7\x9a\xf4\x4e\x5d\x7e\x15\x63\xb5\x44\x66\x55\xeb\xe4\x0b\x8a\x65\xbd\xf5\x95\x4c\xd9\xf7\x8c\x0f\xe8\xc8\xe2\xe4\x7e\x89\x02\xa0\xf1\x29\x7b\xd0\xbe\x85\x42\x8e\x23\x8a\x72\x94\x6b\x85\x01\xf1\xfc\x0b\xac\x18\xbc\x53\x8e\xff\xd3\xe8\x95\xe9\xc9\x71\xce\x57\x45\x3c\xe7\xd0\x0b\xd3\x55\x7b\x0d\xee\xb9\x33\xf8\xb7\xc8\x08\x2b\x6d\x54\xf8\x4b\x99\x15\x76\x01\xff\xb8\x90\xe9\x30\xf4\xe8\xc3\x08\x04\x81\x75\xee\xba\xab\x06\x41\xfa\xd2\x4f\x9d\x35\x57\xb1\x8d\x37\x81\x33\x5d\x8a\x73\xd2\xdb\x15\x0f\x08\xa8\xb3\x06\x10\x48\x79\x7e\x76\x7c\x86\x3e\x4d\x8f\xce\xce\xfe\x62\x6a\xe6\x22\x0e\x73\x47\xcd\x11\x42\x11\xa7\xa7\x4a\x31\xca\x60\x9a\xed\x20\x1e\x6f\xe6\x96\xdb\xd3\x4d\x7d\x40\xce\xe9\xd1\x19\xf8\x7b\x6e\x7c\x66\x76\x71\x74\x76\x11\x73\x95\x7f\xa9\x4c\xfe\xec\x48\x3b\x30\x52\xb0\x5b\x15\x66\xb4\xb4\x81\xa6\x4f\x46\xbd\xac\x1a\x4a\x97\xa5\x0d\x18\xc0\x2e\x5a\xca\x73\xfe\x3c\x26\xcc\x77\xd5\x0a\x62\xc1\x50\x46\x1f\x21\xbf\x50\x73\x3e\xf0\xcb\x44\xd9\xf8\x05\xb4\xe7\xac\xbb\xc6\xb4\xb3\x6e\x55\x67\x57\xe1\x6e\x41\xb9\x49\x05\xa7\x8e\x95\x4e\x08\x9d\xb6\x30\x64\x30\x66\x2f\xa3\xf2\x60\x8e\xf5\xdb\x88\xa9\xcb\xcd\x2e\x60\xc3\x0b\xa2\x69\xf8\xf7\x1d\x91\x7b\xad\xb4\x2d\x62\xe9\x8c\x49\x4c\xb8\xc1\xd6\x19\xc9\x40\xd3\xfa\x40\x5c\xe3\xba\x50\xee\x34\x6b\x47\x94\xd2\x91\xca\x90\x28\xe3\x32\x3b\x3e\x36\x3f\x33\x31\xf7\xc6\xe2\xe5\x99\xa9\xf9\xe9\xce\x9b\x8f\x6d\xd6\x98\x9a\xb9\xcc\xdb\xb9\x9b\x0e\x92\xd0\xb9\x34\x8b\xbb\x8b\x2e\x45\x15\x9c\x3e\x0c\x99\x3c\xab\x74\xa7\x6a\xfc\xeb\x14\x34\xc1\xdb\x80\x36\xb7\x14\x05\xb0\xe9\x29\x77\x5d\x64\xad\xeb\x36\xb5\xfa\x7a\x69\x03\xf7\x6c\x60\x13\x29\xff\xf7\x37\xea\x0f\x59\xda\x10\x84\x2c\x3b\x0e\xb4\xc1\xbf\xab\xf9\x3f\x17\xe0\x07\x5d\x5e\x59\x3c\x8f\x09\x03\x43\xe0\x60\x38\x0e\xa6\xbb\x51\xce\x13\xb2\x38\xb4\x20\x33\xea\x61\xad\x2c\x5e\x99\xb8\x3a\x3f\xc7\x69\xfa\x39\xe8\x1a\x56\xd4\x60\xad\x5a\xb7\x8c\x7f\x36\x96\xcd\xa2\x8b\xff\x22\xe5\x17\x6a\xce\x05\x94\x40\xe7\xe9\xb9\xbc\x53\x84\x23\x3d\xf0\x1c\xff\x40\x08\x42\xd0\xc2\xe4\xd4\xd8\xe8\xe4\x38\xfc\x36\x36\x39\x3e\x3a\x73\xbe\xb3\x35\x27\x90\x9a\x40\x70\xe6\x24\x3a\x8e\x0a\xaf\x5c\x31\x2e\x48\xca\xd8\x02\x8b\x0f\x12\xa8\x15\x19\x61\xbd\x77\x86\x37\x4a\x45\x2d\xae\x47\x2a\x0a\xbc\xd5\xe9\x03\x3a\xd3\x92\x32\x28\x81\x6e\x62\x8a\x16\x1a\xc7\xba\xff\x73\x2e\x57\xb0\x5d\xfc\xab\xab\x1e\x0b\x4e\x09\xe1\xe0\x51\x4c\x88\x69\xee\xa2\x31\xbc\x36\x40\x4b\xdd\x34\xc1\x8e\xd4\x7f\x9c\x9f\x9a\x1b\x25\x10\x87\x39\xf8\x63\x72\xd1\x87\x72\xb0\x0d\x29\x75\x94\x2f\xab\x8c\x19\x31\x2b\xf0\x1c\x42\xe2\x89\x57\x1c\xeb\x38\x15\xd3\xf6\x04\x5a\x8e\x22\x45\xbb\x1a\x3d\xde\x24\x24\x5f\x15\x49\x10\x79\xfc\xa7\x93\x0f\x6a\xb3\xa5\x0d\x56\xc9\x74\x22\xa2\xed\xff\x62\x64\x46\x62\xbb\x61\x0d\x22\xd8\x2e\x7d\x35\xdc\xc3\xd6\x43\x52\x2a\xd4\x7a\x1a\x21\x15\x33\x01\xe5\x36\xbd\x0b\x06\x3d\xd5\x7c\xc6\x9f\xa5\x12\xa0\x0d\x0f\xb7\xc5\x99\x79\x98\x3d\xc2\x6a\xeb\x66\x01\xa5\x03\x87\xd3\x9c\xaf\x0c\x59\x32\x7a\x79\xb6\xab\x35\x2c\x77\x03\xaa\xcd\xb9\x9a\x73\xdd\x2a\x1b\x93\xa3\xaf\x8e\x4f\x1a\xd3\x33\x53\xd7\x26\x2e\x8e\xcf\xc0\x1e\x7c\x7d\xbc\x2b\xb9\x20\xbb\xe0\xe4\x41\x8f\xbf\x57\x67\xa0\xe1\x99\x76\x55\x9d\x32\xb4\x60\xc7\x88\x0b\x49\xde\x01\x1d\xad\x27\x2c\x5e\xb7\x36\xda\x07\x57\x7e\xf1\xfa\xf8\x1b\x71\x5a\xba\xf1\x0c\x21\xd3\xb3\x92\xfd\xc2\x42\x80\xf6\x13\x98\xb8\x83\x41\xea\x0a\xff\x33\x0d\x78\x6c\xdb\x5d\x3e\x86\xd8\xd2\x46\x61\x09\xfe\x83\x7f\x8a\xf9\x0b\xb6\x1f\x68\x1e\xe7\x2d\x4b\x73\xff\x72\x01\xe3\xb5\x69\x03\x5d\xa8\x95\x2a\x17\xa4\x19\x7e\x91\x67\x90\xae\x77\x5d\xed\xa8\x55\xb3\x6a\x15\xa4\xf6\xd0\xbd\xe6\xc0\x47\x06\xcb\x71\xac\x35\x24\x8a\x0c\xfd\x86\xbf\xca\x91\x3e\xd0\x9d\x08\x20\x59\x12\xd4\x2e\x22\x75\x09\x15\x37\xea\xb9\xe9\x15\x14\x52\xd2\x26\x17\xbb\x6d\x31\x27\x11\x02\xc3\xc7\x8e\x7a\xd2\x54\x8c\xb1\x99\xf1\x8b\xe3\x57\xe7\x26\x46\x27\x89\xc3\xa2\x31\xfb\xc6\xec\xe4\xd4\xe5\xc5\x8b\x33\x30\xc9\x8b\x68\xd7\xf1\x87\x46\x96\xaf\xa0\xaf\xc5\x96\x9a\x36\x5d\x51\xd9\x12\x04\x08\x6e\x78\x42\xed\x83\xe5\xc2\x18\x25\xbe\x0c\xa0\xd4\x09\x57\x4d\xdf\xf4\x03\x68\x8c\x92\x53\xb0\x22\xf7\x50\x4a\x4e\xa8\xfe\x0c\x51\x31\xe4\x93\x31\xe4\x77\x3e\xc4\xbd\x2f\x9c\x0b\x50\x1d\x41\x25\xe5\x75\x93\x54\x00\x42\x99\x06\xc5\x05\xdb\x16\xf7\xd3\x25\xcd\x28\x07\x60\x0f\xbf\xec\x0b\xed\x97\x49\x90\xc3\x77\xaf\xf8\xdf\xbd\xa2\x48\xf2\x59\x51\xd9\xc6\x0c\x49\x4b\x55\x90\x93\x81\xa3\x3b\xc2\xc2\xb2\x33\x4e\xcc\x45\xb7\x0a\x9a\x61\x61\x29\x57\x42\x5b\x0c\x4d\x8e\x74\x20\x0d\x29\x35\x82\x3a\x6d\xcd\xbb\xa0\xf9\x33\xe8\xb6\xdb\xb0\x12\x1b\xac\xc2\x78\xf9\xe5\x13\x8a\x86\xbb\xe1\x16\x9d\x95\x91\x0b\x17\x12\x54\x5f\x6d\x8b\x41\x83\x19\xec\x1a\x09\xcb\x11\x68\x90\x9a\x9c\xb4\xcb\xf5\xb7\x2e\x5c\x31\xf3\x1d\x0f\x29\xae\x1d\x39\xa8\xb4\x56\x28\xee\x8f\x96\x8f\x3f\xc2\x23\xf8\x81\xeb\x13\x29\x8b\x28\xca\x62\xd6\xf9\xcc\x92\x21\xcd\xa3\x44\xda\xd2\x98\x9a\x05\xa4\x27\x54\x24\x6b\x84\xbf\x10\x54\x49\x5b\x5e\x80\x30\xdf\x4c\xd8\xc5\xe8\x74\x4b\x55\x67\x46\xc0\x3c\x22\x14\xd0\x2d\x1e\x8e\x9c\x35\x14\x9e\xff\x04\x67\xcc\xdc\x6b\x53\x54\x9a\xe9\x35\xc4\x19\x04\x2d\x5b\x94\x69\x1a\x85\x73\x0e\x8f\x15\x58\x37\x95\x7a\xcd\xc0\xdd\x26\xe5\xea\xab\x1b\xd2\x1f\xed\x03\x3f\x62\xdb\x03\xa2\xd2\x9b\x55\x5d\x76\xaa\x25\xd8\xfd\x97\xc7\xe7\xa4\xbe\x25\x34\x37\x10\xc0\x48\xc0\xb0\x31\xb1\x4c\x08\x5f\xd4\x1e\xa6\x60\x4b\xc8\xd8\x35\xdb\x34\x72\x05\x84\x6c\x9e\x46\x8b\x8f\xac\x9d\x24\xda\xa4\x64\x7b\xb7\x06\xea\xc8\x90\xcc\xe5\xa6\x00\x53\x2c\x4e\x3d\xb7\x51\xe1\x95\x22\xdf\x71\xad\x9a\x70\x2b\xca\x88\x9c\x0b\xb8\x11\x87\x29\x73\x1c\xa3\x18\x9c\x35\xab\x5a\x45\x85\x73\x15\x1a\x44\xf9\x4a\xee\x1d\x18\x08\xd1\x34\xb5\x26\xf3\xa4\x40\x04\xaf\x3a\x05\xf1\xc8\x3f\x49\x88\xed\x4b\xa0\x24\x62\x02\x54\xc1\xc9\x53\xd1\x2e\xea\xc6\x83\xe4\x5b\xb3\x5d\xbb\x26\xfd\x24\x66\xc5\x86\xa7\xdc\xe1\x3c\xa2\x26\x2d\x33\x68\x12\x46\x8c\x0f\xb7\xdf\xc2\xf3\xcb\x3c\x57\x0b\xe7\x2e\xac\xbd\x72\x01\x31\x93\x17\xce\x41\xa7\x34\x9e\x30\xff\xe5\xe8\x5b\x37\x10\xbe\x70\x4e\x1d\x8d\x91\x00\xef\x6f\xe5\xd6\xd7\xd7\x73\x38\x8a\x39\x68\xdb\x2a\x63\x40\x1d\x16\x61\x8b\x69\xb0\x60\x0c\xfc\xe6\x7f\xe2\x22\x1d\xa1\x9b\xb1\xdc\xa3\xd1\xe4\x15\x8c\x7f\xb8\xa0\xda\xcd\x3a\x5a\xa2\x22\x1b\x54\xb1\x79\x2d\x83\xb0\xea\x4c\x85\xe1\xb6\x22\x4d\x59\xe8\x1f\xe9\xa6\xcd\x80\xba\xd9\x75\x6b\xc2\x5a\xd5\x83\x76\x2a\xab\x66\xd9\x12\xde\x11\xb7\xeb\xf6\x82\x4a\x6a\x77\x6d\xb1\x7d\x24\xbd\x69\x8a\x3a\xd4\xdb\xa7\x02\xad\xa6\x35\x4b\xc5\xd8\xa5\xb4\xed\x05\x0c\x46\x64\xe3\x0e\xb4\xd7\x6e\xd7\xee\xb4\xd9\xee\xcd\xe5\x59\x46\x7a\x39\xc1\x0c\x25\xda\x8a\x37\x43\x75\xbb\x26\x62\x94\xff\x9e\x34\x1c\x63\x49\xea\x55\x0f\xd1\x86\xa4\x5e\xb5\x9e\xc2\x4c\x14\xd8\x24\x91\x7b\x24\xfa\x6e\x9e\x6e\x2d\x65\x26\xc4\xc3\xba\x4e\x47\x44\xaa\xc1\x88\xb8\xe1\x77\x3f\xc2\x81\x6b\x7e\x0f\xda\x12\xc2\x52\xb1\x12\xe4\xe4\x01\xd6\x55\xe3\xc1\x0b\x78\xe7\xad\xb1\x87\x26\xb7\x0c\x5a\x6a\xbd\x0a\xff\x16\xcd\x15\xe3\xd2\xf8\xe8\xdc\xfc\x4c\x17\xf1\x15\xb2\x55\x57\xa9\x02\xda\x71\x43\xbd\x0d\xfd\xe0\x8b\x7c\x8f\xf9\x15\x8d\x76\xcd\xae\x55\x5e\xeb\xb2\x81\x35\x2c\x10\xdb\x5d\x1b\xbd\x1d\x1a\xb5\xb5\xce\x3c\xda\xa8\x33\xba\x8a\xe6\x27\xd5\x00\xdf\x38\x86\x12\xa6\x46\xff\x4f\x29\x3f\x28\x67\xe6\x1c\x0e\xd0\x67\x90\x2e\xbc\x64\xd4\x44\x43\x88\xd6\x47\x91\xe8\x5e\xb8\xac\xc3\x20\x5e\x17\x6d\x6b\xc5\xa1\x24\x1e\xab\x0c\xd7\x08\x2a\xc4\x2f\x69\x80\x99\xd5\x5d\xad\x5e\x04\x32\x41\xf1\x26\x0a\x63\xc7\x71\xc5\xaa\xe5\x18\x59\x21\xc7\xc8\x0a\x5d\xad\x12\x44\x37\x36\xde\x94\x15\x7c\x3b\x6a\x42\x80\x5d\x89\x38\x32\xe1\x29\xcf\xe1\xb8\x5d\x98\x9b\xba\x20\xa0\x59\xff\x99\x7c\x2d\xff\x8c\x96\x09\x3f\x28\x8d\x7f\xa3\xbf\xcf\x7b\x47\x0c\x74\x30\x4d\x15\xd5\x39\x18\x9a\xec\xc8\xd5\x12\x3b\x02\xea\xe5\x22\xe2\xd6\x0c\xe4\x96\x07\xd4\x5b\x65\xf4\x15\x2b\x44\xd7\xbf\x5c\xb8\x28\x92\x4c\xdd\x0b\x22\xe4\x0d\x74\xae\x25\xb3\xaa\x79\x3e\xc2\x80\x12\x7c\x6f\xb1\x88\x86\x94\x45\xb3\x54\xf8\xfb\x9f\x69\xda\x00\x6e\xaf\x6c\xe4\x28\x9a\x4e\xbc\x6a\xe5\x57\x75\x7a\x5e\xfc\x28\xe3\xfa\x52\x43\xf5\x3a\xdb\x84\x9c\x20\xf6\x66\xce\xc4\x5b\xad\x34\xb1\xd6\xbd\x03\x48\x56\x2c\x60\x33\xf0\x2f\x55\x0b\xb9\xcb\x12\xfb\x97\x1d\x87\xb7\x41\xd7\xa0\xb9\x76\xfa\x6a\x97\xc2\xb0\x64\x56\x84\xe2\xec\xed\xec\x5e\xb8\xd1\xfd\x66\x4b\x1b\x18\xd5\xd1\x8b\xab\x4a\x6c\x9b\xdd\x5d\x57\x32\x36\xdd\xf9\x95\xc5\xc8\x54\x35\xa3\xdc\xaf\x6a\x19\x1e\xdf\x9c\xbf\xed\x69\xa9\xd2\x49\xe5\x1a\x6b\x2f\x4b\xc7\x02\xfe\xe9\x5d\x1f\xf0\x6f\x74\x90\xaf\xbd\xe2\xff\xfc\x0a\x7d\xd5\xf1\xf2\x77\xfc\xcb\x4a\x67\xef\x77\x11\xf2\x02\xef\x92\xa2\xe9\x76\xdc\x02\x99\x2b\xb3\xa5\x64\x79\xaf\x32\x08\x7c\x67\xef\xd6\xab\x2b\xed\xd3\xd6\x76\x55\xe9\x41\xdb\x12\xe4\xd7\x0b\x90\xa0\xc5\x28\xd6\x43\x67\xe7\xa2\x62\x5e\xe9\xfc\xfd\xce\xc6\x8d\x2b\x3f\x44\x87\x82\x47\x85\x81\x47\x3c\xaf\x44\x82\x77\xb8\xe2\xab\x0c\xbb\xea\x09\xdc\xab\xe3\xbf\x58\xec\x4a\x88\x73\x83\x51\x06\x3f\xbf\x83\xe0\x57\xdd\x74\x23\xad\x76\xd8\x6a\xa7\xdb\x46\x34\xa5\x35\x84\x60\xdb\x3d\x59\xcc\xc1\x8e\x34\x66\x0b\xb5\x37\xfe\xaa\xab\xbe\x94\x2b\x36\xb5\xdc\x71\xf0\x2f\xae\xb7\x9c\xac\x15\xf1\xa6\xaa\x21\xb6\x1b\x3f\xf2\xcb\xc1\xc7\xe1\x69\x65\xa5\x76\xd8\x3d\x46\x01\x5b\xdd\x29\x18\xd4\x48\xb5\xd6\x93\x46\x28\x3e\xd4\x13\x76\xde\xfe\x99\xb8\x7a\x71\xfc\x9f\x3a\x6b\x57\x04\x86\xc3\xbd\xd4\xae\x3a\x65\x74\x64\xe4\xd6\xcc\xaa\x4d\xb7\x5d\x32\xfd\x75\xd4\xac\x4b\x91\xb1\x8a\x2d\xdf\xbf\x23\xc5\x9c\xf6\x1d\x5a\x38\x7a\x1f\xa1\xad\xdb\x95\xdd\x34\xa6\x98\x24\x3b\x93\xdc\x69\x2d\x72\x5a\xab\x60\x47\xe6\xc0\x2c\xbd\xb6\x99\x00\x3b\xb1\xfd\x29\xef\xb4\xc7\xbb\xa4\xe1\xcd\xa5\xae\xd2\xb3\x15\xdd\x4b\x1c\x2f\xa2\x87\x04\x36\x6a\x39\xd5\xd8\x63\x8c\x5f\xbd\xb6\x78\x6d\x74\x26\xf8\xe1\xda\xe8\xe4\x7c\xa7\xab\x4a\x73\xd7\x17\x18\x8a\xff\xcc\x00\x8a\x1d\xb7\x8d\x8a\x21\x21\x8c\x79\x16\x48\x3c\xf1\x66\xa6\x38\xf2\xa2\xe3\x66\x59\xf3\xc1\xa6\x48\xfb\xe9\xaa\xad\x64\xd9\x95\x3e\x24\xb1\x63\x22\xda\x4d\xc0\xf4\x53\xd8\x1a\xdc\x65\xfb\xed\x33\xc1\xa7\x6b\xd7\xf3\x21\xb3\x5c\x9e\xdf\x18\xa2\x8d\x3f\x27\xf2\x08\x7b\x94\x0a\xa0\xe8\x1f\x9d\xbf\xaf\xce\xe9\x22\x4d\x64\xe7\xa7\xb7\xd2\x60\x87\xb2\x5f\x1a\xc7\x39\xd6\xcf\x2a\x74\x6b\x24\xe7\x06\xbd\x9b\x5f\xb7\x83\xd5\x21\x57\x8a\x35\x9d\x74\x04\x55\xbb\xc9\x11\xec\x2a\x47\xcf\x0b\xe4\x7d\xfc\x30\x69\xbc\x89\xe9\x59\x8b\x02\xf3\x6d\xe4\x97\x28\xed\x46\xd0\x00\x41\xff\xc1\x4f\x64\xa3\x41\x8c\x60\x32\x5b\xe4\x28\xa6\x96\x28\xf2\x7f\xc0\x5b\x0d\x2c\x37\xeb\x2d\x50\x1d\xbc\x5f\x44\xbc\x47\xae\xe2\x5a\xf5\x82\x93\xab\xd5\x36\xe8\xeb\x65\xa7\x8a\x01\x95\xc1\x2f\xa5\xff\x43\xf9\xba\xd3\x21\xc8\xc5\xe0\x1b\x25\xbf\xcc\x8e\x89\x42\x77\xda\x25\x8c\x38\x9c\x20\x64\x56\xe9\xb2\x91\x0e\x17\x42\xa2\x14\xea\xb4\xd9\x6e\xf5\x6e\xac\xff\xd9\x5d\x0b\x0c\x32\x1e\x65\x2f\xed\xa8\xb9\x7a\x39\x53\x32\xb0\x2e\x06\x40\xab\x48\x45\xb6\x9f\x3e\xeb\xb7\x2b\x9e\xfa\x96\xa4\x2a\x3a\xe8\x67\x9a\xaa\xd7\x45\x42\xa2\x6a\x57\x8d\xf7\x2d\x25\xd5\xab\x4b\x22\xdd\x13\xec\x7f\xe9\x5c\x75\xa9\x97\xfb\x64\x57\x57\x1b\xee\x9d\x65\x3d\xa1\xd5\xee\x6c\xeb\x99\x1b\xef\x3e\x20\x28\xf3\xf0\x27\xcd\x66\xec\x75\xa6\xc3\x15\xd2\xa7\x6b\x06\x37\xdc\xa6\xc3\x75\x79\xe1\x50\x5b\xed\x8b\x36\x0e\x1d\xf4\x41\x15\xae\x57\x0a\xba\xa4\x5e\xd5\xa7\x62\x7b\xd9\xbd\xbf\x8c\x4c\xef\x15\xe9\xce\xd7\xe1\xab\x7a\x19\xff\xe8\xf0\xf0\x62\x6a\xb2\x27\xd8\xa2\x27\x08\x2d\x89\x52\x54\x74\x93\x15\x83\xae\xe6\x9c\x17\x76\xd2\xab\xac\x19\xc1\xda\xb3\xcb\xde\xf4\x3a\x8c\x49\xa3\xc1\x21\x43\xd7\x94\x16\xfb\xa3\xcb\xf4\xcd\x20\x0d\x7d\x49\xdf\x0c\x75\x91\x21\x7d\xb3\xab\xee\xe2\x03\xbb\x6c\xe3\xca\xe8\x3f\xe5\xe4\x50\xe7\xa2\x33\xb7\x52\xac\xd8\xe7\xb8\x50\x7f\x04\xc9\x58\xd9\x38\x79\x31\x92\xb1\x32\xd3\xfc\xac\x92\xb1\x32\x13\x96\x2a\x19\x2b\xb6\xd5\x5e\x64\x0e\x75\xd6\x57\xba\x54\xad\xc4\x06\x33\xa7\x6a\x25\xb5\x98\x26\x55\x2b\xeb\xa6\x9f\x9b\x41\xd5\x64\x7c\x66\x66\x6a\x06\x77\xf2\xe8\x1c\xe2\x18\xc3\xf6\xa5\xbc\x1e\x2a\xa3\x0e\x63\xf1\xce\x3b\x23\x54\x75\x7c\xbc\x5a\xd5\xe2\x2d\x6a\x7a\x30\xcb\x04\xd0\x46\xec\x60\xde\xb0\xe1\x87\x50\x38\xcb\x06\x4a\x2d\x6f\x6f\x90\xd4\xd2\xb4\xde\xda\x3b\x68\xfe\x61\x5b\xc1\xce\x93\xa8\xed\xbb\x6d\x10\xec\x67\x77\x1a\x08\xe1\x0c\x8f\x1d\x6c\x36\x6f\xed\xa7\xa9\x6f\x86\x54\xbe\x00\x14\xc6\xc0\xe0\x65\xa2\xd0\x18\xbc\xc8\x59\x58\x23\x5e\xfc\xac\x55\xd0\xd6\x4a\xea\x11\xdd\x83\x1e\xf2\xe7\x88\xa8\xed\x66\x20\xd2\xe6\xd9\xce\x57\x1a\x64\x56\x60\x09\x57\x86\x48\xec\x09\xa3\xb1\x0e\x79\xdf\x90\x47\x05\xe3\x23\x97\x18\x08\xd1\x65\xfc\x3d\x2e\xa8\xb9\x64\x89\x06\xb4\xc5\xcc\x22\x01\x85\x19\x2d\x0f\x2b\xc3\x05\x97\xc7\x90\x3a\x0e\xef\x3d\x40\xb0\x3d\x05\x9e\xb7\x61\x34\xbf\x7a\x0a\xbc\x7b\xaf\xc6\xd7\x6b\x13\x0c\x52\x7c\x67\xc9\xac\x5e\xb7\x6a\x30\x3b\x79\x8f\x55\xce\x2a\x43\x04\x22\xd3\x2f\x3d\x17\x07\xd1\xcd\x25\xe3\x3c\xb8\x49\x02\x2e\x44\xa4\x3f\xac\x01\xf1\xf4\x13\x9c\x36\xae\x01\x81\xbc\x4a\x2e\x90\xd1\xe6\x7b\xbb\xad\xbb\xc7\x29\xf7\x81\x47\x31\xd5\x86\xb0\xcb\x98\x16\xc6\x21\x94\x18\x53\xd9\x06\x66\xd9\x23\x16\xda\xaa\x98\x79\x65\xb9\x11\xc7\xb0\xf9\xf8\xb8\x23\x3e\x5e\x80\x2d\x9d\x4c\xa4\x2b\xce\xe3\x25\x07\x4e\x63\xbc\x3b\x71\x45\x60\xba\x46\x19\x0e\x61\x60\xb8\xda\xea\x01\xf7\x0f\x4e\x4f\xb6\x60\x38\x9f\xb4\x6e\xee\x9e\x3e\x46\xd0\x7a\xfa\x02\x57\xe6\xc1\x9e\xf8\x9e\x6a\x3f\x7e\x7c\xdb\x2b\x32\xe8\x53\x96\x00\x7a\x19\x45\x20\x1e\x02\x6c\x52\xf6\x91\xb1\x2f\xf2\x2d\xb0\x10\x5b\xbf\xce\x7b\x4b\x05\xc2\xf6\xdf\xec\x19\x91\xde\x4d\x76\x09\x2b\x2d\x23\x85\x38\x90\x17\x78\x3c\xb5\xd5\x72\x25\x1c\x28\x96\xec\x38\xfb\xf0\x84\x0a\x22\xd3\x50\x5e\x08\x8c\x28\x89\x8d\xcc\x14\xae\x9a\xe5\x15\x02\x0d\x59\xb3\xad\x75\xae\xf8\x2b\x43\x34\xf2\x4e\xbd\x5c\x1b\x42\x29\x7d\x5d\xb8\xa5\xc8\x72\xca\x39\xac\x25\xab\xe4\x54\x37\xf8\x1b\xae\x5e\x9a\x04\xa0\x1e\x5a\x98\xc6\xe9\xd1\x1e\x10\x39\x64\x34\xef\xdc\xc1\x2f\xdf\x3d\x34\x4e\x1f\x3f\x41\xcc\xf1\xb3\x9d\xbd\xd3\xc7\x0d\xf8\xe1\xeb\x3b\x38\xf0\x5f\x1e\x8a\x6f\x68\x9b\x3d\xde\x3c\x7d\xf4\x57\xc4\x7f\xfe\xf6\x08\x8b\xea\xc2\xee\x03\xd1\x1e\xcb\x9b\xba\x99\x98\xd2\x36\x79\x9e\x49\x3c\x07\xeb\xdf\x0b\x41\xc0\x74\xc5\xd2\x41\x39\x31\x52\x1d\xd4\xf5\xe8\xd5\x32\xc1\x42\x27\x47\x9b\xcd\x47\x5b\x67\xbb\x27\xc9\xad\x53\xf9\x68\xd1\xb4\x1e\x72\x37\xa2\xcd\x58\x8c\xdd\x31\x74\xce\x63\xd3\x1e\x52\x7a\x4c\xdb\x5e\x21\xb0\xb3\x7b\x3b\x54\xc8\x38\xae\x61\x4c\x26\x36\x2e\x71\x36\x31\x65\x22\xaf\xc1\xdd\x04\x65\x21\xa1\x02\xdb\xd7\xa8\xf0\x96\xa8\x07\xea\x1a\x63\x93\x81\x07\xc6\x8a\xf6\x15\x1b\x0b\x13\x71\x35\x6d\xac\x4d\x9b\x67\x20\xe9\xe2\x06\xe6\x21\x04\x1f\xa5\xb6\x86\x31\x97\xa1\x5e\x59\xa9\x9a\x05\x8b\x6b\xfa\x40\x9b\xc1\x84\xe7\x11\x4f\x61\x5d\x81\x63\xa3\xbe\x44\xd6\x4a\x35\xeb\x19\x3e\xd8\x7f\x23\x2b\x3a\xe9\xa4\x72\x3b\x67\xcd\x47\x58\xb5\x59\x65\xac\x75\x97\xe0\x72\x91\x2b\xff\x47\xc9\x94\x57\x06\x1b\x4b\x9b\x7e\x76\x47\xa9\xca\x73\xb6\xdb\x68\xdd\x3f\x0c\xbe\x22\xdb\x0b\x15\x9d\x86\xa6\x49\x1a\xdc\xbd\xe9\x15\x5f\x42\x11\xe2\x15\x55\xc9\xc4\x29\x6d\xbb\xa3\xaf\x9b\x87\x27\x29\x6a\xa4\x48\x00\x84\xd7\xac\xa2\x4e\x16\x88\xf2\xeb\xcd\x8f\x1a\xad\xcf\x37\x9b\x0f\x35\x95\x46\x64\x43\x78\xe4\xc6\x36\xd4\xfa\xf4\x38\xbe\x85\xff\x5c\x35\xf7\x79\x70\x7f\x2c\x35\xf7\x75\x73\xf8\x5f\x55\xf7\x3b\xa8\xba\x1f\xbb\x34\xfe\xab\xea\x7e\xbf\xaa\xee\xcb\x35\x8c\x65\xc0\xea\x65\xc4\x74\x83\x65\x44\xe9\x8b\x02\xbd\x8d\x2a\xd4\x82\x70\x28\x51\x5d\xef\x55\xac\xe8\x0a\x3a\x89\x76\xff\x8b\x0a\x18\x07\x72\xa4\x95\xcd\x2b\x46\xe9\xfe\x2e\xf2\x8f\x62\x1b\x94\x56\x38\xee\xf1\x07\xba\xd9\x50\x0d\xdb\xc8\x11\xd3\x92\x5e\xa9\x53\x99\xf3\x02\x2e\x5a\xd6\x0f\xdd\x55\xf3\x65\x83\x2c\x77\xb2\x4a\xbc\x14\x76\x7e\x91\x43\x0d\xed\x81\x31\x57\x2a\x18\xe2\x88\x53\xb3\x58\x9a\x03\x25\xce\xe3\x46\xeb\xbd\x23\x31\xd2\x67\x1f\xef\x81\x8c\x88\x23\x90\xb0\xf6\xf0\x75\xd4\x53\x7c\x61\x2b\x82\xa9\x87\x78\xe3\x22\x74\x4a\xcd\xbc\x8e\xf6\xce\xf5\x55\x34\x29\xc6\xd4\x80\xa3\xd5\x80\x85\x6c\xc3\x7b\x00\x7b\xf1\x09\x24\xd9\xe7\x0f\xbf\x47\x35\xdd\x7b\x7f\x07\x3f\xdf\xda\x03\x7d\x16\x67\xe5\xf4\xdb\x93\xe6\x97\xc7\x6d\xc3\x6e\xe8\x35\x24\xa7\x5c\xb6\xf2\x64\xe5\x2d\xd4\x4b\x5c\x30\xdc\xca\x13\x62\x3f\x66\x8d\x91\x1a\xdb\xdb\xc2\x13\x5a\xd7\x5f\xeb\xee\xd1\xe9\xa3\xa3\xe6\xed\xaf\x86\x8c\x6e\xab\x50\xb0\xa2\x22\xee\xd4\xa1\xa2\xe1\x30\x32\x4f\xf6\x4e\xff\xf2\x54\x14\x85\x83\x01\x7c\x00\xf7\x56\xa1\x46\x6a\x53\xa1\xfc\x61\xaa\x99\x36\xc9\xc8\x1f\xef\xf8\x88\x81\x69\x7d\x77\xa7\x75\xf0\xee\xa0\xe0\xf7\x7c\xe2\x08\x55\x36\x68\x7f\x80\xd2\x9b\x17\xc5\x47\xc5\xc8\xcc\xd2\x57\xd0\x0d\x97\xed\x10\xc1\x3e\xe2\x47\x2e\x81\xcb\x3f\x3e\xdb\x8a\x26\x2a\x59\x5c\xa6\x04\xeb\x9d\x66\x2a\x75\x22\x2d\x39\x3b\xdf\x86\x58\x91\x25\x23\xdf\xdf\xa6\x12\x27\x8f\x9f\x50\xbd\xf5\xb8\x9b\x0a\x9d\xd4\x78\x89\x47\x03\x9f\x5a\x99\x29\x6c\x15\x5a\x28\x8f\x63\x01\xd0\x11\x23\xc1\x14\xad\x2f\xb9\x12\xa8\x8e\x1f\x34\xd2\x60\x4c\x37\xd6\xe4\x54\x5a\x4f\x20\x37\x0f\xf3\x1e\x14\xcc\x23\x86\x34\x93\x3b\x7a\xea\xda\x24\x34\xe9\x6a\x34\x4e\x41\x8a\x42\xad\x25\x50\x53\x40\xe7\x13\x79\x30\xf0\xbc\x10\xb7\x35\x03\x31\x36\x71\x6d\x72\xe5\x44\xa7\xba\xf1\xdf\x74\x54\xf1\xd5\xa7\x75\xff\x63\xb8\xd2\xa0\xc1\xa0\x79\xf0\xc1\xd9\xfb\x07\xcd\x2f\x0f\xc9\xbc\xb5\x7d\x1b\x94\x92\x28\xa3\xc7\x7f\x4b\xa2\x6b\x99\x0b\xc2\x49\x5c\x30\x8e\x5b\xd0\x10\x21\x94\x67\xb8\xb7\x34\xbf\xbe\x23\x75\x90\xa3\xff\xa0\x7f\x92\xac\x69\xa1\x0e\x61\x8b\xe1\xba\x2f\x90\x5a\xe2\xed\xf3\x01\xdc\x68\x12\x0c\x5d\x43\xc4\x15\xf1\xb3\xd8\x15\x52\x9f\x3e\x0e\xb5\x44\x3a\x0d\x4a\x8d\x4e\x49\x14\xf8\xf0\xd8\xea\x7c\xd9\xad\x57\x30\x36\xd5\x2a\x4c\xd2\xb7\xa4\x52\x23\x32\xed\xf5\x32\xdc\x11\xc5\xa3\x2e\xde\xc3\x47\xb2\xc6\x8f\x04\x3b\x25\x0b\x0d\x41\x95\xd1\x2d\xcb\xdf\x29\x7e\x45\x5c\x9d\x0c\xf6\xc6\x21\xea\x25\x79\x3f\x41\xeb\x68\xa7\x03\xa2\xdb\xf6\x54\x32\x4e\x88\x06\x75\x0a\xf4\xbb\x3f\x50\xf5\x28\xb0\xdf\xf5\xa2\x81\x6e\xf3\x9d\xd1\x1d\x90\xd2\x9e\x30\xf7\x0a\x7e\x0b\xc1\x1a\x47\x70\xa0\x40\xba\x27\x8d\xc3\x55\xe3\x3b\x18\x58\x18\x53\x1b\x6e\x6f\xbf\xb5\x54\x53\xbe\x6e\x86\x3d\x4b\x3b\x50\xd1\x3c\x38\x3c\xbb\x77\x27\x95\x1d\x3b\xa2\x33\xf6\x64\xea\xed\xd6\x77\x6f\x82\xf2\xc6\xa5\x8e\xb4\xfd\x25\x2a\xce\xb2\x5b\x71\xaa\x32\x62\x1e\x1b\x81\xe2\x4e\x07\x59\x7c\xbd\x21\xce\x30\x79\x60\xe9\xed\xba\xc1\x56\xf5\xd4\x94\x07\x6a\xd2\xe3\x8f\x45\xc0\x45\x2d\x72\xd0\x93\xea\x15\x34\xf3\xc4\x0c\x06\xd5\x15\x0f\xd6\xf7\x6c\xdd\x6f\x60\xfd\x5e\xa9\xbd\x37\x48\x34\x37\xbe\x4d\x3d\x23\x48\x8c\x53\x81\xbb\xb5\x6f\x12\x8f\xb9\x36\xf8\x16\x70\xa5\xc3\xbb\xc7\xe9\xbb\x5a\xaf\xda\xc0\xf6\x6f\xed\x4a\x5c\x2f\xff\x0f\xfc\xac\xb4\xff\xc9\x49\x72\xfb\x32\x80\xc2\xe3\x22\x91\x01\x1e\xa7\x84\xe6\x44\xf8\x1c\x15\x6b\x26\xcd\x0b\xa7\xa9\x88\xb5\xaa\xd0\x30\xa4\xeb\xe3\xbd\x5d\xbc\x8e\x28\xd3\xb4\x8b\x47\xd5\x17\xfb\xfe\xce\xf5\xcf\xae\x4c\x74\xc0\x95\xb4\x26\xef\xaa\x54\x39\x76\x69\x03\x4b\x5e\x21\x65\xae\x31\x48\xa1\x0e\x04\xb3\xad\x73\xe2\xa2\x11\xff\x93\x83\xa0\x00\x51\x96\x12\xdf\x89\xe8\xce\x14\x22\x6f\x90\xab\x11\xc3\xbd\x15\x4b\x95\xeb\x3c\xb5\x92\xda\xb2\xb5\x4e\x36\x76\xdd\x4a\xbe\xb1\xa5\x96\x0a\x4f\xc3\x3f\x34\x00\x43\x20\xaa\x73\xe2\x1c\xd0\x45\x32\xc6\xcb\x81\x3e\x43\xa1\xab\xdf\xdf\x83\x0b\x8c\xe1\x5b\xc5\x53\x75\x18\xac\x35\xa9\x1b\xce\x40\x95\xc8\x94\xed\xf2\xe1\x45\xa5\xbd\xe2\xc0\x1a\x82\x1e\x8f\x2f\xf7\x0d\xd0\xb2\xce\xde\x3d\xca\xd6\x0b\xc7\xb9\x25\xf6\xd0\x3c\xd9\x06\xd1\xd2\xfa\xf7\x07\xd9\x5a\xef\xc8\x67\x93\xb2\x8b\xc4\x12\xd4\xe9\xda\x41\x94\x51\x5e\x34\x84\xeb\xcf\x47\x70\x97\x7b\xd8\xbb\x20\x22\xe0\x50\x1a\x2a\x18\x9e\xc9\xab\xc7\xe3\xbb\xe8\x78\x3f\x63\xd5\xfa\x25\xac\x29\x5c\xa9\xbb\xab\xe8\x18\xaf\xe7\xf3\x96\xeb\x92\x35\x52\xa7\x85\x7f\x7c\x02\x42\x1f\xcd\x22\xf2\xc2\x0e\xf7\x2b\xa9\x90\x72\x55\x72\x3e\x04\x84\x3d\x2c\x89\x3e\x90\x1f\xb1\xa7\x60\x3a\x36\x0b\xc8\x23\x26\xba\x23\xa2\x2b\x5b\xaa\x44\x08\xc3\x90\xf8\x64\xb1\x4d\x80\x0b\xdf\xa3\x22\xeb\xea\xef\xf2\x3b\xdf\x92\xa7\x3a\xa0\x77\x09\xae\xc8\x18\xc5\x12\x09\xe7\xe5\xeb\x23\x59\xbe\x1e\xe3\x30\x1e\x1f\xc3\xaf\x28\xd8\xd8\x5a\xa5\xbd\x8d\xb7\x51\x8d\xf7\xa1\x25\x9b\xcd\xbb\x66\x9e\x5c\xae\xf4\x73\xc5\xdc\xa0\x02\x8d\xa8\x19\xe9\xc9\x15\x45\xdb\x1f\x37\x40\x3b\x20\xc2\x1f\x6e\x36\xbf\xdb\x52\xc2\x12\x22\x89\xff\xda\x53\x1d\x62\xa9\xc4\xcc\xe7\x1e\xf9\x4b\xcf\xde\x4b\xb1\x05\x69\x08\xc2\xcb\x16\xed\x15\xf2\xbe\xe8\x5a\xb5\x1a\xc5\xd8\x20\xfc\x18\x3c\x15\xef\x6c\x96\x97\xc6\xc6\x03\xb4\x7b\x8a\x63\x47\x59\xb1\x82\x20\x23\x89\xa2\x1f\x44\x7d\x57\x2e\xa0\x1a\x30\x19\x49\xfe\x62\xcd\x1b\x92\xcb\xa5\x98\x4a\xa6\xb1\x54\x6b\x8b\x97\x66\xea\x5e\x68\x1a\x18\x75\x41\x7f\x89\xc6\x70\xf5\xb5\x8d\x75\x1f\x06\x55\x94\xc7\x0d\xf4\x1d\x56\x46\xd2\x31\xf2\x2c\xa8\xcd\x44\x10\xc7\x81\x43\x2b\xff\x88\x7f\xf4\x8e\x28\xb5\x39\x50\xe3\x9a\xb7\xbe\x6f\xfe\xfe\x83\x4c\x94\x79\x45\xcf\x5f\x13\x19\x3d\x09\x74\xf8\x8f\xb5\xa9\x55\x19\x3b\xe4\x3a\xc3\x91\x8b\xab\xeb\x8d\x9c\x40\x43\x8a\x6a\xe2\xfd\x2d\x21\x9e\x4e\x0c\xb7\x2b\x8c\x3d\xaa\xed\x1d\xaf\x60\xa6\x9b\xc7\xa0\x9e\x89\x54\xf5\x68\x59\x47\xe9\xa6\x7e\xeb\x3d\x21\x31\x70\x78\x44\xac\xb7\xde\xae\xb5\xe0\xa9\xdd\x6e\x5f\x7a\x81\x4b\xbb\xa3\x0e\x1c\xad\xca\xb7\x5b\xc9\x3a\x98\x18\xd4\x6d\xfc\x86\x5e\xb7\x36\x94\x13\x27\x66\xdc\x42\xf5\xe4\xfb\xb1\x27\x22\xf8\x0c\xf6\x1a\x8a\x3f\x7b\xef\x41\x24\x23\x99\x06\x85\xb0\xaa\x75\x87\x70\xb7\xbb\xea\xf4\xf1\x93\xd6\xde\x81\x72\x9e\x86\x3b\xc8\x44\x2a\xad\xcd\xc8\x43\xed\x59\x2a\x0b\xe2\x36\xe8\x1f\x7c\x21\x5a\xb2\xb3\x14\xda\x05\x51\x3b\xb3\x6f\x5b\x50\xa8\x3f\xed\xbb\x30\x13\x1f\x1c\xdf\x28\x2b\xa2\x68\xed\xe5\x2f\xb8\xcc\xf1\x2d\x44\x07\x7b\xb0\x72\x95\x9d\xd6\x95\xdc\xa1\xc1\xf1\x7c\x91\x49\xbc\xf8\x54\x84\x5e\x49\xd9\xa7\xcc\x0b\x32\xd6\xad\xaa\x05\x97\xde\x5f\x0b\x1f\xb9\x88\x77\xc4\x18\x28\x73\xc5\xd4\x87\x0a\xb5\x6e\x1d\xb4\xee\x37\xc4\x35\xf2\xf4\x68\xd3\xc0\x68\xdb\xef\x36\x9b\xb7\x77\x5b\x77\xd5\x30\x1b\xf8\x0f\x9a\x81\xd1\x2a\xf0\x51\x23\x4d\x74\xa0\x4f\xda\x90\xbf\x54\xec\x32\x96\x70\x34\x28\x76\x43\xe4\x7b\x0d\x91\x5b\x05\x83\x9d\x2a\x8e\x6b\x79\x51\x75\xd7\xc6\x46\xa7\x65\x96\xde\xac\xa1\x20\x6e\x18\x12\x71\x83\xa4\xc0\x12\x86\x31\xaa\x55\x64\x32\x22\x7b\x88\xeb\xe6\x74\x7c\xac\xae\x8c\xc7\x54\x82\x6a\xe3\xdb\x93\x01\xba\x46\xc1\x66\xdf\x40\xc9\xac\xe5\x57\xd3\xb7\x8e\x13\x81\xd6\x69\x0c\x7a\xda\x85\x9b\x3e\x5c\xf2\x3e\xd4\xdb\xa6\xeb\x6e\x0d\xae\xce\x4a\xc8\xf9\x06\x7b\xd5\x06\xad\xe1\x95\x61\x4c\xd8\xf2\x7e\x3a\x8f\x43\x7f\xd9\xae\x91\x69\x89\x7f\x1e\x48\x8a\x10\xfd\xb5\xb9\x66\xfa\x2d\x0c\xc3\x63\x03\x81\x66\xc8\x8b\x67\x82\xfe\x03\xe7\xd6\x2a\xfe\x50\x33\x57\x3a\x6f\xfb\x6f\xd6\x7e\x3a\xfc\xd3\xe1\x97\x06\x68\x76\x07\xe4\x07\x68\xf2\x3c\x07\xf6\xc2\x9a\xc6\xe7\x6b\x39\x5b\xf1\x28\xb8\x06\x1a\xa5\x87\xbc\xe8\xfb\x01\xe1\xe5\x1d\x40\x72\x06\xca\xf5\x62\x51\x0b\x9a\x9e\x75\xec\x26\xe6\x12\xc6\x6e\xd5\x02\x45\xb0\x2e\xfe\xf1\xdf\xc6\x5c\xd8\x0d\x65\xf0\xa0\x9d\x57\x67\x46\xaf\x8e\xbd\xd6\x65\x73\x7f\x53\xb0\xd6\xac\xa2\x53\x11\x03\xe6\x7d\xe2\xe9\x80\x41\x9b\x8f\x19\x31\xe4\x56\x58\x5a\x44\x98\x17\xec\x45\x1e\x2f\x83\x5b\xe3\x61\x8c\x5d\x77\xb2\x36\x15\x85\x47\xe6\x8b\xf5\x82\x25\xf7\xb0\x40\x2a\x1a\x0a\x84\xc0\xf9\x75\xb6\x4a\xd0\xb4\x8d\x15\x45\xb1\x02\xba\x36\xf7\xe5\xb3\x3b\xad\x47\x24\xaf\xcf\x3e\x3a\x3c\xdb\xf9\x8a\xfc\x08\x8a\xe4\xde\x21\xfb\xcf\xdd\x07\xcd\xdf\xdd\x19\x0a\x46\xc4\xb5\xee\x1e\x36\x7f\x7f\xc8\x41\x71\x41\x9f\x5a\x4c\x7e\x1b\x63\x18\xcc\xea\x8c\xb6\x52\xb1\xd1\xbc\x6c\xba\xab\x4b\x8e\x59\x2d\x8c\x78\x57\xcf\x98\xfc\x23\x90\xa4\x8f\x31\x56\x5b\x79\x38\xba\x55\x8a\x19\x14\x5e\x8f\xaa\x25\xa2\x7b\x48\x2f\x8a\xf3\x7f\xdc\xbf\xdd\xfa\xfc\xb6\x7a\x5f\xa7\xa1\x4a\xd1\x05\x9f\xcf\xe9\x3b\x92\xea\x43\xa6\xfe\x28\xd7\x2e\x93\x37\x8d\x52\xdd\x12\x9a\x8b\x0d\xea\x50\xac\x3c\x69\xda\x8a\xe3\x5b\xe1\x32\x4d\x53\x64\x8d\x48\x4c\xa6\x48\xd5\x54\xf7\xee\x9d\x2c\xbd\x64\x77\xef\x64\x69\xbd\x43\xf7\x4e\x96\x2e\xf4\xc0\xa1\xc1\x6b\x55\xba\x46\xd5\xbb\x93\x2e\x72\x28\x7c\x03\x4a\xd7\x72\x0a\x6f\x54\xea\x76\xc4\x95\x89\x42\x8d\x6d\x3f\xcd\xa0\x0c\x2a\x89\xbd\x52\x16\xb5\x0e\xfd\xe7\x38\x4c\xb0\x58\x8c\x47\xc8\x6b\xbb\x05\xf1\xf6\x56\xf3\x57\xc9\xef\x20\x1d\xc0\x52\xcb\x26\x4b\x7c\xdb\xbb\x24\x8e\x45\x2e\x5b\x02\x4b\x71\x6e\x5e\xff\x18\x48\x31\x38\xe4\xc5\xe6\xf2\x73\x86\x28\x3f\x37\x68\x0f\x5b\xc3\x30\x20\x8e\x6b\xb1\xa7\x0c\xf3\x8b\x58\x5b\xab\x54\x2c\x8a\xf3\x61\x27\x45\x82\xbb\x1b\xfd\x41\x3b\x0d\xdf\x54\x39\x88\xa8\xac\x22\xa0\xd1\x68\x3e\x7c\x72\xb6\xf3\x31\xea\xd3\x52\x8d\xdb\xf4\x9f\x3c\x9f\x8a\xf4\x84\x74\xbb\x94\x6d\x24\xfb\xe0\x92\x9b\xc9\xe3\x7e\xc5\x88\x6b\xed\x94\x7c\x43\x09\x9f\x7f\xf9\xaa\xf5\xfe\x76\xf3\xb6\x26\x21\x99\x1b\x73\x3b\xf4\x82\x27\x51\xf9\x43\xf2\xe4\x88\x00\xab\x90\x33\x47\x0c\x62\xcc\xc5\xcf\x63\xb4\x1f\xce\x9c\x0c\xdd\xf7\xc9\x8e\x14\xe3\xa0\xc9\x40\xdc\x0f\xdc\xf0\x17\x45\xba\x7f\x56\xa5\x1b\x82\x67\xe3\xa3\xca\x40\xd0\x33\xf6\x51\x65\xa0\xcc\x73\x19\xcd\xe0\x1f\x09\x44\x88\x67\x8c\xb0\xf6\x96\xb1\x2b\xd2\xfa\xe3\xb9\x25\xff\x55\x67\xdd\xbc\x00\x0e\xa8\x34\xb2\x3a\x9d\x03\xaa\x67\xde\xa7\x2c\x24\x3d\x6b\xb7\x53\xa6\xc9\xfd\x21\x1a\x5d\x65\x40\x71\x74\xe8\x73\xb6\x01\xd0\xbb\x07\xba\x9e\xa5\x24\x93\x7f\x66\x32\x3d\xdb\x6e\x30\x34\xdb\xff\x9e\x5d\x84\x3d\x9b\x10\xb5\xd1\x80\xe1\x3f\x48\x45\xe0\x6e\x91\x8e\x9f\x28\xeb\x76\xaf\xce\x48\xbd\x29\x3c\x0d\x81\x6e\xbe\x6a\x13\x4c\xc9\x88\xb2\xc4\x94\xaf\xf5\x81\xd8\x8d\x07\xcd\x3f\xdd\xd4\xbf\x15\xdd\x1f\x43\x86\x60\x20\x17\x16\xf4\x13\xc1\x53\x9e\x6d\x4b\x8d\xbb\xd7\x75\x4b\xb7\x20\x8a\xb1\xf3\x9d\x4d\x3b\x5f\xb4\x1a\x27\xbc\x15\x0e\x05\x74\x91\x16\xd7\x27\x44\x02\x21\xa8\x49\xb1\xa0\xa8\x38\x1e\x18\x86\xc3\x96\x77\x19\xcf\xab\xb5\x6d\xec\x12\xda\xc6\x2e\x21\x17\x04\x03\x7a\x55\x77\x24\x3e\xd4\x86\x48\x83\xf7\x9d\xed\x4d\x4c\xe5\xed\x9e\x13\x6f\x2c\x55\x46\x92\xc7\xb2\xc7\x24\xf9\xc8\xe9\x38\x70\x4e\x3e\x6e\x46\x95\x67\x59\x76\x64\xe9\x08\x51\xe6\x39\xf0\xd8\x52\xfd\x19\xda\x6b\xdf\x01\xf2\xf7\xe5\x61\xeb\xe9\x26\xa6\xfc\xde\xdc\x45\x46\x67\x67\x5f\xcb\xd2\x25\x05\x24\xfa\x51\xf9\x68\x08\x60\x14\x03\x0a\xfd\x26\x35\x99\xa1\x9c\x93\xac\x73\x14\x45\x0f\x4a\xed\xcd\x6d\xa4\xe5\xe1\x8e\xef\x5e\x4b\x4d\x07\x1a\xf6\x31\xd6\x4f\xd6\x69\x35\x5c\x87\xef\xe4\x0c\xfe\xbf\x6a\xae\x05\x96\x47\xb9\x40\xf6\xe4\xba\xcb\x6f\x8b\x97\x92\x0c\x05\xe4\xdf\x3a\x39\x6a\x7e\xf8\x47\xa2\x50\xae\x07\xf4\xb1\xdc\x3d\x8c\x08\x54\xe7\x80\x5c\xf1\x06\x2e\x7e\x0f\x28\x21\xc0\x9d\xcc\xdc\xa0\xf0\xc3\x84\x98\x58\xe6\x59\x84\x80\x22\x37\x08\x04\x85\x3b\xf4\x6d\xcc\x5a\x37\xcb\x11\x77\x94\xb6\x03\xb3\x17\x99\x97\x9a\xbc\x44\x3e\x25\x14\x42\x24\xfa\x55\xf4\xde\x11\x3c\xc7\x4b\xe6\x30\xc7\x38\x7f\x20\x83\x18\x22\x0e\xd8\xd7\xf2\xb9\xac\x48\x2b\x85\xe9\x14\xb7\x5b\xff\xb1\x94\x4c\x0b\x39\x97\x56\x66\xf4\x9f\x6f\x5c\xd5\xcf\x24\xc4\x21\x9c\xa4\xf1\x42\x8c\x53\xc4\x8e\x48\x1a\xb0\x17\x70\xb0\xa2\x76\x52\xaf\xc7\x0c\x8f\x0d\x91\xb4\xc9\x1e\xc0\xbf\x75\x07\xf4\x9c\xe2\xaf\x0a\x05\x74\x5e\xc0\xd1\xf9\xf9\xed\x5e\x92\xc0\x2a\x6f\x32\x21\x4a\x2c\x46\x8f\xe8\x41\x84\x49\x6a\x44\xd1\xca\x3c\x7b\x77\xac\x65\x3b\x4c\x84\x37\x35\x41\x08\x49\x6d\xd7\xd7\x05\x3c\x1a\x3b\x72\x5f\xf9\xbb\xbf\xbf\x32\x64\xbc\xfc\xd2\x2b\x3f\xc3\x7f\x2e\x6b\xcd\xc7\x1e\x1c\x1a\xa3\x9e\xb1\xdd\xb8\xed\x65\x5d\x9f\xe8\x02\x36\xb8\xb8\x16\xa7\x3f\xd4\xe0\x10\xf4\x00\x11\x12\xe0\xd9\x6e\xbc\x7b\x76\x63\x2f\x16\x70\xe3\xa2\x23\xb2\xcb\x8b\x4e\x15\x73\x29\x9d\x7a\xad\xa2\x2d\x7f\xdc\xfa\x6e\xaf\x79\xc0\xa7\xea\x8d\x0f\x30\x99\x91\x12\x05\x6f\x9e\xdd\xdf\x4a\x8a\x5e\x10\xdd\x70\x8d\x1b\xf2\x96\x51\xd1\x1b\x09\xa8\xa3\xeb\xef\xf3\xdb\xa7\x8f\xbe\x56\x10\x68\x24\x56\x4a\x62\xb4\x84\xe8\xaf\x64\x56\xa4\x67\x8e\x10\x11\x44\xba\x97\x48\x1d\xc1\x62\xa2\xd2\x4b\x40\x7a\x51\xa5\x6a\xad\xd9\x0e\x8c\x2e\xe5\xd0\xb8\x0c\x87\x92\x2a\x43\x0c\x17\x96\x34\xdf\x10\x50\x0b\xf9\x03\x04\xa1\xcd\x87\xb7\x09\x61\xc6\xcf\x26\x43\x05\xea\xa0\x61\x70\x02\x8e\x90\x37\x81\xf7\x25\x5a\x8e\x1f\x81\x13\xcb\x27\x17\x97\x11\xb9\x16\xe6\x32\x26\x25\x21\x0b\x7a\xa5\x8e\x7b\x66\x28\x1e\x91\x56\x0e\xbd\xdc\xff\x38\xd5\xd0\xe6\xaf\x5b\xd5\x9c\x5d\xa2\x6c\x17\xc7\x4b\x22\xe4\x4d\x81\x8a\xdc\x85\x82\xf2\x48\x0e\x05\xae\x16\x0e\xd6\x93\xb1\xdc\x2a\xe5\xbf\xff\xf9\x04\x48\x10\xde\x15\xa9\xd3\x5d\x08\xff\x2e\x32\xe5\x75\xfb\xc6\xc9\xd7\x31\x8c\x88\x3a\xc2\xf4\xad\x64\x5f\xfd\xe1\x09\x4e\x02\x3c\x92\xe8\xa9\x67\x6b\x38\xb3\xab\x60\x21\x6b\xf7\xbf\x34\x6b\x33\x4b\x81\x37\x62\x3a\x70\x47\x92\xda\x1b\xd1\xbd\xce\x38\x6f\x86\x59\xc3\xbc\x60\x90\xd6\xa6\x5d\xb4\x0a\x12\x69\x02\xd1\x1d\x10\x22\x7b\x9e\xd1\xca\x28\x9e\x83\x00\x76\x86\x3c\x28\x2c\x97\xd6\x94\xb9\x06\xef\x71\x08\x16\xee\x0d\x94\xb0\x2b\xf6\x9a\x45\xc3\xa9\x85\xa4\xba\xf5\xa0\xf5\xd9\x31\x27\x18\xd3\x66\xdd\xfe\x2a\xdc\x6f\x08\xe5\x49\xcd\x7c\x36\x5a\x7f\x78\x8a\x18\x4c\x0f\x1b\x38\x0f\x62\x5b\xb4\xa1\x44\x05\xf5\xf7\xe4\xd4\x6d\x39\x1e\x1e\x80\x90\x80\xcf\x18\x70\x0d\x2a\x56\xe8\xd6\x4b\x46\xc1\xb1\x5c\x3f\x82\x8b\xb2\xca\x8c\x92\x55\x33\x0b\xa6\x36\x3a\x40\x65\x35\x8c\x2c\x24\x80\x36\x80\xbc\x47\xc7\x20\xf8\x5b\x8d\x43\xda\xfb\x07\x9b\xad\xfb\x7f\x6c\xbd\xbf\x8d\x40\x98\x67\x37\x36\x45\x52\x7a\xe3\x88\xd0\xd9\xd2\xc6\x81\x5d\xac\x97\x2a\x01\xe8\x20\x9c\x3e\x0b\xa6\x1b\x85\x15\x43\xc8\x68\xa5\x37\xe2\xcc\x50\x1e\xfa\xad\x83\x48\x70\x9e\xe8\x1e\xc7\xaf\x5e\x9b\x98\x99\xba\x7a\x65\xfc\xea\x9c\x71\x6d\x74\x66\x62\xf4\xd5\xc9\x71\x83\x6a\x48\xe8\x22\x68\xce\xee\xed\x22\x14\x65\xf3\xf1\x26\xce\x11\x9b\x8e\xd3\xb7\x3d\xab\x5b\xf9\x81\x66\x35\xab\xdf\x47\x7e\xd7\x6a\x02\x58\x4b\x33\xe9\x65\xa3\x0d\x27\xdd\xf5\x90\xd1\x0b\x4b\x08\xdb\xbe\xe2\x14\x0b\xc9\xcf\xe5\x09\x4a\xbe\x6a\x96\x16\x57\x96\x16\xce\x8d\xfc\x2c\x1a\x26\x3e\xfc\xce\xbf\x5c\x40\x24\x15\xd2\x67\x2e\xd4\x4a\x95\x0b\xd2\x7f\xb5\x98\x77\xca\xcb\xf6\x8a\x16\x1d\x3e\xd8\x4e\xcd\x58\x38\x87\xe0\xca\x43\xce\x32\xa2\x29\xad\xb8\x0b\xe7\x62\xc7\xe4\xc7\xca\x73\xf2\x54\x4f\xda\xe5\xfa\x5b\x17\xae\x98\x79\xfe\xa8\x74\x12\xa8\xa3\x45\x45\xc5\x02\x4c\x56\x10\x04\xc7\x45\x70\x52\x97\xea\x01\x54\x61\x23\x52\xea\xbc\x52\x02\xe1\x17\xd0\x84\xb3\xee\x1a\x12\x36\x0e\x3a\xb3\xb2\xf4\xb3\x70\xee\xed\x85\x85\x60\x57\x0b\xd8\xd9\x82\xda\x1d\x7c\x78\xc7\xab\x16\x21\x7b\x9c\x76\xd6\xad\xea\xec\xaa\x55\x2c\x66\xe4\x2b\x55\x77\xc8\x5f\x2d\x30\x23\x31\x8d\xa6\x99\xdd\xa4\xc5\xf9\x4c\x66\x89\x75\x4d\x50\x32\xff\x6b\x8a\xa2\xa6\xa8\x9b\xbd\xc4\x60\x25\x5e\xef\x85\x25\xef\x4f\xd7\x2e\xae\x81\x72\xa7\x17\x1f\xe9\x37\x52\xea\x4e\xc4\x9c\x89\x7e\x16\xa8\xa7\x2c\xd3\x93\x85\x9b\x70\x3f\x92\xa3\xcc\x6d\xa5\x13\x92\x9d\xb4\xed\x09\x4e\x23\xfd\x69\xd1\xff\xa9\xd6\xef\xc6\xff\x9a\xe7\x1e\xce\x73\xf4\xae\xe6\x0b\x82\x57\xb5\x85\x2d\x03\x9e\xb9\x56\x84\x7d\x4b\x18\x06\xb7\x02\x62\x48\x1b\x58\x28\x1d\x4c\x14\xe6\x4d\xb8\x06\xfb\x1f\x37\x6f\x3d\xc1\x6b\xb3\xd7\x3e\x1b\x17\x84\x7e\x1f\x4b\xd2\x6b\x73\x73\xd3\x98\x6d\xf2\xd6\x86\xc4\x32\x47\x5c\x6e\x49\x90\x86\x04\x7c\xc4\x0f\x33\xa7\x26\xa8\x8c\xc2\x3e\x25\xbc\x24\x77\xda\x5f\x17\x60\x9a\xae\x5f\x6c\xd7\x5f\x7a\x0e\xfa\xee\xf2\x8b\x25\x05\x06\x48\x14\x12\x64\xa3\x97\x36\xe8\xfd\x03\x42\x9c\x64\x03\xa5\x18\xac\x14\xde\x2e\xd1\x4b\x6f\xfd\x7c\xb1\x5d\x05\xfd\x7b\x8a\x41\x26\xd9\xb5\x17\xed\xcd\x23\x28\x62\x25\x50\x30\x15\x05\x3f\x48\xcf\x5e\x16\x97\x1e\xf1\xfa\x23\xf0\xe8\x25\xdb\xd8\xc3\x9c\x76\xeb\xc9\xeb\x07\xb3\xe9\x3d\x54\x7d\xe6\xf7\x07\xef\xc1\xeb\x68\x7c\xfe\x93\x7a\xee\x32\x8c\x55\xaf\x3d\x76\x5d\x74\xdd\x53\x4f\x5d\x1a\x3a\xd6\xfc\xec\x5d\x18\xe2\x6b\xa6\x70\xd2\x1b\xeb\xa6\x2b\x90\x3b\x6b\x3a\x3a\x82\x96\x43\xf5\x6d\xaf\xb0\x01\x93\xa0\xa4\x5a\x80\xf4\x4f\x30\x01\x93\xf9\x59\x2c\xdf\xc8\x80\x69\x1c\xa6\xcb\xf3\x13\x17\x07\x46\x74\x18\x54\x03\xf4\xb3\x58\x35\x11\xeb\x2e\x70\x1a\x91\xae\x20\x70\xdf\x08\xe6\xd9\x68\x1e\xed\xb5\x6e\xec\x8f\x68\xb0\xa9\x98\x3e\x3a\xc4\x19\x18\x9e\x34\xd9\xd8\x5c\x49\x71\x42\x47\x76\x13\xd7\x49\x5e\x26\xb0\xfb\x88\x5c\x76\xd1\xd2\xb2\xed\x61\x6b\x31\x90\xa6\x92\xae\x9e\x91\x39\xaf\x5f\xc1\x5c\x72\x89\x47\xc1\x67\x5c\x8f\x4a\x1b\x69\xba\xae\x09\x94\xd4\x44\x48\x6f\x7c\x30\x0d\xc3\x99\x7a\x4f\x07\xcb\x1a\xd7\x61\xba\x6e\x22\x42\x37\x87\x53\x00\x85\xa7\x81\x28\xf0\x29\x42\x4d\x8c\x89\x3a\xfb\x74\x2b\x84\x5d\x1b\x0b\x21\xce\xd4\x16\x22\x33\x5b\x78\x4f\xa5\xa0\xd5\x0f\xa6\x8e\x4a\x68\x69\x1b\xb7\xcc\x54\x45\x27\xbc\xa4\x81\xfb\x4d\x93\xd3\x12\x4d\x5f\x3c\xe2\xaf\x20\x50\x1b\x8d\x11\x93\x81\x7c\xe3\xdd\x6c\xb1\x17\x91\x93\x0c\xaf\x0a\x0c\xfe\xce\xe8\xe3\x33\x28\x53\x70\x46\x5a\x2a\x05\x89\xf1\x84\x79\x25\x37\x48\xf8\xf8\x72\x43\xef\x26\x12\x52\xd6\x2b\x5a\xa1\x5d\x55\xd4\x48\xaa\xbe\xd9\x46\x92\xa6\x73\xb2\x8e\xf4\xa2\x73\x4b\xa7\x14\x68\x7a\x8e\x3b\xf1\xbb\x58\x18\x5a\x32\xba\x5e\x17\x1d\x2e\x88\x65\xae\xee\xaa\x38\xb9\xf1\xd2\x92\x0a\xd0\x9b\x3b\x96\x35\xb4\x7c\xa3\x0e\xe1\xa5\xeb\x4e\xfe\xd4\x5b\xbc\x9d\x30\xce\xd8\x4d\x3e\x2e\xdb\xe8\x52\x71\xdc\x63\xe9\x4a\x4d\x54\x1f\xe4\x62\xaf\xc7\x2d\x65\xb9\x05\x81\xbf\xaf\xeb\x36\x4d\x4f\x61\x25\xd2\x3f\x65\xd2\xa4\x23\x44\x69\x91\xe9\xa6\x2a\xdc\x7e\x17\xa4\xf6\x81\xba\x74\x04\x45\x25\x2a\xa5\x21\x2a\xaa\x3a\x4c\x2f\xc8\x72\xaa\xeb\x66\x95\x28\x43\xc9\xa4\xd5\x86\x11\x9c\x04\xd3\xf3\x0e\x1a\xcd\x5b\x87\x1d\x28\xc1\x2b\x02\x85\x05\xe5\x58\xde\x29\xe8\xd5\xee\xb4\x8d\x20\x98\xb0\x2e\x5a\x82\x84\xa5\x87\x1b\x0c\x72\xa1\x75\x70\x82\xb4\xea\xee\x26\x69\xfa\x54\x4c\x99\x20\xc6\x4b\x25\xaa\x42\x93\xda\xa8\x49\xf6\xf7\x9d\xbf\x8a\x12\x84\x09\xe4\xa4\x1a\x48\x59\xa4\x91\x6a\x48\x73\x08\x1f\x87\xf8\xc0\xac\x5f\x02\x4d\x9f\xcb\xc9\xeb\xd7\x93\xff\x4c\x30\xce\x48\x44\xe4\x89\xc2\x96\x7f\xfa\x1a\xdd\x04\x69\xa8\x4e\x43\x33\xd5\x69\xc0\x89\xd3\x2d\x32\x71\xf1\x48\x3f\x75\x69\x7a\xc5\x0e\x79\x84\xd6\x5e\xb9\x40\xcb\x46\x37\x6f\xf0\x3b\xf7\x2d\xad\x29\x19\xd6\x50\xaa\x49\x43\x37\x05\x82\x01\x71\x2e\x68\xec\x3e\x80\x81\x38\xfb\x6c\x9b\x6e\x1f\x9c\xdf\xd9\xfa\xeb\x1d\x8c\xb7\xea\x1d\x31\x62\xbd\xc8\x60\x2f\x1e\x22\x8c\xff\xd2\xd3\x24\xc3\xb8\x22\x02\xd4\xc2\x91\x5d\x3d\x24\x94\xa1\x96\xb8\xb2\x92\xc5\xf5\x7c\xbc\x34\xb8\xf8\xdb\x52\x5c\xeb\x04\x1e\x82\x55\x54\xb0\x8b\x99\xe9\x31\x69\xc3\xd3\x72\x8f\xcf\x28\xa9\x9c\xc7\x5b\xa7\x27\x47\x67\xf7\xa2\x19\xfb\x1f\xb1\x8c\x81\xf0\x70\x57\x4d\xd2\x0a\xff\xd7\xec\xd4\x55\x4d\x7f\xf8\x13\xd5\x9c\xbf\x71\xd8\xc4\x2c\xf4\x8c\xcb\x1f\x6b\x92\xf8\x12\x97\x6a\xcb\xd1\xa0\xc5\xc9\x4c\x2a\xff\xc6\x25\x49\x0e\x3b\x9b\x33\xd9\x6b\x17\xc5\x50\xb4\x3d\xc7\xf5\x5b\x81\x21\x4d\x33\x9e\xa7\x4f\x0e\x9b\x87\xb0\x58\xbf\x6b\xb4\x1a\xfb\x1d\xf7\x22\x20\xc1\x74\x62\x8c\xd0\xba\xba\xed\xca\xaa\x62\x1d\xa1\xd4\x46\xb1\xd6\xd6\xee\xd9\xa7\x1f\x64\xef\xa6\xea\x48\xd3\x20\x46\xc4\xe0\x64\x51\x01\x5a\x2a\x32\x4a\xc7\xc3\x40\x8a\x7d\x16\xd3\x96\x59\x33\xbc\xa6\x02\x2d\x65\x24\xaa\xcb\xdd\xae\x34\xe9\x0b\x3b\xdc\xf1\x56\x55\x2f\xee\x60\xb3\x3f\x6a\xc8\x13\x51\x0a\x36\xa3\xf5\x68\x97\x2a\xb9\x64\xde\x1b\x18\xa1\xd4\x6e\x7f\x4c\x54\xfe\x42\x86\x48\xda\x24\xfb\x7f\xd5\x6e\xcf\x74\x7a\x9f\xa4\x45\x5e\xcd\x63\xaf\xe3\x09\x5d\x66\xe9\x87\x06\xbe\xa3\xce\x82\x37\xef\xd6\x5e\xa3\xf5\xbd\x06\x7d\x2d\xa6\xe7\x4c\x53\x9e\x8a\xf9\xa4\x29\x5f\x86\xfe\x57\xe9\xec\xf7\xf1\x1f\x62\x0e\xfd\x00\x94\xc3\x8d\x2d\x06\x1d\x3e\x00\x56\xa9\xf0\x70\x07\xfd\x97\xcd\x52\x8f\xad\x8d\x94\x7d\x20\x8a\x5e\xeb\xa8\x4a\x6b\x77\x14\xa2\x8d\x94\xc3\x98\x85\x21\x44\x5c\x92\x21\x26\x65\x4f\x9e\x16\x86\x0a\x58\x70\x59\x74\x25\x63\x10\x52\xb0\xb8\xe6\x01\xa0\x24\xef\x6c\x1f\xf6\x24\xe6\x90\x48\xbd\xa1\x6b\x55\xdb\xa2\xde\xdd\x1a\xcc\x73\x47\x17\xac\x70\x23\xdd\x4a\x5d\xd7\x5c\x53\x05\x5e\x97\xad\x51\xd8\x73\x8f\x17\xb3\x52\x20\xaf\xab\x85\xec\xd1\xc6\xf9\x6a\x8b\x94\x5f\xb1\x58\xdb\xa8\x58\x71\x36\xc7\xf6\x87\xf5\x04\x65\xb6\x3c\xb2\xd7\x25\x74\x77\x4d\x57\xb9\x2f\xe2\xfe\xea\x7b\x69\xd2\x3a\x43\xd2\xd8\xae\x7c\x1a\x7b\x3b\xa7\x11\xa4\x66\x9c\x50\xac\xb3\x47\x97\x0f\xa7\x13\xe7\x19\x75\xfb\xc9\x91\xfe\xd0\x48\xb3\xa5\x7f\x6b\x57\x2a\xa1\xe9\xcb\x30\x61\x3b\x3b\xad\xef\xa2\xcd\xc3\x71\x7d\x46\x1a\xda\x30\x2f\x8a\x81\x13\x10\xf7\x99\x31\xac\x4d\x97\x23\xbc\xaa\x2b\x94\x6e\xc6\x9e\xfe\x69\xc7\x25\x44\xc6\x01\x98\xce\x9a\xfa\x11\xa5\x2f\xdc\xdf\x30\x64\x12\x5e\xae\x59\x2b\x56\x75\xd8\x30\x2e\xe1\x5d\x08\x2b\xc5\xbb\x1b\xe5\x9a\xf9\x16\xec\x9d\x62\x65\x88\xaa\x5c\xfd\x2a\xbf\x2c\xc3\x3a\xfd\x85\x91\x5b\xfd\x55\x4c\x9c\x44\x04\xd9\xcc\x35\xde\x44\x07\x58\x5f\x18\xe0\x0c\xc4\x13\x50\x96\x29\xfa\xc9\xb7\x66\xc1\xa1\xf6\xde\xae\xff\xd8\x5d\x0e\x7a\x3b\xd8\x81\x27\x71\x8d\x9f\xed\x34\xe0\x10\xf2\xcb\x4d\x11\x1c\x6c\xe3\x04\x77\xa2\x54\xf3\x3f\x6a\xb4\x3e\xdf\x6c\x3e\xbc\x8d\xf8\x87\x3a\xf2\xd9\xf6\x7a\xd2\xfa\xe2\x28\x05\xc2\xb8\xa8\xc1\xac\xf5\x10\x70\x11\xe5\xd8\x77\xaf\x3a\x0c\xf6\x4c\x70\xd4\x49\x89\xb3\xa2\x41\x3f\x4f\x93\xca\xd0\xa6\xae\x85\x2a\xba\xc4\x83\xb5\x80\x11\xb3\xc6\xba\xc9\x3b\x88\xba\x85\x19\xce\x1b\xbf\x76\x96\xe8\x62\x01\x8f\x52\x96\xe1\x00\xee\x2e\x44\xf1\x74\x75\xd0\xe1\x92\x28\xc4\x0e\xff\xe8\x1e\x69\x1b\x5c\x38\x39\xd8\x4c\xeb\x5e\xa3\xf9\x87\x6d\x14\x8a\xaa\x42\x82\xa0\x9d\x7b\x5c\xb8\x9e\xae\xeb\x8f\x9f\xc6\x52\x9e\xe4\x65\x48\x55\xb5\x7a\x9c\xd3\x7c\x5d\xca\xf3\x25\x8d\x83\xb3\x6f\x2d\x51\x3d\x15\xc6\x06\xc3\x71\xad\x72\xa1\xe2\xc0\x46\xc8\x76\x0a\xbe\x55\x61\x0b\x88\x6a\x8b\xe4\xa8\x47\x93\xed\x80\xce\x32\x82\x02\x5e\x60\xa8\xeb\x8a\x69\x57\x5d\x51\xca\xdb\x70\xf2\x54\x79\xac\xa0\xd6\x65\x36\xca\x96\x59\x05\xf5\x02\xc7\xf2\x8d\x52\x71\xb6\x0c\xf2\xc6\xaa\xc1\x78\xa6\x8f\xd5\xdc\x3f\x46\xc8\xbe\x0b\xa7\x47\xff\x66\xb4\xb6\x7f\xc7\xe1\x57\x6c\x32\x7c\x6a\x9c\x3e\xba\x21\xa3\x0c\x77\xb7\xe0\xb0\x5a\x28\x9f\xfe\xe5\x29\x5c\x9e\xf0\xa9\x70\xed\x67\xad\x86\x1f\x49\x5e\xea\xd1\x71\x03\xc3\x93\x89\x2d\x3d\x1f\x09\xdd\xfb\x47\x92\xec\xdb\xb5\xe4\xcc\x18\xff\x73\xa1\xfe\xd2\x4b\x3f\xb5\x18\x8c\x7c\x88\xa4\xa4\x5d\xa3\xe8\x20\x02\xf9\x9a\x03\x15\xe0\x9d\x77\x62\x84\x5c\x28\x20\x08\xe1\x12\x65\x93\x30\x07\x1c\xc4\x7c\x02\xaa\x43\x14\xdd\x78\x42\xc3\xe7\xf7\x76\xfd\x9e\x5a\xf7\x6f\xc6\x47\x0f\x29\x4c\x4d\x57\x9d\x8a\x55\xad\x6d\x84\x98\x5b\x72\x9c\xa2\x65\x6a\xcb\x2f\xb4\xbd\xe8\xd1\xde\xfc\x6e\xb3\xf5\x99\x96\xd0\xa4\xb0\xa6\x64\xc2\xe4\x86\x70\x41\xa5\x2d\xaf\x68\x4b\x24\xc7\x10\x78\x78\x82\x52\xfe\xee\x71\xfc\xb2\xee\x0d\xb5\xe5\x7a\x69\xc9\xaa\xb6\xaf\x08\xf9\x78\xe2\xca\xd0\x30\xd1\xda\xfa\x3f\xc8\x44\xd2\x72\x08\x76\x93\xb4\x2c\x2e\x8d\x4e\x4c\x8e\x5f\xd4\x6d\x27\xca\x7d\xd6\xbc\x38\x3e\x3a\x37\x3f\x33\x6e\x5c\x9a\x1c\xbd\xac\xcb\xa0\xe5\x98\x65\x1f\xea\x5e\xd3\x12\x65\x76\x1b\x8c\xf9\x2c\x1d\x7d\x55\x87\xd3\xba\x31\x10\x48\x7f\x70\xca\x68\x1f\x90\x3d\xa7\x8f\xb6\x3d\x90\xcf\xbb\xdf\x9c\xed\x1c\xd0\x41\x27\xc0\xf4\x29\x96\x0d\x94\x71\x2f\x9b\x3b\x96\x92\x65\xab\x96\x5f\x0d\x28\xb2\x6e\x9a\xd8\x23\xc5\x04\xfa\xaf\xbb\x20\xef\xe8\xe0\xa2\xfe\x32\x46\x17\x85\xc9\x60\x87\x75\x3a\x1a\xbc\x48\x9d\x1e\xd3\x60\xad\x81\x66\xe8\xa6\xbb\x72\x80\xba\xf1\xe8\x01\x5e\x7a\x92\x69\x88\xbf\x58\x84\x89\x80\x85\x91\xe3\x48\x7c\x54\x44\x68\x89\xb0\x8f\x77\x06\xfe\x9c\x73\x04\xce\x88\xc0\x5c\x4a\x77\xe5\x88\x7e\xd9\x5b\x42\xbb\x62\x4d\xe5\xfc\xc0\xb2\x1e\x0f\x2c\x46\x6c\x64\xa8\xc1\xde\xf3\x31\x25\xfb\x46\x95\x71\x57\xfd\x25\x96\x64\xe7\x68\x1c\x49\x2c\xd5\x54\xc3\x91\x89\x98\xf4\x54\xa4\x5a\x62\x19\xba\x27\x87\x7e\xc4\x0a\x23\x87\x7d\xe7\x6b\x4c\xf7\xba\xba\xca\x28\x0c\xa0\x7f\xab\x8c\xc3\x6f\x86\xb3\x45\x77\x48\x6c\xd1\x74\xa4\xa4\x88\xe7\x10\x54\x81\x58\x17\x25\xff\x31\x03\x90\x47\x5a\x94\xf0\x58\x94\xd0\x15\x71\x6e\x92\xd0\xc3\x22\x1f\x0e\x46\x91\xdc\x42\x1c\xe8\xe9\x93\x9b\x92\x14\xa9\x49\x0f\x61\xf9\x01\x81\x29\x82\x3e\x22\x2b\xb2\xa0\x93\xf6\x48\x0a\x97\xf1\x65\x1a\x86\x8c\x40\x48\x38\x39\x54\x55\x97\x92\x0a\x04\xb2\xbf\x9d\x70\x3c\x01\x61\xc2\xeb\x98\xc5\xe5\x98\x6a\x2c\x18\x81\x87\xcd\xdb\xf1\x73\x30\x35\x8a\xcf\x48\x6b\x2e\xa1\xee\xc4\xf7\x21\x12\xaa\x30\x5c\x81\xff\xbc\x54\x34\x11\xf2\x55\x00\x2b\x16\x62\xf4\xa1\xe0\x0b\x32\x11\xca\x07\x51\xf1\x62\xe8\x13\x74\x37\x2d\x0d\x9c\x01\xd6\x0d\x09\x5f\xa7\xe9\x58\xe7\x64\xe4\xe6\x34\xaf\x62\x9c\x05\xa6\x1b\xf0\xbd\x1f\x1d\xe6\x45\x2c\x1f\x55\x32\xaf\x5b\x86\x8b\xdc\x50\xe6\x19\x3e\x65\xbd\x65\x53\x26\x6b\x4d\x20\xdc\x54\x4c\x98\x21\xa0\x1d\x7f\xac\xc4\x85\x90\xf8\xce\x28\x82\x79\x3e\x24\xc5\x32\x68\x29\xf0\xd1\x6d\xe4\xc3\xc7\x0a\xce\x0d\xac\x6c\x91\xcb\xe2\xf7\x45\x1b\xf0\xfe\x16\x28\x5e\x38\x3b\x67\xf7\x76\x40\x29\x49\x61\x29\xb9\xe4\x60\x21\x9f\x25\x11\x61\x85\xf5\xba\xd0\xfe\x40\x09\xc3\xd5\x52\x9c\xdd\x2c\xae\xb9\x02\x57\x84\x18\x2c\x30\xce\x54\xa5\xea\x10\xa2\x10\x06\x9c\x2b\x0d\xeb\xe1\x9d\x28\xe6\xf9\xf4\x68\x87\x42\x9f\x09\xbc\x6b\x90\x19\xa2\x21\xa2\x3d\x20\x74\x4c\x4a\xc6\x3d\x84\xff\x0a\x04\x2c\x06\x2d\x0b\x00\xe2\x68\xf0\x92\x14\x4a\xd1\x16\x90\x81\x73\x26\x85\x65\xc7\xb1\x11\x45\x6d\x5c\x8f\x02\x37\x89\x33\x01\x29\x8a\xa4\x47\x83\x5e\xb2\x57\xaa\x66\x77\xbc\xa0\xf8\xda\x3f\x46\x45\xe3\x60\x4b\xd8\x42\x53\xf3\xd5\x1d\x18\x6e\xea\x6e\x60\x57\xb3\xcc\xe4\xda\xef\x92\x55\x5e\x62\x3a\x26\x13\x16\x09\xc1\xac\xed\x7c\xab\xd4\x31\x44\xe9\x9a\x9a\xa4\x7a\xb9\x67\xdb\xe7\xf2\xf8\xdc\xdc\xc4\xd5\xcb\xc6\xec\xdc\xe8\xcc\x5c\xcc\x35\x51\x80\xae\x81\x20\xd3\xb4\x33\x39\xf5\xea\xe8\xa4\x31\x35\x3d\x37\x31\x75\x55\x8b\x8c\x74\x7a\xb2\x89\xd6\x7e\xbc\xc8\xed\x3e\x81\xc9\xd6\x04\xf3\x5d\xb6\x6a\x70\xa1\xf6\x3c\x7f\x5e\xfd\x42\x8a\xc4\x76\x57\x8d\x7c\xd1\xc6\xbb\x4a\x4c\x70\xcc\xd9\xbb\xc7\x4d\x92\x61\xad\x4f\xd9\xc2\x82\x36\x52\x19\xa3\xa5\xd6\x36\xf4\xc3\x9e\xf4\xac\x01\x35\x28\x82\xdb\xfd\x3f\x6c\xba\xc3\x85\x91\x50\x14\x07\xfb\x6f\x7f\x1d\x0d\x71\xa9\xba\xe7\x98\x46\xac\x8a\xc4\x51\x4f\x02\x06\x10\x74\x84\xeb\x56\x0d\xb4\xcd\xbc\xa5\xcf\x98\xc3\x1d\xf6\xf4\x13\xbc\xa0\xf3\x0e\xfb\xf0\x81\x17\x35\xc8\x19\xf5\x5e\x1e\x7d\x44\x0c\x98\x2e\x77\xee\xb2\x1f\x67\xe9\xbe\x98\xd5\x6c\x08\xbb\xe0\xdb\x08\x86\x12\x38\x52\x0c\x02\xc3\xc3\xda\xc4\x07\xdf\x10\x10\xd1\x81\x2e\xd3\x41\x76\x21\x2e\xfb\x31\xa5\x76\x7b\x5e\x36\x38\x10\xc6\x9e\x79\x4c\x2c\x25\x53\xd2\x43\xf4\x34\xde\x7e\xe1\x2b\x1a\x71\x12\x64\xa0\x9c\x51\x10\x3d\xa0\x5d\x65\xcf\x3c\x34\x64\x34\xe9\xc7\x98\x68\xd7\x5e\xdf\x47\xc5\xb3\xee\x68\x46\x24\x69\x7d\x73\x28\xd9\x8f\x69\x99\x78\xda\x73\xe6\xf5\xa1\x3b\x33\x32\x85\x19\x90\xb3\xc0\xef\xfc\x30\x3e\x9e\xe0\x72\x20\x92\xfa\x59\xd6\x26\xd7\x06\x60\x27\x0e\x93\x47\xeb\x73\xaf\x12\xe4\x33\x92\xe1\x68\xf6\xc9\x4f\xaa\xaf\xf2\xec\x8a\xaa\x47\xd5\x56\x51\x41\x03\x3a\x9f\xac\x1f\x67\x25\xb3\x4e\x87\xc2\xfd\xa1\xf0\xdd\x29\x8f\x3a\x94\x94\x8c\x07\x94\x9f\x9d\xd5\xc1\x91\xc2\xf7\x56\xd7\x2f\x0f\x8a\x99\x0f\xae\x5d\x73\xaa\x36\x1c\x35\xd0\x80\x36\xb1\x58\x28\xb9\x31\xb9\x10\x1a\x92\x12\xa4\x6b\x80\x22\x8f\x9a\x0d\x43\xeb\x8e\x8f\xcb\xc6\x50\x25\x4d\x42\xbf\x91\x25\xa6\x48\xfe\xf4\xab\x6e\x5d\x47\xe7\x1e\x91\xd9\x3d\xb8\x4e\x77\x44\x04\x1c\x1f\x6d\xb4\x18\xd9\xd7\x70\xd8\x35\xd2\xe1\x6a\x16\x50\xee\xbd\x23\xa8\x63\x55\x4d\x82\xca\x47\x69\x09\x29\xf5\xb2\x58\xaa\x3b\xef\x3d\x53\x37\x69\x1a\xd4\xb5\x18\x4f\x61\x5d\xaa\xb2\x54\xb8\x21\xa8\x9c\x18\xa2\x48\x17\x7f\x79\x19\xbf\xbb\x9a\xb0\xca\x03\xea\x87\xee\x75\x14\xd6\xa7\x7f\xd9\x6b\x7d\x7f\xaf\xa3\x55\x1f\xa4\xd2\xed\xa5\xbe\x94\x5e\x23\x92\xe7\xa1\x80\x62\xea\x5d\xa5\x42\x0f\xbe\xa6\xa3\xb3\x2c\x44\x16\x4e\xac\x5f\x55\xf1\x55\xfa\x0b\xd7\x5e\x39\x88\x97\x28\x16\x92\xf7\xb9\x37\x2a\xb4\xd7\x9d\x57\x7c\x11\xf1\xd5\xdb\xbb\x8a\x80\x3c\x7c\x66\xa3\xd0\x8e\x94\xf5\x1c\x87\x67\x28\x48\x86\x37\x1a\x43\x3f\x88\x41\xeb\xe3\x82\x89\x18\x93\xe7\xc0\x79\x5f\x18\xec\x2f\x1b\xfd\x5f\xc5\xcf\x63\x59\x3e\xc7\x4d\x1b\xb5\x12\x9f\x9f\x50\xeb\xd7\x46\x7c\x56\xfb\xcd\x4b\x41\x73\xfb\x72\x6b\xf4\x72\xd7\x3a\x54\x33\xd4\xaa\xc4\x3d\xb9\x21\xb6\x97\x23\xee\x50\xad\x0d\x20\x0e\xe3\xe5\x48\x78\xc6\xd2\xc0\x9e\xf6\xc0\x22\x13\x03\xe5\x18\x46\x07\xee\xc6\x0e\xd3\x11\x97\xb1\x1c\x3d\x5b\xc2\xdb\xbd\x58\x2f\x7e\xb9\xe8\x04\x6f\x59\x5a\xc6\x5f\x60\x3e\x03\xd0\xda\x1d\x31\x19\x51\x0a\xbb\x57\x36\x0a\x6d\x2d\x6c\xa4\xbf\x8b\x05\xe9\x93\xdc\x83\xbb\x4a\x88\xc6\xce\xa4\x2b\x45\xf3\x45\x15\xe6\x8e\x5d\x16\x71\x12\x37\xb9\x3c\x77\xbb\x45\xdf\x83\x2e\xea\x44\x08\x63\x4e\x2a\xa5\xfe\xcc\xe2\x5f\x98\xf9\x13\x58\xf6\x9e\x3a\xf0\x2c\xfc\x40\xe1\xce\x92\xb6\x40\x80\x6c\xb4\xaf\xde\x88\x04\xd6\x49\x9e\x47\x4a\xcc\xfd\x01\x31\xde\x05\xaf\x1c\x55\x1b\x5d\x4b\xfe\x82\xce\x35\x12\xb1\x8e\xbb\x59\xc2\x01\x0e\x23\x5d\x20\x3e\xbc\xfa\xfd\xdb\x19\x0c\x1a\x71\xcc\xf5\xb9\x50\xbe\x47\x6e\x26\xd9\x46\x95\x23\x08\x3d\x83\x4a\xe7\xe5\x8b\xf5\x02\x9d\xaf\x8c\xcf\xc3\xc9\x6e\x4b\x4e\x61\x63\x08\x2b\x0d\x0c\xfc\xc3\x00\x68\x0d\x58\xb0\xd4\x2a\x18\x4b\x1b\x08\x8f\x4f\x51\x89\xb0\x3a\xf0\x75\x44\x67\xa0\x17\x3d\x34\x8e\x4c\xf6\x3e\x22\xa5\x64\xd5\x56\x9d\x82\x31\x78\x79\x7c\x6e\x68\x7a\x6a\x16\xfe\x33\x3f\x37\x74\x71\x7c\x72\x7c\x6e\x7c\xc8\xaa\xe5\x75\xa1\x79\xf4\x2e\xc6\x2e\xbc\x8f\x11\x17\xf4\xb6\x41\xaf\x1b\xf8\xbe\xc1\x0d\x18\xcd\x4f\xbe\xd5\x04\xdd\xbd\xe6\xb8\x35\x62\x83\xeb\x20\x96\x36\x72\x6e\x7d\x89\x23\x30\x74\x5d\x9e\xed\x92\x47\x05\x53\xba\x29\xad\x92\xeb\x21\x06\xdf\x8c\xef\x4b\x1a\x0c\xb9\xa0\xe7\xa0\xc8\xa7\x15\xf1\x4b\xab\x26\xfe\x29\x82\x40\xb4\x6c\x47\x36\x95\xd0\x6d\x5d\x64\xfb\xe6\x9d\x12\x96\x0e\xf4\x22\xf3\x8c\x8b\x53\x57\x46\x27\xae\x52\xf8\x2f\x15\xb5\xd8\x50\xa8\xc3\x9c\x26\x5b\x5b\xd9\xb4\x4f\x3d\x72\x00\x5b\x17\x7d\xe2\x9a\x2e\xc0\x1e\x0a\xb4\xdc\x83\xb1\x9c\xb8\x3a\x3b\x37\x3a\x39\x39\x7e\xd1\x98\x9e\x9c\xbf\x0c\x1c\x8c\x4d\x5d\xb9\x32\x7a\xf5\xa2\x2e\xff\x89\xab\x44\xb6\xd5\x55\x64\x44\x36\x4d\x17\x2b\x65\xcc\xa2\x0e\xe0\xca\xa4\x03\x93\x31\x9a\x87\xc7\xda\x02\xb9\x13\x62\x8b\x7b\x08\x2a\x02\xf6\x48\xee\xf9\xb4\x05\x73\x19\xd2\x55\xa0\x22\x21\x90\xa0\xae\x82\x08\x74\xe8\x54\x11\xe5\xcb\x98\x77\xcd\x15\x0b\xcb\xfc\x68\xb3\x0c\x0e\x9b\x47\x77\x9a\x7f\x3c\xf6\x42\x64\x37\x85\x50\x6b\x3e\xda\xa1\xf7\xd2\x74\x30\xdc\x69\x0f\x7e\x82\x5c\xfa\xbe\x8c\xd1\xb2\x9f\x2d\x6f\xbb\x06\x15\x30\x23\x67\xa8\x28\x43\x4c\x0f\x17\x37\x0c\x0b\x86\xdd\x81\x15\xd9\x03\xea\x44\xae\x3b\x25\xd6\x6e\x35\x9a\xfb\x7f\x45\xec\xf8\xbb\x5b\xa7\xdf\x1e\x51\x89\x1b\x6e\x04\x21\x66\x8e\x1b\x20\xa2\xc8\x3a\x7f\xf8\x1d\x15\x45\x69\xc7\x97\xcf\xc0\xe9\x98\x87\x4d\x58\x86\x2d\x52\x34\x57\x5c\x90\x95\x6f\xe5\xad\x4a\xcd\xc8\x2d\x9f\xc7\xf2\x27\xc8\xf1\x92\xa8\x0f\x03\x7b\x6f\x7d\x15\x43\xcf\xb9\x6c\xaf\x51\xaa\x17\x6b\x76\xa5\x68\x71\x28\x20\xfb\x67\x83\x6b\x5b\x77\x10\xa6\x1d\x95\x30\xa2\x92\xb8\x88\xdd\x3d\x84\xed\x26\x8b\x02\x73\x99\x60\x11\xa1\x7d\xfa\xe8\xaf\xad\xcf\x8e\xfc\x9a\x5c\x7e\x76\xe2\x60\x6e\x19\x13\xcd\x5b\xf7\x4e\xce\x73\xf1\xe2\x77\xb3\x95\x68\x6d\x1b\xbb\xd7\xc6\x47\x27\xe7\x5e\x5b\x1c\x7b\x6d\x7c\xec\xf5\xc5\xb9\x37\xa6\xc7\x61\x3c\x5c\x1a\xac\x85\x73\x88\xd0\xb9\x70\x0e\x57\xcc\xc2\xb9\xb2\x53\xb6\x16\xce\x2d\xc0\xac\x74\xbd\x48\xda\xba\xc4\x07\xbd\xde\x44\x01\x20\xd9\x23\x05\xc0\x1e\xb7\x76\x9e\x1a\x7e\x02\x83\xa0\x22\x1d\x83\x57\x1d\x7f\x1b\xc8\x63\xac\xa7\x2b\x5d\x62\x35\xb4\x67\x78\x64\x58\xc2\x3a\x2a\x49\x31\x86\x27\x32\x02\xd8\xb4\xb5\x3f\x23\x01\x31\x06\x60\x95\x53\xa1\x68\x8c\x89\xf4\xff\xa0\x98\xae\x01\xd4\x03\x25\x19\x6e\xcf\x06\x09\xf7\x79\x6c\xb7\x51\x88\x17\x19\xc6\x2e\x86\xb7\x67\xca\xd1\x00\xc1\x13\xf4\x82\x0f\xe9\xc6\xf4\xe2\xc6\xfb\xc9\x47\x7b\x67\xbd\x9a\x8f\xd1\xe9\x69\x63\x76\x7c\xe6\xda\xc4\xd8\xf8\x22\xa9\x25\x57\xc7\xc6\xfb\xc7\x48\x54\x6f\x3d\xe4\x84\x6b\xff\xe1\x31\x23\x34\xc3\x7e\x32\x42\x9d\x61\xf5\x3e\xee\xab\x57\x0b\x2b\xc0\x46\xbb\xe4\x7f\x26\x1c\x45\x48\xff\x3e\x30\xf7\x4c\x97\x9d\xc7\x5b\xff\x97\x9f\xcf\x45\xcf\x19\x88\x9a\x87\x5e\x10\xda\x97\xd1\xee\xd5\xa2\x79\x75\x7e\x62\xf2\xe2\xf4\x28\x2c\x45\x6c\x75\xc8\xb8\x3a\xfe\x8b\xc5\xe0\x77\xfd\x5b\x39\xc1\x7e\x70\xfd\xb4\xf7\xde\x2b\x3e\xa5\xcc\xea\x62\x6b\x74\xda\x25\x81\x70\xa5\x58\x0c\x59\xdb\x9f\x1c\x7d\x75\x7c\x72\xc8\x98\x9e\x99\xba\x36\x71\x71\x7c\x86\x78\x9b\x9b\x7a\x7d\xbc\x8f\x92\x39\xd4\xe5\x10\xf7\xd7\xab\x39\x6a\x63\xe8\x19\xb1\xd1\x2b\x29\x35\x35\x73\x39\x70\x3e\xf6\x85\x76\xe8\x04\xfd\xf1\xbd\x3d\x17\xc3\x94\xf7\x6b\xe0\xfb\x45\xbc\x10\x5e\xff\x38\x3f\x35\x37\xda\x57\xea\x3d\x49\x45\x5d\xf5\x6a\xe1\xcc\x8c\x4f\x4f\xf9\x47\xf7\xfc\xcc\x64\xbf\x44\xd2\xec\xf8\xd8\xfc\xcc\xc4\xdc\x1b\x8b\x97\x67\xa6\xe6\xa7\xa9\xb7\xe9\x51\x50\x46\xe6\xa6\x16\x11\x8a\x60\x71\x66\x7e\x72\x7c\x76\xf1\xd2\xc4\x64\x1f\xa5\x7e\x90\x06\x1c\x4b\x0d\x09\xbd\x5a\x1f\xc1\x0e\x87\xbc\xc5\x3e\x3b\x3d\xda\x4f\xbd\x28\xa2\xdb\x21\xee\xb3\x57\xcb\x46\x1e\x64\xaf\xce\x80\x14\x9e\xe1\xb3\x3b\xf8\x5d\x3f\xb9\x4b\xea\xbb\x5f\x5c\xce\xc3\x17\xbc\xdd\xa7\x47\x67\x67\x7f\x31\x35\x73\x71\x28\xcb\x96\xe9\x9e\x55\x0d\x01\xbd\x5b\xae\x21\xf5\x44\x7e\xf1\xfa\xf8\x1b\xfd\x67\x32\xaa\xd7\x5e\xcf\xa4\xaf\x78\xc1\x2e\x54\x17\x4e\xff\x2f\x2b\xe1\x9e\xf0\x34\x8a\xa2\xa0\xaf\x2c\x3f\x97\x09\x45\x4e\xfb\x31\xa7\x53\xf3\x33\x63\xe3\x39\xb4\x3d\xcc\x8d\xce\x5c\x1e\x9f\xa3\x3f\xfb\xc7\x55\x54\x77\x3d\xdb\x79\x7c\x20\x3c\x03\x3d\x88\x7a\xea\xbd\x26\xe4\x33\xd0\x67\x4d\xc8\xa3\xbf\xa7\x6a\x10\xb5\x9a\xf3\x4d\x18\xf4\x91\x7a\xc8\xf5\xf7\x22\xea\x77\x4c\x46\x8c\x50\xbf\x3d\x9d\x1d\x56\xf3\x48\xe4\xf8\x1f\xfb\xcb\x58\x54\x97\x7d\xe0\xa9\x5f\x16\x8f\xde\x13\xed\x1f\xe0\xa4\x93\xcd\x4c\xf5\x53\xdd\x8d\xe8\xac\x4f\x7c\xd0\x40\x3d\x63\x76\x94\x3e\x7b\xc5\x55\x3a\x63\x49\xe7\x6e\xaa\xae\x68\xab\x54\x38\xa2\xa6\x5f\x8b\x1d\x01\x4f\x24\x12\x78\x8f\x86\xb3\x52\x59\x44\x92\x87\x44\xbc\xca\x62\x98\xfe\xde\xae\x8f\xc8\xee\x7a\xc6\x4b\xcf\x49\xee\xd5\xc2\xf0\x30\x67\x04\xf3\x04\xeb\x86\x87\x58\x45\x40\xf2\xf7\x6f\xc4\xc3\x5d\x33\xce\xdb\x90\xc0\xf3\xee\x15\x83\xab\x8e\x5b\x23\x86\x44\x61\xd6\xbe\xb1\xe3\x85\x6e\xa1\x7a\xa1\x80\xde\xf4\x66\x05\x39\xc5\x82\xb2\x89\x81\x9d\xb2\xb5\x1e\xb9\xab\x7b\xcb\x14\x3a\xf1\x0f\x1a\xca\xee\x46\x3d\xa3\x75\x63\xab\x0f\xfb\x1d\x39\xc4\x00\x47\x5e\x0c\xc8\x9e\xfc\xd4\x7f\xf6\x04\xb2\x33\xf1\x33\xc4\xfc\xa9\x5f\xf5\x8c\xc5\xea\xca\xb3\x14\x69\x91\xdd\xf5\x8a\x17\x91\x4f\x30\x14\x48\x05\x19\x6a\x07\xa3\xe8\xdf\xdc\xf9\x39\x98\xe1\x04\x91\x21\x0d\x46\x45\xaf\x64\x0a\x87\x97\xf7\xf7\x3c\xa5\x58\xe8\x1e\xaf\xbf\xb5\x97\xa5\xbd\x00\xff\xf4\xdc\x15\xf8\xf7\xe4\xe8\x55\x63\xed\x15\xff\xe7\x57\xf8\xab\xbe\xcd\x5e\x66\x52\xba\x1a\x03\x1d\x26\x60\x2c\xdd\x1a\x80\x40\xbf\x69\x89\x2f\x5c\x32\x6b\x23\x7e\xdd\x1f\x34\x06\x23\xae\x2a\x96\x25\x5a\xa8\xc1\xff\x97\xaf\x99\x45\xbb\x20\x9e\x66\x28\x55\xb3\x54\xa1\x82\x7e\x6f\x2e\x94\xa1\x75\xfc\x8f\x81\x71\x54\x55\xa7\xe6\xe4\x9d\xe2\x02\x74\xb3\x70\xae\x96\xaf\x2c\x9c\x1b\x92\xbf\x15\xa8\x24\x19\x11\xce\x3f\xbf\xfc\xd2\xf0\x2b\x3f\xfb\xd9\xf0\xcb\xc3\x2f\xff\x77\xe5\x31\x0c\xc5\x72\xf9\x81\x9f\xfe\xf4\xa5\xbf\x5f\x38\x87\x3f\x00\x21\xbf\xcc\x30\x00\x84\xed\x7b\xb6\xbb\xd3\xba\xb5\x3f\x22\x02\xdf\x34\x8c\xc9\xb7\x4f\xc4\x3b\xa2\x2a\xef\xee\xd6\xb3\x65\x4d\x33\x4d\x8c\x3c\x3a\x36\x39\x21\x00\x53\x32\xba\x22\xe8\x75\xa5\xfc\x2d\x8c\xc0\x34\xfd\xc5\x25\x2a\x63\xa3\xec\xd5\x07\x83\xd1\xb9\x1c\xb4\x1b\x1b\x3d\x2f\xe1\x73\x74\x53\xa6\x08\xb4\xf8\x06\x8c\x2b\x56\xc9\xa9\x6e\xa4\x68\x07\xa3\xdc\x11\xae\xe6\xcb\xc3\x84\x16\x65\x88\xa1\x69\x94\x9d\x72\xae\x6c\xad\x40\x73\x6b\x96\xac\xd4\x94\xa2\x27\x4a\x1d\xd8\xdf\x16\x1a\x6c\x6b\xa7\xd1\xbc\xb5\x2d\xca\x27\xb5\xee\x1e\x72\xb4\xa0\x36\xe8\x77\x8d\x36\x12\xad\xb5\xa8\x62\x8d\xda\x38\x69\xb5\x54\xa3\x6e\xc1\x73\xf0\x71\x7c\xcf\x33\x02\xb1\x1d\xff\x8d\xc1\x35\x8f\x90\x29\x04\xc5\xae\xbc\x1a\xdb\xcd\xec\xec\xa4\x31\x66\x55\x19\x43\x18\xe3\x08\xb1\x76\x11\x45\x14\xce\xd9\x95\x2b\x96\x1b\x1b\x56\x28\x9f\xe7\x62\x5e\xed\xa4\x60\xe3\x9c\x81\x0b\xc3\xd1\xde\x68\x2c\x61\x5c\x9c\xa9\x97\x43\xaf\x94\x6b\x4a\x31\xfe\x69\x0a\x63\x46\x8d\xbe\x9a\x70\x3c\xa2\x01\x39\x92\x7d\x10\x9a\xed\x4a\x5d\x80\x0b\x83\xdc\x5a\xb3\x0b\x22\x7d\x22\x97\xa7\x18\xe5\x61\x63\xba\x68\x99\xc0\xbf\xf8\x11\x36\x83\xb2\x30\x9d\xa5\x5f\xe3\xd9\x40\x35\x80\x89\x5a\x99\xd0\x02\x0d\xd7\x40\x09\x23\xe8\xd2\xf6\x17\x74\xc2\x04\xfa\xf4\x42\x88\x75\x53\x7a\xfa\xe4\x10\x31\xe9\x11\x9e\xf9\x60\xef\xf4\xf1\x13\x8e\xdd\x56\x50\xb5\x43\x72\x1a\x33\x78\x4e\xb6\x5b\x07\xfb\x54\x50\x92\xa3\x76\x63\x1e\x21\x10\x61\x0a\xc6\x97\x30\xd4\x02\x93\x70\x57\x5c\xd9\x38\x9e\x19\x7b\x4e\x01\xc1\x2d\xc7\xd9\x2f\xae\x8b\xf9\x6e\x88\x62\xc5\xf9\x60\x03\x46\x4e\x4a\x5c\x7a\xa4\xe0\x80\xe2\x82\x51\xe0\x04\x40\xae\x19\xa5\x50\x13\x71\x0b\xce\xab\xce\x9b\x0b\xa5\x4d\xc8\x1f\x48\x2e\xc5\x94\x2f\xf3\x18\xb0\xdd\xeb\x9c\xb7\x49\xa7\xe3\x45\xf8\x28\xd2\x41\xb3\xd6\x41\x88\xa0\xf2\xce\x1d\x94\x98\xef\x1e\xfa\xa9\x9c\x69\x3b\xe9\x92\xe6\x7e\x91\x99\x44\x19\x23\x4f\xe6\x08\x79\x32\x47\xc8\x93\x15\xb3\x6a\x96\xa8\x39\xfe\x6d\x0c\x7f\xe2\xb2\x43\x19\x48\x6c\x6f\xb7\xf9\x10\xee\x01\x7b\x8c\xbb\xaa\x69\x3e\x96\x52\xef\x66\x93\x77\xea\x65\xae\x54\x2a\x8f\x47\x77\x0c\xbf\x42\xa6\x27\x02\x0f\x29\xc7\x26\x9b\x55\x92\x8f\x4c\x8d\x18\xf3\x0e\x6c\x60\x41\xd2\xdf\xde\x7b\xc4\x93\xb4\xc7\x3f\xfd\x58\x40\x4c\xaa\xa7\x6d\x52\xc4\x60\x88\xeb\x12\xe9\x14\x46\xd1\x2e\xd9\xcc\x3c\x2b\x19\x93\xf8\xb9\xc3\x65\x14\xad\x89\x00\x69\x20\x52\x1a\xb1\x7d\xa4\x22\x39\x30\x48\x81\xc9\xe9\xf9\xb4\xb4\x75\xd5\xa6\xfa\xf4\x60\x0a\x92\xf9\x29\x22\x0a\x49\x6d\xd5\x2c\xab\x4f\x8a\xd5\xd1\x2f\xce\xda\x7b\x32\x9a\x7f\x3e\x69\x3e\xdc\x8e\xca\x03\x89\x67\x94\x6e\x4a\x49\xe9\x9e\x5a\x45\xce\x13\xe4\x34\xd0\x9f\xdf\x86\xb3\x33\xb6\x08\xb8\xec\x55\x26\x0e\x0d\x1b\x7e\x81\x40\xf8\x52\x5f\x05\xb3\xbd\xff\x2b\x5e\x13\xcd\x87\x5c\x0e\x3c\x6d\xe1\x37\x8f\x88\x88\xdd\xd5\xcd\xd6\xd2\xed\xa6\x8c\x5b\xa9\x0f\x9b\xbe\x77\xfb\x5c\x43\x5c\x4f\xce\x61\x3d\x91\x1d\x9e\xc0\x2a\x2e\xa4\xb1\x52\xb7\x0b\xd4\xe4\x65\xf8\x23\x73\xa2\x10\x37\x88\x55\x0a\xa8\x26\x84\x77\x5c\xce\xf1\x37\x9d\x0a\x63\xb5\x18\x6a\xdb\x59\x19\xd5\x76\x2c\x79\x3e\xe4\x34\xea\x68\xc1\xda\x83\x03\x8c\x42\x48\x65\x17\xaf\x99\xc5\x54\x75\x9c\xff\x47\x7b\x2b\x5a\xb5\xf8\xe8\xdf\x62\x3b\xd0\xd1\x6d\xd7\xd8\xc2\x0e\x02\x01\xee\x44\x9c\x7d\x3f\x44\xdf\x58\x5c\xbb\x69\x59\x14\xdc\x61\x9c\x71\x51\x0f\x87\x30\x06\xf4\x06\x32\x2f\xed\xbf\x75\xbc\x85\x10\xda\xf7\x80\xbe\xe3\x4d\x58\x59\x43\x4a\xa5\x9b\x36\xa4\x64\x51\xe2\x90\xdf\x26\xdb\xc1\xc1\x8e\xde\xe4\xa5\xa1\xdc\xb5\x8a\x78\x23\xc1\x1f\xf2\x70\x26\xac\xb0\xa9\x56\xb0\x84\x25\x47\xdd\x8a\xc5\x15\x3d\x68\x0b\xb9\x1d\x31\x21\x91\x79\x1a\x07\x67\x37\xf6\xd1\x49\x00\x8b\x06\x6e\x07\x43\x54\x24\xf1\xbb\x3d\xb1\x7f\x12\x58\x98\x34\xe1\xfc\x9a\x82\xb9\xe5\x2e\xa3\xa9\xc0\xa2\x12\x0f\x37\x9b\x0f\x3f\x20\x1b\xfd\xfd\x8f\x35\x4d\x61\x51\x4f\xb4\xff\xc8\x32\x11\x7e\x65\x5d\x9e\x2a\x5d\xeb\x0c\x6f\xae\xcc\x84\x40\xf1\xc5\x8a\x29\xef\xc1\x91\x7d\x9c\xd4\xdf\x9a\x69\x17\x69\x99\x88\x5b\x4c\x9e\x73\x5c\x75\x15\x43\xc4\xdc\xc2\xad\x03\x66\x9a\x0a\xb6\x73\x87\x11\x39\xdd\x9d\x11\x40\xdc\x73\x26\x3c\x66\xd0\x2a\x78\xc1\xb0\x7a\xd1\x21\x86\xef\x14\x0a\xea\x4f\xb6\xb6\x98\x54\x42\xdf\x7e\x05\x8b\x78\x4c\x64\xbf\x86\x45\x2a\x96\x10\x06\x3a\xbe\x41\xe1\xae\x49\xd5\x9a\x40\x6a\x15\x6b\x22\xcf\x80\x18\x02\x23\x44\x64\xe9\xcb\x2f\x55\xd4\x3a\x2d\x62\x43\xa3\x75\xff\x50\x22\xef\x88\xdb\xb4\xfc\x92\x71\x34\xfc\x55\xe4\x57\x16\x4c\x45\x69\x08\x4e\x35\x61\x4c\x03\x70\xa9\x29\xdb\x0f\x3a\x6b\x7a\xb2\x51\xa2\xd1\xc1\xd3\xd1\xe3\x21\x0f\x99\x04\x76\xa2\xdb\x32\xe1\x61\x95\x83\x9f\xaa\x0f\x46\xc5\x19\x34\x85\x17\xc7\xc6\xfa\xb9\x95\x2a\xd7\x5f\xe7\xac\x71\xc3\xdd\x70\x6b\x56\x69\x48\x40\x97\x90\xc5\x06\xe8\x61\xb9\x84\xc0\x3a\xe2\x67\xd0\xb0\x6b\x98\xa3\x6e\x54\xeb\x54\x83\x47\x8b\xa8\x21\xc9\x64\x9f\x0e\x93\x39\x28\xd1\x6e\x36\x65\x22\x39\xd7\x5e\xf2\x52\xc2\xa9\xba\x99\xd1\xfa\xec\x18\xb8\x33\x5a\x8f\x8e\xe1\x60\x46\x43\x0b\x5a\xcc\xbe\xf8\x33\xc1\xe8\x83\xe4\x38\x68\x88\xbd\x44\x30\x10\xc2\xfe\x7e\x6b\x0f\xdb\xbe\xb9\xa7\x81\x0a\xf1\x86\x82\xca\xf2\xd3\xce\x17\xa2\x2a\x85\x00\x68\x7d\x77\x07\x45\xd5\xed\x68\x39\xe5\x21\x8d\xa7\x9b\x0b\x0f\x10\x43\x1c\xa5\xfe\x12\x70\x96\x3b\xd9\x83\x7e\xcd\x19\x75\x5d\x28\xe7\x69\x67\xdb\xd0\xc3\xdf\x21\x2c\x8b\x0c\xcb\xd2\x3b\x2f\x93\xbb\xf1\x84\xb6\xb3\xbc\x6c\x51\x1d\x6a\xd9\xa1\x82\x51\x17\x73\x22\xb6\x95\x59\x32\xda\x0e\x96\xd6\xee\x83\xb3\xdf\x3d\x6d\xa6\x12\x93\x1e\x39\x2c\x16\x65\x4d\x4c\x81\x53\x96\xf6\x28\x13\xfb\x12\x4b\x28\x7f\x7e\x5b\x41\x4e\xcb\xd0\x7f\x1d\xed\xd2\x59\xbb\xe5\x2f\x32\xf4\xa7\x94\x45\x52\xc4\x9f\x7e\xaa\xa5\xf0\xf3\x67\xdc\xab\x8c\x9c\xd8\x97\x57\xb7\xc1\x6c\x93\xbf\x31\x56\xf4\x76\x91\x2a\xea\x2a\x24\x77\x18\x80\xa2\xd7\x31\x14\x2e\xbc\x9b\xd8\x6a\x18\xea\x5b\x0c\x9d\x28\x61\x1f\xfe\x95\xaa\xb0\xd6\xcb\x65\x51\xb8\xcb\x2b\xbb\xaf\xe3\x98\x44\xa1\x11\x55\x70\x7f\x37\x74\xd0\x89\x32\xf6\x38\x07\xd9\x0e\x40\x1d\x03\x35\x73\x85\xf1\x12\x6b\xb2\x8e\x50\x22\xb5\x91\x64\x92\x0c\x26\xeb\xc7\xc3\x9d\x6e\xa8\x0c\x40\xcb\xba\x0c\x09\xa6\xa5\xa4\x1d\x06\x56\xa8\xdc\x19\x7a\xf2\xa1\x5f\x53\xad\x47\xcf\xb3\x92\xbe\x0b\x81\xdb\x9a\xd8\xbc\x87\xc5\x9a\xd8\x34\xce\x98\x70\xd9\xc2\x71\xc6\xee\x57\x57\xef\xa2\xd5\x41\x27\x51\x2f\xb1\xce\xd9\x49\x2c\x91\x6a\xa0\x2f\x1a\x57\xc7\xba\x59\x2d\x48\xdd\x9a\xd7\xc8\xb0\x31\xb7\x0a\x2a\x05\xfa\x89\x48\x35\x58\xc2\xaa\x9b\xcb\x76\x19\xa8\x2a\x39\x54\x4f\x15\x55\x09\xd8\xeb\x5a\x98\x7e\x2a\x92\x4a\x0e\x17\x44\x01\x3b\x68\x34\x6f\x1d\xd2\x5a\xfa\xd7\x7b\x18\x3f\x71\xec\xbb\x83\x48\x1b\xf8\x18\x56\xd4\xa3\x2d\x0a\x64\x42\x81\x74\xb0\x03\x4b\x4f\x51\x21\x92\xec\x4e\xc0\xce\x75\x5a\xf6\x9e\xe6\x4e\x95\x89\xab\x54\x5b\xcc\xa8\x57\x0a\x66\x4d\xaf\x0a\xdc\xbd\x29\x6c\x6d\x1f\x9e\xf8\x20\x2a\x28\x09\xbf\xd8\x57\x34\xfc\xd6\xfd\x83\xd3\x93\x2d\x5d\xf7\x8c\x6e\x67\x68\xbd\xf3\xca\x19\xfa\xc5\x1e\x4f\x53\x42\x53\x8e\x1e\x69\x2a\xdc\xd6\x4e\xa3\xf5\xf9\x0d\x6d\x73\x2b\x30\x67\x16\xda\x0a\x5c\x5d\xf8\x08\x37\x83\xcb\x08\xfd\x65\x7f\xd4\x95\x94\xc4\xb6\x08\xc0\xa9\x5e\x8b\x29\xcf\xa0\x90\x94\xb0\x02\x57\x56\xaa\xe8\x78\x07\xe1\x04\xf7\xf6\x8a\x63\xa3\x83\x41\x60\x44\x91\x43\x8d\x5d\x98\x71\xe0\x5e\xec\x31\x0c\xa2\x1a\xa9\xed\xb6\xee\xde\xc1\xd9\xfb\xe8\x10\xcb\xea\xa2\x9a\x44\x98\x50\x3a\x7a\x9c\xeb\x84\x52\x58\x21\x13\x0f\xf6\xca\x81\x0f\x03\xed\x05\x6a\x82\x6e\xba\x74\xce\xbc\xb6\x02\x3a\xe1\x5e\x4e\x1f\xc1\x61\xac\xa9\x59\x7a\x05\x0b\x19\x9b\x30\x22\x95\x0d\x59\x44\x55\x68\x32\x79\xa7\x20\x3c\xd8\x58\xeb\x53\x91\xf2\xe4\xb2\x2d\x3b\xb0\x29\xaa\xc3\x86\x31\x5f\x26\x63\xba\xb3\x06\x2b\xc1\x06\x5d\xb9\x3c\xc4\x17\x44\x68\x30\xe7\xb5\xc4\x20\x56\xeb\x36\x15\x07\xe2\x8a\xad\xa4\x5b\xfb\x8d\xea\x66\x9d\xd4\x95\xf6\xe3\x43\x54\xc9\xbc\xf5\x00\x1d\xb2\x11\xbf\xef\x3d\xf5\x62\xae\x61\x58\x50\x10\xff\x15\x27\x8c\x24\xc2\xe3\x27\xb0\xce\x7d\x53\x3b\x15\x6c\x7b\x74\x8c\x3e\x61\xb1\x41\xf1\x7e\x0a\xdd\xaa\x2c\xb0\x7d\x81\xef\x22\xed\x67\x59\x23\x58\x2b\x36\xc9\x8c\x2f\xc6\x1c\x37\x63\xce\xf3\x9f\xb7\xc7\x05\x7a\x2a\x1e\x8c\xf7\xd8\x25\xba\x3f\x69\x06\x09\x7e\xe5\xba\x78\xe4\xd4\xf5\x8d\x50\xe4\x72\xd6\x5c\x38\xc9\x27\x1d\x54\x0c\x77\x85\x68\xe2\xda\xe9\x31\xb4\x93\x3c\xa4\x23\x6a\xc0\x0d\x84\x37\xc2\x3a\x28\x17\x37\x8c\x35\xdb\xb5\x91\x70\x44\x1b\x0c\x68\x8c\xc8\x67\xcc\x95\x59\xd7\xa5\x02\x58\x26\xea\xc5\x43\x3b\x75\x3a\xf0\x97\xeb\x45\xe8\x10\xae\x99\xe9\x50\xfa\x28\x06\x80\xd8\x23\xa1\x44\x5e\x0f\x4d\xbc\x43\xb0\x5b\xdb\x55\xca\x80\x87\x2c\x23\x05\x1b\xa3\xdd\x60\xff\x0e\xc1\x20\x04\x02\x1f\x2c\x1b\x77\x89\xa8\x40\xcb\xf1\x90\x20\x3c\xa4\x23\x25\x2d\xc9\x0d\x69\x2e\x69\xde\xb9\xd3\x3c\xf8\x00\x94\x09\x5c\x7e\x62\xb6\x75\x85\xc2\xfd\xf8\x63\x69\x73\x91\xed\x66\x8a\x46\xb8\x62\x56\xc4\x2d\xd4\x91\xb7\x00\x5c\x8f\x35\x3c\xc3\x63\xaa\xea\xe2\x30\x73\xa5\xc6\xe6\x1f\xbe\x22\x01\xe9\xeb\xff\x0f\xa1\x5f\x8d\x51\xf2\x8a\xf9\x96\xb1\x6e\xda\x35\x2e\x2d\x2c\xab\x54\x7a\x5b\x82\x24\x47\xbd\x82\x76\x07\x10\xe8\xe5\x7a\xcc\xd1\xfb\x64\x0f\xb6\xb5\x18\x04\xc5\xca\x42\x36\x85\x4d\xd2\x34\x6f\xe2\xc6\xa7\xc0\x1a\x32\xe5\x0f\x36\xbf\x6b\x68\xec\x01\xed\x54\xf9\xca\x80\xd0\x86\xd3\x93\xa4\x9c\xfb\xaa\xfe\x9b\x81\x16\xbb\x54\x2f\x19\x66\x89\xfc\xe6\x20\xb2\x85\x77\x87\xd7\x98\x27\xa3\x7d\x27\x3c\xfc\xb0\x6a\xae\x49\x8c\xd5\x97\x5f\x7a\xe5\x67\x57\x86\x8c\x97\x2f\xc3\xff\x5e\xba\xac\xad\xb9\xde\x26\xe4\x82\x37\x2b\x2e\x2e\xef\x2d\x3c\x61\x89\x11\x0c\xfa\x2e\xa1\x77\x0f\x81\x27\x46\x68\x0d\xf7\xfb\x2c\x98\x1b\x36\x72\x2f\xe3\xe9\x0a\x47\x0e\x15\x82\x85\x87\xeb\x65\x32\xe1\xa3\xeb\x92\xfa\xd0\xea\xbf\xfd\x1e\x00\x25\xe6\x37\xf7\x32\x79\xd2\x0e\x8f\xd9\xb3\x24\xde\xa2\xa3\xea\xbd\x5d\x58\xad\xcd\x1b\x37\x13\x8e\x93\x67\x3e\x6a\xc6\xe0\x45\x6b\xd9\xac\x17\x6b\x23\xfe\x6f\xcf\x6d\x2d\x75\x32\x94\x83\xf8\xf5\xe3\x13\xf2\x80\x79\x8f\x9f\x4f\x18\x60\xda\xfe\x83\xe8\x2c\xb0\x40\x83\x2c\xb8\xe7\x49\x16\x60\xfc\x2c\x48\x44\x12\x10\xa1\xfb\x30\x0b\xac\x21\x83\x74\x25\x11\x08\x68\xb8\x78\x30\x08\xa7\xa4\x0b\x67\xc1\x06\xbd\xa1\x0b\x42\x85\xd6\x39\x0e\xb4\x5d\xeb\x38\x16\xea\x06\x68\x2e\xf2\x4e\x41\x42\x44\x04\xa1\x49\x11\xc8\x12\xa5\x75\xbc\xa5\x0e\x94\xd4\x9c\x28\xfc\xd0\x68\x9d\x7c\x11\x70\x6b\x72\xa4\x1c\xe2\x6f\x36\x6f\xa7\xbe\x29\x5d\x51\xbc\xcc\x62\x65\xbd\xf2\x77\x7f\x8f\xf3\x24\xa7\x4b\x6b\xfd\x0d\x39\x91\x79\x96\xdb\x5e\xd6\xf4\x4a\x81\x99\xc2\xef\x1c\x1f\xf9\x89\x07\x10\x8c\xd8\xc3\xcd\xd0\xd3\xd1\x0d\xdb\x2b\x55\x50\x34\x22\x5c\x00\x9e\x4e\x1c\xa8\xf1\xe1\x2b\xc5\x71\x9a\x6c\x28\x0f\x23\xa4\xc7\x86\x7f\x15\x5a\xac\xc6\x61\xf0\x10\x6d\x99\x78\xbd\x62\xa3\xe6\x4d\x4d\xf8\x06\xe6\x74\xea\x8f\x69\xd0\x0f\xf4\xaf\x69\xb3\x02\xe8\x3d\xcd\x65\x0e\x6f\x25\x9d\xf4\x47\xca\x11\xdc\x40\x40\xf6\xac\xd8\x6e\xcd\xaa\x06\x7c\x71\x99\x34\xc6\x84\xb6\x10\x24\xb7\xca\x5a\xac\xef\xf6\x13\x16\x7e\x50\x6b\x8a\x4e\x1e\x35\xcc\x6c\x3d\x5a\xeb\xc6\xb4\x00\x99\xd4\x31\x7f\x63\x8b\x7c\x13\xa0\x6c\x3f\xda\x3a\xdb\xd5\xdc\xd2\xb1\xa1\x72\xcc\x08\xde\xd8\x32\x62\x47\xd1\x31\xfe\xd6\x65\x2d\x55\xd3\xc2\xdf\xba\x20\x6a\x07\x41\x24\x9e\x0f\xeb\x8e\xba\x78\x4e\x68\x73\x74\x7a\xc2\xbf\x4a\xbb\x16\x1c\x00\xf3\xa0\xe5\xe2\x3d\x13\x2e\xc5\x76\x79\xce\xae\xe0\x3d\x53\xc4\x30\xc0\xc3\xe2\x0b\x54\x14\xd9\x52\x0c\x1b\x44\xbe\xaf\x3b\x72\xb1\x8f\xd0\xb5\x9a\x24\x1f\x59\xe7\xfc\xdb\x59\x00\x49\x39\xfc\x02\x49\x7a\x61\x7a\x7e\xb8\x09\xef\xa1\x2c\x3c\x78\xd0\xfc\xfa\xb8\x8d\x58\xa1\x14\x07\x08\xf6\x47\x46\x94\x17\x4f\x54\x8f\x11\xdc\x36\xcf\x97\x62\xb8\x18\x95\xe1\x3e\xfc\x86\x53\xe7\x30\xb3\x82\xed\xd2\xed\x4d\x18\x26\x51\x3e\xc0\xf5\x57\xdc\x92\x96\xdb\x4b\x11\x49\x69\x22\x1d\x3d\x5c\xda\xb7\x4c\xd8\xfe\x65\x03\x84\x11\x0c\xbd\x52\x3f\xcb\x7b\x44\xc0\x41\xe3\x6a\x0e\x14\x92\x81\x1f\xb5\xda\xcd\x17\x47\x22\x81\x14\xe6\xfe\xec\xd3\x0f\x74\xa3\x1b\xf0\x1d\x07\xae\x97\x22\x58\x3f\xa6\x26\x91\xe2\xfd\x22\x39\xe7\xd5\xb6\x56\xcb\x6f\xc9\xb8\x8d\x9d\xad\xb3\x9d\xaf\x3c\x71\xf7\x80\x26\x0e\x4e\xef\xcf\x1b\x51\xb5\x71\xc8\x96\x77\xef\x44\x75\x63\x79\x6e\x86\x40\xeb\xcd\xef\x36\x5b\x77\xe1\xa6\x9f\x2a\xb6\x2e\xd3\x4c\x8a\xc1\x9e\x86\xc9\x14\xa4\xd1\x19\xf0\x9f\x60\x5a\x83\x5c\xff\xa0\x66\xb7\x62\x6b\x64\x98\xb4\xa3\x61\x41\x84\xa0\xac\xea\xb3\xa8\x92\x83\xa1\xca\x28\x19\xb3\xd5\x91\x28\x82\xcb\x32\x5a\x2b\x5c\xdf\x4e\x41\x41\x65\x6c\x07\xcc\x76\xa0\x39\x02\x34\x3e\xe6\x28\x91\x6e\xf9\xd4\xc7\x88\x1f\xfd\x12\xdb\xae\x77\x45\xce\xd6\x3a\xc7\x6e\xb9\xc6\xba\x45\x15\x1c\x0a\x5a\x6f\x30\x05\x5e\x91\x0d\xf0\x1b\xd2\x74\xe3\x9b\x95\xae\xcf\x58\x8a\xfd\x6c\xf6\x2c\x14\x93\x13\xc1\xf5\xec\x1c\x78\x14\x55\x44\x9d\x61\x7d\xf2\x92\xf7\x08\xf9\xd0\x40\x17\x78\xf4\x40\xae\xbf\xf8\xde\xb8\x7c\x80\xa7\xf1\x10\x32\x7b\xdb\x98\x69\xed\xb0\xd2\xa9\x42\x1d\xd1\xd9\xaa\x15\x2f\x11\xe3\x9b\x70\x77\x00\x4a\x30\x97\x9d\xe2\xed\xc8\x9f\x2e\xcd\x85\x43\x68\x25\xa5\x45\x2c\x2a\x21\xb4\xa9\x15\x81\xf7\x12\xbc\xd1\x82\x6c\x59\xef\x9e\x52\xf5\x45\xe1\xa1\xe3\xb0\xf9\xcc\x7b\x82\x5f\x26\x23\xaf\x5e\xb3\xf0\xa9\xeb\x68\xe3\x22\x13\x58\x7e\x46\xc7\xfb\x25\x2e\x3e\xe4\xf7\x92\x8d\x51\x3f\x87\x29\x9a\xd9\xe8\x3e\x3a\xe6\xa4\xf7\x0c\x3c\x0f\x92\xf5\xeb\x4d\xeb\xa1\x4a\x4b\xbc\xfc\xbe\xcf\x4b\x2a\x41\x7a\x7b\x44\xa4\x17\x58\xc1\xa2\xfd\xb1\x12\x31\xa2\x1a\x7f\xc6\x7e\x52\x75\x20\x0e\xd2\xf4\x2d\x8b\x18\x0b\xab\xbc\x66\xac\x99\x55\x1b\x15\x3b\x97\xad\x61\x4b\x16\x46\x29\x5b\x5a\xe7\x28\x87\x5c\x9c\xdd\xdb\x05\xe9\x66\x70\xc8\x77\xe4\xa9\x9f\xa2\xf7\x70\x68\x45\x62\xaf\x81\xa0\x08\x5a\x50\x19\x7a\x75\x91\x3b\x4a\xb6\x5c\x35\xdd\x24\x36\xf5\xad\xa4\x8b\xb5\x0c\xc6\x9e\xc4\x4f\x46\xb8\x4c\x6d\xec\x72\x8d\x2e\x40\x9b\x7e\xe6\x65\x67\xd7\xad\x8d\x40\x11\x56\xcf\x2c\xea\x2b\xbe\x32\x4f\x27\xf6\x28\xd6\x98\x65\x74\xad\x84\xea\xb4\xbe\xf7\x20\xc5\x89\xad\x92\xec\xb7\xfb\xba\x25\x02\xfb\x85\x96\xf7\x22\x30\x13\x45\x5e\x07\x76\x06\xc9\x86\x1f\xe3\x97\x6e\x49\x78\x91\x7b\xd9\xc4\x8c\x5f\xeb\x36\x4d\x2f\x19\x97\x5b\xef\xcf\xf2\xfe\x9f\xde\xd9\x94\xaf\x8c\x3a\x97\x4e\xd3\xf2\xea\x98\xf6\xef\x30\x14\x41\xb3\xa6\xeb\xda\x2b\x65\xad\x69\x4f\xa1\x30\xac\xe0\x26\x4d\x74\xc2\x12\xf2\x58\xcc\xb0\x7e\x44\x98\x5d\x07\x07\x95\xea\x57\xec\xea\xb8\xf2\x43\xfd\x54\xd1\x9f\xb6\xeb\xee\xce\x2c\x0a\x21\xf7\xc3\x23\x3a\x39\xaf\x45\x94\xb7\x8c\x83\xe8\x6a\x28\x28\x58\x43\x06\xaa\x75\x40\x8c\x12\x94\xb1\x43\x81\xa9\x5d\x10\x53\x33\x8a\x1c\x7c\x65\x97\x7d\x23\xc6\xd8\x25\xb2\x6e\x06\x77\x2a\x3c\x87\x0f\xc5\x47\x54\xed\x9f\x68\x6f\x72\xf2\x81\xd0\x66\x0c\x77\xd5\xc9\x9e\xac\x59\x23\x1c\x45\x80\x1e\x30\x34\xb9\x19\xae\x53\x62\xc7\x98\x6e\x0c\x8f\x4e\x4e\x1f\x1f\x8c\x18\x32\x86\xe3\xee\xcd\xd6\x5d\xba\xd6\x60\xf0\xcd\xfb\xdb\x86\xef\xbb\x3a\xfd\xf6\xa4\xf9\xe5\x71\x5a\xc7\xd5\xd5\x7a\x69\x09\xc3\xe2\x96\x7d\x1f\x4f\x1a\x44\x18\x68\x3d\xba\xbd\xa9\xd7\x75\x77\xe8\x7b\x3b\xda\xe8\xbc\xa9\xe9\xb9\x89\xa9\xab\xda\x4a\x96\xbb\x4f\xb4\xfe\x1d\x04\xbd\x1f\xbd\x78\x65\xe2\x6a\xac\x9e\x2f\xf2\xd0\x62\x9a\x98\xbf\x38\x31\x37\x35\x93\xd0\xc8\xd1\x6d\x9c\xe2\xfb\xb7\xf5\xed\x5c\x19\xbd\x3a\x7a\x79\x3c\xa9\x1d\x22\x26\xae\x1d\xed\x48\x50\x03\x9a\xd7\x12\x32\x0f\xb4\x6f\x89\x44\x15\xc6\x1f\x71\xd5\x08\x77\xc5\x99\x9b\x70\xce\x45\x3b\x68\x85\x37\x3b\xa1\xfb\x80\x19\xd4\x2c\x62\x45\xdf\x0d\x86\xf3\xd0\xad\xc4\x08\xc3\x29\xf5\xb7\x7f\xdc\xfc\xf3\x09\xfb\xd3\x35\xe2\xa3\xad\xbf\x20\x7e\x08\xe5\xbc\xf1\x67\xb6\x4a\x63\x20\x57\x46\x22\xee\xbe\x2f\xcb\x62\xe2\xa7\x76\xeb\xad\x5a\xd4\xb1\x43\x32\x63\xa0\xa5\x34\x24\x25\x49\x01\x78\x4d\xeb\xee\xa4\x76\x34\xee\xce\xa9\xe4\xec\x9b\xd8\xe9\xe7\xb8\x49\xcb\x03\xc3\x29\x70\x60\x85\x8c\x51\xf5\x62\xcb\x74\x81\xaa\x1e\xc0\x0c\x47\x34\x08\xac\x9b\x40\xa8\x18\x55\x23\xa5\x20\xc7\x8c\x34\x78\x09\x9a\x9d\x91\x12\x08\x1d\xef\x86\x2e\x19\x33\x0a\x22\x3a\x14\x36\x4a\xa1\x78\xbc\x55\xe1\x50\xb6\xab\x4e\x99\xea\x4c\x9a\xcb\x68\xa6\x08\xc5\xa0\x56\x8a\x96\x3e\x3a\x4b\x7d\xb6\x75\xaf\xd1\xfc\xc3\x36\x39\x28\xc4\xee\xe6\xd3\x5a\xba\x4a\xa2\x93\x2e\xd4\x08\xd0\x58\xb6\xa6\x4d\xbb\x10\x8c\x9a\xd4\xad\x9b\xbd\x03\xa4\x23\x1c\x16\xa0\x6b\xd5\x75\x39\xc7\x1d\xb8\xac\xa2\xae\xcb\x68\x0f\x30\x9d\x1c\x32\x89\xde\x70\xdf\xf8\xe1\x0d\x95\xd4\x63\x58\xb7\xd3\x26\x50\xf9\x69\xee\x38\xc1\xd8\xb2\x74\xe8\x50\x00\x3e\x1e\xf9\x77\x0f\x8d\x28\x1b\x89\x67\x0b\x88\x89\x2a\x4d\x43\xbc\xa2\x10\xf7\x89\x78\xad\xde\x9c\x96\x85\x18\xef\x7f\xb2\xe7\x5f\x36\x60\xc0\xaa\xf7\xb2\x25\x7c\xb1\x57\x32\x6b\xf9\xd5\x14\x8d\x53\xb4\xf7\x97\xfb\x7c\x1a\x3c\x6d\x7d\xbf\xab\x94\x6f\xd5\x09\x5b\x74\x10\x85\x0a\x70\x47\x77\x34\x06\x47\xa4\xf5\x56\x8d\x05\x05\xf9\x46\x65\xf1\x7a\x38\x3f\x31\xf4\xb5\x46\x81\x31\xf9\x55\x98\xca\x3c\x6e\x41\xae\x5b\xcf\x90\x5e\xf0\x3b\xa5\x8a\x7a\x69\x21\x45\xd3\x5d\x35\x06\x2f\x9c\x1f\x36\xe6\xaa\xa6\x4d\x50\x82\xf4\x1d\xfa\x23\x30\x54\x7c\x09\x23\x3e\xab\x76\xa5\x82\x57\xd1\xa5\x7a\x4d\x96\xc6\x77\xe1\x8f\xbc\x65\xaf\x61\xb9\x63\xac\x67\x6e\x1a\xb5\xc0\xfb\xfc\x36\x0d\x98\x46\xd8\x4f\x4b\xe4\xb1\x4a\xc5\x17\x6b\x94\xdb\x8c\x68\x64\xbf\xb5\xd9\x8d\x26\xe5\x0d\x2a\x06\xe4\xa8\xf1\xe5\x4f\xa2\x30\xa4\x74\x78\x45\xd6\x79\x26\xf8\xf0\xf7\xad\x7f\xff\xea\xec\xe6\xed\xd6\xc9\x01\x0a\x11\xec\xd9\xcb\x39\xf0\x30\x0e\x48\xae\xc6\x33\x12\x60\x42\xd2\xaf\x5b\x2d\x11\x64\x29\x1d\x7b\xa8\x65\xf1\x3d\xa6\x0c\x62\x4e\xd5\x5c\xe6\xaa\xf1\x9a\xb6\xac\x2a\x82\x8d\xa2\xac\xb0\x51\xda\x1b\x04\x6a\xc5\x07\x1a\x2c\xc6\x12\xd6\xd0\x5e\x5f\xb5\x38\x24\x5b\xd4\xbb\x17\x31\xdc\x45\xa9\x6f\x89\x22\xe2\xba\xa1\xbb\xf5\x55\x6b\x6b\x8f\xb6\xd8\x7b\x87\x64\x0f\x22\x47\xbb\x10\x20\x9e\x49\x9a\x60\x74\x45\xca\x2d\x69\x80\xb4\x01\xef\x1e\x36\xbf\xdb\x24\xac\xb8\xed\xdb\xcd\xc7\x0d\xcf\x65\xad\x61\x06\x03\x0a\x42\xba\x99\xdc\xa2\xba\x20\x03\xbd\x52\x14\xe3\xd1\x17\x3e\xfc\x04\x47\x28\x91\xe3\x37\xa4\xc4\x00\xf8\x35\xc8\xe3\x4c\x20\x91\xaf\xca\xae\x53\xdb\x45\xf4\x54\xa0\x65\xbb\xec\x44\x44\xeb\xe1\x52\xe5\x50\xbe\x0e\x28\xc3\x4d\xd8\x16\x66\x47\xea\xab\x16\x3e\x39\x89\xfc\x91\x48\xfa\xe3\xbc\xae\x7b\x9a\x57\xb4\x5d\xb8\x8a\xea\x6e\x2c\x6d\x60\xfa\x3e\x68\x4f\x76\xbe\x5e\x34\xab\xa9\xb2\xc5\x3f\xfc\x1e\x13\x22\x83\xf1\x21\x6d\xca\x3b\x5f\x6d\x62\x55\x12\x4e\x86\xc8\xaf\x3a\x8e\xeb\xe7\x42\xe0\x81\x80\xbb\x0c\xa3\x6a\xf0\xef\x61\xe3\x55\x07\x8f\x1f\xf2\x4e\x9b\x55\x8b\xd6\x7b\x05\xb7\x6b\xad\xc6\x62\x61\x89\x0b\x38\x5b\x5e\xe2\x85\x8b\xf1\x7d\x22\xab\x48\xeb\xb0\xbe\xbb\x85\xc1\x27\x12\x6f\x82\x3f\xa1\x3d\x0a\x63\x51\x70\xa9\x11\x10\x4b\xc0\x54\x41\xc9\x82\xc1\xec\xc1\x3f\x7d\x45\x09\x84\x1f\xdd\x03\xc9\xc8\xf9\xf1\x94\x07\x24\xc6\x44\x68\x0f\x07\x69\x4b\xd4\x8b\x01\x61\xab\x8c\x61\xae\x98\xda\xac\x3e\xa1\x4d\xaa\x06\x98\x24\x93\x4a\x08\x73\x93\xa3\x1b\xd1\x9c\xab\x64\xe1\xa8\x93\xaf\xe2\x6d\xf6\xe9\xc6\x6b\x34\xdf\x3b\xa6\x30\x9d\xdb\x8a\x95\x37\x75\xea\x09\x27\xa9\x1a\x31\xf1\xa4\x41\x68\x85\x98\xb0\x48\xd1\x94\xcd\x09\xb0\x82\x7d\x94\x0f\x98\x0d\x9b\xaa\x71\x81\x4a\xfc\x97\xaf\x5a\xef\x6f\x37\x6f\x6b\x00\x78\x45\x37\x94\xe7\xe3\x81\x1c\x47\xde\x5f\xd3\x33\x14\x6e\x08\xbe\x1d\x04\x39\x73\x3e\x41\xd0\xe8\x09\xc1\xc4\x1d\x61\x62\xa0\x48\xb7\x5e\x90\x22\xcc\x0e\x0c\x0c\x9e\x30\x3a\x18\x87\x4b\x94\x15\x8c\x85\x73\x81\x4c\xc6\x85\x73\x21\xe3\x87\x97\x4f\x85\x7e\x08\x11\x5d\x4d\xaf\x6a\x23\xe0\x3c\x34\xf8\xb6\xa6\x91\x8d\x68\x28\x0e\x92\xda\xbe\xe1\x44\x31\x7f\x8a\xb0\x6c\xd1\x68\x23\xbd\x79\xd3\x63\x95\xf4\x55\xe0\x54\x1c\x4f\x4b\x76\xd9\xc4\xc4\x0c\x2f\xb5\x0f\x4f\xf4\x0d\xb8\x75\x1a\x53\xb3\x23\x5a\xc4\xde\xcf\xee\xb4\x1e\x7d\x13\xce\xc5\xf6\x11\x2c\x10\x3d\x02\xce\xf1\xa9\xd9\x40\x28\x9f\x02\xf7\xf0\x4a\xeb\x61\xa3\xdd\xef\x12\x4b\x79\x78\xd1\x04\xb2\xed\xea\x65\x5b\x66\x92\x27\x42\x7c\x2b\xe7\xa9\x47\xb9\x70\x05\xe0\x7e\x02\x59\xf0\xed\x51\x18\x8e\x37\x13\x65\x6b\xf0\xc5\x35\xb8\x33\xda\x08\x2d\x17\xa4\xb3\x2b\x2a\x83\x0d\xfb\x4b\x5d\x24\xc6\xa7\xa2\xb8\x8a\xa1\x86\x18\x2c\x28\x16\x02\x9c\x79\xe6\x4a\xd9\x71\xe1\x2c\x26\xc5\xc4\xad\x15\xf4\xc9\xd8\x14\x64\x48\x53\x6f\xc0\xfc\xa1\xe6\x09\x2b\x90\xdf\xa0\xb9\x87\x81\xfc\x7f\x75\xe2\x8e\x3a\x46\xd0\x3b\xb8\x75\x91\x51\x6f\x59\xc4\x05\xe2\xb1\x13\xba\xf1\x84\x2e\x38\xa6\x97\xae\xef\xdd\x81\x44\xfa\xa2\xb4\x1e\x38\x7c\x96\x5c\x1c\x1f\x35\x96\xcc\x3c\x48\x10\xed\x9d\x37\x98\xae\xe8\xa9\x0c\xde\x3d\xa3\xf9\xa7\xaf\x29\x6d\x45\x9c\xd1\xac\x76\xf8\x3f\x7b\x57\xa3\x14\xcc\x22\x45\x6b\x3c\x5b\x3a\x6a\x1e\x35\xa8\x94\x49\x96\xa6\x90\xfb\xcb\x1c\xee\x8b\x69\x3e\xeb\x26\xd7\x03\xaa\xf1\xd9\xad\x15\xe3\xf0\x2c\x23\x11\x51\x1c\x23\xa7\xe3\x34\x7f\x77\x44\x56\xa1\xfd\x8f\x71\x27\x5f\x76\x88\xff\x34\x24\x39\x20\x27\x30\x49\xbc\x04\xe7\x3a\x8c\x7e\xc1\x59\x2f\x17\x1d\x13\x7d\x62\x42\x9a\xe0\xd9\x6e\x95\x94\x2b\xa9\x5e\x92\xdc\x6f\x90\x56\xd1\x9e\x46\x8a\xfa\xc6\x67\xc7\x68\xbe\x63\xa4\xa4\x57\x08\x6d\x8f\x76\x27\xe6\xda\x93\x22\x7c\x78\x02\x5f\x18\xcd\xa3\xbd\xd6\x8d\xfd\x11\x9d\xf8\xa8\x3a\x1c\x23\x4d\xd7\x2d\x4a\xd4\x05\x05\x14\xbd\xae\x66\x71\xc4\xf8\x5b\x17\xb1\x43\x29\x91\x0c\x95\x12\x6d\x86\x82\xd1\xba\x75\x70\xb6\x7b\x42\x45\x83\xee\x34\x30\xd8\x83\x54\x4f\x12\xd4\xff\xfb\x66\xf3\x0f\xdb\xed\x00\xde\xf2\xeb\xd3\xc7\x07\xc4\xcc\x3e\x1a\x72\x04\xb1\x49\xc1\xc1\x12\x2e\x31\x0a\x81\xd1\x8f\xa4\xf5\xe1\x4f\x19\xc0\x82\x31\x0e\xd9\x58\x0e\x2a\x5d\x79\x05\x73\xbb\xea\x15\x44\xbe\xc0\xe0\x4a\xa1\x8e\xd1\xbc\xc1\x53\x0c\x2f\x58\x43\xe1\x8f\x4b\x47\x27\x91\xbc\x6b\xb3\x9f\xc9\x1f\x26\x08\xb7\x49\x23\x2a\xf0\x56\x19\x0d\xf4\x81\x11\x32\x22\x23\x7a\xdf\xf1\xe0\x2f\x1e\x6e\x22\xe0\xab\xef\xee\xf3\xdf\x51\x9a\xa5\x69\x97\x21\xda\xbe\x5d\xb3\xf9\x51\x23\xcd\xd1\xc7\xfa\xa7\x16\x20\x98\xb4\x3f\xad\xe7\x67\xba\x5e\x15\x1e\x67\xbe\xc7\x29\xa0\xb9\xcc\x7f\x6c\x55\x89\xe0\xa3\xea\x25\x6d\xf7\xdd\xd3\x27\x87\xca\x82\xd6\x82\x47\x44\x10\x10\xb8\x3b\xc7\xf6\xaf\xb9\x65\x67\xea\xde\x45\x7b\x96\xac\x5d\x85\x91\x3d\x58\x51\x40\x86\xe9\x52\x92\x19\x2b\x47\x02\x28\x28\x2e\x4f\x08\x4d\x4d\x2c\x5a\xb9\x84\xc0\xd9\xbd\x3b\xa1\xe0\xdc\x06\x2e\x93\xd6\x17\x5e\xb2\xf6\xd9\xc7\x27\x30\xb9\xb1\xa4\x21\x8a\x46\x91\x6d\x60\x83\x64\x7d\x03\x1a\xf1\x5f\x3e\x6d\xe4\x26\x39\x3f\xa2\x05\xc9\xa4\x93\xec\x29\xf6\x38\xe8\x67\xba\x13\x7a\xbe\x77\x10\xf0\x27\x71\x59\x3b\x2f\xa8\x1a\xd1\x81\x62\x12\x90\xba\x71\x11\x7d\xf3\x5c\x90\x0d\x66\x82\xbe\xcb\xe2\x50\xf3\xb1\xb0\x84\x83\x3e\xd8\x48\x9b\xaa\x1b\xe3\x61\x63\x7a\x70\xaa\x28\xdc\x44\xe6\x8b\xc0\x9c\x82\x4e\x22\xe1\x0b\x30\xe8\x74\xd0\x7a\x4b\xc2\xe7\x91\x27\xdc\x21\x80\x5c\xf4\x76\xd4\x8b\x35\x3e\xab\xa9\x05\x32\x75\xc3\x49\x24\xdd\x32\x04\xf6\xa5\x4d\xb7\xbd\xb1\x45\x96\x6d\x1f\xe4\xc0\x77\xc0\x89\xc0\x9a\x03\x1f\xf9\x6b\x90\x94\x31\xf2\x2e\x8b\xad\xdf\xba\x47\xde\xfe\xaf\x8f\x3d\x2f\x8e\x7c\x56\x0d\x8c\xf9\x4a\x93\x8e\x99\x8a\x77\xbe\x96\x3e\x23\xee\x3d\x84\xbb\x67\xc6\x7d\x68\xf9\xa5\xba\xf8\x85\xde\x09\xf6\x1a\x73\xd1\x9b\x19\xff\xc7\xf9\xf1\xd9\x39\xad\xe7\x92\xf4\x47\x8d\xe7\x72\x66\x7c\x76\x7a\xea\xea\x6c\x4c\x96\x27\x16\x1c\xd1\xbd\x3c\x35\x39\x3e\xab\xdf\xe4\x5c\xcf\x45\xbb\x65\x67\xa6\xe6\xe7\xc6\x75\x2e\x7e\xcf\x8c\xaa\x79\x17\x36\x73\x8e\x60\x46\xfc\x7c\x2c\xdc\x4d\x76\x79\xd9\xa1\x43\x16\x6f\x7d\xd5\x38\x94\x5e\x91\x67\x04\x33\xf9\xf8\x98\x6a\x11\x3e\x3e\x06\xb5\x01\xc4\xb5\x9a\xc8\xb4\xff\x57\xc2\x63\x38\x68\xb0\xdd\x48\x82\x85\x9d\x7e\xb7\x0d\x3f\x6b\xf9\xb2\x4c\xbc\x78\x14\x2c\x74\x35\x02\x55\x15\x90\xdb\x96\xc0\xb4\x76\x7f\xce\x87\x79\xa9\xa2\x07\x99\x47\x32\x76\x1a\x84\x92\x11\x08\x6f\x7e\xef\x1b\x4a\xcf\xde\xc5\x10\x97\x47\x07\x7c\x6a\x9f\x7e\xbf\x1d\x68\x31\x05\x41\xc2\x76\x7c\xc5\x81\xcf\x5c\xc9\xc1\xfb\x28\x65\x25\x82\x38\x83\xf2\xbb\x81\x26\xa3\x15\xdc\x81\x4e\xde\x36\xa5\xc2\x06\x6a\xcc\xcf\xf5\x0b\x58\xdf\xec\xe9\xe3\xa7\x83\x30\xd0\xe7\x39\xb7\x0b\x6d\xa4\x47\x18\x01\xa2\x60\x64\xee\x7c\x03\x77\x01\xbe\x62\x6b\x58\xed\x09\x7f\x1d\x51\xaf\x44\x37\x75\x42\x9b\xb0\x3e\x47\xc4\xd2\x06\x50\xd1\x39\xad\xbc\x22\x0c\xdc\x53\xc5\x42\xbb\x51\x1a\x16\x3a\x26\x88\x59\xeb\x6d\x3f\xfd\x7c\xa1\xfe\xd2\x4b\x3f\x4d\xb6\x70\x47\xf6\xec\xf1\xa7\xeb\x37\x90\xab\xae\xa1\x60\xb0\xb5\xf7\xf4\x3c\x39\xf4\x23\xec\xe5\x6d\x03\x26\xc8\x8d\x1b\xb6\x0a\x28\x62\xed\xd9\xf7\xed\x0a\x21\x8f\xdb\x58\xd1\xa9\x17\x8c\x4b\xa8\xab\x57\x37\x74\xb3\xac\x0f\x72\x0e\x47\x37\x8b\x01\x09\xb4\xea\xd5\xcc\x51\x74\xb9\xac\x6b\x21\xc8\x94\x8c\x72\x6e\xf7\xe7\x74\xc4\x93\x87\x5e\x1a\x6e\xae\x2f\xfc\x08\x07\xac\xad\x94\xe4\xca\xc3\x35\x85\x3d\xd7\x02\x38\x4c\x47\xf3\xd6\x2e\x5e\xf0\x76\xa2\x0b\x10\x05\xea\x6f\xb5\x95\xa8\xd0\xdc\x3b\x67\x30\x42\xd5\x05\x8a\x60\x90\xc5\x95\xcb\x47\x0f\x65\x60\x77\x1b\xcb\xa7\x52\x29\x29\x37\x62\x7c\xa9\x9c\xc6\x12\xde\xd8\xa4\x32\x5b\x32\x09\xb5\xcd\xf3\x39\x93\x6b\x38\x98\xb1\x90\x3e\x55\x81\x14\x10\x3a\x8c\x7d\x77\x3c\x5e\x55\x83\x34\x78\x95\x39\x9a\x30\x03\x12\xa7\x96\x26\xc9\x73\xd8\xdd\xc3\x02\x9d\xbb\x30\x16\x6d\x15\xa8\x5a\xf7\x0f\x4f\xff\xb2\x89\xb0\x1d\x32\xb6\x01\x67\xb4\x83\xe1\xf2\x11\xc8\x7e\x3c\xe3\x16\x84\x9c\xe9\xd5\x20\x8a\x81\x0b\x83\x43\xeb\x62\x02\x34\x48\xd0\xa9\xfa\x10\x30\xc3\x58\x5f\x8f\x26\x81\xe1\xe3\x92\xa2\x8d\x61\x18\x4e\x1f\x6d\x8b\x6d\x4e\x48\xc3\x5c\x67\x2f\x55\x97\xf5\xaa\x80\x82\x17\x3d\x96\xe3\xee\x9b\x1e\xfc\xdc\xfc\xcc\xa4\x02\x1f\x9d\xa6\x23\xaa\x41\xa0\xe4\x66\xb3\x23\x0a\xd6\x90\x4e\x3f\x64\x9d\x21\x22\x09\x3b\x98\x41\x90\xaa\xf3\x72\x20\x98\x5b\x1b\xb8\xab\x06\x03\xa5\x6b\x16\x55\xd2\x2e\xa6\x4b\xe8\xa8\x29\xa7\x2b\x9c\x28\x80\x47\xc0\x35\xb3\xaa\x9e\x26\xe1\x04\x63\xbc\x60\x39\xe1\x20\xcb\x0b\x62\x9d\xe1\x09\x82\x7f\x48\xad\xd0\xc5\x6f\xc6\x38\x54\x62\x1e\x18\x49\xb0\x83\x04\x9e\xf4\x34\x83\x88\xd8\xcc\x0b\xa1\x8e\xa4\x97\x70\x37\x48\xaa\xbf\xba\x82\x33\x11\xe0\x32\x85\x75\xc5\x1b\xab\x6a\xa0\x4e\x25\x0f\x10\x61\xa3\x62\x05\x17\x5a\x7e\x4c\xbb\x32\x48\xfc\x35\x30\x10\x1c\x26\xfe\x9a\x78\xe8\xe5\x40\xa9\xbd\xf9\x43\x15\xec\x2c\x30\x58\x01\xaa\x23\x16\x94\xcf\x6c\x60\x4d\x3d\x93\xe1\xea\xe3\xa8\x3c\x1b\xee\xeb\xac\xbe\x53\xd9\xd0\x5e\xed\x26\x24\xb6\x9c\x6c\x52\xf4\x1f\xeb\xe9\x3e\xf2\xb8\x09\x8b\xea\x4e\x86\x24\x9e\x81\x4e\xba\xe1\xca\xe1\x3e\x5e\x44\x12\x50\x84\x87\x74\x79\x74\xe7\xf4\x3f\x4e\xe0\xe2\x9e\xd0\x70\xa7\xea\x48\xa7\xfd\x74\x84\x5f\x9f\xb9\xb3\x98\x6c\x3c\x79\xfc\x67\x6a\x31\xe1\xc0\xcf\xdc\x5a\x52\x65\x88\x2c\x0d\x0a\xf3\x77\x70\x7d\x7b\x17\xe4\x17\x79\x53\x7a\x1b\x30\xb8\x2f\x05\x98\x07\x07\x1a\xa8\x5c\xf8\x37\x6b\x1a\x16\x8a\xae\x49\xda\x3c\x38\x3a\x3e\x46\x29\xdf\xeb\x5f\x95\x9f\xc3\x83\x15\xfa\x21\x96\xf3\x88\x76\x14\xb4\x96\x76\x16\x42\x0f\x77\xca\x4b\xdb\x2c\x86\x67\xba\x0f\xd3\xd7\xfb\x19\x09\x4a\x1d\x31\x2d\x29\x19\xca\xc4\x4d\x94\xe4\x52\x7b\x4b\xcd\x5a\xf2\x1e\xd4\xf9\xc9\xda\x8c\x55\x2f\xbe\xd6\xe9\x6d\xcc\x98\x60\xd9\xf0\xa8\x05\x1e\xed\x78\x5d\x48\xee\xd1\xfa\xa6\xd0\xe5\x0f\xa1\xf2\x65\xd4\x00\xf6\x6d\xa4\xfc\x31\x09\x91\xe6\x2b\x18\x6d\x23\xe2\x3f\x95\x79\x3c\x2a\x4e\x5c\xb4\x9f\x72\x63\x8e\x09\xf5\x9b\x61\xeb\xbf\x17\xe8\x3d\x3b\xfb\x1a\x87\xbc\x15\x9d\x75\x8e\x20\x4d\x73\x52\x0a\xc6\xe1\x65\x8a\xe5\xa6\xe8\x51\xc4\x59\xe5\x50\x6e\x76\x18\x64\xea\x9f\x2b\x23\x16\x30\x78\x26\x04\xcb\x2b\xc2\x30\xa9\xc6\x43\xbc\x96\x10\x01\xa4\x8b\x11\x32\x18\xe9\xd0\x6c\x6c\x85\x51\x75\x15\xfa\x65\x60\x5e\x5a\xfa\xd9\x8a\xa1\x0f\x23\x91\x13\xa1\x8b\x02\x99\x11\xe1\x4e\x15\xd7\xaa\x17\x9c\x5c\xad\xb6\x41\xe3\x1f\x1b\x55\xaa\x3c\xcb\xde\x2f\x61\xf7\xd1\xf5\x80\xe9\x40\x29\x74\x14\x19\xbe\xa0\xe4\xf6\xc4\xb5\x18\xa9\x56\xfc\x10\x64\x56\x40\x99\x88\xe2\x3a\x61\xeb\x71\x82\x5d\xea\xe1\xa4\x2c\xb7\xd8\xb6\x70\x24\xa3\xac\xf6\x08\x61\xb8\x1c\xd8\x00\x01\xea\xbb\x3a\xf7\x42\xe3\x10\x95\xa6\x17\xa4\x24\x08\xa8\x9b\x86\xb7\x5a\xd5\xb6\xd8\xc0\x63\x97\x0b\xf6\x9a\x5d\xa8\x9b\x45\x2f\x16\x88\x8a\xda\x90\xa3\x0c\x7a\xa8\xd5\xb5\x79\x7d\x37\xde\x3d\xbb\x41\x89\x92\x1c\xe9\x40\x49\x3e\x98\xa1\xd6\x90\xf5\x4c\xbd\x20\xf4\xd8\xda\x1d\x0a\x35\x54\xb9\xbe\x52\x34\x39\x75\x66\x6a\xd4\x2b\x51\xe4\xe5\x8c\x78\x65\x1c\x31\x31\x40\x1f\xfa\x2f\xb2\x56\x1a\x27\x62\xbc\xb8\x29\x51\xbf\x88\x89\x41\x50\xb4\xb3\x8f\xf7\xb4\x81\x22\x5a\xb2\xb8\x0e\x2c\x4c\xfd\x80\x4b\x95\x7d\x87\x0d\x63\x14\xe1\x2e\x49\x4e\x72\x91\x79\x86\x72\xa3\xc1\xc3\xf8\xc5\x4a\xdd\x4f\x7a\xa1\x4a\x00\x2e\x85\x58\x55\x2d\xcc\x06\xd0\x06\x01\xfb\xe5\x62\x59\xaf\xbe\x3c\x3f\x71\x91\xd2\x52\x89\xfc\xb3\x1d\x0a\x12\x63\x0e\x94\x32\x20\xe2\x61\x8c\x93\xb9\xb1\xe9\x61\x4f\xd2\x54\x19\xad\xef\xf6\x9a\x07\x14\x4c\xd5\xfa\xf4\x09\xd6\x19\xbc\x1d\x1f\x51\x96\x30\x04\x20\x4d\xa2\x86\x20\xc4\x30\x39\xb5\x33\x32\xec\x69\xae\x29\x79\xf6\x9e\x0f\xb1\xdd\x5b\x7e\x85\x92\x98\x82\x67\xef\xc2\x9c\x91\x6f\x55\x47\x4b\xc9\xba\xfa\xca\xb3\xe0\x3e\x77\xdd\xda\x78\x06\x23\x80\x68\x4c\x2f\xe4\x28\xe0\xe1\x95\x86\x7f\x3a\x56\xb3\x72\xef\xa9\xa3\x29\xd9\xf6\x9e\xef\x2f\xcf\x58\x40\xd5\xe3\x59\xcf\xb2\xac\xb3\x9a\x89\x65\x51\x1d\x35\x35\xcb\xde\xf3\x3d\x62\xd9\x0b\x2c\x57\x0e\x3f\x57\x3d\xfd\xf0\x47\xcb\xcc\x73\x6a\x57\x4e\x2d\x0c\xae\x8b\x7e\x39\x7a\x57\x39\xf9\x84\x13\xc7\x4f\x63\x90\x11\xad\xbb\x46\xe4\x01\x1a\x3a\x39\x95\xf8\xf2\x54\x67\x68\x54\xa2\x6f\xc7\xf9\xf2\x31\x79\xf0\xc1\xc0\xf6\x8e\x49\xeb\x38\x1b\x3e\x31\xcb\xbd\x43\x02\xab\xf5\xa2\x52\xa5\x96\x25\x59\x10\xe4\x30\x1c\x4c\xe4\xed\xf6\xd8\x9b\x18\x81\xb4\x86\xe3\x85\x42\xd0\x52\x48\xfa\x5e\xeb\xfb\x7b\x69\xa8\xa5\x0b\xb7\xb7\x3e\x91\x56\x5c\x9e\x88\xa6\xe4\x55\xad\xef\xd6\x98\xa4\x42\x9f\x2b\x4b\x19\xe9\x0f\xaf\x61\x41\x71\x82\x72\x1e\x41\x38\xf4\x7c\x89\xe9\xbd\x04\xe4\xf7\xc6\x02\x16\x68\xb0\x63\x1a\x3b\xdb\x48\x5d\xd3\x9f\x71\xcb\x75\xc3\x4d\xf2\xde\xeb\x9e\x9b\x4e\x76\x69\x3c\x4f\xd2\x65\xf3\x9a\xe3\xd6\x84\xa5\x17\x3e\x5d\x24\x74\x6b\x71\x65\x82\xcf\xe3\x18\xa4\x6a\xd1\xed\x28\x53\xee\x7d\x8a\xe6\xf1\x0a\xcb\x50\xe4\x3d\xe9\x88\xfe\x80\xb6\xd6\x4d\x0e\xaf\x5d\xa2\x44\x8d\x5a\x7b\x0e\x78\x44\xe4\x1d\x10\xd7\x59\xa7\xec\xcd\x4a\x0b\xd1\x14\xf2\x7d\x85\x12\x0d\xb5\x31\xbd\xc1\xce\x94\x7c\xcd\x2c\x2c\x8a\x39\xc8\xce\xa6\x80\xf7\xf5\x86\xb8\x7a\x19\x3f\x02\x21\x5e\xfd\xbb\xec\x6d\x26\x54\x55\xd6\x86\xfa\xc2\xbb\xb8\xd1\x30\xd4\x63\x7e\x66\x42\x16\xf1\xf4\x92\x6b\xd4\x44\x6a\x89\xde\x8f\x1b\x14\x9f\x35\xeb\x35\x58\x7b\x35\x3b\x8f\x81\x77\x5a\x04\x3c\xee\x7f\xfb\xa6\xec\x02\xa7\x88\x6b\x79\xb6\xa5\x18\xc1\xaf\x1c\x21\x74\x1b\xd3\xc1\x83\xd5\x0c\x24\x3a\x5e\x07\x69\xdb\x33\x78\x6e\xea\x14\x22\x3a\xd5\x74\xef\xb1\x48\x1d\x57\x84\xd0\x35\x29\x84\x68\xca\xb4\x55\x59\x63\x44\xa5\x26\xda\x7b\x76\x7c\x0c\xd8\x9f\x7b\xc3\xb8\x3c\x33\x35\x3f\xad\x1b\x4c\xf5\x50\xd6\xb5\x33\x73\x6d\x62\x6c\x3c\x1e\xaf\xce\xbb\xc9\xc4\x41\xd6\x89\x96\xb4\x30\x71\xb2\x11\xcd\xdb\xd3\xa3\x49\x54\xb0\xc3\x34\x96\x04\x6e\x24\x1e\x37\x4f\x34\x13\x8f\x9b\xc7\x2d\x5d\x1c\xbf\x36\x3e\x39\x35\xad\xc7\xce\x93\x6d\xed\x61\x5a\x5b\x7c\x5b\x09\x28\x7c\x2a\x73\xf1\x2d\xe9\x11\x09\xb1\x09\xcd\x8b\xb3\xaf\x89\x4c\xa5\x67\x61\xe7\x96\x11\xfb\xd0\xab\x86\x1c\x10\x01\x3f\x12\xbb\x2e\x72\x8c\x83\x42\x61\xbe\x71\xa7\xfd\xac\xd4\xbd\xe3\x25\x41\x60\xcb\xea\xf6\x7e\x10\xfc\x15\x68\x92\x8a\xfd\xe2\x8a\x38\x19\x52\xa5\xb8\x04\x91\xc1\xa3\x9a\x89\x4b\x74\x49\x41\x05\x7c\x47\xd5\xa8\x17\x4b\x49\x75\xe0\x12\x29\x89\x68\x4a\x43\x55\xd1\xca\x7b\x48\xc8\xc6\x20\xdc\x7e\xe8\x02\x0f\xaa\x21\x1e\xa4\x78\x24\x5d\xb7\x2b\xe7\xb5\x82\x58\x44\x65\x10\x14\xc9\xa0\xc8\x7e\x1b\xc7\x57\x29\x7d\x78\x0b\xc3\x45\x8d\xd3\x6f\x71\xd5\x37\xf7\x36\xcf\x6b\x27\x88\x89\xe0\xd5\x9c\x99\x06\x11\x7a\xd1\x2d\x0d\x54\xdb\x90\x06\x6d\x88\xff\xa1\x02\xd2\x58\xac\xf1\xa5\x57\x86\x8c\x92\x2c\xd3\x27\xd0\x82\xf0\xa4\x56\x42\x5a\x97\xac\xbc\x59\x67\x9c\x07\x0f\x7e\xb2\xa2\x20\xfe\xe9\x23\x47\xd2\x90\x23\x6e\x4d\x4c\xcf\xcf\x5e\xfa\x69\x1b\x81\xf8\x95\x47\x21\x96\x7d\x92\x30\x34\x58\xea\xdf\xa9\xda\xbf\x65\x1c\x9a\x8a\xc0\x97\xa2\x1b\x8d\x07\xed\xc0\x55\xa3\x62\xce\xa1\x47\x0d\x51\xfd\x7c\xc8\x33\x27\x53\x31\x6a\x41\x0b\xff\xe6\x7d\x27\xc8\x51\x6a\x15\xfa\xf8\x0f\x5c\xe0\x49\xc5\x9d\x3a\x10\x09\x49\x29\x41\x2e\xe3\xc7\x65\xc4\x18\xe5\x8c\x2a\x98\x81\x82\x55\xa6\x1a\x31\x34\x1c\x05\x87\x46\x83\x80\x8e\x2b\x55\x7b\xcd\x2e\x5a\x22\x1b\xd5\x7a\x0b\xb6\x0e\x65\xde\xd8\x6e\x12\x22\x4f\xe2\x58\x8c\xf8\x79\x56\xa8\x87\x21\x32\xc4\x77\x9b\xed\xa9\xde\x98\xd7\x2d\xca\x71\x37\xc4\xb5\xaf\x97\x03\x81\x77\x93\x6a\x75\x96\xbe\x1a\x83\x6f\xde\x79\x27\xb8\x5e\xf8\xf7\xd1\x8a\x3d\x8e\x5f\xca\x27\x4a\x4a\x1d\x4a\xf8\x21\x90\x60\xd3\xd1\x78\x44\x91\x11\x5a\x2a\xd1\x94\x04\xab\x5c\xb6\xd1\xa2\x1d\x0e\xbc\x4f\x90\xb3\x67\x8e\xfc\x46\xf0\xee\xa4\xb9\x64\x15\x59\x1a\xca\xac\xee\xd4\x40\xac\xc1\x90\xb6\x2f\xf7\xa5\x0b\x49\xd7\x6c\x00\xd6\x26\xc5\xe4\x21\xb5\xaf\x7a\x71\x34\x91\xa9\x96\xc9\xa4\x05\xa2\x63\xc2\x89\xbe\xe9\xe9\x90\x57\x2e\x29\xb9\x48\x8a\x49\xe4\xf2\x4c\x21\x7f\x7e\xd5\x34\xd0\xca\xe8\xba\xe8\x81\x25\x25\x40\x38\xce\x26\x27\x4a\x25\xdd\xdf\x32\xa7\x47\xa5\x04\x6d\x8b\x22\x2d\xf2\xb2\xda\xd1\xd2\x4a\x51\xab\x22\xfb\x8c\x4a\x52\x47\xda\xc2\x81\x32\xd1\x14\xf1\x7a\x6c\xb7\xba\x3a\x1f\x11\x30\x80\x5d\x5b\x00\xfa\x53\xf1\x23\xfb\x50\x7b\x49\x70\x41\x26\x17\xca\x73\x13\xd3\x23\xc6\xc4\x32\xc2\x23\xd1\x79\x5c\xab\x6e\x90\x41\xce\x11\x59\x74\xa6\xb1\xf6\x72\x5b\x2a\xdd\x10\x3d\x4e\xc8\xa4\xd2\x18\x90\xab\x90\x85\x37\xc5\x38\xf8\x45\x44\x42\x67\xc8\x42\xf9\x6c\xfb\xdd\x11\xec\x4f\x57\x72\x24\x94\x44\x87\xe6\x00\x50\xa3\x10\x69\xe1\xb3\x23\xa4\x20\x80\x2a\x27\x33\xd1\x53\x55\x2e\x6c\x1b\xa7\x0c\xdb\xb8\x83\xaa\x28\xb3\xba\x78\xbe\xd4\xf8\xdb\x9a\xe8\x39\x89\x8d\x98\x6e\x59\xa8\x3b\x27\xed\x59\x4a\xdd\xe8\x5f\x8c\xeb\x4e\x1b\xa9\x91\x60\x46\x10\x6f\x6b\x75\x6b\x8f\x2a\xdd\xfb\xb5\x70\x06\x12\x7b\x50\x92\x52\xad\xc2\x05\x24\x84\x21\x4a\xdf\x8b\x04\x4f\xc0\x20\xac\xa2\x35\x8c\xfb\x6a\x72\x6a\x6c\x74\x72\x1c\xcf\xac\x81\xb1\xc9\xf1\xd1\x99\x81\x21\xbc\x37\xac\xd9\x4e\xdd\x15\x8f\xb1\x1e\x88\x99\xd5\x5a\x9d\x4e\xa0\x24\xe0\x29\x4a\xf7\x52\x46\x56\x64\xa3\x98\xe7\x7a\xe4\x9e\x70\x57\x89\x9e\x08\x0f\x9c\xf7\x06\x5e\xf0\x0f\x1a\x6a\x03\xc7\x22\xcf\x3a\xc9\x11\x89\x6c\x71\xd0\xc8\x22\xe1\xbc\x2e\xd6\x36\x2a\x22\x04\x07\x15\x53\x46\x9b\x1c\xc0\x60\x3c\xae\x4c\x5c\x76\xca\x96\xae\xd6\x4e\x7b\x3b\x81\x0d\x2b\x5a\x91\x25\x83\xa9\xa5\x80\x05\x50\x4f\x21\xf4\xbc\x66\x5b\xeb\x3e\xba\xa2\x8d\x79\x75\xba\x8b\x29\xa7\xaf\xb1\x2d\x72\x52\xb4\xed\x61\xb8\x3c\x3e\xd6\x86\xe3\x06\x7a\x5a\xf5\x2b\xf8\x04\x0a\x0b\xc6\x77\x1a\x51\xb5\x8e\x20\xfc\xe5\x15\x35\x03\x29\x02\x9b\x46\x4d\xe9\xa3\x48\xd6\x71\xf1\x31\xce\x76\x12\x91\xd5\x87\x33\x10\x78\x5b\x89\x73\x26\xaa\xe2\x0d\x21\x4c\x4e\x60\x8f\x21\xac\x92\x97\x38\x46\x85\x52\xc4\x37\xd7\xcc\x62\xdd\x62\xd4\xa7\xf6\x92\x9c\x3f\x3c\x7b\x51\xbb\x9c\x50\x19\xf7\xf4\xb8\x10\xf3\x9d\x0c\xef\x6f\xa2\x90\x4f\x04\x30\x47\x44\xa8\x72\x6f\x03\xf5\xef\xde\x0e\xf7\xac\xa0\xf9\xa4\xe7\xe1\xf9\x38\x57\x33\x10\xf8\xa2\x7b\x56\xbb\x64\xe5\xc5\x73\xab\xa6\x61\x68\x15\x75\x53\x93\xcc\x22\x88\x7b\xc0\xd5\x82\x05\x2e\x7d\x72\xca\x13\x46\x37\x9c\x1e\xed\xa1\x0a\x8e\x60\xc5\xb2\x8c\xb0\x81\x18\x69\x7b\x9a\x08\x6d\xec\x92\x15\x66\xea\x2a\xec\xc4\x15\xa0\x5c\xfd\xdf\x77\x48\x7b\xb8\xf3\x30\x07\x09\x63\xe7\xac\xfb\x88\x62\xc1\x70\x91\x78\xf0\xb0\xa0\x05\x37\x2e\x18\x95\xfb\x28\x16\x43\x35\xbb\xd2\x6a\x59\x32\x94\x23\xb0\x54\x12\xfb\x5b\xb5\x8a\x5a\x06\x3e\x6a\xb4\x3e\xdf\x6c\x3e\xbc\x9d\xdc\x0a\x02\x1a\x55\x4b\xec\x3c\x21\x7a\x45\xa0\xd8\xa0\xe9\x47\x8c\xe1\xc2\xb3\x72\x8c\x49\x49\x70\x9d\x5c\x37\x6d\x48\xd4\x65\xa0\x83\x18\x56\x61\xc5\xaa\x9a\x2c\xe3\xc4\xcf\x5c\xf0\x08\x7e\x02\xf9\x41\x85\xbe\xb5\x80\x5a\x5e\xd8\x18\xe3\x25\x09\xb2\x07\xe5\xf7\x9b\x86\xac\x02\xee\x19\xe2\x14\x74\xf0\xd6\x67\xc7\x70\x40\x19\xad\x47\xc7\xa8\xd0\x11\x24\x66\xa3\xf9\xc5\x9f\x09\xfa\xe3\xbd\x43\x52\xfc\x28\x7b\x8c\xc0\x6d\x09\xf7\xd3\xf0\xca\xb6\x69\x30\xb6\x68\x68\x24\xde\x53\x1a\x84\xa7\xe4\x81\xc6\xd6\xd0\x66\xe3\x22\x56\x25\xda\xa3\x63\x41\xad\x5a\x5b\x7b\x52\xf7\x13\xdd\x78\xb5\xdd\x12\x7b\x22\x78\x9f\x82\x55\x33\xed\xa2\x58\x83\x2a\x34\x7b\xf8\x32\xab\x8b\xd1\x16\xf0\xec\x51\xf7\x3c\x09\xe7\x8f\x11\xdc\x88\xbc\x4d\x38\x7f\xc9\x74\xf1\xf1\x1d\x33\xa2\x01\x78\xbc\x54\x83\x8a\x25\x3a\xca\x04\x27\x2e\xca\x9c\xeb\x06\xf5\xc9\xde\xe9\x5f\x9e\x1a\x32\x9f\x94\x8a\x99\x27\xb7\xde\x66\xfe\x88\x5b\x0d\x9a\xec\xda\x94\x8c\xb8\x8a\x71\x26\x55\x2f\x68\x1c\x49\xdd\x38\x47\xbb\xc6\x34\x2b\xf4\xef\x4c\xed\x25\x4e\xa7\x68\x35\xfb\xac\x72\xfb\x1d\x6d\x16\xc1\x48\xea\xcd\x82\xe2\xca\x4b\x5a\xa0\xeb\x28\xe7\x8d\xfc\x18\x74\x72\x91\x65\x21\xbd\xb9\x62\x2c\x12\x0f\x4b\x1c\x92\xf6\x3c\x89\xde\xdc\x55\x9e\x73\xea\x33\x2b\xc3\x69\xc6\xe1\xba\x5d\x11\xc8\x90\x32\x33\x98\x5c\x88\x35\x27\x03\xc4\x4a\x18\x5f\x45\x84\x1a\xb3\x97\xf3\xf3\x23\xfd\xe5\x16\x3b\x5f\x75\xdc\x1a\x49\x03\x42\xbe\x8a\xcb\x69\x3b\xdb\x25\x79\x83\x02\x0d\x65\xc2\xde\xc1\xd9\x67\x5f\x61\x11\x34\x2e\xd1\x94\xb6\xbf\x40\x3d\x28\xa1\x2b\xe3\x35\x59\xde\xae\x87\x0d\x2c\x09\x0a\xf2\xd6\x29\x81\xce\x5c\xb0\x0a\xff\x2d\x9b\xaf\x34\x31\x04\x37\xe6\x3d\xa3\x27\xe0\xab\x51\xe2\xa8\x3b\x0c\x56\x85\xb8\x04\xe7\xbb\xd7\xa9\xce\x46\xc7\x25\x91\xfb\x5c\x20\x32\x71\x9c\xc3\x7b\x36\x65\x04\x62\x54\xce\x6e\xaa\x32\x91\xf4\x62\xfc\xd0\x69\x07\x0c\xe1\xe3\xb9\xea\x8c\x28\x2b\x46\x9a\x29\xa1\xbf\x42\x03\x64\x7c\xa4\x9f\x28\x10\x80\xc1\xe6\xb1\xc2\x97\xc4\x0e\xe6\xc7\xd1\x9f\x2c\xf0\x62\xb1\x04\xa1\x38\x08\xd6\x9d\x2a\xa1\x8b\x79\x58\xe7\xda\xf2\x2f\x42\x9b\x24\x20\x58\xbf\x56\x02\x39\x8a\xbd\x3a\x85\x5e\xa5\x69\xa5\x06\x0c\xff\x4a\xd6\xea\xb6\x22\xd0\x9b\xd2\x6a\xe9\x03\x17\x0b\xb0\xfa\x63\xbf\xde\x13\x16\xa6\x0d\x43\xac\x7b\x80\xb4\x09\x26\x4d\x52\xeb\x59\x92\x3d\x63\x35\xdf\x1b\x1d\x56\xec\x9f\xa3\x7e\x2f\xac\x00\x9d\xc4\x35\x26\xdd\xee\x75\x2b\x36\x5d\xee\x6b\x5c\x62\xa8\x68\x02\x4e\x61\x2c\x60\xec\xd4\x6b\x0b\x65\xe1\xc1\x1a\x55\x42\xe0\xc8\x2f\xb5\xc4\xa9\x33\x96\x5a\x4b\xa1\x6a\xaf\xac\xd6\x0c\xb4\x32\x0f\x93\x37\x19\xf6\x36\x4a\xfa\x55\x2c\x93\x97\x77\x0a\xd2\x62\x82\x0f\x70\x51\x76\xfc\xf4\x7f\x4f\x4f\xcd\xcc\x45\x5a\x4b\xb4\xbe\x2e\x8f\x0b\x83\x80\x4c\xf7\xb8\x64\xb2\xd1\x3a\xde\x82\xcb\x3c\x92\x4c\x7e\x2e\x8d\xa8\x12\x58\x8d\x27\x94\x74\xf3\xe1\x89\x84\xd8\x7b\xf4\x4d\xeb\x2f\x5f\x51\x91\x00\x78\xf4\xd3\x90\x4f\x4b\x3c\x4b\xa9\x3a\x3b\xbb\xb0\x12\x28\x78\xe1\xce\xd7\xb2\x28\x02\xc8\xc6\x5b\x07\x82\x93\xc0\x8c\xf9\x9e\xf0\x14\x31\xb4\x3c\xfa\xf5\xb2\x5f\xfd\xc3\x1b\xfe\x88\x0a\xf6\x28\x91\x4a\x4e\xd5\x52\x2f\xd8\xda\x48\x59\x1e\x2c\x58\xfb\xdb\x5f\xf9\xe3\x03\x6a\x44\xe3\x84\x16\x39\xa9\xcd\xe4\x14\x78\xbb\xbb\x22\xf5\xc4\x82\x55\x60\xf7\x15\xff\xad\x77\x76\x11\x55\xcd\xdb\x5f\x85\x9e\xd6\x37\xfc\x63\x09\x7f\x14\xd3\x11\xa7\x1e\x22\xbb\xf5\x8a\x8c\x45\x1a\x62\x37\xb0\x63\x94\xeb\x98\x95\xe4\x20\xbc\x38\x7f\x21\x3d\x62\x9c\xf8\x2e\x1e\x8f\x33\x82\x6c\xd2\x9a\xbf\x29\x62\x8f\x86\x24\x40\xb8\x2c\xf8\xca\x11\x49\xe2\xae\x73\xff\xb0\x2d\x32\xbc\x71\x3b\xd1\x5d\x54\xd3\x17\xa9\x63\xfd\x58\xff\x5e\xdd\x95\x6b\xa1\x16\x13\xa4\x40\x8d\x04\x1e\xd4\x34\xe8\x54\x52\x88\x43\xd8\xf1\x0f\x37\xf5\x2d\x54\x7e\x2c\x8b\x8e\xf8\x8c\x5f\x74\x74\xdc\xe6\x44\x34\x53\x41\x1f\x77\x2f\x8e\x3e\x11\xd6\xa3\x39\x8e\x50\x6e\x69\xc1\xcb\x51\x00\xe9\xd0\xc7\xf9\x45\xf8\x3c\x8f\x42\x6f\xec\xd2\xe2\xd5\xd1\x2b\xe3\x42\x8b\xca\xe1\xe5\x28\x27\x83\x92\x72\x32\x23\x9b\x2b\x79\x5e\xe7\x2b\xbd\xf7\xb3\xb4\x79\xb8\x4a\xa5\x2a\x78\x70\xec\x12\xe9\x10\xb1\x94\xe1\x43\x3e\xcc\x9c\x7f\xdb\x67\x8e\x7d\xa3\x95\x2a\xdf\x3d\x95\x02\x6f\x66\xfe\x96\x49\xc7\x41\xa6\x83\x82\x8e\x84\x31\x51\x4c\x83\xaa\xc4\x52\x94\x27\x1c\xd1\x1b\x1c\xcd\x28\x0a\x6b\x48\xaf\x8a\xa2\xdd\xbb\x70\xbe\xd4\x6c\xca\x6c\xdc\xa0\x78\x14\x51\x94\x5a\xef\x1b\xd7\x9e\xa5\x8d\x20\xd4\x04\x0e\x40\x73\x67\xfb\xf4\xfb\x6d\x5c\x67\xb2\x20\x07\x3b\x5d\x22\x5e\xc7\x88\xf7\x40\x11\x0f\x78\xf8\xe0\x5d\xc6\x77\x69\x2b\xeb\x12\x33\x0c\x4a\x68\xcd\x92\xb5\x6a\x97\x0b\xa0\x65\x2e\x83\x5a\xbd\x4e\x80\xac\x84\xa3\xff\x9b\xba\x5d\x25\xac\x8b\xd7\xe6\xe6\xa6\x31\xa2\xed\xad\x8d\x21\xbe\x8e\x72\x96\xf3\x6a\xad\x56\x71\x17\xe9\xfb\x68\xaf\x0d\x05\x85\x56\x51\x55\x87\x01\x06\xc1\x3b\x6c\x8c\x17\x5d\x6b\x48\x14\x66\xa5\xc2\x67\x65\xab\x86\x4a\x3d\x5e\xae\xca\x16\x85\xd2\x66\xcb\x59\x22\x5e\xae\x3a\x42\x84\x48\xc7\xf7\x90\x7f\xf0\x2f\x33\x38\xa4\xa2\x00\x60\x51\x0a\x71\x7b\x8b\xf5\x8c\xd3\x04\xb6\xbb\xc7\xfd\x6b\x54\xb0\xe8\x8e\x57\xe1\x30\xf0\x8a\xb2\x9e\x23\xa9\xc9\xae\x2a\x10\xc7\xf3\x82\xbd\xd1\x8a\x1d\xe4\x0c\x2f\xa9\x76\xb9\x6e\x79\x2e\x28\xb8\xb0\xa2\x67\x25\x68\x33\x88\xe5\x18\x74\x78\xf6\xaf\x68\x9c\xf1\x3e\xa5\x77\x0f\x8d\xd3\xc7\x8d\xd6\xfb\xbf\x0b\x72\x19\x20\xaa\x4b\x06\xc7\x2e\x79\x4d\x05\x64\x33\x31\x6b\x81\xca\x07\x9c\xd1\x42\x0a\x78\xf8\xbd\x82\x39\x28\xdb\xac\xe5\x65\x58\x59\x71\x2c\x07\x2f\x0b\xe1\x1a\x39\xbc\xbd\x42\x13\xa9\x23\xab\x6b\x76\x05\xb4\x51\x48\x61\x35\xcb\x32\xfd\x0f\x45\xf0\xf3\xe3\x1d\xae\x00\xb0\x10\xc4\x95\x4e\x54\x0d\xd2\xd0\xdd\xed\x48\x04\x96\xf5\x73\x9c\xe9\x6e\x19\xf2\x25\xd1\x7c\xa5\x00\x07\x99\x87\x89\x18\xe4\xb0\x4e\x3f\x72\x24\x7d\x12\xf0\x29\x1f\x2d\x18\x08\xef\x83\x2f\x02\xf5\x77\x6f\x0a\x24\xf4\x0f\x4f\xc2\x62\x47\xdb\x75\x07\x4c\x99\x2b\xac\x6d\xe2\x1f\x19\xb3\x77\xe7\x40\x9d\xa0\x80\x24\xc5\x45\x54\x74\x56\xd2\x3b\x64\x85\xbb\x88\x33\x2c\x8d\xd6\x77\x77\x60\xca\xbc\xba\x51\x31\x1e\x85\x39\x35\x22\x4a\xd5\x09\xf5\x75\xaa\xa2\xe3\xa2\xc2\x2f\xc7\xf7\x16\xa5\xd8\x66\xe8\x91\x4d\x94\x6d\xaf\x47\xf7\x29\x4b\xee\x05\xe2\x42\xd4\x0c\x3c\x2f\x4e\xdd\xac\x29\x20\x25\x70\xf2\x5b\x6f\xd1\x81\xcf\xce\xb4\x1a\x42\x34\x88\x1a\x64\x9e\x7b\xcd\xaf\x7c\xef\xb5\xe6\x63\x38\x00\x59\xdc\x4a\x32\x68\xc9\x8d\x0f\xb8\x74\x29\x29\x87\x42\xc5\x41\xcb\xc1\x49\x84\xa6\xd3\x1e\x19\x4f\x45\xfe\x04\xc0\x49\x34\xbc\x17\xd5\x3d\x0b\xbd\xe6\x57\x6f\x16\xdd\x8b\x4b\x9a\xf2\xd8\xd9\xbd\x3b\x49\x71\xb8\x73\xc0\x29\x99\xde\xde\x96\x45\x43\xc7\x29\xf7\x05\x85\x50\xa4\x51\x16\xf4\xc5\x82\xc5\x00\x2f\xa2\x40\x80\x6f\xb4\xd4\x2e\x01\x7d\xe3\x8a\xa5\x51\x2d\x23\xd0\x66\x68\x8c\x28\x64\xab\x5d\x31\x94\x59\x55\xa0\x8c\x4c\x63\x7d\xd5\xce\xf3\x7c\x7a\xc2\x87\xcb\x71\x93\xae\x06\x4b\xb9\x50\xaf\x06\x61\x65\x31\xc3\x3a\x87\x95\xf5\xe3\x12\xa0\x14\x88\x66\x4a\x9c\xc6\x92\x8c\xa7\x8f\x0e\xbd\xa2\x92\xaa\xfc\xe2\xb2\xfa\xc2\x34\x84\x9e\xc3\x86\x6e\x33\xd3\x98\xa2\x6e\xe3\xe7\xc6\x2b\x25\xcf\x25\x08\x09\x6c\x75\xad\xc7\x81\x87\x49\x62\xe0\xc8\x88\x47\xa5\xee\x7b\x54\xc1\x73\xad\xb5\x3c\x05\x41\x5c\xe3\x4c\x1f\x0e\x24\xe6\x0d\xd5\xca\x7e\x50\x03\x92\xa1\xef\x03\x14\x13\x56\x9e\x8a\xa4\x5e\x0f\x51\x02\x3d\x55\x2d\xce\x02\x6c\x07\x38\xb4\x87\x85\x09\x91\xef\x8b\x7c\xe1\x71\xdc\x1a\x7a\x3f\x59\xf8\xe5\xe0\x62\x34\x35\x3b\x47\x77\x54\x20\x1f\xcf\xf9\x5c\x0e\x68\x2e\x38\xa5\x1c\x37\x0e\xc7\xfa\x8a\x55\xb6\xaa\xbe\x44\xe5\xef\xa9\x16\xe8\x2a\x08\xdf\x0a\x15\x55\x8c\xab\x08\xfa\x76\x1b\x8c\x04\x89\x42\xb5\xe2\x36\x6d\xa6\xfb\x37\x83\xc9\x0a\xbe\xef\xd1\x47\x68\x55\x08\x0e\x96\xb3\x06\x3d\x9e\x55\x21\x14\xae\xdf\x1e\x61\xe0\x6f\x90\x93\x36\xb5\x1f\x05\x6d\x90\xa2\x1b\xfb\xad\xc6\xb7\xa1\xaa\xa1\x5c\xb9\x31\x8d\x4e\xa1\x06\x2d\xab\x17\x15\xb8\xcf\xd4\x8b\x05\x06\xf8\xc0\x3b\xb7\x09\xe2\x48\x7b\xe3\xd6\xb6\x8d\xb7\x58\x4a\xe9\xf4\xce\x45\x79\xb2\x89\xe8\x43\x9c\xfc\x4a\x25\xa6\xac\xb8\xe7\xa8\x0e\x1e\x5a\xca\x19\x92\x32\xc1\xc1\xa7\xa6\xe6\xa0\xed\x05\xf4\x7a\xae\x7c\x48\x4a\xbd\xc0\x10\xf3\x0a\x9f\x53\x2c\xba\xcd\x4e\x02\x5c\x78\x5a\x5b\x83\x80\xfb\x3a\xf0\xca\x19\xa2\xc9\x71\xab\x79\x08\xff\x3c\xfc\xd7\x60\xf6\xa4\x2c\x66\x0e\x2b\xe6\xe0\x8f\xe9\xe6\x86\xeb\xdc\x62\xaa\x02\x25\x42\x8a\x44\x58\xa5\xcc\x0f\x3a\x32\x50\xd1\x44\xf4\xd8\xf9\x6a\x11\xf4\xca\x11\x1d\x7a\x2c\x3e\x56\xf5\x1e\x53\x4b\xee\x89\x62\xd7\x94\xda\x2a\x0f\x08\x4e\x79\x24\x58\x0e\xae\xe5\xfb\xe9\x56\x62\x0d\xf3\x4e\x09\xe6\x74\x49\xa7\x8a\x3a\x16\xaa\xb7\x76\x45\xab\xdd\x66\xe9\xa2\x1a\xd9\xc5\xdf\xba\x3a\xe2\x31\xeb\x82\x43\x3b\x11\x12\x0e\xe3\x4b\x31\xc9\xb8\xea\xb8\xae\x27\xb4\x61\x93\x5f\xc4\xc4\x0c\x5a\xc9\x35\xb6\x64\x55\x95\x72\x3a\x3e\xd2\x16\x97\x1e\x1c\x22\x89\x43\x8f\x91\xb5\x0f\x57\x1d\x9a\x66\x85\x0e\xe7\xf7\x58\x2f\xd3\x16\x23\x27\xd2\x42\x79\x94\x6f\x5c\x86\xbc\x7a\x19\xeb\x66\x59\x18\xcf\xbd\x7a\x7b\xd1\x51\xa8\x3f\xd7\xcd\x7e\xf0\x40\x11\x8a\x20\x2e\x56\x19\x38\xfa\xff\x53\x77\xb5\xbd\x71\x1c\x47\xfa\xfb\xfd\x8a\xc1\x01\x81\x74\x38\x92\x92\x8c\x7c\x92\x3f\xd1\xd4\x4b\x78\x90\x28\x81\x2f\x0a\x2e\x92\xa0\x2c\x77\x87\xe4\x9e\x77\x77\xf6\x76\x76\x49\x13\x81\x00\x25\xde\x13\x98\x88\x46\xa4\x98\x8c\x69\x99\x12\xe8\x3b\x1d\x24\x07\x3c\x80\x96\x18\x1f\x8d\xc4\xf7\x83\xb8\xe4\x7f\xb8\xae\xaa\xee\x9e\xee\x99\xae\x9e\x99\x25\x69\xc8\x38\x5c\x60\x71\xa7\xab\xdf\xab\xab\xab\x9f\x7a\x0a\x0d\x01\xc4\x8e\x26\x16\xd9\xbd\x56\xe6\x13\x9d\x8b\x0f\xae\x38\x59\x7e\x30\x8b\x72\x47\x25\x99\x47\xb3\xd1\x16\x94\xbc\xc0\xd3\x55\x16\x7e\x7a\xb2\x6b\x9e\x20\x86\x15\xc5\x82\x5d\xbd\x89\x0b\xd9\x45\x0a\xb3\x2b\xb1\x65\x10\x5c\xd5\x3a\xd7\x55\xf9\xa3\xf5\x5b\x39\x28\xa7\x8f\xc3\xd5\xd8\xab\x98\x34\x85\x23\x8e\x26\x5e\x84\x00\x6d\x42\x2f\xdf\xd0\x32\x4c\xfa\x6c\xc4\x90\xe6\x6a\x28\x68\x19\x5e\x5c\xd4\x81\xb8\x54\xc1\x95\x4e\xb0\x1b\x7d\xad\x41\x98\x99\xb7\x69\x49\xf2\x55\x79\x5e\xa5\x30\x17\x66\x52\xd5\x2d\x71\x47\xb0\xed\x56\x4f\xf3\x70\x29\x13\x67\x80\xe2\x86\xa5\xc7\x1d\x70\xc9\x8e\x05\xec\xc2\x25\x20\x99\xe9\xb0\x61\x13\xeb\x81\xbe\xdf\xb7\x3d\xb5\xc0\xa0\x2d\xe6\xfc\xeb\x17\xe6\x0b\xa7\x29\x2c\xb9\x4c\x1b\x44\x1d\x85\x93\xea\xcd\xd2\xd3\x31\x99\x67\x98\xf7\x19\xfd\xae\x2a\x93\x1a\x6b\x61\xf7\x29\xbd\x33\x7d\x4d\x5a\x94\x00\xbb\x99\x27\x5e\xae\xde\xb6\xf4\x52\x54\x6a\xb5\x51\xba\xac\x8c\x82\xd6\x3a\x47\x83\xba\x08\xcf\xd5\x1d\x49\x7b\xd0\x66\x21\xa2\xe8\x93\x50\xd4\xe0\x78\xf1\xfa\xfc\x5b\x31\x56\x86\x27\x22\x2d\xbe\x9c\xef\x5e\x2c\xb6\x46\x70\x53\x68\x39\x36\xc1\xda\xd1\xfe\x0b\x08\x7f\x07\x25\xc0\x91\xf6\x90\x94\x4a\x33\xea\x51\x56\xe1\x26\xca\x0b\xce\x87\x63\x8b\x63\xc1\xa5\x8b\x1f\xfc\xfc\xe6\x48\x70\xe9\xba\xf8\xff\x8b\xd7\x59\xac\x84\x59\x4b\x70\xfc\xdb\x5d\x31\xf6\xe7\x8f\xb6\xd6\x2e\x67\xca\x97\x69\x81\xe2\x10\x01\xb4\x06\x12\x2d\x94\x6a\x52\xb2\xd1\xe0\x5e\xd0\xb7\x30\x1a\xa7\xd1\xdc\x56\xaf\x39\x0f\xc4\xa5\x0b\xf2\x40\xf1\x0d\x4d\x92\xea\x67\x6d\xab\x98\xcc\x34\x9a\xd7\x27\x9e\x43\xf3\xb2\x75\x75\x60\x54\x8b\x6c\x24\xda\x3e\xe4\x51\xf2\x71\xcf\xcf\x8d\x8f\x27\xe6\xa9\xa4\x24\xa3\xac\x50\xd5\xa8\xb5\x50\x5f\x44\x37\x01\x17\x2f\xf9\xd7\x5d\x00\x00\xca\xcb\xbc\xcc\x98\x27\xe4\x65\x12\xd9\x21\x07\x19\x53\xff\xf4\x0d\xd8\x97\x74\x61\xd7\xce\x33\xed\x1c\x4e\x1e\xac\x50\x49\xce\x43\x60\x8d\xd0\xe2\x4d\x96\x8a\xa0\x40\x2d\x3a\x99\x63\x52\x13\xad\x03\x5d\x87\xf8\x61\xa5\xd2\xa9\x01\x65\xc8\x8c\x30\xd1\x9b\xc6\x8d\x0e\x24\x29\xe4\x0b\xbe\x18\x95\x6b\xc7\xcc\xf8\xf5\xab\x5e\xd4\xd2\xe0\x2d\xf3\xa0\x8e\x45\xd9\xc7\x58\x55\x96\x79\x85\x9d\x9b\xb9\x3a\xed\x67\x08\xd3\x6f\x9b\x3e\x92\x30\x10\xc3\x72\x68\x29\x09\x4c\xd1\x96\x7a\x78\x95\x89\xae\x5d\xce\x44\x32\x4b\x88\x03\xc4\xc7\x96\xef\x7c\xef\x76\xdf\x99\x6d\x8b\x47\x8b\xce\x6d\x23\xbd\x16\x46\xad\x10\x31\x50\xc8\x96\x22\x93\xa5\x49\x16\x1d\x32\x69\xc4\x21\xdd\x16\xab\x93\xdd\x21\x48\xe3\x12\x50\xf2\x71\x6d\x20\xfe\xfd\xf8\xf9\x3a\x6c\x1c\xa2\x3e\x41\x38\xd1\xf3\xcf\x06\x9f\xbf\x28\x72\xd7\x37\xda\xd8\x83\x4b\x77\x17\x33\xd4\xf2\x76\x0b\xd0\x95\x38\xc7\x23\x4f\x3c\x59\xc5\x23\xf2\x8e\x7f\x4e\xdd\xdc\xcf\x15\xe5\xb5\x90\x16\xa4\xa3\x66\x53\x98\x6d\xdb\x96\x6b\x5f\x17\x7d\xc4\x61\x30\x31\x81\x97\xec\x3b\x61\x27\x46\x44\xa6\x83\x4f\xb1\xdc\x1d\x3b\xa9\x24\x9a\x07\x8c\xac\x72\x79\xa2\xb3\x04\x34\x41\xa8\xfd\x99\x44\xfe\xa9\xfe\xe5\x5b\xb3\xe6\x57\x3a\x0a\x51\xba\x41\xb7\x6c\x37\xa8\x71\xad\xfd\xf3\xdf\x8a\xf0\x1c\x24\x0d\x6e\x57\x3a\x71\x7a\x44\xe8\x15\xf3\xf6\xa4\xfc\xa7\x18\xf6\xb2\xa3\x81\x96\xb2\x38\xd4\x29\x14\x43\xe6\x00\x2d\x9c\x77\xc6\x40\x42\x13\x34\x1d\xc8\x22\x76\x18\x6f\xa8\xaa\x2d\x49\x25\xe4\x8c\xc6\xc5\x36\x9c\x55\x00\x00\x0b\xa7\xc9\x40\xbb\x53\xad\xb2\xfa\xe7\x05\xd9\xcc\xb5\xe6\x09\xa4\x60\x07\x0a\x96\x1e\x5b\x3b\x76\x50\xbf\x67\xe6\x0c\xb1\xa7\x6e\xe2\xba\xee\x92\x21\x63\x53\x5e\xc3\xca\x77\x61\x49\x58\x80\x10\x07\xfa\x80\x50\x44\xab\xdd\x00\x40\xd4\x18\xcc\x1f\xbb\x4b\x46\xa6\x9c\xdc\x2e\x59\x29\x68\x7e\xe4\x8e\xa5\x62\xc4\xe4\x4a\x41\xf5\x5c\x72\x3f\xfb\x45\x16\xcb\x8c\xcc\x58\xae\xa5\x7a\x55\x85\x5a\x1b\x8d\xb2\xb6\x1c\x16\x76\xe2\xf1\x48\x2b\x70\xa4\x2f\xef\x31\x5a\x8f\xc2\x43\xb8\x54\x6d\x5c\x5e\xa4\xd4\x58\x17\x50\x38\x30\x6a\xcd\xca\x6a\x20\x4e\xc8\xe5\x90\xc0\x17\x4d\xf1\xbf\xc4\x08\x98\x7a\x42\x58\xee\x35\xc0\xd9\x2f\x0e\x96\x0f\x03\xbc\xbd\xd5\xb3\x77\x1b\x9e\xfd\x4a\x42\xdb\x62\xd3\x4c\xc1\xd3\xf9\x4a\x64\xf9\x30\xc4\x77\xd5\x30\xac\x71\x8e\x8b\xf7\xbd\xd9\xc1\xf9\xd5\x0b\x2d\xe6\xb2\x99\xb4\xdd\x95\x74\xb7\x78\x9b\xce\x6a\xdd\xe6\xb5\x3a\xce\x67\x29\xc5\x9e\x48\xf0\x71\xea\x80\xc0\x96\xf4\x0a\xa4\xbe\xea\x71\x24\x0d\xf0\x7c\x73\xb0\x17\x1c\x6d\xf7\xc5\xfa\x96\x08\xe5\xc3\xbd\x3f\x39\xb5\xa9\xab\x71\x65\x74\xd1\xd0\xfd\xd5\xa7\xc7\x89\xfa\x6b\x9c\x2b\xef\x6b\xaf\xc5\x0f\x62\x15\x56\x5a\xf2\xe6\x43\x0c\xf8\xb1\x95\x2a\x7c\xc8\xde\xfb\x24\x9f\x7a\xb7\xc3\x4f\xda\x61\x15\xde\x12\xe8\xa1\x03\x7c\xc1\x51\x15\x03\xb2\x6a\x97\xf1\x8a\x28\x5f\x34\x58\xe3\x6b\x0d\x30\xad\xdf\x03\x99\xc2\xdf\xf0\x6a\x47\x2c\x96\xf4\x9e\x63\x4b\x60\x5a\x80\x1b\x5e\x66\x15\x51\x58\x0a\x88\x38\x94\xb1\x61\x84\x65\x0a\x2a\x9d\xc5\x1e\xc0\x4f\xd9\x97\x07\x40\xe8\xe3\xd9\xbb\x86\x28\x5a\x0a\x32\xc4\xd0\x24\xeb\x2a\xd1\x7f\x05\x8d\xf5\xe5\xdc\xd7\x2d\x82\xd5\x20\x1b\xa4\x91\x1b\x53\xf9\x36\xb4\xf9\xa1\xa7\xf2\x9c\xd3\xa9\x11\x41\xb0\x98\x09\xd8\x20\xa0\x1c\x5e\x6c\x08\x4d\xc6\x5a\x65\x06\x52\xcc\x72\xc2\x1a\xfb\xc8\x44\x6e\xec\x1c\x1e\xac\xe5\xac\x92\xd8\xc1\xfb\x54\x8a\xe6\x49\xb1\xad\x14\x3a\x99\xe3\xb3\xa4\x5d\x09\x8e\xfe\xf7\xcd\xd1\x63\xf6\xe2\x18\xfb\xf9\x57\x70\xeb\xff\x48\xbc\x47\xd2\xc8\xc9\xa1\x60\xc1\xde\xf8\x07\x94\xb0\x87\xa5\x32\xae\x1b\x4b\x28\x47\x68\x31\x66\x17\xfb\x16\x50\x46\x3a\x59\x05\x15\x9d\xf3\xb0\x10\x0f\x44\x42\x49\x3b\x44\x5d\xe5\xf3\xc6\x97\xaf\x63\xc8\x9c\xf1\x85\x2b\x6a\x19\xe1\x0e\x61\x1c\xf5\x3a\xca\x71\xc0\x39\xe6\x64\x60\xc2\xcb\xa7\x47\x5f\x3d\x35\x3d\x14\xc3\xd4\x68\xf8\x29\x72\xaa\xcb\x84\x86\x17\xad\xce\x19\xd1\x92\x37\xaa\x3e\x89\x14\x9c\x27\xff\x9b\x3f\xee\x4c\xd5\x2a\x43\xf4\x92\x32\xbc\x78\x18\x95\x9f\xc5\x0e\x46\x43\x60\xa7\xfb\x59\xcc\x39\xa0\x5c\x45\xc0\xff\x05\x45\x12\x63\xa9\xd8\x98\xa1\xfa\x26\x98\x96\x8c\xfd\x88\xd1\x29\xb6\x8c\x38\x09\xfc\x43\x6d\x62\xc2\x74\x8b\x01\xec\xa9\x15\xae\x84\x9d\x31\xe0\x09\xef\xe8\x30\x6d\x19\x5e\x51\x8f\xb1\xac\x34\xae\xed\xa2\x2c\x92\x85\x00\x5d\x2c\x9c\x39\xa7\x41\x60\x11\x7e\x4a\xc8\xb0\xcd\xfe\xd1\xf3\x0d\x33\x14\x95\x22\xb4\x09\x65\x0b\x91\xcd\x6c\xdb\x12\x30\x55\xde\x68\xfd\x84\x69\x37\xac\xf1\xcd\x3f\x1d\x6c\xec\xa7\x10\x96\x4a\xed\xef\x6d\x7e\xea\xdb\xc0\x7d\x8c\x14\x6b\x84\xd3\xb9\x79\x0a\x83\xc9\xf0\x07\x96\x6e\x5f\x81\xdb\xc1\x89\x6c\xff\x22\x79\x34\x0a\x6f\xf7\xec\xe1\x79\x4a\x8e\x9c\x22\x87\x6d\xd1\xf1\x34\xcf\x5c\x68\xdb\x29\xcd\xb9\x97\x07\xfe\x04\x0d\x75\xb8\x27\x32\x2d\x2e\xb0\x67\x92\xcf\x98\x41\x75\x70\x76\x0f\xdf\x76\xc7\xbb\xc1\x69\x0c\x31\xe7\xfd\x1f\xaa\x91\x16\xaf\xfe\x4f\xd2\x69\x99\x17\x15\x7b\xa2\xa9\x6c\x44\x15\xed\xe3\x05\x08\x42\x8c\x57\x11\x34\x40\x28\xed\x9e\xc7\x62\xf9\x7a\x1b\xb9\x19\x54\x28\xc6\xb7\x9a\xad\xe3\xab\xa7\x18\xe4\xbe\xdd\x17\xd7\x52\x53\x54\x4e\x1b\xce\xe8\xa4\xd0\xcd\x2c\x30\x0c\xe6\x79\xe7\xad\xd2\x38\x15\xcb\x57\xf1\xab\x7a\xfb\x9a\x18\xeb\x8f\x56\xc5\x65\x1b\xb2\x6f\x88\x3f\xc1\xbf\x27\x00\xdd\x03\x97\xc1\x3a\x9f\xdd\x2d\xbf\xb4\x9a\x04\xd5\x2c\xa6\x3d\x2c\x9f\xf4\xdc\xf4\x0d\xa6\xc8\xc9\x58\x31\xce\x80\xff\x42\xb5\xc8\x08\xee\x44\x36\x6b\x4c\x75\xd0\xa5\xb8\x3f\x69\x55\xc2\xe6\x46\xfa\xb3\x02\xa4\xd6\xfa\xb6\x6f\x44\xe7\xbe\xdb\x97\x10\xf7\x34\x47\x83\x51\xff\x70\x1d\xa8\x00\xfa\x61\x14\xd1\x0f\xed\x4a\x1c\xaf\x44\x1d\x74\xb7\x37\xa2\xc5\x3a\x3b\x96\x1a\xda\x00\x38\xbe\xbd\x47\x83\xb7\x6b\xc7\x5b\xd9\x28\x5b\x9d\x51\x90\xad\xdc\xd0\x8c\xdd\x0a\x1f\xd6\x91\x56\x3d\xc7\x9f\x82\x60\x8f\x54\x00\x42\xe3\xb8\x93\xd2\x2b\x8c\x65\x50\xf5\xa4\xca\x97\x49\x11\x01\x25\xf2\x49\x15\x52\x3d\xe2\xe0\x3c\x42\x56\xae\x08\x4f\x59\x38\xd8\xf2\x5b\x80\x28\x04\x4e\x08\x3d\xc9\x98\x1c\x57\x5a\x9d\xb2\xf1\x60\x29\xa2\xa9\xa4\x84\x5c\x1e\x5c\x68\x17\xd5\xd6\xb1\x72\xa5\xe2\x4b\x0a\xaf\x8b\x92\x6f\x4c\x08\x1f\xd6\xe2\xab\x83\x38\xaa\x7e\x83\x94\x22\x85\x34\xbc\xf1\x9d\x24\x9b\x32\xc2\x58\x58\xa5\x7b\xe7\xea\xf4\xcc\xe4\xad\x29\x36\x91\xdd\xdb\xfe\xd1\x4e\x9f\x99\xbf\x3b\xc0\xd3\x17\xfc\xcb\xcc\xad\xa9\x20\x9a\xff\x37\xc8\x95\x26\x99\xdc\x0c\xab\x6d\x54\x12\x91\x55\x25\x88\xaf\xd7\x21\xb4\x52\xbb\xd2\x11\x4d\xed\x8a\x9b\xe1\x48\xb2\xc1\x64\x72\x81\x7a\x6b\xb4\x01\x68\x9a\x08\x03\xe8\x2a\x38\xa7\x63\xc1\x35\xa4\x75\x55\xd9\xd1\x25\xa2\x3b\xac\x79\xe4\xc6\x21\x38\x30\xab\xe8\xbc\xa6\x5f\x55\x66\x78\x0f\x39\xac\x07\xbf\x04\xd3\x07\xa1\x81\x32\x2a\x16\x57\x0e\x5a\x63\xb8\x41\x00\xc4\x0c\xb0\x50\xcd\xc4\xf1\xae\x1f\x48\x58\xe2\xe0\xf5\x2b\xc8\x2e\x89\xb1\xd1\x80\x2e\xa2\xec\xea\x14\x89\xaa\xc8\x9f\x70\x18\xc1\x85\x7f\xb0\x7e\xb4\xf3\x42\xac\x91\x31\x09\x30\x97\x72\x1d\xa2\x92\x54\xec\x70\xeb\xe6\xe9\x6b\x11\x48\xb7\xf3\x26\x18\xec\x1e\xc0\xaf\xa0\x03\xf7\x0e\x84\x0a\x2f\xa0\x7d\x4f\x7d\x8a\xeb\xad\xf7\x6f\x6a\xd9\xae\xf7\x08\x63\x85\xb9\x2f\xce\x09\xf3\x6f\x54\x5d\x41\x46\x31\x2c\xf7\x9c\xca\xba\x37\x1f\x06\xad\x70\x51\xc8\x5b\xe6\x74\x99\xb3\xb4\x95\x53\x1f\x1e\xd6\x80\x15\xee\xc5\x3a\xce\xec\xdf\x8b\xc2\xe4\x34\x87\xdb\x14\xaf\x49\x55\x32\x13\x8f\x1a\xbd\x43\xec\x23\xb7\xe5\xf1\xea\xc1\xc4\xab\xb3\x34\x38\xfe\x72\x93\x3d\x38\xa5\xcb\xc7\xab\x55\x98\x92\x60\x9d\x00\xfa\x76\x04\x41\xf1\x9d\xae\x0c\xb2\x91\xef\x20\x31\x51\xbb\xa9\x48\x0a\x56\xc1\xdb\x61\x12\x2a\x12\x0a\x0d\x93\x11\x34\x55\xde\xed\x88\xbd\x30\xa2\x02\xde\x29\xf3\x06\xa7\xf5\x7f\x39\x3e\x3d\x35\x39\x75\x9d\x48\x80\xe8\xe0\x84\xf5\x8f\xc6\x93\x36\x48\x20\x94\x43\xbf\x99\xd1\x22\xc7\xf8\x33\xf0\xd6\x2d\xd5\x17\x97\x1a\xab\x10\x85\x56\x15\x65\x2a\x8b\x61\x0d\x45\xfd\xab\x25\x00\x60\x05\x62\x25\x2d\xd7\x29\x72\x13\x30\x7f\xa0\x0e\x63\xec\xbe\xfc\x11\xd8\x48\x3b\xb4\x8f\xa8\xfa\x78\x29\x6c\x34\x84\xfc\x18\xe2\x9f\x81\x49\x8d\x73\xfb\xbe\xfd\x41\x74\xf9\xb2\xd1\x93\xb4\x5d\x44\xef\x78\x88\x93\xa2\x50\xb7\x6d\x43\xb9\xa9\x80\xa0\xcd\xb5\x20\x21\x5b\x4c\x09\xc1\x60\xb2\x27\xaf\x40\x99\x89\x83\x67\xf0\x72\x5d\x72\xc2\x52\x0c\x1d\xc4\x09\x49\xf3\xf0\xf7\x5b\xc1\x31\xc4\xa3\xbc\x4a\xc2\xab\xe1\x71\xf9\xeb\x17\x83\xa7\x49\x10\xae\x81\x96\xcd\x9b\x96\x00\x43\x57\x24\x4b\x63\x84\xe1\x34\x42\x31\xc4\xc4\xd2\x48\x90\x2b\xcb\xd5\x21\x91\xb2\x76\x7c\x6c\x96\xf9\x1a\xcc\x31\xb1\x12\x5b\x8b\xa2\x48\xc2\xd7\x14\xe9\x44\x9a\x24\x06\x57\x02\xbd\x8f\x05\x1f\x5c\xbc\x08\xbf\xff\xfc\xd2\xc5\x11\x15\x8a\x9a\x95\x0b\xef\xbc\xf3\x61\xd8\x52\x29\x80\x46\x10\x4b\x42\x9c\xbb\xed\x25\xf4\x11\xc3\x1c\xc7\x30\xc5\x13\x8d\xa8\x57\x13\xea\xb1\xd7\xaa\x75\x56\xcf\xc5\x81\xb8\xb0\x57\xe6\x2b\xb1\x50\x99\xe3\x62\xd6\x3f\x6e\x45\x2b\x8d\xb0\xb6\xa8\x69\x04\x32\x75\x29\x14\x39\xc5\xb0\xd5\xe8\x0d\xcd\x12\x6a\x52\x5d\xea\x61\xa2\xf7\xf8\x58\xee\x3b\x4d\xd3\xcd\x86\x4b\xc9\xc5\xa5\x43\x88\x81\xab\x53\xc5\x4c\x59\xa1\x54\x59\xea\x81\x6f\xff\xe3\xe8\x65\x5f\x1c\x74\xd6\xd1\x99\x38\x8e\x70\x61\x7e\xb6\x21\xdd\xcf\x69\x66\xab\x2f\x1e\xeb\x1b\x47\xa6\x24\xac\x46\x98\x0f\x79\x5a\x8b\x39\xd1\xfc\x04\x80\x80\x56\xc4\x8a\x32\x74\x4b\xfc\xf4\xcd\x1e\xd3\x4e\x90\x64\x8d\x19\x9e\xbb\xe4\x3c\xe8\xef\x0d\xde\xee\x80\x1c\x4a\x99\x0c\x5a\x65\x53\x5c\x85\x76\xd6\x12\x40\xf5\xe0\x77\x6f\x0e\xdf\xbe\x19\x3c\x7b\x8a\x61\x72\x32\x05\x13\xe4\xde\x14\x8b\x1b\xfe\x24\xc4\xdb\x69\x9d\x8c\xce\x10\x92\x60\xe3\x1b\xbc\x69\x99\x44\xe8\x29\x4e\x50\x67\xbb\x0d\xc5\xa7\xa2\x03\x85\x41\xf1\x04\x8d\x05\xbb\x3f\xd2\x7d\x22\xe3\xf9\xfc\x7c\x0d\x67\xb2\xe9\x74\x12\x36\xf7\xa6\xa3\xdd\x04\x48\x85\x4c\x44\x0b\xc5\xf4\x9c\xf1\x7e\x1a\x6e\x1b\x25\x6d\x34\xf7\x91\xda\x5c\xc0\x2e\x1d\x54\xba\xdd\xb0\xd9\xee\xea\x0a\x9a\x95\x5a\xa8\xc8\xa6\x2a\x55\xd7\x38\x7e\xa8\x61\x4d\x66\x6a\x58\x54\x40\x10\xe2\x56\x13\x77\x9a\x4e\xb4\xaa\x88\x4d\x53\x73\x60\x44\xf7\xc9\xb1\xc9\xb4\x55\x8c\xc4\x02\x04\xa5\x39\x6b\xc1\x1c\x80\xe2\x20\x52\xd0\x33\x60\xbf\x95\x36\x3b\x0d\xbe\x62\x8f\x1b\x05\xbf\xf7\x28\xf9\xbd\xa3\xcc\x8f\xb2\x35\xd8\xcf\x66\x5b\x47\xbc\x56\xc5\xbc\xb5\x7a\x6c\xb0\x78\x09\x25\x63\xe5\xe7\x3b\xa9\x86\x11\x5b\x54\x6d\x9f\xf7\x4c\x3d\x58\x9b\xfd\xcb\x47\x2e\xc5\x81\x8e\x99\xac\x9e\x38\xa9\x6a\x70\x0d\x24\x41\x7f\x9e\x69\xd2\x32\xec\x8f\x38\xf7\xff\xd8\x77\x85\xc8\x72\x53\xa1\x32\x3e\xea\xa8\x5f\x2a\xa8\x43\x8c\x33\x09\x8a\xd1\x2e\x91\x03\xcb\x4f\x90\x0c\x72\x37\x46\xd1\x29\x8c\x48\x16\xf8\xb5\x2c\x0f\x13\xe7\x7a\xc6\xd6\xab\x46\x21\x95\xc3\xce\xa6\xb0\x6e\xf0\xcf\x5f\xf6\x91\x60\xc7\x61\xdd\x94\x53\xb2\x75\xd0\x62\x5d\xf0\x9a\x20\xe9\xaa\x35\x55\x1f\xa6\x76\xbb\x41\xc4\x38\x1f\x2a\x8d\x02\x21\xef\x48\x41\x48\xc0\x84\xd8\x99\xf3\xd4\x2e\x59\x69\x88\x0a\x21\xfe\x0c\xb9\x46\x3a\xf5\x66\xa5\xb3\x8a\x51\xad\x55\x08\x6d\x49\xf8\x45\xcc\x46\x62\x78\x6b\xbb\x81\xa1\xce\x19\x25\x84\x91\x6f\x75\xd8\xf8\x4d\x4c\x53\x05\x7b\x7f\xf9\x52\x30\x63\x67\x1f\x86\xf7\x68\x69\x56\x79\x0b\x7e\x80\x5f\x42\xce\x8c\x10\x80\xb8\x6e\x05\x8c\x0a\x5b\xd4\x01\x6f\xf0\xd8\x3a\x51\x0c\xff\x7b\x2c\x08\x7e\x19\x26\x1c\xff\x10\xc5\xaf\x74\xa7\xfc\x5c\x43\xa1\x90\x5d\xab\x47\x60\xac\x5a\xb4\xd2\x52\x1f\x25\xda\x0c\xd2\x3c\x62\x6e\x96\x5a\x0d\x39\xfb\xc5\x24\xa5\x9a\x30\x1f\x62\xf6\x0d\xe2\x5f\x1f\x0b\x6e\x81\x8d\xe6\x3b\xd2\x9a\xf5\x45\xe0\x38\xa9\x8d\xa8\xca\x12\x02\x51\xd1\x58\xea\x0d\x04\xb6\x7a\xcf\xa6\x12\x0a\x35\xb3\xfd\x41\x95\xfd\x6e\x7f\xf0\xdd\x23\xf5\x85\x7e\xc1\xcf\x55\x01\x45\x4c\x2b\x0c\xa7\x46\xe0\x0b\x54\x4d\x54\x29\x2e\xba\x4d\xab\x8d\x5b\x9a\x22\x78\x7b\x07\x05\x52\xd0\xc3\x1f\x30\x35\xac\x18\x23\x4d\x5d\x03\x9a\x4b\x4c\xb4\xfc\xb7\xca\x2b\xc9\x99\xa2\x32\x22\x7d\xf0\x5a\x5c\x76\x9e\xc9\x2d\x6c\x65\xa6\x4d\x5e\x33\xc5\x8a\x83\x12\x42\x51\x1d\x6f\xf5\x15\xaf\x92\x5b\x9f\xd1\xfa\xcc\x7c\x9d\x7c\x03\x2f\xcf\x7b\x1b\x87\xff\x77\x40\x89\x6d\x3f\x35\x46\x38\xe9\x0b\x70\x37\x28\x58\x9d\xe6\x42\x7e\x86\xbc\x30\xfa\x56\xf5\xdd\x06\x06\xae\xa5\x99\x53\x24\x41\xbe\x1a\x53\x19\x67\x2f\x44\xdb\x6a\x57\x51\x80\xa9\x56\xc0\x78\xff\xe7\x13\xa7\xbe\xce\xe8\xd6\xd7\x6b\xe2\x73\x78\x37\xdf\x59\xa3\xe8\x13\x70\x59\x09\xad\x6c\x8e\x1e\x9c\x4f\x49\x67\xf8\x33\xa6\x8c\x92\xac\x74\xc0\x44\xb9\x0c\xfc\x6b\xc4\xc4\x09\x51\xb0\x36\xcb\x0d\xd1\x68\x01\xc4\xc8\xf8\x24\xb6\xbe\x89\x25\xeb\xac\x4e\xf3\x91\x77\x87\x36\x88\x3c\x75\x85\x99\x38\x63\x64\xe3\xba\x1c\x18\xdf\xc5\xb9\xb4\x9f\xdc\xd8\xb3\xf7\x5f\x35\x00\x92\xef\x09\xc2\xa5\x29\x1b\xa2\x74\x59\xc5\x61\xf7\x01\x24\x71\x89\x1f\xcc\xaf\x3e\x50\x90\x07\x0e\xf1\xa4\x7a\x07\x9b\xeb\x0f\xff\x9d\x38\xa7\x38\x31\x56\x9c\x2b\x5c\xa7\x72\x1a\x49\x28\x67\x48\xd1\x05\x0d\x05\x0f\x4f\xde\x30\x5b\x5c\x84\x16\x6f\x8d\x3c\xcf\x99\x1a\x3b\x75\xa1\xae\xc5\x6c\x0b\x93\x3a\xaa\x21\x01\xf1\xb5\x49\xc8\xc8\x9b\x24\x00\x88\xbb\x35\x61\x2d\x33\xf5\xd3\x8f\x8a\x43\x1f\x8a\x42\xc5\x28\x4f\x68\x9d\xc1\xae\x68\xd2\xe7\x7c\x6a\x19\xaa\x5d\xb1\xa0\x2f\x83\x13\x11\x4f\x1c\x99\x99\x71\xa1\xce\x21\x68\xc9\xc1\xab\x9c\x21\x88\xb4\xf7\x56\xf4\x2b\xc8\xd7\xd3\xa9\x2e\xd5\x97\xc3\xe4\xf1\x48\x7a\x67\x0b\x20\x4e\xa1\xb8\xb0\x99\x8e\xbe\xdf\x07\xb7\xe0\xc1\x7a\x8a\x35\x6e\xdf\x1b\xe5\x79\xf7\xe6\xdc\x8d\xd9\xc9\xdb\xe3\xd3\xb3\x17\xae\xdd\x9a\xbe\x39\x7a\x65\x7c\x76\x3c\x98\xb8\x35\x35\x7b\x75\x6a\x36\xf8\xc5\xe4\x95\x2b\x57\xa7\xee\x33\xf5\xde\x05\x3d\xfb\xea\x19\xb8\xcf\xc5\xfa\xbf\x70\xf4\xe7\x67\xc2\xee\x4c\xec\x65\x33\x4b\xe4\x1a\x58\xc6\x47\xaf\x9f\xde\x67\x1a\x71\x7b\x7a\xf2\xce\xf8\xec\xd5\x00\x6b\xcf\xa9\xd5\x40\x25\x27\x55\xe5\x55\xe0\xe2\x5e\x8e\xd9\x2a\x2c\x0a\x54\x4e\xe4\x62\x23\x9a\x17\x76\x81\xa4\xa6\xba\xaf\xaf\x56\x77\x15\xca\x3e\x1e\x1b\x1b\xbb\x1f\xdc\x55\x7f\x57\x1f\xb2\xfd\x3a\x78\x04\x6f\xd8\x90\x7a\x09\xbd\x76\xf7\xa5\x55\x1b\xdc\x25\x40\x3e\x49\x53\x18\x7d\xfa\xc4\xdd\x34\x52\x22\x6c\xb4\x9d\xdc\xe8\x5c\xd9\x6e\xc4\xc2\x76\x37\xbf\x16\x83\xcd\x94\x6b\xb0\x29\x9b\xff\x02\x77\x22\xb6\x54\xb4\xc2\x86\xea\x1d\x7f\xb1\x86\xa4\xdd\x6f\xb8\xc2\x45\x12\x27\xe5\x27\xf2\xf1\x46\x26\xb2\x45\x84\xed\x57\x89\x97\xd8\xb6\x23\x7c\xf0\xbb\x6f\x06\x7f\xe4\x2b\xe5\x67\x88\xab\x15\x20\x68\x8a\x3a\x6b\x41\xa8\x5f\xbe\x76\x42\x94\x29\xbe\x30\x4c\xce\xe1\x96\x99\x30\x26\x73\xd3\x97\xa2\x33\x66\xc4\xa0\xe9\x7c\x39\x41\x87\x71\xd2\x94\xa9\x62\x7e\xea\x96\xa8\xb4\x1e\xfb\xa0\xa9\x54\x1c\xf3\xa6\x39\x0f\x90\x11\xb4\xef\x01\x8c\xc2\x0e\x15\x28\xb1\xe7\xfb\x84\x1e\x41\x7e\x2c\xe8\xef\xbe\x97\x9c\xa5\xda\xee\x31\xc2\x26\x6e\xcf\x31\x45\xfc\x8b\x05\x17\x0a\xbb\xd0\xb1\x30\x9f\xed\x92\x4a\xf3\xe7\x76\x2d\x49\xf2\xcf\x22\xe5\x5f\x09\xbd\xc2\x95\xc6\x5c\x9c\x6c\xc9\x24\x89\x26\x53\xbe\x1e\x17\xd9\xe5\xf8\x20\x71\xbc\xc9\x8c\x80\x10\xc2\xc6\x5b\x6c\x6c\x80\x0d\xfb\x5b\x86\x5d\x04\x4a\xb2\x2b\x48\x15\x65\x56\x50\x41\x20\x47\xfe\xcb\x1e\xc5\xc1\x70\xad\x50\xd1\x28\xbe\xb2\x99\x18\x16\x4c\x79\x25\xa9\xef\xe8\x93\x11\xca\xd4\xd0\x0a\xc4\x8a\xd7\x7f\xf4\xa0\x0c\x38\xa2\xb6\x47\x2a\x2a\xc6\x24\x81\xc3\x8b\xdf\xe3\xf5\xf4\x9f\xc1\xee\x18\x3c\xf9\xd2\x78\xdf\xa1\x1c\x17\x59\x09\x26\x1f\x1d\x61\x89\x7e\x5d\x5d\xd0\xee\x17\xec\xc7\x28\x35\xf9\xd7\x36\xf1\x66\xce\xb3\xb6\x67\x78\xec\x91\x90\xc3\x63\x8f\xd9\x50\xc3\xe3\x18\x07\x18\x1e\xc7\xa8\x71\xc3\x93\x95\xe0\x1d\x9e\xe1\xc7\x85\x4d\x04\xa6\xab\x66\x97\xfe\x0a\x8f\x6d\x7b\x06\x2c\xc5\xbe\xe4\x36\x14\x61\xc7\x6a\x3b\x0f\x62\x46\x12\xd7\x23\xd0\xec\x76\x07\x3c\x51\xdd\x55\x05\x78\x8b\x97\x4c\xa2\x53\x48\x57\xc4\x69\x14\x8b\xc1\xde\x21\x4a\xcc\xe2\x79\x71\x45\xfb\x27\xc8\x39\xa4\xa7\x69\x4d\xa7\xe6\x62\x94\x10\xba\x84\x3c\x66\x06\x26\xe6\x75\x17\xa5\xc3\x3a\x10\x17\x3a\xca\x69\xb6\xb0\x00\xf6\x7d\x0c\x59\x39\xc3\xea\x52\x84\xbe\x37\xfd\x7a\x2c\x6a\xe9\xac\x1a\x51\x9f\x57\x12\xfd\xcd\x9f\xab\xd6\x73\xfe\xe6\xff\x0c\xfe\xf2\x0d\x7a\x64\x7e\xd8\x3a\x7a\xbc\x11\xc0\xbd\xfc\x87\x8d\x74\xf8\x20\x5a\x05\x6c\x3d\xee\x7e\x88\x6e\x78\x70\x5e\x0a\x8d\xe9\x41\x27\x2c\x74\x42\x74\xc0\xb5\x2b\x75\xf6\x44\xde\xdd\x1f\xfc\xd7\xba\xf2\xd0\x8a\x8d\x22\xfe\xe5\x16\x96\x0d\x05\x12\xfb\x9e\x91\xea\x88\x01\x7a\xc4\x10\x4f\x3a\xc5\x2a\x6b\x53\x5c\xa1\x8b\xd7\x90\x24\x92\xc4\xa1\x37\x28\x1c\x39\x63\xd4\x59\x37\xa6\x81\xa4\xa4\x5c\xa5\xea\xd6\x95\xaa\xf4\x8c\xeb\x5c\x8f\xa3\x98\xcd\x09\xa1\x58\x92\xdd\x25\xf5\x03\xb5\x24\xe9\x6b\xd4\x9b\x75\x7e\x93\x98\xa4\x1e\x09\xe1\xde\xe6\xf6\xe1\x3b\x66\xb9\x28\xf1\x68\x2e\x2a\x0a\x83\x49\x00\xdd\x00\x18\x58\xcc\x48\x1c\xb5\x88\x33\xf6\x93\x7a\xd7\x5a\xc0\x23\x70\x6a\x77\x1f\xc4\x49\xea\x2f\xf8\x84\x32\x81\xf1\x40\x6f\xa3\x85\xee\x2a\xc1\x2d\xb6\xbd\x33\x54\x95\xde\x0e\xf2\xf7\x97\xa4\x45\x39\x12\x58\xf0\xa6\xd9\x29\x4e\x06\x66\xea\x0d\xea\xad\xa5\xb0\x53\xef\x52\xf2\x51\x71\xac\x2a\x30\x66\x0e\xf6\x52\x33\x19\x11\x04\x6e\xdf\x48\x07\x0a\x81\x64\x8f\x3f\x93\x39\x43\xfd\x95\x2f\x6b\x98\x96\x3a\x05\x26\xae\x3d\x98\x99\x1d\xbf\x3e\x39\x75\xfd\xc1\xec\xe4\xcd\xab\xb7\xe6\x66\x95\xb6\x62\x67\xd0\xd6\xfd\x59\x01\xe4\x79\xca\xb6\xf3\x70\xef\x4f\x86\xec\xa1\xda\x39\x3d\x3b\x77\xfb\x44\xed\x34\x05\x9c\xa0\x9d\x8d\xca\x7c\xc8\x5e\xc6\xd1\xb1\x3b\x38\xd8\xe0\x8a\x02\x70\x4f\xbd\xff\x70\x32\x5e\xaf\xc1\x23\xec\xeb\xdf\x4b\x3f\xbe\x47\x54\xaf\x4d\x77\x2f\xd6\x0c\x51\xa2\x94\x2b\x5c\xe1\xf8\xc5\x21\xcc\x2c\x55\x54\x30\xbc\x6d\x81\x8c\xae\xec\x4d\x0a\x08\x01\xf8\xb2\x2f\x77\x0e\xbf\x67\x2c\x9a\xa6\x8f\x54\x35\x87\x50\x95\xca\xb2\x43\xa0\x0a\x33\xfd\xf5\xc1\xaa\x3d\xe7\x6c\x2b\x6a\x05\xf3\x95\xb8\x5e\xd5\x0f\x4d\x7c\x14\x31\xbe\xc0\x24\x8f\x02\x1e\x6f\xa1\x90\xca\x67\xb3\xf7\x15\xeb\x52\x2a\x70\x8d\xed\x94\x5e\x0c\x61\x13\x79\x8e\x1e\x72\x5f\x20\xfd\x84\x3a\x84\xdc\xdb\x82\xa9\x36\x8f\xe3\x80\x2d\xc5\x2a\x63\x5f\x31\xb8\x6b\x70\xe5\xd0\xde\x77\x97\x03\x43\x48\xbf\x1c\xe2\x3b\x20\x27\x04\x0d\x21\x13\x3c\x84\x8f\x30\x9c\xd4\xee\x52\x29\x8c\x2c\xd4\xec\x8d\x37\xe6\x8b\xb1\xe9\x0e\x7d\xe5\xa2\xb8\xee\x73\x48\x60\x34\x15\x53\x94\x00\xc8\xac\x93\x12\x51\x8e\x2c\x65\xe8\xbf\xfb\x12\x9e\xe7\x65\x3a\x07\x18\xab\xa4\x67\x2e\x47\xd1\x9a\x2c\xf7\xd8\x97\xc2\x54\xaf\x77\x5f\x32\xd3\x94\x2c\xf6\xd4\x4f\x09\x63\xbb\x44\x41\xe2\x00\x60\xea\xd4\xe7\x91\x96\x13\x7c\x26\x0f\x70\xa0\xce\x29\xf6\xde\xd2\xbd\x4d\xcb\xd4\x56\xca\xe9\x89\x24\xbd\x7a\x7a\xf2\x30\x4e\x63\x48\x71\x3e\xca\x67\x1d\x2b\xc2\x94\x25\x7c\x16\x37\x8d\x3a\x9b\x86\xbb\x74\x79\xe6\x10\x4e\x0e\x6a\x20\xd6\xcd\x27\x95\x8e\xb7\xf0\xd0\x04\x23\x7e\xa9\x43\xd1\x7c\x14\x13\xc9\xbb\x35\xcb\xcb\xfc\x38\x64\x49\xd7\x4d\xbc\xa7\x5f\x88\x47\x0d\x17\x53\xfc\x36\x92\x29\x57\x94\xf6\xc7\x7b\xa5\xe5\x0e\x13\x53\x1a\x5d\x6d\x9c\xdd\x81\xee\x32\xa6\x60\xdd\x33\xdd\x2f\xf6\x8f\xbf\x62\x8c\x9e\x7c\x86\x53\x4f\x39\x8a\xed\xe6\x6f\x51\xa9\x40\x6d\x46\x9f\xa2\xa8\x1c\x21\x5c\xd1\x78\x49\xa7\xb7\x30\x1c\x0e\xe0\x40\xf7\x78\xd3\x66\x66\x7e\x21\xc3\x8b\x4c\x77\x83\x0c\x17\xdb\x5c\x13\x86\xb4\xc6\xcb\x90\x37\x80\x31\x8d\x73\x6a\x87\xdb\x20\x0d\x93\xb7\x6b\xf2\x26\x78\xc6\x8d\xf2\xfb\x17\x3d\x95\x9f\x46\xad\xa7\x36\x12\x43\x35\x46\xcf\xc7\x02\xfb\x4c\x9b\xaa\xd2\x33\xea\xdb\x92\xea\xa5\x5c\xcd\x27\xe9\xff\x89\x97\x80\x9a\x84\x72\xdd\x3f\x49\xbf\x4f\x63\xda\x87\x9f\x6f\xb8\x3a\x99\x73\xce\xd5\x5e\x7c\x9c\xb7\x0c\x6f\x42\x89\x61\xc0\x77\xb0\xd6\x50\xed\x18\xb6\x01\x5d\xcf\xeb\x2f\xc5\xc5\x72\x9a\x14\x72\xdc\xf8\x6c\x2a\x48\x55\xe3\xb1\xa9\x7c\x36\xba\xc7\x32\x27\xc7\xdf\x50\x05\x23\x20\x9e\xe5\x4a\xe2\x4b\x0b\xbf\x60\xa8\x70\x50\x41\xb4\xff\x25\x71\xb5\xa6\x2c\x9a\x8c\xb4\x4b\xc7\xcf\xd7\xa5\x3b\x2e\x38\x7a\xb9\xab\xd8\xc5\xbf\xea\x07\x39\xf5\x40\xd0\x3e\x3f\xa0\x87\x7b\xcc\x99\xdc\xc5\x4c\x26\x45\xbc\xc3\x76\x16\x16\x8f\x53\x18\xfc\xdb\xfc\x25\xf9\x78\x8b\x49\x76\xd1\x6b\x41\x58\x48\x4b\x25\x5b\xe8\xb2\xe6\xda\xe6\xba\x0a\x19\x40\x1c\x1f\xa6\x5b\xe0\x44\xfa\xdd\x51\x83\xdd\x7d\xf2\x48\x31\xc5\xcb\xf3\x52\x88\x22\xdc\x0a\xf3\x96\xe1\xf6\x91\x28\xc4\x6c\xa2\x5e\x5c\x59\xe4\x6f\x97\x39\xb9\x41\x00\x5b\xe8\x2d\xca\x5e\xd0\x2d\x52\xba\x3c\x11\x32\xa6\xd1\x2d\x69\x79\xe8\xc8\xd5\x55\xde\xe2\xdd\x5a\x73\x17\xf9\x0d\xe5\x01\x91\x48\xd4\x87\x0f\x83\xf3\x48\xc3\x46\x4d\xb8\x4c\x54\x2b\x75\x19\x4b\x3b\xd3\x85\x08\xa9\x87\x0f\xb9\x5c\x45\x69\x59\x28\x4a\xc6\xef\x73\x92\xb8\x46\x4d\x5c\x53\x44\x3e\xed\x3a\x5f\x9d\xfe\x4a\xd4\x94\x2f\xca\xc7\xd6\x61\x7e\x97\x43\xc9\x61\x7e\xba\x52\xa1\x94\xde\x5d\x8a\x14\xb8\x1e\x59\x43\x77\x3d\xd2\xc4\x73\xf9\xd5\x6a\xfe\x0c\x21\x84\x06\x2d\x25\x22\xe1\x09\x43\x04\x11\xab\xf0\x90\xaf\xa5\xd7\xea\xde\x5a\x90\x01\x0d\xb1\x68\xa8\xc2\xf1\xfb\x28\x90\xd2\x85\x74\x8b\x9c\xf8\xea\xa3\x2f\x72\xf1\xd1\x20\x94\x00\x44\x8a\xf7\xc6\x8f\x27\xca\x7e\xef\x83\xa2\x01\xd8\xa1\x1e\x7f\x3c\x07\xfb\x1d\x08\x0b\x17\x02\xf9\x17\xc9\x43\xe5\xc1\x48\x18\xc5\x2e\xa4\x4b\xb1\x75\x09\x1d\xac\x9a\xe5\x81\x19\xa4\xbe\x2c\x80\x3a\x70\xbe\x63\xcb\x0c\xb5\x9a\xce\xe7\x9a\x9a\x16\x3b\xb5\x3c\x32\xe9\x18\x61\x89\x31\xa5\x14\xa5\x6c\xbb\x09\x97\x8e\x67\xd6\x5d\x55\xeb\x24\xf4\x59\x96\x9d\xad\x4c\x28\x1a\x46\x2e\xbc\xdb\x37\x73\xd2\x3b\x1a\x5b\x9e\x76\x47\x3d\x16\xdd\x6b\xdd\xeb\xe2\xff\xd1\x88\x7c\x64\xe7\xb0\x56\xf0\xfa\x60\x05\x92\xee\x82\x8b\xfe\x1e\xf2\x30\xf7\xe2\x25\x5d\xf9\xbd\x7f\x44\x7b\x18\x73\xce\xa8\xf8\x14\xd8\xae\x32\xfb\xaa\x4e\xde\x4d\x91\xa3\x12\xc0\x1c\xeb\xf4\x83\x92\x41\x15\xb2\x1e\x21\x16\x46\xcd\x09\x93\xed\x1f\x88\x21\x5c\x54\x12\x49\xf2\x6d\x4b\x8a\x9b\xa8\x49\xf4\xab\xdd\x5d\x92\x69\x7b\x34\x6b\x93\x7f\x1a\xcd\xa1\xa2\x19\x04\x2c\xe7\xe3\x75\x74\x07\x61\xb4\x1f\x85\x63\x60\xee\xb8\x54\x76\x71\xb0\xfd\x5d\x03\x97\x4c\x9b\x8c\x2b\xdb\x09\x06\xc2\xcc\xb0\x60\xda\x14\x69\x90\xd6\x08\xd0\x47\x8b\x3e\xc4\x28\x93\x90\x86\xf4\x53\x4b\xc7\x31\xa6\xbe\x95\x83\x95\x68\xce\x2a\x05\xd7\xe7\xa9\xab\x86\x5e\x81\xb4\xf6\x7a\x27\x22\xd7\x32\xc5\xd1\xfc\x9c\x01\xdb\x16\xf0\x8c\x51\x04\x06\xa8\xc4\x56\x63\x35\x58\x89\x3a\x62\xaf\xf4\x30\x8d\xe6\xc4\xb5\xc0\x38\xde\x41\xf3\xdd\xac\x7c\x52\x6f\xf6\x9a\x09\x79\x2b\x51\x42\x24\x34\xaf\xd6\xb9\xcd\x93\xbb\x16\x68\x8d\x66\x9e\xcd\xb6\x42\x51\xbe\xea\x6a\xfe\x79\xd8\x76\x48\x2a\x58\x51\xc5\xc4\x8d\x49\xe3\x1c\xd5\x05\x61\x8f\x48\xb2\x3f\x47\x43\xcc\x2a\xe0\xcb\x64\x36\xe4\x81\x4f\xb1\x29\x16\xa4\x4d\x2e\x5f\x12\x86\xe1\x34\x7f\xdd\x16\xdb\x0e\xe6\xd5\xd5\x35\x93\xbb\x57\x1f\xa9\xf8\x74\x2c\x61\x5c\xfe\xe8\x77\x18\xd2\x06\x85\x19\x6a\x2a\x3a\x8a\x68\xe1\x97\x5d\xba\x80\x0f\x58\x0d\x6b\x22\x6c\xda\x87\xaa\xf8\x43\xee\x99\x6a\x14\xba\x90\x2a\xc3\xd6\x23\x34\x6a\x63\x56\x5c\x8a\x44\x19\xf5\x4f\x65\xf5\x15\xc1\xc8\x7b\x45\x24\x74\x64\xf9\x48\x7a\xa0\x79\x54\xe0\x01\x29\xcc\x0b\x53\x77\x7c\x9f\x33\xa4\xe9\xcf\x21\x8f\x5a\x27\x5a\xec\xf0\xf1\x0e\xae\x3a\x5e\xf7\xbd\x6f\x2a\x8e\x22\x71\xaf\x0a\xa9\x59\x4a\xf5\xa4\xff\x2d\x7b\x35\xc9\x40\x12\x75\xfa\xc7\x0a\xe4\xa2\x24\xca\x03\x84\x38\x12\xda\x84\xaf\xd5\x16\x93\x00\x1b\x77\x0f\x40\x2b\x7e\xb1\xaf\x60\x74\x83\xfe\x53\xe4\x25\xda\xd7\x28\xc7\xdc\xed\x91\xd7\xc2\x93\xb6\xec\x84\xed\x29\x0c\x07\xf5\xb4\xc5\x09\xff\xcc\x6d\x88\xc9\x83\x7c\x9e\xb6\xa8\xb0\x7a\x6e\x80\x27\xe0\xe1\xc3\x9b\x96\xaf\x63\xc4\x04\x91\x59\xdf\x05\x4e\xe4\xdc\x88\xe6\xa2\x8b\xd5\x77\x2a\x3f\x79\x42\x7c\xaa\x7f\x52\xc6\xea\x48\x60\xa2\x08\x50\xc7\x4f\x45\xad\x8f\x00\xfe\xa1\x8a\x8c\x13\x06\xdf\x7b\xe9\xcc\xe9\x57\xda\x39\xe3\xe9\x9b\x17\xe9\xe7\xe8\xa3\x7e\x22\x75\x76\x53\x9b\xc8\x23\x41\x06\x04\xe1\xef\x2a\x37\x83\xd3\xf4\xe6\xaa\xf4\x38\x69\x67\xcc\xb9\xab\xfe\x94\xc4\x70\xfb\xdf\x67\xb3\xc2\x2e\x64\x64\xd9\xe9\x07\x72\x1e\x74\x89\xff\x0f\xdd\x97\xaa\x7c\x8e\x3b\xd3\x51\x22\xcf\xc3\xe9\xa9\x04\x67\xfe\x0a\x05\x7d\x78\x57\x0b\x5f\x67\x4a\x82\xa7\x05\xdd\x94\x0e\x1f\xd3\x17\x35\xc7\x35\x2d\xea\x98\xbf\xd8\x97\x05\x04\xbe\x1a\xcc\x05\xe4\x8a\xf5\x73\x2c\x76\xed\xb3\x60\x4c\xc2\xd9\x24\x5e\x02\x33\xa8\x22\x2f\x9a\x4d\x7f\xea\x68\x98\x54\xb1\xce\xc6\x0d\x65\x79\x2a\x03\x00\x4c\x0e\x34\x86\xc5\xbd\x87\x36\x98\xf8\xe3\x27\xe6\xb6\xcb\x2c\x57\xbe\xc7\xe5\x85\x66\xde\xbe\xff\xe1\xfe\xff\x07\x00\x00\xff\xff\x5b\xc6\x01\x40\x08\x03\x03\x00") + +func cfI18nResourcesKoKrAllJsonBytes() ([]byte, error) { + return bindataRead( + _cfI18nResourcesKoKrAllJson, + "cf/i18n/resources/ko-kr.all.json", + ) +} + +func cfI18nResourcesKoKrAllJson() (*asset, error) { + bytes, err := cfI18nResourcesKoKrAllJsonBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "cf/i18n/resources/ko-kr.all.json", size: 197384, mode: os.FileMode(420), modTime: time.Unix(1456502789, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _cfI18nResourcesPtBrAllJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xfd\x4b\x73\x23\x49\x76\x20\x0a\xef\xbf\x5f\x11\x4a\x7d\x32\x66\xb5\x01\xcc\xaa\xea\x96\x6c\x8c\xd7\xc6\x5a\x28\x12\x99\xc9\x69\x92\x60\x83\x60\xb6\x6a\x8a\x6d\xec\x20\xc2\x09\x46\x25\x10\x81\x8a\x07\x98\xac\x52\xca\xec\xda\x2c\x64\x77\x71\x57\xd7\x66\x73\x57\x53\xea\x85\xac\xdb\xac\x56\x6d\xb3\xd1\x96\x7f\xec\x9e\x87\xbb\x87\xc7\xc3\xe3\x05\x90\x59\x9a\x51\xcf\xa8\x12\x04\x22\xce\x39\x7e\xdc\xfd\xf8\xf1\xf3\xfc\xe6\xff\xe7\x38\x3f\xc0\xff\x39\xce\x0b\xdf\x7b\x71\xe0\xbc\xb8\x0a\xae\x82\xd9\xf1\xf9\xc1\x55\xf0\x62\xc0\xdf\x27\x91\x1b\xc4\x4b\x37\xf1\xc3\x40\x3d\x70\x74\x7c\x38\xc2\x27\xe0\x81\x8f\x83\x2a\x08\x5f\x87\x69\xe4\xfc\x97\x8b\xc9\x99\x13\x27\x91\x1f\x2c\x9c\xf8\x21\x48\xdc\x0f\x8e\x1f\x3b\x7e\xb0\x71\x97\xbe\xb7\xef\x38\xe7\x51\xb8\x16\x91\xf1\x53\x72\xe7\xc7\x07\x8e\x33\xbf\x75\x62\x91\x0c\xa3\x34\x08\xe0\xd5\xa1\x08\x36\x7e\x14\x06\x2b\x11\x24\xc3\x8d\x1b\xf9\xee\xcd\x52\x0c\x17\x51\x98\xae\x9d\xbd\x1f\xae\x5e\x04\xee\x4a\x5c\xbd\x38\xb8\x7a\x01\x60\x53\xf8\x34\x28\x7f\xf5\x71\xaf\x66\x2c\x17\xa9\xeb\xc4\x3e\x92\x20\x1c\x0f\x3e\x8a\xef\xd2\xc7\x3f\x07\x73\xdf\x65\xfa\x1f\xff\x84\x14\x3f\xfe\x08\x24\xbb\xfb\xce\x48\x3f\xea\x7a\xf0\xa0\x0b\x2f\xc0\x03\x22\x4e\xdc\x83\x27\x21\xfb\x49\x19\x0c\x54\x2f\xfe\x1d\x32\x78\xa7\x64\x5b\x18\xfc\x0b\x67\x76\x27\x62\x01\xf8\xa2\x8d\x3f\x17\xce\x7a\x09\xc3\x72\xee\xdc\x0d\xd0\x15\x38\x6e\x1c\x87\x40\x7f\x22\x3c\x67\x1e\xc6\xc9\xbe\x73\x18\x09\x18\x32\xcc\x82\xab\xdf\xf0\x03\xa0\x33\x80\x0f\xf7\xfe\x72\x09\x7f\xcd\x61\xbe\x90\xfd\xfc\x86\x95\x5d\xbf\x70\xc6\x71\x2c\x62\x42\x18\xc6\x8e\x27\x49\x78\xfc\x57\xf8\x23\x79\xfc\xf3\xca\x49\x57\xce\x3c\x8d\x93\x50\x11\xe1\x85\xc8\xb4\x39\x0c\xff\xf1\x5f\x1f\xff\x18\xe2\x1b\xe9\xca\x25\xf4\x8f\xff\x42\x5c\x36\x60\x20\x1d\x61\x14\x89\xe8\xf1\x47\x27\x10\x80\x88\x61\xed\xdb\xd8\x30\x5a\xaf\x61\x7d\xb9\x11\x8c\xb4\x46\x1e\xe0\x53\x7e\xe0\x13\x31\x76\xa1\x80\x4f\xfd\xf0\xc3\x3e\xfc\x73\x06\xd3\xf0\xf1\xa3\x73\xef\xc6\x0a\xb8\x93\xc6\xc8\x3d\xc9\x9f\xd5\xca\x0d\x3c\xe7\x0f\xf0\xf0\x21\x7f\xfe\xf8\xf1\x0f\x35\xe8\x27\x8e\x5b\x04\x7d\x1b\xfa\x9a\x22\x80\x0d\x20\x42\x5c\x43\x02\x81\xd3\x1f\x25\xe0\x16\xa2\xcf\x80\xcf\x6b\xdf\x11\x81\xb7\x0e\x61\x5d\xe2\xfa\xb3\xcf\xdd\x99\x08\xee\x60\x7a\x12\x11\xad\xfc\xc0\x5d\x22\xe3\x47\xe7\xc7\x80\x33\xb8\xf5\x17\x69\x84\x53\x65\xc3\x33\x0d\x53\xa0\x0e\x66\xf5\x06\xa6\x2f\x58\xc1\x80\x80\x29\xc0\x8c\x20\x4c\x60\x8a\x60\xc6\x82\x64\xf9\xe0\xc8\xef\xe1\xb1\xe4\x4e\xe0\xa8\x97\xfe\x9c\xf0\xdb\x69\x9a\x86\x89\x0b\x10\xbe\x0d\xf1\x65\xe1\xe2\x66\x09\x71\x39\xc0\x02\x88\x44\xe2\x23\x51\x4e\x80\xeb\x06\xd8\x03\xdf\xd1\x43\xb0\xe7\xdc\x24\x75\x97\xf8\x30\x2c\x7d\x37\x72\x1d\x64\x03\x23\xdb\xd8\x07\x81\xc7\x86\xe3\x5c\xc2\xaa\xda\x83\xad\xba\x72\xa3\xf7\x22\x81\x75\x0c\x7b\x60\x18\x3b\x17\xe3\xe9\xbb\xe3\xc3\xf1\x1e\x52\xbf\xf1\xc5\x3d\x70\x27\x86\x55\xbb\x46\x52\x63\x27\xbc\x85\xf9\xf2\xfc\x8d\xef\x01\x5e\xb9\xdb\xe0\x3b\xd7\x59\xf8\x1b\x11\xa8\x4d\x65\x1f\x26\x1d\x48\x8d\xa8\x69\x28\x1b\x3f\x06\x1c\xfe\xf7\x6e\x24\x49\x80\x7d\xf3\x3f\x05\x6d\x35\xb9\xe9\x34\x25\x7e\xcc\xdb\x09\xfe\x2b\x27\xd5\x0b\xf5\x5e\xaa\x67\xc3\x28\x8e\xfd\x45\xe0\x44\xe1\x12\x40\xdf\xfb\xc9\x1d\xc8\x24\x58\x72\x3c\x95\x40\x67\x04\xab\x14\x85\x59\x18\x2d\x86\xf8\xd0\x9e\x83\x6b\xbe\xfa\x99\x78\x0d\x03\xe1\xa7\x1a\x18\x70\x24\x10\xab\x70\x6e\xd3\x40\x8e\x0a\x16\x7c\x23\x66\xd1\x02\x6f\xdd\x58\x89\xed\x08\xe1\xf5\xcc\x8d\x16\x22\xd1\x1b\x8b\x26\x3b\xa1\xef\x40\xdc\xdc\x3b\x04\xb0\xcd\x1c\x56\x03\xa3\xe9\x83\x39\x03\x49\x0b\x93\x17\x84\x1b\x5c\xb5\x6b\x90\x7b\x61\x3b\xf2\x6c\x64\x01\x27\xda\x12\x55\x43\x8c\x8b\x70\xdc\x00\x16\x16\x09\xe2\x5a\x92\x52\xb9\x50\x97\x21\x9c\x64\xce\xd0\x25\x39\x31\x1c\xc6\xef\xfd\xf5\x30\x8e\x97\x43\x3a\xc0\x89\x8a\x3d\x80\x4a\x8f\xa2\x18\xaa\x79\x0a\x77\x75\xba\x5e\x47\x20\xd4\x59\x8c\x8a\x28\x0a\xa3\x96\xfb\xa5\x15\x19\x69\x1b\x32\x88\x2b\x40\x48\xe4\xaf\xfc\xc8\xa1\x13\x06\x09\xa9\x66\x06\x7c\x3a\x7c\x7d\x7d\x36\x3a\x1d\x3b\x6e\x0a\x3b\x04\x8f\xe7\xbf\x17\x1f\xdc\xd5\x7a\x29\xf6\x71\xe1\x5e\xbd\xb8\xba\xba\x7a\xb1\x86\x93\xee\x3e\x8c\x3c\xfc\x7c\xf5\xc2\x79\x09\x9b\x16\xa4\x94\xf3\x5d\x1a\x26\xb0\xc0\xfd\x5b\xe4\x26\x08\xcb\xc0\x51\x0f\x7e\x66\x19\xf6\x36\xf8\x60\x8e\x5d\x58\x6b\x70\x62\x09\x3c\x50\x3c\xf8\x14\xe0\x61\x1f\xdc\xb9\x9f\xf5\x1e\xdd\xea\x41\xd3\x8c\x88\x70\x55\xc8\x51\xdd\xc2\xac\xab\x9f\xa4\xfc\x70\x79\xfb\x7c\x66\x3d\x09\xfb\x20\xd4\xc3\xe2\x89\xc3\xe1\xb0\xcc\x00\xa1\x27\xf7\xd6\x67\xb6\xd3\xd1\xc0\x37\x0f\xd7\x0f\xc3\x18\x54\x52\x10\xb8\x17\x93\xcb\xe9\xe1\x78\x38\x3a\x3f\x77\x66\xa3\xe9\x9b\xf1\x8c\x3e\x7e\x33\x0c\xd5\x9f\x93\xe9\x9b\xdf\xc3\xdf\xb1\xfa\xfb\xe2\x7c\x74\x38\xc6\x6f\x86\x41\x38\x8c\x04\xa9\x04\xbf\xb7\x8e\xb2\x91\x16\x5e\xcc\x2f\xc3\x95\x9f\xe0\xca\x88\x90\x0d\x24\x5c\xd5\xc8\x71\xaf\xf0\x43\x70\xa2\x8b\xc8\x9d\xc3\xa1\x26\xe0\x74\x1d\x0e\x35\x0c\xd2\xd9\xd6\x51\xb8\x5a\x27\x34\x15\x37\x61\x72\xd7\x8a\xf1\x06\x72\x1f\xa5\x02\xa0\x26\x0d\x24\x7d\xfc\x31\xf2\x41\x5c\x31\x8b\x99\xdb\xe2\x56\xc0\x29\x1b\xe5\x68\x01\x52\x5c\x3e\x76\x0d\x6a\xe2\x10\x8e\x5e\x1f\xd8\x02\x07\xb4\xbb\xba\x09\xe3\x36\x53\x22\xf7\x34\xec\xd0\xd0\x79\x59\x1c\x17\x9c\x6e\xc0\x13\x27\x8d\x96\xc8\x8c\xf0\x26\x71\xe1\x59\x10\x60\x81\x18\x26\xfe\x4a\x94\x59\xd5\x62\x4b\x55\x22\x04\xe6\x05\x62\x4e\xea\x06\x6a\xa5\x97\xd3\x13\xa9\x4f\xdc\xc0\x68\xe9\x2b\x66\x08\x9e\xc4\x30\xed\x8f\x3f\xc2\x4c\xf0\x13\x12\x6d\xcb\x61\xa6\xe5\xd5\x3e\x5c\xf7\x96\x1f\xed\x67\xba\x3b\xe2\x3a\x41\xd2\x7e\x5a\x6d\x68\x9f\x4c\xa2\x74\xc5\xbb\x23\xc1\x52\x8b\x76\xed\xfe\xed\xdf\xde\x87\xd3\x23\xe7\x65\xbc\x16\x73\xff\xf6\xc1\xb2\xdf\x01\x33\x1c\xf6\x29\xee\xab\x78\xfb\xc1\x66\x58\x05\xa3\x05\xb5\xb8\x66\xab\xc3\x5b\xa1\x46\xdf\x6e\xeb\xae\xd3\xf8\x0e\x0e\xd9\x73\xfe\xeb\x9b\xe1\x8d\xf3\xd5\xe5\xf1\xc9\x11\x88\xc9\xdf\xd0\x57\x28\x2b\xe7\xce\xe1\xe4\xf4\x74\x74\x76\x84\x7f\x78\xce\xd1\xe4\x74\x74\x7c\x86\x9f\x6f\x1d\xf8\xf6\xf8\xf5\xf8\x62\x76\x7d\x3e\x9a\xbd\x25\xb9\xea\x85\xf3\xf7\x22\x1a\xfa\x2b\x77\x21\xe0\xd1\xc3\xdf\x8c\xa7\xd7\xc7\xa7\xa3\x37\xe3\x2d\xc4\x2c\x11\x59\x46\xd7\x1d\xe0\x84\xae\x00\xee\x12\x24\x70\x26\x99\x96\x7e\x9c\xe0\x05\x80\x2e\x83\x43\x4f\x2c\x41\x9f\xc0\x7b\x22\x5c\xfd\x51\xbf\x71\x13\x16\x65\x70\x5b\xba\x8f\xfc\x24\x81\x2b\x82\xbc\x14\xbd\x3b\x1c\x9d\x5f\x4b\x85\xff\xc2\x31\x4c\x04\x8e\x32\x11\xd0\x4e\x70\x83\x07\x10\xea\x29\xac\x12\xe3\x16\x15\xdb\xee\x17\x44\xe5\x9c\xa8\x24\xe1\x3c\x60\xb9\xf6\xf8\xaf\x2e\x89\x30\x24\x96\xae\xd9\x44\x9d\x24\x96\x76\xf6\x1a\x50\x6d\x1e\x7f\x82\xd9\x5f\xc2\x5f\xdf\xa5\x74\x13\xc7\xdb\xd6\x22\x72\x37\x6a\xef\x23\x61\x2c\xf8\x70\xe8\xab\x1b\x9f\xe4\x7f\x7e\x20\xb4\x8b\xbe\xc3\x1b\x09\x00\x89\x8c\xcb\x58\x0c\xd8\x17\x70\x2d\x89\x2d\xd7\x91\x6a\x06\xcb\xfb\xd4\x50\x2d\xe0\xec\x8e\x8a\x8f\x12\xb6\x15\x5e\x79\xf0\x2e\xe4\x20\x85\xa0\xe1\xb1\xb5\x26\xbc\xf9\x56\xcc\x13\xf8\x7a\xb8\xf4\x03\xb1\x7f\x15\x18\x4b\x22\x5d\x83\x1a\x08\x40\xa5\x05\x04\xd6\x68\x6b\x3b\x0c\xda\x89\x6c\x6b\xe1\xd6\x5f\xe2\xc5\x3d\xc0\x43\x8a\x2c\x5d\x5b\x12\xbf\xef\x10\xae\xd9\x1d\x9e\x73\x20\x06\xe5\xca\x31\xde\x63\x8c\x6e\x80\xeb\x0b\xcd\x3d\x37\x70\x02\xe3\xfd\x1c\x66\x33\x12\xb8\x2c\x36\xd9\xab\x4c\x5f\x13\x23\x70\x6f\x5c\xcf\x26\xd7\xaf\x8f\x4f\xc6\x72\xac\x63\x16\x2b\xb8\xca\x4b\x24\x1e\xd0\x13\x3f\xd0\x7f\xe1\x7f\x57\x2f\xe6\xcb\x34\x06\xd2\xae\x83\x10\x4e\x4a\x60\x5d\xf6\x1b\xff\x0c\x4b\x39\xc1\xaf\xff\x76\x90\xfb\x7e\x25\x56\x61\xf4\x70\xbd\xba\xc1\xdf\xbe\xf8\xfc\xcb\x5f\xa9\x5f\x3f\xd2\x87\x8f\xdd\xd7\x3b\x70\xe9\xf1\x5f\x80\x4d\x11\x1b\xa7\x34\xeb\xd9\xf8\x44\x12\xf1\xf1\x27\x98\x14\xfc\x39\xbb\x2b\x3b\x82\x04\x3f\x0e\x0e\x58\x46\x03\x65\x8b\x5f\x48\xe6\x40\x81\x76\xaa\xe5\xee\x17\x93\x6d\xcb\x82\x3c\xfe\x2e\x85\xcd\x43\xab\x4a\xa0\x3d\x68\xd7\xc3\x92\x6b\x6c\x02\xab\x68\xe5\x07\x77\xa1\xb6\xa2\x48\xc4\x9e\xc8\xa1\x5c\x87\xbc\x29\xc9\xba\x27\xdf\x90\xab\x2e\xc4\x9b\x97\x5c\x75\x12\x4c\x36\x80\x5e\xcb\x4e\xc0\xb2\x23\x0a\x2a\xe8\x7e\xb6\x85\xf7\x09\x84\xd5\x81\xe4\x80\x62\xd7\x8d\x1f\x78\x9a\x59\xfa\xb8\x95\x22\xf7\xfa\xf8\xec\x62\x36\x3a\x3b\x1c\xff\x6f\x2c\xc6\xda\x33\x68\x5b\xf1\xb6\x46\xeb\x5a\x1c\xe3\x19\x8c\x0b\xe6\xea\x45\x24\x5c\x6f\x18\x06\xcb\x07\xd0\x9c\x7f\x7e\x92\xea\x39\x57\xd2\xff\x66\x32\x6c\xcb\x35\xd7\x49\xb6\xb5\x58\x75\x3f\x03\x31\x35\x47\xdf\x52\x26\xd5\x25\x2b\x9c\xf3\x93\xd1\xd9\xbf\x23\x61\xb5\x7b\x59\xb5\x2d\x9f\xfe\x43\x25\xeb\x2e\xe8\x9e\x7e\x2d\x7e\x42\x71\xf7\x2c\xd2\xee\x49\x56\xed\xcf\x5a\xa3\x3b\xc7\x5d\x1b\xdf\x85\xe9\xd2\xa3\xcd\xed\x7c\xef\xaf\x69\x03\x0f\x32\x0b\xa4\xf9\x25\xde\xce\x9d\x65\x38\x47\x07\xaa\x1f\xc1\xce\x03\xb4\xfb\xce\x79\x18\xfb\x24\x6a\xfc\x18\x7e\x5e\xd3\x5f\x1b\x41\x56\xd3\x85\x88\x06\xe8\xaf\x82\x49\x89\xfc\x30\xf2\x93\x87\x01\xd9\x7f\xe0\xc9\x38\x24\xef\xf2\x6d\x14\xae\x00\xe4\xbd\x88\x13\xc4\x76\xe7\x2f\xee\x84\xdd\x09\x9f\x5b\x05\x9e\xd8\xe8\x79\x56\x4b\x01\x68\x1d\xe4\xcd\x99\xf9\x1f\x71\xfe\xd1\x69\x08\xd4\x27\x8f\x7f\x41\x63\x10\x0d\x67\xdf\x99\xba\x01\xec\x2c\xe9\x84\x7d\xfc\x13\x3e\x14\x3c\xfe\xdb\x4a\x44\x21\x0d\xc4\x87\x7f\xe5\xc8\xc2\x41\xb6\xa0\x71\xbc\x34\x30\xcf\x85\x29\x16\xf8\xe2\x7c\xe9\xc2\xb9\x85\x96\x27\x58\xda\x1e\xfa\x76\x61\xb0\x37\xae\xff\x41\x2f\x5b\xfa\xc6\x5d\x5a\x7d\xfb\x38\x31\x68\xc1\x59\xa5\xcb\xc4\x47\x99\xe7\xae\xd7\xda\x2c\xb8\x72\x03\xff\x16\x38\x64\x0f\x02\xc2\x65\x17\x6c\x7c\x37\x22\x13\x07\xd9\x82\x36\x64\xf7\x8a\x19\x90\xb4\xf4\x99\x80\x6c\x64\xd0\xa1\xc0\x07\x8f\xc7\x22\xbe\x87\xca\x7a\x9c\xa8\x25\xc6\x31\x1a\x18\x45\xb2\xc0\x51\x45\x91\xfb\xc0\xc3\x32\x64\x39\x9e\x52\x31\x1e\x74\xec\x00\xbe\xe1\xd8\x03\xe1\x44\xe9\x52\xd4\x1a\x81\xf4\xb2\x60\xbb\x36\x0a\xcb\xed\xd4\x9e\x23\x5c\x5e\xca\x14\xfe\xf8\x6f\x01\xcc\x28\x30\x2d\x89\xfc\xef\x89\x85\xbc\x9f\x63\xa6\x3d\x20\x51\x9f\xf0\xa2\x8f\x02\x36\x9a\x47\x00\x00\xa5\xa1\x1b\x03\xa6\x45\xe4\xd6\xd8\x81\xb6\x65\x34\x43\xa0\x83\xda\xe0\x35\x0d\x63\x2b\x7e\x33\x5c\x7a\xfc\x2b\x37\x16\xce\x44\xaa\x43\x31\xeb\x9f\xe8\x4b\xc1\x4d\x8c\x5b\x1a\x75\x33\x7a\x33\xfe\x2e\x75\x23\xe1\xdc\x44\xee\xfc\x3d\xee\x7c\xfc\xd1\x8c\xca\xb9\xf3\x81\x3c\xa9\x57\xe1\x83\x11\x1c\x69\xb0\x1d\xc9\xcc\x9f\xc8\x51\x00\x62\x29\x41\xdf\xd1\x61\xff\x6d\x0c\xe2\x85\x86\x27\x2d\xbe\x2c\x3a\xbf\x91\x82\x2e\x13\x93\xa0\x39\x46\x61\x12\xce\xc3\x25\xab\x8d\xc9\x7c\x8d\xc7\x5a\xf6\xb3\x74\x0b\xe3\xca\xe1\x27\xbe\xf8\x7c\xff\xcb\x5f\xfd\x6a\xff\x8b\xfd\x2f\xfe\x53\xfe\x49\xd8\x3d\x89\x54\x3e\x7f\xf9\xcb\xcf\xff\x4e\xea\x9d\x4a\xa8\xfe\xfe\x99\x96\x22\x40\xcb\x8e\x39\x5e\x90\x80\x7f\x77\x4b\x12\xe0\x4f\xf8\x64\xba\xc1\x09\x56\x61\x5f\x80\x83\x1c\x65\x18\x9c\x03\x62\x43\x04\xf0\x46\x88\xb2\x63\x39\xbf\x13\xe8\xb3\x80\xe5\x28\xf1\x0d\x61\x5e\xee\x8c\x98\x27\x27\xc6\x43\x1e\x5d\x4b\x71\x8c\x72\x07\x2d\xa9\x61\x36\x9e\xf2\xc9\xa8\xc6\x47\x93\x9c\x3b\x1a\x3f\xe9\xfc\xda\xf6\xea\x3b\x8c\x90\x01\x9d\x3c\xbc\x27\x93\x35\xfa\x70\x5c\x15\x47\xa2\x54\x07\xfe\xd2\x16\x12\x42\x40\x74\xa4\xcb\x9c\xde\xa7\x0b\x0f\xf0\x5b\xba\x62\x4a\x90\x6c\xd4\x7c\x33\xf4\x9d\xb3\xcb\x53\xad\x88\x5c\xa0\x57\xe1\xbd\x73\x74\x7c\xf1\x1b\xfc\xb4\x72\x4e\xc7\xa7\x93\xe9\xd7\xe4\x6b\xb8\x0b\xe3\x84\x5c\x30\x6f\x27\x17\x33\xfc\x66\xed\x28\x3f\x44\xec\xc0\xeb\x87\xf4\x4a\xe2\xcc\x8e\x4f\xc7\x93\x4b\x7a\x22\x75\xde\x8e\x47\x27\xa0\xd7\x1c\xbe\x1d\x1f\xfe\xe6\x7a\xf6\xf5\x39\xbb\x83\x23\x0c\x8a\x1a\x92\x14\x9a\xc2\xa3\xe3\x06\x0f\xc3\x27\x22\xd4\x7a\xb4\xb9\x1e\x0a\x5a\xe0\xb5\x75\x8a\xfc\x00\x94\xb1\xc7\x9f\xbc\x90\xbd\x44\xb6\x09\xf0\x42\xc1\x91\x60\xe2\x03\xba\x45\xd0\x9d\x05\x3b\x6b\x1d\xda\xc0\x72\x3c\x17\x3e\x2b\x18\x30\x6c\x75\x7c\x1e\x34\x0b\x52\x47\x2c\x68\xd0\x2f\x62\x03\x49\x12\xc3\xf2\x1e\x29\x1a\x78\x75\x7e\x50\xe1\x7c\x36\x28\xdf\x3e\xfe\x98\x0b\xcd\x6b\x03\x30\xc4\x90\xb7\x66\x80\x09\x86\x99\xac\xd6\x7e\x1d\x50\x10\x06\xc9\x83\x0d\x14\xc8\xa3\x8d\xfb\xbd\x95\x39\x32\x16\x4f\x5d\x6d\x41\x6f\x1d\x38\x70\x44\xa0\x38\xcb\xf9\xd3\x07\x8e\xd8\x5f\xec\x3b\x77\x49\xb2\x3e\x78\xf5\xea\x21\x4c\xa3\x6b\x64\x3d\x3a\x0f\x6b\xa7\x8b\xb4\x41\xd6\x28\x65\x2c\xec\xff\x91\x77\x32\xc1\x2f\x03\x52\xb6\x04\x0b\xb5\x41\x35\x8e\x7a\xea\x37\xae\xbf\x24\x81\x02\xc7\x20\xbe\x62\x5f\x9a\x46\x4c\xa0\xe7\xc7\xeb\x30\x78\xfc\x09\x3d\x54\x20\x64\xcd\x95\x64\x5d\xb2\x12\x61\x24\xf0\x55\x0f\xce\x7b\xd0\xe0\x99\x5b\x2b\xf7\x3d\x1c\x52\x29\x9c\xc9\x7e\xc2\xca\x3c\x73\x74\xbd\x4c\x17\x92\x2a\xab\x06\x66\x10\x25\x21\xe3\x41\xb3\xef\x1c\x8a\x28\x01\x6d\x18\x74\x6b\xb8\x48\xa1\xb4\x67\x4f\xdb\xb7\x6e\x71\xe5\x73\x90\x5f\xba\x18\xfa\xfa\x10\xb0\xe9\x4b\x48\xfe\x2d\x7a\x08\x6d\xc4\x9c\x21\x31\xa4\xd8\x83\x84\xb5\x2e\xbb\x08\xae\x4d\x1b\x7d\x05\x91\x5e\x4d\x49\x12\xa8\xf4\x22\xb6\x81\xa7\x17\xf1\x68\xf4\x0c\x07\xa3\x39\x96\xd8\x12\x61\xf6\xe2\x9c\x38\x09\xa7\x8e\x52\x80\xf4\x50\x94\xf6\xa3\x98\xe7\x01\xf0\xc4\xb5\xb1\x5b\x1e\xd9\x26\xc0\x20\x3f\x66\x87\x42\x94\xd1\xfb\xa8\x67\xda\xee\x89\xdc\xcb\xf6\x10\xa8\x05\x28\x9c\x22\x8a\x9f\xa6\x88\xba\x7d\xe7\x42\x70\x2c\xda\x9d\x58\xae\x6d\xab\x72\xcf\xd8\x2b\x3a\x94\x97\x81\x51\x74\xad\x73\x18\x06\x31\x5c\x68\x4c\x48\x95\xb4\x7c\xa6\x05\x0c\x89\x49\xab\xce\xff\x19\x49\x18\x16\xa5\x96\x61\xfd\xe2\x17\x23\xf4\x3f\xe3\x1b\x07\x8e\xe4\x14\xa9\x9c\x37\x18\x18\xe8\x63\xf4\xa7\xf4\x50\xdf\x3c\xc0\xfe\xa5\x47\xc9\xd8\x06\xd7\xec\x08\x6f\xe2\x1e\x45\x6b\x85\x11\xa8\x49\xc7\x18\x33\xbe\x5c\x92\x36\x8b\xa1\x1b\x6b\x05\x2e\x71\x70\x97\x3b\xe1\x3d\x6c\x10\x3f\x7e\xbf\xff\x8b\x5f\x50\x16\x46\x88\x5f\x3b\xf7\x6e\x40\xd7\x5a\x5f\xbe\x4d\x96\x35\xde\x4d\x3f\xfc\xb0\xcf\x24\x7d\xfc\xf8\x6b\xe7\xe5\x03\x6a\xf7\xd6\x50\x1e\x1c\x88\x08\xc8\x7a\xc2\x03\x19\x22\x6a\xd2\xb3\x60\x28\xf2\x72\xc7\x7e\xeb\x90\x3d\xdb\x40\x77\x18\x61\xac\x3a\x8e\x0a\xcd\x45\x1c\xb9\x44\x73\x44\xb7\x57\xf4\x6a\xfb\x7a\x5c\x78\x77\x55\xa3\x22\xd8\x08\x03\x34\x14\xb6\x33\xc2\x8f\x30\xb4\x79\xa8\xc6\x26\x68\xff\xf2\x98\x40\x81\x09\xf5\xbe\xcd\x8f\x29\x46\xc5\xd6\x16\x27\x34\xd2\xc1\xe4\x68\x58\x05\x1e\x85\x4b\x66\x14\x87\x7d\xb1\x3e\x75\xb8\x0c\x53\xcf\x79\x8d\xfb\x23\xb2\x9d\x0e\x97\x20\x80\x6f\xe1\x84\xa1\xab\x3b\xed\x44\x00\x48\x61\x4b\x6a\x19\xca\x40\x17\x06\xbd\xf0\x23\xd6\x95\x0b\xc0\xab\x89\x3c\x3a\x7a\x35\x05\xb5\xe4\x1d\x5a\x7d\x2e\xdf\x1c\x9f\x59\x68\x38\x3e\x3b\x3c\xb9\x3c\x9e\xca\x67\xa7\xf4\xf0\x10\x9e\x6e\x07\xd4\x99\x8e\xcf\x27\x17\xc7\x33\xd0\x7e\x5a\xc2\x97\x2f\x3c\xfe\x3f\xd3\xe3\x89\x73\x34\x6e\xc2\xf7\x0e\xf5\xad\x23\x0b\xec\x11\xfc\xfa\xf8\xcf\xa3\xa3\x89\xe5\xed\x93\xe3\xd1\x45\xa7\xb8\x11\x0c\x41\x55\x41\xf9\x96\x17\x67\xf9\x30\xfc\x66\x38\xce\x4b\x7d\x74\xc7\x70\xae\xba\x6b\x7f\xdf\x08\xfd\xb1\x6d\x9b\x02\x1a\xe7\x65\xe9\x8c\xae\x04\xd6\x48\xcd\x41\x3b\x7c\x07\x2d\x20\x71\x6e\x84\x3f\x96\x7f\x7f\xb4\xd9\x98\x8b\xa0\xcb\xef\xf5\xc0\xe5\xbc\xc4\xdf\x37\x22\x8a\x49\x42\xf2\xcf\xef\xf8\xcf\x8f\x1f\x5b\x72\xb5\x0a\x2c\xc2\xa0\x84\x17\xd7\x7c\xc2\x80\xdc\x8e\xd8\x5e\x5c\x69\x66\xc9\x79\xc7\xf5\x3c\xc7\x9b\x2c\x07\xe9\x65\xc9\x0f\x78\xb7\xf6\xe7\x29\xca\xbf\x9b\x28\x7c\x2f\x6c\xf1\xdc\x23\x7c\x59\x5e\xeb\xb3\xc4\x21\x38\x23\xf9\x2d\xd3\x18\xde\x88\x5e\x59\xa2\xe9\x6a\x54\xa4\x42\xfd\x18\xde\x82\x34\x04\xad\xae\x05\x3d\x2a\x30\x4e\x1b\xe0\x65\x82\x52\x08\x10\x12\x37\x9f\xe0\x94\xd1\xe9\xda\xe8\x44\x33\x0e\x9a\x8f\x64\x96\x1d\xbc\x3c\x4f\xd1\xe4\xeb\x50\xe2\x57\x4c\xd7\x2d\x98\x20\x15\x08\xf8\xd1\x9a\x99\x36\xf2\x18\x94\x87\xc1\x58\xe9\x5a\xe5\x5a\xa1\xc1\x35\x40\x9d\x5b\xac\x70\x17\xcf\x53\x76\x27\xf0\xfd\xac\x00\xb8\x81\x44\x99\xa7\x56\x20\x11\x29\xcc\xc1\x69\x49\x5f\x81\xbc\x04\x04\x4c\x18\x71\xa8\x21\x11\x97\x87\x59\x4d\x9a\x07\xba\x06\x65\x3c\x18\xca\x36\xe9\xa1\xb6\x73\xef\x18\x2f\xa8\x3e\x19\x94\x28\xdd\xc2\xa2\x4b\xd7\xa1\x43\x0b\x7f\xa4\xb2\x9b\xd0\xd2\xb8\x5e\x37\x22\x03\x0d\x31\xe4\xb5\x81\xf7\x21\xf6\xd8\xe0\x7b\x36\x34\xb4\x20\x08\x07\x70\x01\x5e\x01\xf1\x80\xc8\x8a\x59\x61\x30\xe2\x30\x5a\xe0\x77\x93\x68\x21\xbf\x7b\xc5\x31\xb0\xf8\xe5\x05\x7e\x90\x5f\xf3\x24\x5d\x6a\x86\xee\xef\xdb\x54\x44\xa6\x9a\xec\x5d\x4c\xb5\x26\x21\xa8\x20\x21\x28\x64\x89\x14\x89\x91\xa1\xb1\x45\x72\xd4\x0c\xe7\x09\xaa\x66\xc7\x12\x8d\x61\xf9\xfc\x36\xa5\xf7\xcb\x69\xbf\x11\xc8\x30\xa9\x2e\x72\x9e\x19\x2c\x0b\xb6\xf9\x1e\xbe\x56\x3a\xd3\x2b\x17\x21\xed\x3b\xce\x54\x90\x2c\x40\x00\x05\xb0\x4a\xbb\x6a\x00\x8f\x6c\xf7\x40\x0c\xc1\x9c\x00\x28\xba\x7e\xb2\x49\x18\x1f\x60\x07\xb2\xd4\x78\xad\x57\x11\xc7\xad\x1a\x56\x90\x69\x85\x78\xe3\xe3\x9b\x61\x4c\xc6\x47\xa9\x38\x7a\x85\xdb\x02\x0f\x0a\x47\x19\x70\x2e\x1b\x8e\x0e\x24\x94\x8f\xa6\xc6\xea\xe4\xc0\x76\x58\x58\xf6\xb2\x7d\x8d\xb5\x5a\xf9\x9b\x74\x47\xc2\xe8\x6c\x57\xcd\xea\x19\xc3\x39\xc9\xcd\x04\x45\xa8\x33\x87\xf7\xb4\x0e\xcc\xeb\x63\x0f\x66\xe9\x6b\xd0\x83\xe7\x64\x95\x4f\x22\xbc\x5c\x48\xf6\xe2\x54\xd8\xde\x22\xae\xc3\xc4\x05\xc6\xd5\xc1\x8f\xd5\xe3\xe6\xb4\xf9\xc1\x06\x0e\x92\x9a\x25\x00\x04\xbc\x0d\xef\xc5\x06\x5d\x71\x78\x27\x91\x0e\x82\x5b\x3f\x82\x1b\xef\x6d\xca\xf7\x1d\x00\x86\x39\xb1\x84\xd3\xf1\x57\x6b\x54\xc1\xe1\x84\xc9\xd1\x8a\x3f\xd1\x7d\x0b\xff\x28\x53\xcc\xb4\x75\x5c\x26\x55\x2b\xc0\x98\xd4\x0a\x6e\xbe\x0b\xe7\x8f\x7f\x26\x7b\x7a\xe4\xa3\xac\x05\xa5\x9f\xb2\x05\x2b\xae\x23\x65\x1a\xc5\x00\x45\x16\xca\x6a\xdf\x73\x07\x92\xb7\x8f\x3f\x0e\x97\x72\x95\xcc\xef\xdc\x15\x81\xa8\x5e\x6f\xfb\xce\x19\xee\x13\x60\x54\x02\x0a\x24\xda\xe3\x87\x64\x64\xf2\x57\xe4\x20\x14\xe4\xfe\xa6\x69\x49\xd4\x8d\x2b\x94\xdc\x94\x87\x44\x7b\x4a\xe9\x62\x1b\x58\xef\xb6\xa3\xa5\x91\x8b\x49\x6e\x17\x79\xfe\xe3\xfd\x56\xdd\xa0\x5d\xd2\x1d\x7c\x1d\x59\x0d\xef\x80\x88\xb3\xd9\x35\x66\x21\xde\x95\xc2\x2c\xc1\xd9\xd0\x0c\xe8\xae\x0d\xbb\x0b\xf6\x8b\x4b\x86\xfd\x9f\xf0\xfa\x08\xfb\x20\x09\xd1\x64\x8d\xde\x81\x4c\x76\xfe\x4f\x61\x31\x80\xf4\x21\x9a\xd6\xbd\x3d\x0d\xb0\x17\xd1\x98\xc8\xd4\x26\x25\xb0\x15\xbd\xa0\x80\x3e\x05\x9b\x11\xec\xd3\x32\xba\x44\xf8\x6e\x58\x5d\x24\xbc\x03\xb3\xc3\x7b\xe7\xe2\xe2\xad\x5c\x01\x92\x24\x51\x9b\x9a\x7a\xae\xc4\xba\xcb\x7a\x2d\xbe\x2e\xdd\xec\xb5\xf9\xa7\xa3\x65\x8c\x3b\x72\x29\x12\x41\x09\x07\x32\x7d\x9b\x34\x15\xdb\xc4\x8d\x3f\xb0\x12\x94\xb8\xab\x9b\xc7\x3f\xad\xb2\x19\x89\xc8\x83\x23\xf3\xb3\x6d\x33\xc2\x0a\xce\x2a\x05\xa1\x7b\x23\x64\x8a\xab\xc0\xb0\x0b\x18\xa6\xfa\x5b\x96\x29\xa8\x19\xef\x91\x94\x39\x3a\xbb\x95\xf4\xf5\x9c\xda\x02\xc2\x89\x53\xa6\x8d\x67\x1a\x98\x01\xaa\x50\xb7\x2b\x11\xbc\x40\x8a\x87\xcf\xfe\x0e\xe9\xc0\xbd\xf5\xc5\xd2\x66\x93\x3d\x93\x77\x0d\x54\xbb\xa4\xd0\x87\x2b\x37\xfa\x10\x23\x7f\xe1\xd6\x39\x3f\x4a\xc5\x09\xf2\x3e\x97\x9a\x03\xa7\xa4\xe1\x65\xce\x17\x9b\x54\x2d\xe9\xa5\x38\xc0\xfb\x30\x7a\x4f\x81\x2c\xef\xfd\xf5\x3a\x53\x68\x29\x3e\x08\xb1\xb5\x26\x80\x07\x0e\xcf\xdd\xb8\xcb\x3b\x50\x4d\x00\xa6\xbf\x08\xc2\x88\x8e\x1a\xa3\x4e\x04\xab\xab\x1d\x48\x94\x3b\x9a\xd3\x66\x12\xd6\x51\x79\xc7\xf3\x43\x1d\x98\xa4\x76\xf2\x8f\x32\x7b\xc5\x71\x2b\xa0\xd9\x28\x83\xe3\x8f\x2c\x2d\xb8\x24\x30\xa2\xc7\xf3\x5d\x18\x1f\x2c\xc3\x79\xcc\xd1\x0a\xcb\x70\x41\x7e\x7c\xdb\xcd\x2a\x10\x1f\xf0\x38\xc7\xd7\x1e\xff\x82\xef\xc9\xcb\x9f\x4c\xb3\xd4\x75\x34\x10\x49\x2e\xb6\x07\xed\x7e\xe1\xc2\x4a\x98\xca\x23\x72\xee\x84\xbb\xc4\xf0\x8a\x3b\x31\x7f\xef\x24\x0f\x6b\x21\x4d\x4b\x7b\xe8\x0e\xe6\x8c\xee\x20\x0c\xc4\x9e\xd5\xfa\xe1\xf3\x7d\x0f\xd4\x29\x0a\xf2\xd1\x14\xdd\xa6\x01\x05\xc8\x71\x04\x91\x67\x56\x65\x28\x18\x9e\x24\x2a\xfc\x32\x71\x3f\xa3\xec\x6d\x42\xe9\xbc\x0c\xa8\x4a\xc5\x67\x36\xfb\x88\x31\x0c\x5d\xc2\x04\xae\x37\xe2\x83\x85\xd6\xc7\xff\x3b\xf0\x50\xe8\x7b\xf9\x9a\x23\x26\x69\x56\x4c\xb1\xcd\xc8\x65\x79\x83\x6b\x2a\xb8\xec\xaf\x96\xf7\x49\xfb\x51\xc2\xc5\x10\xa4\xf8\x42\x07\xb8\xe3\x96\x25\x59\x03\x26\xbe\x1c\x32\x3e\x4f\xdc\xfa\x01\x07\xa1\xd1\x32\xab\x17\xa1\x06\x6e\x7e\x51\x4f\xe2\x5c\xde\x6d\xd5\x5d\xcf\x6d\x96\x9d\x79\x72\xb0\x22\x03\x93\x80\x37\xfe\x36\x14\x70\x3d\x08\x46\x9f\x43\xab\xd2\x15\xeb\xf1\xf2\xb1\xb2\x1d\xda\xc2\xf9\xd1\x16\x39\x48\xfc\x77\x18\x24\x6a\x41\x07\xbf\x85\xac\x99\x2f\x02\xab\x13\x8e\x21\xb1\x4c\x5d\xd2\x55\x7f\x0a\xff\xb2\x91\x00\x87\xe2\x94\xaa\x5f\x64\x96\x02\x2e\x42\x01\x57\x74\xf8\xd6\x6e\x04\x90\xa3\x66\x2b\x80\x1e\x75\x86\xc8\x35\x12\x43\x4b\xc8\xaa\x6c\x02\x45\xb4\xbd\xc7\xc5\x80\x6a\x87\x65\x98\x40\xf8\x6b\xb2\x3c\x68\x23\x48\x8e\xd8\x9d\xb1\x20\x47\x57\x13\x07\x72\x76\x91\x3c\x8d\xca\x32\x52\xa2\xf2\x29\x39\xf6\xb3\x61\x4c\xdf\xd1\x17\x4c\x92\x00\x41\x7d\x73\x4d\xdf\x30\x47\xf4\xb2\x88\x25\xb3\x33\x6e\x28\xaa\x12\xb2\xb5\x97\x6c\x9a\xad\xb8\x51\x6d\xd8\xac\xa2\xc5\x0d\xcd\x05\xa0\xa8\xa9\x62\x4e\x81\xae\xb2\x65\xb4\x0d\x73\x0c\x99\x0f\xef\xfe\x16\x3f\x48\xbd\xc5\x64\x4a\x3f\x73\x61\x6e\x35\x14\x4f\x82\x02\xb6\xfc\xb0\xfb\xda\x03\x13\x34\x15\x93\xd6\x4f\x2a\xc3\x7d\xb0\x0c\x5d\x8f\xbd\xd3\x0f\x1c\xee\x48\xb1\x09\x1c\xc1\x27\x12\x0c\x5b\xc2\x2a\x32\xf6\x21\xcc\xc8\x38\x01\x03\xb8\x75\xbf\x87\x2d\xa3\x41\x7a\x59\xb0\xbc\x72\x18\x2b\xef\x01\x3e\xe5\x90\xd9\x42\x48\x17\xc0\xb1\x44\xd7\x92\xee\x95\xbf\x88\x5c\xb6\xef\x4a\x2d\xf1\x58\x2a\x27\x47\x59\x19\xa9\x3a\xbe\x6b\xa2\x09\x52\xd4\x06\x90\x95\x2c\xe9\xec\xa7\x78\x5a\xb8\xa5\x92\xfd\xe6\x1c\x3e\xf0\xe4\xfc\x01\xaf\xc3\xea\x2a\xfc\x87\xa2\x5a\xfb\x07\x15\x05\x71\x1b\x09\x15\x52\xab\xf5\xac\x3f\x94\xa9\x52\x6f\x19\x55\xe4\x5c\x59\x74\x0e\xa3\x1d\x12\xb4\xa1\x51\x6c\x80\xeb\xad\x40\xc9\xc0\x40\x88\x04\x4e\x44\xff\x96\xcc\x70\x70\xd9\x0e\xde\xf3\x95\x9b\x0a\x03\x72\x55\x20\x1b\x8f\x0c\xff\x7f\xc8\xf7\xef\xd2\xd0\xcc\xeb\x78\xc5\xd8\x54\x78\xc6\x22\x7a\xfc\x31\x41\xcf\xff\xc8\x54\x0a\x6b\x86\x67\xd4\xa5\x13\x59\x8d\xbb\x7d\x67\x1c\x24\x70\x71\x15\x2b\x8e\x11\x48\x42\xe9\x56\xcf\x06\xeb\x91\xcb\xca\xd9\x90\xc1\xce\x9d\xdf\xc1\xd4\xa2\x91\xd6\xc7\x7b\x3a\xdf\x30\xd0\x6d\x6f\x0d\xf3\x19\xa5\x68\xff\x4c\x50\x51\x15\x7c\x02\x80\x96\x3c\xcc\xd5\x85\xb1\x31\x2b\x4d\xf8\xc5\x28\x13\xdf\x01\x9b\x26\x72\x85\x5c\x1a\xf1\x62\x70\x94\x75\xd9\x6a\x2c\x18\xe7\x64\x5d\x93\x06\x30\xbc\x7d\x80\x34\x12\x1f\xd6\x78\x5b\xc6\x1a\x90\x1c\x76\x85\x77\xa2\x1b\x17\xae\x23\x3e\x69\xaf\x91\x18\xba\xc6\xd0\xf7\x55\xd5\x4f\x2a\x09\xf5\x07\xb3\x24\xd4\x55\xfa\xf9\xe7\xbf\x9c\x2b\x97\x29\xfd\x25\xb0\x34\x06\x7f\x8f\x2c\x53\xdf\x85\xf2\x3b\x90\xc1\xea\xab\x58\x7e\x45\x42\x93\xbf\xfc\x83\xac\x29\xa3\xa9\x41\x83\x70\x91\x1c\x1b\x37\x30\xe4\x84\x1f\x92\x66\x75\x1c\x66\x98\xc2\x3a\xc1\x5a\x3a\x42\x52\x8d\xc5\xb8\x8c\xda\x75\x54\x9b\x2b\xff\xe2\xbe\x2e\x62\xfa\x1c\x03\xae\xa8\xf6\x93\x91\x88\xd1\x58\x32\x48\x17\x55\xe6\x2a\x62\xed\xb3\x1e\x46\xf2\xac\xa3\x5d\x89\xc2\xd8\xf7\x64\xe0\x1d\xe7\xce\x70\x88\x4b\x88\xc1\x2f\x58\xd7\x67\x1e\x7a\x36\x4d\x7a\xc2\x1b\xdb\x23\x75\x9a\x43\x7b\xb4\xfd\x8f\x17\x36\x06\x5a\x4a\xb8\x78\x07\xe5\xa8\x55\xda\xab\x8f\x7f\xf1\xfc\x45\x98\x2b\xe2\x53\x4d\xf3\x57\xc7\x27\x27\xc7\x67\x6f\xb0\x66\xc8\xe8\xcd\x78\x6a\x21\x05\x7e\x19\x9f\x1d\x1e\x8f\x8e\x26\x53\x0c\x3c\x79\x3d\x9a\x5d\x4e\x47\xa7\xe3\xb3\x99\x25\x7c\x44\x57\x47\xe9\xe6\x73\xff\xca\xc7\xa4\x81\xa2\x2e\xd4\x78\xb5\x3b\xf1\x17\x6c\xee\xaa\xd2\x5e\x9a\xef\x72\x56\xac\x68\x85\x54\x01\x82\x45\xaf\xb6\x2c\x0c\x89\x75\x8a\xd0\x60\xa9\x9c\xdf\x66\xed\x92\x3e\xd4\x3e\xfe\x8f\x2c\xb4\xb0\xd2\x09\x4e\xe5\x4c\x51\x20\xc7\xae\x0e\x71\x32\x6b\x8f\xe4\x9c\xe4\x4f\x37\x5e\xe5\x49\xff\xe4\xe3\x35\xbc\xee\x16\x13\xac\x1e\x6e\xa1\x0a\x6c\xc2\xfe\x61\xd8\xd8\xfd\xd6\x68\x05\xb8\x3a\x5f\xba\x62\x83\xb5\x10\xac\x5b\xeb\x53\x27\xb4\x73\xc4\x84\x1e\xdc\xce\x14\xe3\x5c\xdd\x88\xe4\x5e\x08\x0a\xd7\xcb\x1f\xf6\x24\xf0\xf3\xb6\x56\x29\xb4\xc8\x6a\x6a\x15\xfd\x68\x29\x94\x52\x9f\x94\x82\x32\x60\x61\xb3\xc4\xfa\x16\x33\xa7\xa2\x75\xe5\x3e\xc0\x68\x31\x36\x51\xda\x14\xd9\x2f\x50\x0e\x29\xc0\x64\xa9\x25\x07\xae\xde\x3c\x94\x67\xc5\xa6\xdf\xec\x3b\x85\x50\xcd\x75\x14\xce\x85\xf0\x7e\x6d\x19\xec\x27\xa7\xcb\x79\xf9\xf0\xca\x16\x54\xa9\x88\x2b\x53\xd1\x1a\x6f\xf7\x48\x8c\x96\x77\xed\x7a\x8a\xdb\xdd\x7a\x3d\x71\xeb\xa6\x4b\xc5\x6a\x25\x69\xdb\x05\xed\xe0\xb6\xeb\x7a\xb5\x45\x31\xe3\x45\x74\xcc\xb2\xa2\x50\x88\x3a\x6a\x11\xd8\xd3\x6d\x80\x5a\x9a\x3e\xd5\x98\x38\x16\x22\x12\xf8\x6f\xdf\x81\xf0\x4a\xb2\x2e\xa0\x9d\x84\xf7\xb4\x5c\x54\x19\x03\xb4\xf4\xb4\xd2\xe5\xee\x3e\xe6\xa7\x9d\x6d\xc7\xce\xb9\x5d\x72\xac\x8d\x85\xa3\x96\x5d\x4f\xc7\xa6\x16\xa6\x10\xc5\x23\x53\x66\x99\x24\x34\x8f\x49\xbf\xe9\x96\x5e\xac\xc6\x98\xfa\x4b\x6f\x8d\x17\x1d\x78\x5c\xff\xa1\x98\x90\x4b\x41\xb0\xaa\xe5\x37\x75\x30\xb2\xf4\x84\x1e\x04\xb4\xf5\x71\xd6\x52\xd0\xec\xef\xfc\xea\x21\x41\x73\x1a\x1c\x31\x28\x9a\x94\x73\xda\x0d\x54\xf2\xbe\xca\x3a\x4f\x03\x9f\x94\xc1\x15\x5c\x58\x53\xd0\xc2\xb0\x68\xdf\xd2\x7f\x2f\x9c\xd3\x81\x73\xfa\xd5\xc0\x79\x43\xb5\x01\xde\x7c\x65\xd5\x10\x18\x07\x65\xc9\xc3\xff\xbf\x41\xb4\x66\xfa\x7e\x31\xd5\x9e\x6f\x2f\x84\x57\xbd\xb3\x82\xeb\x8d\x27\x6b\x36\x2a\xac\xe8\x3b\x03\xa4\x95\x43\xd3\xf5\x76\x3d\x6f\xc8\xa1\x49\x43\x4a\xab\xc2\xd8\x79\xfe\x05\x96\x0b\xde\x35\xc7\xff\x30\x3a\x3d\x3f\x19\x73\xc6\x29\x96\x51\x2e\xbc\x70\x1e\xf9\x1b\xb8\xf8\x4e\xf1\xb3\xcc\xeb\x5a\x3d\xac\xf9\x4b\x95\xdb\xf5\x0a\x3f\xbc\xea\x74\xf2\x69\xfa\x30\xec\x41\xd6\xf3\x8e\xe3\x3b\x87\x4a\xee\xd2\x4f\xfd\xc0\xad\x7d\xe7\x1b\x18\x99\x2d\x3f\xb9\xe9\xed\xb5\xae\xec\xd3\x0f\x00\x56\x37\xbe\xbc\x18\x4f\xe9\xaf\xf3\xd1\xc5\xc5\xef\x26\xd3\x23\x64\x73\x2f\x70\x54\x72\x88\x73\x4d\x95\xf4\xe4\x72\x9a\xe5\x02\x1c\xdf\x0c\x6f\xcb\xb9\xa3\x59\x49\xce\xf3\x11\xde\x53\x67\xe3\xe9\xc5\xf5\xe8\xe2\x1a\xd3\x9c\x7f\x6f\x4c\xfe\xc5\x41\xb9\xd2\x51\x1e\xad\x59\x69\x74\xf5\x80\x06\x4f\xae\x7b\x19\x39\x06\xca\xd5\x03\x30\x70\x0b\x48\x73\x4e\x7e\xc7\x44\xe8\xad\xa0\x60\x6d\x17\x4a\xdd\xa3\x4a\x2e\x04\x2e\x2b\xe4\x72\x1c\x38\xbf\xc3\xa0\xd8\xfb\xd8\x39\x0f\xef\x45\x74\x71\x07\x37\x09\xca\xfe\xf1\xc2\x14\xfb\x74\x50\x55\x5a\x6f\xe0\x70\x31\x5e\xae\xb4\x83\x59\xd2\x3f\x60\xb1\x5c\x06\x7b\x85\x80\xaf\x24\x68\xf8\xf7\xa3\xcc\x9e\x36\x60\xcb\xa8\x39\xe7\x04\xd3\x7b\x10\x3a\x97\x21\xb0\x40\xdf\xab\x03\x6e\x8b\x13\x6f\xb3\x76\x64\xc7\x17\xa5\x08\xc9\x26\x24\x17\xe3\xc3\xcb\xe9\xf1\xec\xeb\xeb\x37\xd3\xc9\xe5\x79\x7f\xf0\xb5\x60\x9d\xc9\xf4\x0d\x6f\xe7\x6d\x10\x34\x95\xdb\xb2\x2c\xee\x2d\x50\xca\x1e\x2e\x4f\xc0\x32\x75\x3e\xd9\x4e\xd4\xfa\xd7\x29\x66\x83\xb7\x01\x6d\x6e\x25\x0a\x60\xd3\x53\x22\xba\x4c\x41\xb7\x6d\x6a\xf3\xf5\xd5\x03\xee\xd9\xdc\x26\x32\xfe\xf7\xd7\xe6\x0f\x5d\x60\x48\x42\x6e\xc3\x10\x60\xf0\xef\x66\x6a\xd1\x2b\xf8\xc1\x32\xf2\x86\x31\x36\x30\x86\xca\xd1\x20\x1f\xdc\xf8\x21\x98\x53\x9d\x70\x80\xa0\xd2\xe3\x61\xad\x5c\x9f\x1e\x9f\x5d\xce\x38\xe7\x7e\x08\xa8\x61\x45\xbd\x4c\xa2\x54\x38\xff\xe8\xdc\xba\xcb\x18\xff\x45\xca\x5f\x25\xe1\x2b\x94\x40\x9f\xd1\x73\xf3\x10\x1d\xf8\xb9\xe7\xf8\x07\xca\x32\x05\x08\x27\x93\xc3\xd1\xc9\x18\x7e\x3b\x3c\x19\x8f\xa6\x9f\xf5\x5b\x73\xb2\xca\x12\x08\xce\xa1\x2a\x49\x63\x16\x58\x5e\x3b\xaf\x14\x65\x6c\xbe\xc5\x07\xa9\x48\x15\x59\x70\xf5\x3b\xfb\x0f\xab\xa5\xb5\x28\x47\x2b\x0a\x32\x55\x4a\x1b\x2d\x69\x49\x39\x94\x6b\x77\x3c\xa1\x85\xc6\x41\xf2\xff\x38\x1c\x7a\x7e\x8c\x9f\xb6\xc2\xe8\x85\x2b\x2c\xee\x8e\x62\x42\x4e\xf3\x16\xc0\xf0\xb6\x00\x90\xb6\x01\xc1\x7e\xd5\xdf\x5e\x4e\x66\x23\xaa\xc8\x30\x83\x0f\x27\xd7\x59\x5d\x06\xdf\x51\x52\xc7\xf8\x32\xe2\x02\x10\x17\xb2\x38\x43\x41\x3c\xf1\x8a\x63\x1d\x67\xed\xfa\x5a\xa0\x0d\x29\x3a\x75\x2b\xee\xf1\x26\x21\xf9\x6a\x48\x82\xca\xe3\xbf\x9d\x7c\x30\xc1\xae\x1e\x58\x25\xb3\x89\x88\xd2\xff\x6a\x64\x46\x23\xdc\xa2\x06\x91\x87\x4b\x5f\xed\xef\x10\x7a\x41\x4a\x15\xa0\xb7\x11\x52\x3f\xa7\x09\xd8\x8a\xf1\xc1\x93\x30\x3c\x68\xcf\xe8\x36\x0b\xbd\x5e\xc9\x50\x55\xe7\xf0\xd4\xbf\x9e\x5e\x02\x57\xa9\x00\xdd\x36\x3b\xab\x5d\xc5\x3b\x8b\xe2\xc1\x85\x59\x46\x6f\x2e\xb6\xda\xdc\x4a\x4c\xe0\x7d\x62\x98\x84\xef\x45\xe0\x9c\x8c\xbe\x1a\x9f\x38\xe7\xd3\xc9\xbb\xe3\xa3\xf1\x14\x84\xd3\x6f\xc6\x5b\x09\x4c\x85\x42\x26\x62\xaa\xf1\x7d\x35\x05\xc0\xd3\xf2\x1d\x86\xf2\xdd\x60\x25\xcb\x9b\xda\x3c\x04\xe5\x75\x27\x43\x7c\x2f\x1e\xca\xcc\x55\x5f\xfc\x66\xfc\x75\xdd\xf5\xc5\x79\xc6\x12\xf2\x5d\xc9\xfe\xd9\xd6\x3b\x7d\xca\xba\xcc\x3d\x98\xb4\x55\xb1\xd3\x36\x95\x72\x4b\x46\x8e\x1a\x62\x57\x0f\xde\x0d\xfc\x07\x3f\xca\xf9\xcb\xc3\xcf\x81\xc7\x79\xeb\x02\xee\x9f\x5e\x61\x24\x3d\x6d\xa0\x57\xc9\x6a\xfd\x4a\x39\x23\xae\x79\x06\xe9\xde\xbb\xd5\x8e\xba\x73\x23\xe1\x29\xb5\x6a\x7b\x95\x8a\x45\x3b\x1f\x70\xd8\x24\x49\x76\x47\xfa\x8e\xbf\x1a\x92\xa2\xb4\x9d\x08\x20\x59\x92\x57\xbb\x2a\x95\x2c\xb3\x3a\xd6\x27\x53\xb8\x28\x06\xa7\x24\x17\xb7\x85\x38\x54\x75\x0f\x8b\xc7\x8e\x79\xd2\xac\x9d\xc3\xe9\xf8\x68\x7c\x36\x3b\x1e\x9d\xd0\x08\x97\xce\xc5\xd7\x17\x27\x93\x37\xd7\x47\x53\x98\xe4\x6b\x34\x78\x65\xac\x51\xbd\x39\xe8\x6b\xb9\xa5\xce\xdd\x58\xf6\xaf\x04\x01\x82\x1b\x9e\x6a\x11\xc2\x72\xe1\xa2\x2f\x99\x0c\xa0\xc4\x96\xd8\x4c\x88\xcd\x22\x8e\x9c\x55\xe8\x89\xca\x3d\xd4\x72\x24\xd4\x90\x87\xa8\x18\x64\x64\x0c\x32\xe4\x03\xc6\x7e\xf5\x22\x47\x75\x05\x95\x94\x77\x44\x52\x01\x03\xaf\x88\x06\xc3\x17\x5d\x0a\x94\xda\x92\x66\x94\x03\xb0\x87\xbf\xc8\x84\xf6\x17\x24\xc8\xe1\xbb\x2f\xb3\xef\xbe\x34\x24\xf9\x85\xec\xfa\xe3\x16\xa4\xa5\x29\xc8\xc9\xf2\xb3\x1d\x61\x45\xd9\x59\x27\xe6\xaa\xa1\x82\x06\xe7\xdd\x0c\x57\x68\xa4\xa2\xc9\x51\x6e\xb0\x81\xd1\x34\xa9\x2f\x34\x7d\x73\xcd\x66\x30\x2e\x1b\xf7\x1a\x01\x46\xc0\xaf\xac\x73\xc4\xd2\x89\x1f\xe2\x65\xb8\x38\x78\xf5\xaa\x41\x45\xb5\x42\xcc\x5b\x12\x61\xd7\xa8\x52\x28\x39\x80\x04\xf2\xc4\x0f\xd2\x0f\xaf\x4e\xdd\x79\x6f\x96\xe2\xda\x51\x4c\xa5\xb5\x42\x01\x82\xb4\x7c\x32\x0e\x1f\xe0\x1f\xdc\xbb\xc9\x58\x44\x55\xa6\xc4\xfe\x33\x4b\x16\x46\x4d\x89\x32\x32\x32\x35\x57\x48\x4f\xa1\x2d\xd8\x01\x7f\x21\xa9\x52\x46\xce\x1c\x61\x99\xfd\x74\x0b\xee\x6c\x4b\x55\x3f\xeb\xe8\x1c\x8b\x3f\x90\x79\x03\x8e\x9c\x0d\x0a\xcf\x7f\x80\x33\x66\xf6\x76\x42\x5d\xab\xde\x62\x35\x45\xd0\xb2\x65\x07\xab\x11\x9c\x73\x78\xac\xc0\xba\x59\xa7\x89\x83\xbb\x4d\xc9\xd5\xaf\x1e\x94\x57\x3e\xab\x59\x89\xb0\xf7\x64\x43\x3b\x11\xdd\x86\xd1\x0a\x76\xff\x9b\xf1\x4c\xe9\x5b\x52\x73\x03\x01\x8c\x04\xec\x3b\xc7\xb7\x54\xec\x8c\xe0\x61\x92\xbb\x2a\x84\xbb\xf1\x5d\x67\xe8\x61\x2d\xea\x73\x34\x85\xa9\xb6\x52\x12\x26\x95\x2f\x88\x13\x50\x47\x06\x2a\x5b\x9e\xc2\x6e\xb1\xe7\xf4\xec\x61\xcd\x2b\x45\xbd\x13\x8b\x44\xba\x59\x55\x94\xd2\x2b\xdc\x88\xfb\x94\x9b\x8f\xb1\x1c\xe1\x46\x44\x11\x2a\x9c\x77\x00\x10\xe5\x2b\x79\xbe\x80\x11\x12\x34\x41\x53\x69\x6d\x20\x82\xef\x42\x4f\x3e\xf2\x0f\xfb\x92\x15\xaf\x41\x49\xc4\xbc\x34\x2f\x9c\x53\x47\x31\x42\xa3\x4b\x11\x6e\xfc\xd8\x4f\x94\x03\xc9\xc5\x6a\x88\xf3\x78\x7f\x8e\x35\xa8\x6e\xb9\x04\x15\x06\xc8\xef\x97\x6f\xc7\xf3\x5b\x9e\xab\xab\x17\xaf\x36\x5f\xbe\xc2\x0a\xce\x57\x2f\x00\x29\xf1\x13\xe6\x3f\xa8\xbc\x14\x23\xe1\x57\x2f\x4c\x6e\x1c\xe4\xc6\xfe\x61\x78\x7f\x7f\x3f\x44\x2e\x0e\x01\xb6\x08\x30\xf8\x10\xbb\xc3\xd5\x00\xf4\x9c\xbd\xef\xfe\x33\x2e\xd2\x03\xba\xc9\xaa\x3d\x5a\x4d\x9e\xe7\xfc\xfd\x2b\xd3\xa0\xd8\x6b\x89\xca\xf4\x5c\xc3\x18\x78\x0b\xc2\xaa\x9f\x0a\xc3\xb0\x2a\x6d\x7c\xe8\x38\xda\x06\x66\x4e\xdd\xdc\x1a\x9a\x34\xe3\xed\x00\xce\xfa\xce\x0d\x84\x74\x1b\xc5\x5b\xc3\xcb\x2b\xa9\xdb\xc1\x62\xdb\x49\x7b\x93\x11\x21\xb4\xdb\x8d\x72\x50\xdb\xda\xeb\x6a\xec\x46\x56\x78\x39\x4b\x1a\x19\xff\x73\xf0\xca\x06\xff\xbe\x60\xb7\xf7\x23\x74\xe1\xf4\xad\xa5\xd6\x71\x01\x56\xbd\x19\x6a\xdb\x35\x51\xa3\xfc\xef\x04\x70\x8d\x25\x69\x57\x18\xaa\x0d\x49\xbb\x82\xde\xc2\x4c\x94\xdb\x24\x95\x7b\xa4\xfa\x6e\xde\x6e\x2d\xf5\x20\x64\x0c\x84\x4c\xba\x10\xd2\x8a\x21\x15\xb7\xfc\xed\xb9\x9c\xbb\xea\xef\x00\x96\x14\x98\x86\xa5\x60\xa8\x0e\xb1\xad\x80\xe7\x2f\xe1\xfd\xa1\xb1\xfb\x6a\x78\x0b\x9a\x6a\x1a\xc1\xbf\x4b\x77\xe1\xbc\x1e\x63\x38\xff\x16\xc1\x27\x0a\x6a\x6c\x34\x49\xed\x0d\x68\xb7\x71\x31\x7c\x99\xdf\xf1\x78\x25\xd0\xad\x87\x2b\x82\xcd\x96\x00\x36\xd8\x40\x77\x3b\x18\xbb\x65\x8d\x09\xad\x9f\xbb\x1f\xf5\xc6\xd8\xd0\xfe\x94\x2a\x90\x19\xc8\x50\xca\x24\xf4\xff\x28\x41\x0a\xe5\xcc\x2c\xe4\xc4\x05\x2e\x7d\x86\x17\x8d\x44\x02\xc2\x7a\x89\x14\x96\xaf\x03\x87\x43\x2e\x8d\x76\xe4\x8b\x45\x48\x29\x4f\x22\x80\xab\x04\xf5\xff\xd7\xed\xbd\xe3\x3b\xdb\xf5\xea\xe7\x40\x26\x28\xdf\x44\x61\x2d\x1f\x17\x22\x19\x72\xd5\x8b\x21\x57\xbd\xd8\x6a\x95\x60\xe5\x66\xe7\x1b\xd5\xe0\xb8\x17\x08\x59\x52\x4c\x06\xd9\xc9\x30\x82\x21\xf2\xed\xd5\x6c\xf2\x4a\xd6\xc4\xfd\x47\xf2\xb7\xfc\x23\x5a\x27\xb2\x88\x3d\xfe\x8d\x3e\x7f\xa6\x8f\x19\x40\x70\x4e\xed\xe0\x39\x2c\x9c\x6c\xc9\xd1\x8a\x9d\x01\x69\xb0\xc4\x4a\x42\x7b\xc3\xdb\x3d\xf3\x66\x59\x7d\xcd\x2a\xd0\xf5\x4f\xaf\x8e\x64\xfa\x6c\xfc\x4a\xc6\x03\x82\xde\x75\xe3\x46\x96\xe7\x2b\x8c\x28\xf9\xf7\xae\x97\x68\x4c\xb9\x76\x57\xde\xdf\xfd\xca\x02\x03\x46\x7b\xfa\x30\xa4\x50\x43\xf9\xaa\x98\xdf\xd9\x74\xbd\x7a\x2e\xe3\xfa\x32\xe3\x18\xfb\x6d\x42\x4e\x89\xfb\x66\x48\x85\x5c\x95\x99\x35\xd5\x07\x90\xea\xcd\xc0\xa6\xe0\xdf\x9b\x56\xf2\x98\x25\xf6\xef\x7b\xc7\xfe\x01\x6a\xd0\x5e\xfb\xbe\xba\xa5\x30\x5c\xb9\x6b\xa9\x3c\xeb\x9d\xbd\x0b\x17\x77\x06\x76\xf5\x80\x21\x2f\xbb\xb8\xae\xd4\xc2\xdc\xee\xca\xd2\x11\xf4\xf6\xd7\x96\x8e\x6c\x6f\x98\x43\x4e\x4c\xd7\xba\xa6\x72\x37\xc5\xce\xe6\x0b\xe5\x22\xc0\x8f\xfa\x22\x80\x9f\xd1\xd5\xbd\xf9\x32\xfb\xf9\x4b\xfa\xaa\xf7\x22\x0e\xb3\x6b\x47\xbf\xf7\xb7\x88\xea\x81\x77\x49\x5d\x8c\x7b\x43\x20\xc3\x63\xb7\x1c\x33\xfd\x2a\xd7\xc7\xef\xf7\x6e\x1a\x2d\xca\xd3\x56\xba\x74\xec\x00\xb6\x2a\x96\xac\x43\x1d\x48\x9c\xc9\xf5\xd0\xef\x74\x33\x0c\x25\xfd\xdf\xef\xc7\x37\x6e\x68\x51\x1d\xed\x5e\x15\xe9\x5e\xf1\xbc\x11\xec\xde\x73\xc5\x47\x5c\x92\x56\xef\xdf\xb3\xf1\xef\xae\xb7\x12\xc5\x0c\xb0\xca\x74\x97\x21\xc8\x7f\xb5\x0d\x1a\x65\x7f\x43\xa8\x7d\xb7\x8d\x04\x65\x35\x69\x20\xec\x9d\x2c\xe6\x3c\x22\x8b\x01\xc2\xc4\xc6\x5f\x6d\x85\xcb\xb8\x28\x13\xe4\xde\xf1\xcd\xb8\xde\x86\xaa\x8d\xc6\x37\xa6\x9e\x57\x36\x63\xcc\x6f\xf3\x8f\xc3\xd3\xc6\x4a\xed\x89\x1e\x03\x9d\xc5\x76\x6a\x02\x01\x89\x92\x9d\x00\xa1\x10\x58\x2d\xec\xf4\xfe\x39\x3e\x3b\x1a\xff\x43\x3f\xb8\x32\xf6\x1d\x6e\x97\x7e\x14\x06\xe8\x92\x18\x6e\xdc\xc8\xa7\x3b\x2b\x19\xf1\x7a\x81\x8d\x29\xf8\xd7\xb0\xca\x67\x37\x9d\x9a\x9e\x5e\x3d\xed\x14\xbb\x0f\x42\xb7\xed\xca\x6d\x80\x19\xc6\xc5\x7e\x92\xbb\xad\x6d\xcd\x6a\xdf\xeb\x65\xd8\xeb\x86\xb5\xc2\x98\xd7\xc7\x8a\x67\xbc\x53\x8e\x5e\x69\x33\xbe\x98\x50\xb5\x1f\x9a\x0d\x4b\xfd\x78\x24\x96\x86\xa1\x24\x43\xd3\x74\xe3\x8c\xcf\xde\x5d\xbf\x1b\x4d\xf3\x7f\xbc\x1b\x9d\x5c\xf6\x5d\x5d\x96\x9b\xbb\x2c\x21\xf9\x8f\x5c\x37\xb2\x37\x6c\x54\x10\xa9\xd8\x9a\xb6\x27\xe2\xc9\x37\x9d\x70\x2c\x45\x6f\xb0\xac\x01\x21\x28\xd2\x82\xb6\x82\xd5\x2c\xc3\xda\x07\x19\xf6\x26\xa2\x6c\xd0\xa5\x9f\x8a\xb6\xdd\x2d\xe1\x97\x67\x82\x4f\xd9\xad\xe7\x43\x25\xf4\x7c\x3a\x1e\xa2\xc5\x7e\x28\x53\x26\x77\x94\xf5\x60\xe8\x21\xfd\xdf\x37\xe7\xf4\x9a\x26\xb2\xff\x29\x6e\x00\xec\x79\x06\x28\x53\x37\x47\xef\x09\x6f\x5b\x93\x37\x03\xd4\x37\xc0\x6d\x99\xd5\x73\x54\x86\x6d\x9c\x74\x05\x53\xcb\x19\x52\xf5\x5a\x4e\xd0\x94\xdd\x0a\xf0\x8f\x13\xe7\x1b\xcc\x44\xbb\x96\xe5\xee\x0e\x7e\x8f\xd2\xee\x00\xaf\xff\xf4\x1f\xfc\x8b\x2c\x2e\x58\x8f\x99\xac\x02\x43\x8a\x92\x25\x8a\xb2\x1f\xf0\x76\x03\xcb\x8d\x6a\x36\xe8\x5f\x64\x04\xc7\x70\x1d\x8b\xd4\x0b\x87\x49\xf2\x40\x5f\xdf\x86\x11\x86\x48\xe6\xbf\x54\xde\x0c\xe3\xeb\xbe\x2c\x18\xd6\x54\x77\x6a\x7e\x99\xdd\x0c\xde\x76\x5a\x26\x70\x1c\x4e\x10\x6a\x9e\xba\x25\x90\x9e\x0b\xa1\x51\x0a\xf5\x05\xbb\xad\xfe\x8d\x8d\x4c\xb7\x83\xc0\xd5\xdb\xab\xac\x9f\xbd\xc0\xa5\x41\xa7\xbc\x67\x9b\x57\xdf\xaa\x4c\x55\xc2\x6f\x9f\xe0\xbc\xd5\x98\x9e\x2c\x1f\x57\x22\x78\xca\x8c\x5c\x8d\xa2\x21\x27\x77\x2b\xe0\x4f\x96\x7d\xab\x7b\xb9\x28\x67\x03\x7b\x53\xfa\xab\x2e\x69\xf0\x44\x56\x72\x13\xf0\xee\xec\xe4\x0d\x50\xb7\xb3\x94\x77\x06\xbe\xbd\xad\xbc\x33\xfb\x9b\x66\xb3\xf6\x3a\xd3\x73\x85\x3c\xd1\x35\x83\x01\x97\x74\xb8\x2d\x2f\x1c\x26\xd4\x27\xd1\xc6\x01\xc1\x13\xa8\xc2\xe9\xda\xb3\xe5\x2f\x9b\x9d\xd3\x7d\x9d\xc8\xfc\xfb\xca\x4c\x66\x99\xd9\xfd\x1e\xbe\x4a\x03\xfc\xd0\xf3\xf0\x62\x6a\xba\xe7\x12\x7f\x33\x0c\xc8\xa2\xa8\x44\xc5\x36\x79\x2e\xe8\x38\x1e\xea\x20\x92\x5d\xe5\xc1\xc8\xa1\x3d\x5f\x3e\xa6\x46\x58\x93\x18\x83\x2c\x43\x17\x95\xb5\xcc\xc9\x96\x09\x99\x79\x1a\x9e\x24\x21\xb3\x80\xa2\x43\x42\xe6\x56\xe8\xea\xc3\xb4\x7c\xe7\x74\xf4\x0f\x43\xc5\xea\x61\x75\x2e\x56\x8b\x15\xfb\x09\x17\xea\xff\x02\xe9\x55\xdd\x46\xf2\xf3\x48\xaf\xea\x4c\xf3\x73\xa5\x57\x75\x26\xac\x55\x7a\x55\x2d\xd4\x5d\xe4\x02\xf5\xc3\xd5\x2e\xf9\xaa\x11\x60\xe7\xe4\xab\x26\x88\x6d\x92\xaf\xba\x6e\xfa\xd9\x14\x55\x93\xf1\x74\x3a\x99\xe2\x4e\x1e\xcd\xb0\x90\x33\x6c\x5f\xca\xd4\xc1\xca\x70\xe7\xc0\x8b\x8f\x1f\x61\xde\xe0\xf3\x38\x8a\xac\x05\x25\x2d\x18\xdc\x80\x6a\xd1\xd1\x70\x30\x13\xd8\xc9\x42\x29\xc2\x5b\x07\xa5\x96\xde\x1b\x24\xb5\x2c\xd0\xcf\x64\x09\xfa\x75\xc8\xed\xe1\x96\x19\x44\x37\x32\xaa\xe1\xc6\xdc\xbf\x56\x35\x4b\x8e\x75\x13\xe2\xb5\xbb\xb0\x15\xf7\x45\x1a\xb7\xa5\xef\xf1\xff\xfa\xf4\xa4\x39\x2f\x8f\x38\x9d\xea\x40\x07\xc1\x0a\xcf\xd6\x8c\x6a\x6b\x82\x9d\x97\x54\xe0\x14\xdb\x0a\x78\x22\x76\x11\x84\xeb\x85\x96\xea\xb2\x30\x0e\x5c\x05\x32\x2d\xa7\x58\x51\x76\xa0\xbf\x21\xef\x09\x46\x36\xde\x70\x51\xc7\x98\x0b\x0b\x72\xc3\xd1\x1b\x21\x01\x58\x1b\xc5\x95\x16\x89\x90\x7d\xf7\x6c\x05\x93\xb3\x4e\x9c\xea\xc9\xf9\x9d\xbb\x11\xb9\xf1\x3a\x42\x15\x29\xa6\x62\xae\xb2\x63\x67\xed\x38\x29\x40\x73\xe5\x46\xef\x45\x02\xfc\x9b\xeb\x11\x73\x6a\x18\xd6\x57\x72\xb3\x36\x7e\x75\x55\xc9\xcb\x23\xa2\x4a\xd7\x91\x31\x19\x54\xdf\x30\x9a\x63\xe1\x76\xf8\x98\x70\x83\x38\xac\xd2\xb9\x32\x8a\x96\xab\x86\x7e\xb6\x5e\x4a\x26\xdd\xd4\xfc\xc2\x0f\x30\xc3\x8b\x23\x21\x31\x34\xb2\x54\xeb\x73\x57\x03\x91\x88\x24\x77\xd5\x82\xe3\x62\xb3\x25\xa4\xbd\x06\xf5\x33\x17\x3d\x48\x62\x2c\xcf\xe4\x9b\x10\x4e\x64\xbc\x3f\x71\xe7\x64\xba\x4a\x39\x21\x55\xb6\x88\x6d\x85\x3c\x2b\x16\xbd\x2a\x6f\x01\xe4\xb9\xab\x1b\xd9\xfa\x73\xcd\x2c\x1e\x50\x11\xcd\x65\xf8\x5d\x2a\x7c\x5c\xda\xdc\xec\x51\x7d\x61\xa9\xf5\x59\x45\x26\x1e\x07\x6c\x5c\xce\x8a\x7f\x1f\xf1\x7d\xd0\xb3\x77\x0d\x6c\xa4\x36\x04\x0a\x73\xa0\x45\x11\x70\x2b\x0a\xf5\x85\xf6\x06\x9b\x52\x23\x79\xc8\xcb\x57\xcc\xd2\x7e\xc4\x11\x24\x64\x9e\x86\x9d\x31\xf2\x55\x0b\x1e\xde\xb9\xc1\x82\xaa\x81\x6c\x7c\x71\xcf\xcd\x92\x55\xc4\xc6\x3c\x4c\x83\x64\x80\x52\xfb\xbd\xf4\x4e\x91\x01\x95\x93\x53\x57\x62\x15\x46\x0f\xfc\x0d\x37\x89\xad\x2b\x11\x7f\x9a\x7a\xd8\x1e\x38\xc5\xa4\xd1\x54\x76\xa0\x70\x59\xb7\x5b\xc0\xee\xf1\x84\xb9\x62\x07\x4e\xc8\x70\x85\xd9\xaf\x08\x1f\xf3\xe3\x39\xae\x0e\xf3\x67\xa0\x03\x5b\x6d\xba\xdc\xea\xdf\x5e\x65\x5e\x0e\xd4\xdc\x5a\x4c\x76\x49\xee\xd7\x0e\x81\xe5\x80\x29\x87\x09\xaf\x4d\x92\xd7\xd2\x42\x99\x2f\x4a\x4d\xb4\x60\x1d\x61\xa5\x75\x92\xac\xc1\x1d\x75\x3a\xac\xef\x63\x47\x90\xa9\x0d\xb7\x04\x5b\xd3\xed\x85\x20\x07\xd4\x64\x07\x60\x5b\xcb\x0a\x1f\xa2\xa3\x1e\x41\xea\x6a\xf0\x76\x98\xef\x64\x0f\xc9\xac\x43\xbd\x1d\x2c\x26\x0a\x3b\xaf\x39\x53\x98\xb2\x8c\x37\x70\x4b\x41\x79\x48\xc5\x8e\xfd\x77\xd4\x93\x4c\x76\x62\x8d\x9d\xc3\x93\xdc\x03\x87\x4b\xff\xd4\xc7\xd6\x49\xdc\x8b\x1c\x9b\x00\xcf\xb9\x74\xf5\xf2\x01\xf3\x0b\xf2\x8f\x12\xac\x7d\xcc\x51\x48\xd7\x8b\x08\xcb\xef\x52\x17\x23\x80\x99\x4f\x66\x3e\xd0\xaa\xeb\x02\xce\x91\xf4\x86\xec\x96\x66\x46\x33\xfc\xe1\xff\xb5\xea\x41\x65\x93\xcc\x23\xc2\x2e\xdb\x9e\x72\xfa\xb4\x93\x1f\x6d\x71\x84\x02\x97\xa1\xf1\x12\x0e\x36\x37\xc8\x51\x92\xaa\xf6\xdb\xdc\x7c\x88\xbb\x0d\x05\xd9\x5b\xb9\x81\x9e\xe3\x31\xc5\x0d\xb3\xd4\x80\x19\xea\x80\xc7\x29\xba\x0e\xb4\x7a\x06\x65\x11\x83\xb7\x62\x69\xdb\xf6\xa3\x6f\x61\xd3\xe0\x7e\x38\xe4\xee\xe3\xf5\x80\xf0\x38\xb5\xc9\x40\xd9\x6c\xb7\x15\x9c\x62\x77\x7b\x4e\x37\x91\x3e\x82\x1b\x81\x6b\x59\x3a\x0e\x30\xe3\x1e\xfb\xe1\x52\x7f\x7e\x81\x9d\xfa\x73\x5d\xf0\x61\x75\x4d\x39\xf8\xd3\xde\x8c\xbe\x09\xbc\xd1\xd8\x5e\xd9\x07\x92\x58\x3d\xc0\x9a\x0c\x9d\xaa\xb1\xb5\x11\xd1\xc4\xd2\xbb\xdd\x6c\x2b\x8f\x6d\xa8\x78\x4d\xc0\x66\xf6\x42\x09\x1f\xb5\xaf\xaa\x7e\xf4\x30\x4e\x1a\x71\xb8\x8f\xe3\x03\xd6\xfa\xc2\xda\x21\xbe\x1d\x16\xae\xc2\xaf\x5a\x57\x83\x88\x57\xbf\xc9\x26\x1a\x30\x3e\xeb\x09\x64\x99\xb5\x98\x0e\x08\x63\x36\x90\x97\x92\xcb\x15\x5d\xf4\x49\x0e\xc0\x89\xb5\xf4\x40\xdb\x7c\xc8\xf7\xf9\xb7\xbd\xa5\x4a\x21\x04\x6a\x3e\xb8\x7b\x99\x7c\xdc\x9c\x3a\x3f\xd8\x84\xef\xeb\x96\x01\x10\xf0\x16\x2e\x36\x1b\x34\xc9\x60\x93\x8b\xf8\x8e\x48\xe1\x2b\xc2\x6d\x8a\x05\xc0\x52\x6c\x49\x87\x47\x0c\x57\x76\xe0\x2e\xfa\xa8\xf3\xe5\x68\xc5\x9f\xb8\x8f\x08\xfc\x51\xa6\x98\x69\xeb\xbc\x54\xaa\x56\x41\x50\xd3\xad\x7f\xdf\x79\x47\x72\x66\x1d\x02\xcd\x70\xa4\x61\xd5\x05\x37\x6a\xdf\xeb\x7f\x80\xc7\x35\x76\x6e\xf0\x3d\x77\x20\xb9\xfb\xf8\xe3\x70\x29\x57\x0a\x5c\x67\x56\x04\xa2\x9a\xdc\x7d\xe7\x8c\x1a\xaf\xb8\x41\x62\xdc\x85\xd4\x1d\x07\x7f\xa1\xf6\x7e\x30\x31\x89\x12\x8b\xa1\xe4\xa7\x3c\x9b\xdb\x53\x4a\xc5\xe4\x03\x6b\x3d\x79\xb5\x3a\xb1\x8d\x59\x1a\x60\xa5\x35\x58\x20\x94\x50\x28\x6b\xaa\x51\xbf\x5d\xd8\xe8\x2b\x6a\x7a\x7e\x87\xed\x6b\x41\x87\xb0\x4d\x90\x94\x5f\xce\x6f\x61\x27\x5d\x50\x07\xba\x31\x45\x73\x60\xd3\x38\x67\x1c\xc7\x2e\x16\x95\x26\xfd\x88\x37\x0e\xf2\x9f\x4a\xca\x73\x5b\x5f\x10\xa6\x2b\xd7\x8f\x95\xce\xb1\x11\xdf\xdb\xc9\x5e\xa7\xd4\x09\xde\xc3\xa5\xc8\x8a\x5d\x7c\xe7\x7e\xe1\x90\xe5\x4d\x35\xd1\x57\x42\x2b\xeb\xcf\x68\xa3\xdb\x5d\xce\x53\xe4\x25\x9a\x34\xb1\x15\x1e\x72\x75\x43\xfd\x70\x09\x6a\x55\x3b\x46\x4f\xf3\xbd\x8e\x46\x2a\x80\x87\x20\x50\xbd\xc8\xe4\xa6\x8c\x8b\x1e\xf0\x8e\xc4\x7a\x26\x89\xfb\x1e\x4d\x96\xf7\x77\x68\x15\xb4\xab\x20\x92\x52\xd2\x6b\x10\x2c\x4b\x26\xa6\x23\xce\x24\x16\x40\xa6\xb6\x7d\xc4\x60\x0f\x75\x59\xee\xe4\xb4\x0e\xd3\xb9\xbd\xf9\xdd\x61\x18\x04\x62\x4e\x26\x58\x2f\x5d\x71\xe7\x74\x31\xa7\xde\x01\x98\xa0\x45\xfa\xe4\x6e\xfb\x5e\x58\xfd\x72\x40\x0a\x50\x02\x23\x19\xd0\x49\x8f\xe3\x45\x92\x64\xdb\xf0\x58\xd2\xa5\xfa\xbc\x3c\x71\x0b\x8c\x2b\xeb\x14\x6b\x7e\x25\xae\x4f\xf2\xed\x53\x32\x2a\x47\xc3\xa7\xe5\xcb\xfa\x81\x16\x3e\xa8\xa1\x73\xd9\x13\x55\x12\x72\x41\x5f\x01\x39\xdc\x32\x44\x06\xe2\xc8\x1f\xb9\x1d\x2f\xff\xf8\x24\xfd\x54\x80\x30\x9f\x1b\xaa\x44\x3e\x5d\xcc\xc2\x2a\xba\x0c\xd6\xf1\x45\x1d\x76\x71\x58\xa4\xef\xe9\x5b\xac\x1c\xd2\x11\x8b\x17\x6c\xb4\xcb\x99\x4d\xa1\x8a\x26\x9a\xab\x60\x8c\xbd\x48\x0f\x9c\x06\x6b\xf1\x99\x6a\x3d\x68\x1a\x84\xb0\xb9\x99\x5b\xd3\x60\x86\x81\x1b\xb0\x1b\x88\x9d\xc3\xe4\xe7\x25\xef\x81\xa3\xec\xd8\x61\x27\xda\xe6\x38\x5b\x51\x95\xc4\x2d\x40\x6c\xa0\xc8\x43\x0f\x11\xb9\x19\xf0\x50\x90\x17\x29\x07\x4b\x5b\xe2\x22\xe5\xe6\x8e\x70\xd9\xff\xab\xf6\x94\x29\x88\x74\x4e\x20\x80\x04\x2f\xe9\xb0\x64\xb2\x8b\x0c\xac\xae\xdb\x34\xa0\xee\x8e\xf8\x45\xf8\x57\x4d\x54\xde\x72\x7b\x3a\x55\x9c\x8b\x43\x0d\x3a\x4c\x24\xd6\x78\x97\xad\x2f\xf1\xe5\xc7\x9f\x02\x3f\x74\xa4\xb5\xb8\x1d\x6e\x58\xef\x48\xac\x47\x7a\x84\x96\x18\x7b\xb8\x15\x55\xd5\xf6\x3e\xf4\xa8\x9d\x04\x9a\x38\xd9\x0d\x8b\xe0\x61\x6f\x69\xf0\x6d\xe8\x94\xd5\xec\x11\xca\x65\x10\xa7\x6b\x0c\x2f\x15\xde\x09\x7d\x4b\xba\x1d\x96\x8b\x7d\x1f\xc0\xed\x4e\x3e\x1a\xe3\x05\xfa\xa0\x6b\x08\x48\x1e\x29\x19\x54\xa8\x7e\x18\x5d\x98\xb2\x4d\x92\x75\xf4\xed\xc7\x1b\xb6\xb8\x70\x2b\x5e\xbc\xab\x54\x83\x6e\x43\xa2\x4d\x3a\x50\x53\x3b\x29\x41\x4c\xce\xf7\xa3\xd7\x2a\x27\x58\x6c\x4a\x79\x92\x47\xd4\x8a\xfa\x9c\x64\xd7\x07\x80\xee\x40\x2e\xe5\x6b\x5f\xb2\x8b\xe2\xd8\x2e\xc1\x9b\xe9\x8d\xf1\xce\x00\x80\x85\x69\xb0\x6f\x4f\x96\x7a\xbd\x68\x87\x6f\x8f\x96\x5d\x96\xf5\xc6\x69\x2b\x4e\x92\x51\xba\x1d\x6d\xe3\xd9\x23\x4f\x68\xae\x75\xc7\x96\x9d\x8e\x47\x8c\x74\x18\xe0\xaa\xc8\xf1\xbb\x00\xcf\x4e\x47\xb0\x97\x28\x9f\x3e\x36\x0d\x95\x8d\xd6\x43\xb4\xfe\xa0\xfd\xa6\xc3\x81\x12\xe1\x79\xa2\x34\x79\x82\xb5\x36\x6d\x49\x04\xad\x9e\x8e\x70\x0d\xd7\xe9\xcc\x18\x5d\x73\xa7\xa8\xc0\xef\xde\x44\x3e\xc9\x43\x75\x97\x50\x70\x1a\x90\xde\x47\x68\x0d\xfe\xde\x5f\x77\xc4\xb7\x88\xdc\x8d\x6b\x22\x04\x10\x16\x54\x2a\x64\x22\x23\xc9\xa2\x41\x11\x0b\xe1\x88\x69\xa2\x5d\x01\x94\x21\x73\xd4\x9c\x9a\x34\x3a\x9c\xb8\x25\xb6\xe2\x42\xa3\x50\x13\x16\x7d\x90\x09\xee\x2f\x96\xdf\xb0\x34\x79\x29\x5d\x73\xe0\x96\x0b\x07\x70\xd4\x8e\x18\xb8\xc7\x26\xea\x82\x4b\x8d\x71\x6f\x1e\xb0\xad\x17\x42\x8f\x9d\x97\x14\xe3\x40\x15\xb3\x6d\x6e\xdc\x32\x79\x68\x3a\x42\xbe\xbb\xdc\x20\x2d\x26\xa3\x51\x88\x57\x78\x4f\x7a\x82\x32\xc2\xd1\xe5\xf6\x32\x0e\x59\x4d\xc8\xba\xaf\xd3\x90\x6c\x9e\x5c\x35\x80\x40\xdc\x93\x5d\xbd\x89\xb0\x20\xdc\x34\xda\xd2\x15\x4c\xb2\x92\xaf\x64\x0f\x52\x9c\x1d\xba\x93\xda\x9d\x1d\x0a\x09\x5b\xc0\x81\x71\x00\x87\x7d\x14\xdc\x73\x33\x46\xa8\x56\x3f\x45\x16\x9b\x63\xf6\xd7\x6c\x1a\x4f\x45\xbb\xcc\x46\xf8\x7c\x1a\x52\x83\xb3\xba\x7a\x0e\x1a\x07\x07\xc9\x71\xc3\x6e\xb3\x31\x7a\xb3\xbf\xa3\x88\x93\x03\xe2\x1a\x77\x10\x87\xcd\x75\x07\xdf\xe0\xc9\xc9\xe6\xa7\x93\xd3\x46\x63\xa9\x71\x28\x6b\xda\x6b\xdb\x72\x6b\x50\x58\x67\x94\x97\x15\x55\xf6\xe7\x23\xbe\xcb\xfe\x97\x4b\x0c\x88\xc7\xe2\x42\x79\x3f\x74\xd7\xcd\xcf\x45\x9a\x74\xcb\xa2\xcc\xa7\xc7\xe2\x00\x3b\xfd\xdf\x60\x93\xe5\x75\x1a\xdf\xa1\x5f\x3d\x9d\xcf\x45\x1c\x93\x6d\xb3\x89\x1b\x1a\xa8\x47\x2b\x5f\x92\xc6\x77\x5e\x94\x0c\x28\x95\x31\x8d\x46\x49\x05\x44\x41\x2a\x1f\x20\x01\x1c\x0d\x6c\x24\xb1\xd9\xc8\xa8\x9c\x64\x6c\x00\xe8\x21\xc5\x98\x4b\x8f\xe5\x5f\xd9\x88\x26\x43\x25\x06\xf2\x2f\x69\x65\xc1\x3f\x30\x8f\x3f\x4a\x62\xbb\x01\x82\x48\x10\xce\x42\xc0\xb5\x6a\x4e\x07\x2c\x42\x35\x7d\xf1\x14\xe6\x16\xc3\xad\x86\x7b\xf6\xc7\xd4\xa8\x7f\xc9\x52\x23\x8c\xad\x56\x84\x12\xb9\x78\x7d\xbb\xf1\xd9\x90\xec\xce\xc9\x7f\x4b\x3f\xaf\xdd\x07\xea\x70\x89\xea\x54\x17\x3a\xd9\x43\x8b\xb3\x36\x0f\x6f\x58\xaa\xc0\x03\x64\x8a\x2f\xc6\x47\xb8\x0b\xbe\xc6\x35\x10\x8b\x89\xd5\x9d\xdc\xae\x4c\x15\xc5\xbf\xa8\x65\xd3\x63\xdf\x12\x43\x8a\x0b\x1c\xad\x2e\xea\xb2\x1b\x8b\x24\xa1\xc8\x1e\x2c\x57\x06\x4f\xd5\x50\x83\xe6\x91\x8a\x35\x4d\xd2\x1d\xbd\x1f\x78\xa0\xe9\x0e\x1e\x92\x43\xa8\x53\xa2\xdd\x36\x6c\x10\xfc\xb2\xf1\xfc\x33\x74\xce\x55\x23\xf9\x24\xcd\x71\xf5\x58\xeb\xba\xbd\xb6\xa1\xbd\xe9\xfd\x7a\xec\x52\xdb\xc1\x48\x0e\xfa\x24\x07\x82\xeb\xb3\xc4\xf0\x3e\x9c\xd5\xda\x4f\x11\x03\xf7\xfa\xaf\xe3\x72\x1f\x66\xee\x80\xe6\x9d\xd3\xc4\xd1\xe8\xf0\xd2\x6f\xf1\xc3\x16\x74\xcd\x2b\xe0\xf4\x21\x48\x77\x92\x7f\x2b\xd3\x89\xda\xa1\x8f\x24\xfa\xfc\x5b\x2d\x51\x71\x1b\xe7\xca\x65\xb5\xf5\x3e\x6e\xa0\xa1\x45\x97\xf6\x96\xad\xd9\xb3\x65\xdd\xb6\x35\x7b\xdb\x46\xec\x06\xb1\x45\x95\xb4\x5b\xf3\xf4\x8c\xc4\x16\xaa\x6a\xc7\x9e\xe7\x25\x22\xa5\x76\x0a\x00\xb6\x90\x10\x65\x15\xd7\x00\xd8\x67\x79\x5b\xa9\xcb\x1d\x22\x15\x0b\x6f\xb7\x8b\x2e\x7f\xb4\x97\x4d\x61\x4f\xd5\x3e\x3f\xdb\xb0\xd5\x2a\x42\x99\x92\x67\x69\x98\x5f\xe2\x0c\xaa\x41\x19\x29\xbf\x11\x0f\xc6\xd1\x53\xc3\xbd\x63\xf9\xd5\x76\xac\x61\x65\xaa\x9a\x2b\x19\x29\xf2\x8c\x6a\xe4\x63\x81\xa6\xbe\x8c\xa1\x1a\xd8\xb6\x13\x79\xab\xc3\x17\x28\x22\xcd\x6c\x79\xe7\x7a\xe5\xa3\xb8\xd7\x26\xa3\x75\x5a\x79\xb4\xed\x48\x77\x90\xe7\x9d\x11\xfe\x58\xc0\xf3\x34\x1a\x44\xe5\x06\xac\xda\xab\x3d\xc5\xb2\x65\x33\xd5\xef\xc1\x9e\x2b\x8a\xa3\x2b\x55\xe7\x15\xab\xed\xff\xa9\x25\x91\xe1\x10\x80\xb5\x11\x88\xb9\x8f\x77\x5c\xb1\xcc\xac\x4f\x9f\x5a\x26\x11\xa3\xb4\xf3\xb6\xfd\xb8\x4c\xfa\x8b\xef\xda\x30\xaa\xbc\x25\xe7\x1e\x2e\x99\x70\xc7\xfd\x56\x46\x07\xc8\x28\x4c\x8c\xdc\x82\x8b\xa4\x3d\xc0\x69\xa4\xb2\xdb\x40\x1e\xf9\x14\x47\xe0\xae\x08\x8c\x9f\xb8\x1e\x46\x0e\x53\x2c\x0f\x5a\xf7\xe8\x36\x6a\x8d\xea\xc9\x28\x19\x64\x6b\xc4\x0f\xb0\x47\xa4\x43\x71\x28\x32\xfd\x6c\x40\xbe\x21\x8c\xc8\x5a\x87\xb1\xd0\xc1\x7e\xef\x0e\x47\xe7\x2a\x69\xf0\xc2\x31\x0a\x80\x38\xaa\x00\x08\x09\x82\x1b\x0c\xa6\x34\xdb\xd4\x74\x2c\x34\x22\xef\xa6\xe7\xf5\x21\xc2\x17\x14\x1a\x4c\x21\xa2\xf5\x70\x54\x4c\xb0\xe3\xf9\xec\xba\x58\xb9\xc9\xfc\xce\x1a\xc5\xca\x21\xc7\xe4\x0d\x71\x02\x5c\x85\xf3\x10\xe0\xc4\xeb\x30\xf0\x44\x6a\xc3\x14\x27\xe1\xca\x8c\x73\x7f\x60\x77\xe0\x4b\xb1\xbf\xd8\xc7\x64\x31\xfd\xd3\x67\xc8\xe7\x37\x7e\x42\x86\x2b\xfe\x79\xaf\x29\x28\xf5\x5b\x77\xe3\x66\x10\xf6\xe1\xb1\xbd\x1c\x18\x72\x3f\xba\x0e\x5a\x2a\xe6\x77\xf8\x43\xe2\x2e\xfa\xc3\xfe\xeb\xcd\x2f\xf7\x7f\xb9\xff\xf9\x1e\x4d\xe5\x9e\xfa\x03\x40\x7e\xc6\xa1\xc4\x31\x07\xdd\x27\x18\x58\x96\x35\x82\x77\xd0\x2e\x3e\xd0\x21\xff\x7b\xd2\x5d\xbd\x87\xe4\xec\x05\xe9\x72\xd9\xb1\xe2\x14\x73\x54\xf5\x70\xa2\x50\xc4\xf9\x32\xa5\x80\x79\x5a\x8a\xb2\xfe\xcf\x20\x17\x94\x96\xf5\xa3\x5a\x01\x6e\x1f\x3b\x6f\x62\x0b\x75\xdb\xf2\x3b\x74\x6f\x04\x28\xf1\xcb\xbb\x10\xb6\x17\x21\x04\xc9\xe3\x85\x32\x46\x86\x10\xfa\x98\xe7\xea\xc4\x21\xac\x64\xd8\x6a\x24\x95\xb0\x8d\x95\x25\x5a\x2d\x4b\x50\xf0\x5c\x67\x83\x52\x02\x64\xe7\x46\x7c\x6f\xf3\xe1\x71\xad\x80\x8b\x4e\x9c\x39\x72\xe3\xbb\x9b\xd0\x8d\xbc\x03\x7d\xc5\xb2\xbc\x7f\x0e\x02\x45\x2c\x8d\xc7\xaa\xe1\x51\x20\x9f\x74\x21\xc0\x3a\xe7\xd0\x1c\x3a\xe4\x2d\x70\xe9\x0d\x9f\xad\x8b\x28\x71\xf4\x99\x1d\xe1\x4d\xc8\x66\xb5\xcc\xe1\xe1\x73\x66\x27\xd8\x0c\x65\xc1\x86\x98\xd2\xdc\x9a\x5d\x58\x63\x99\x74\xd6\xec\xc4\xd2\x20\x6b\x83\x31\x0c\x78\x32\x9f\xad\x01\x5a\x1d\x1b\x32\x60\xcc\x81\x06\x50\x74\x07\x6f\x01\x2a\x6a\x06\xd5\xda\x61\x62\x8c\xb7\xb7\xcb\xa4\x84\xb5\xd6\x65\x62\xce\x58\x4b\xa7\x49\x09\x41\x83\x1d\xd6\x64\x56\x17\xf3\x6b\x09\x8f\xbd\x8a\x67\x6e\x6a\x8b\x77\x94\x26\xe8\xe6\xfd\xa1\x99\x4b\xd5\x97\x83\x26\x1c\x35\x8e\x1f\x73\x8d\xb7\xda\x84\xe6\x1d\x82\x83\x7b\xb3\x5c\x80\x00\x0e\x6a\x7f\x11\xc8\xd6\x82\xd9\x73\x1c\x27\xb8\x5c\xd6\x97\xaf\x33\xd9\xc8\x90\xf5\x9a\x2b\x5e\x2a\x84\xac\x98\xcd\x91\xdd\x8b\x40\xad\xce\xf2\xf5\x03\x93\x38\x43\x3c\x12\xd0\x5b\xc1\xdf\xd9\x64\xb9\x1a\x61\x8d\x1b\xd6\xe0\xd6\x65\xad\x0f\x56\x01\x23\xdf\x33\xf7\x7f\x73\x64\xff\xb7\x97\xfe\xbe\xd8\x07\x16\x85\xb1\x60\x07\x15\x26\x01\xb1\x56\xb3\x5e\x0b\x0a\xe6\x61\x8b\xbf\xcd\x49\xad\x88\xd0\x2e\x68\x94\x01\xb1\xf3\xf8\x97\xe8\xf6\xf1\x8f\x98\x48\x0c\x27\xb6\xf8\x20\x56\xeb\x25\x1e\x75\x70\xca\x2e\xe1\x57\xf4\x56\x91\x32\x84\x79\x10\x7f\xc4\xc0\xac\xb5\x40\xcd\xd3\x74\x69\x59\x7c\xd4\x6a\x2c\x75\x79\x72\x06\x63\xac\x8e\x82\x0c\x8e\xdd\xed\x65\xae\x81\x16\x8e\x2f\x09\x72\x8e\xfb\x1f\xc3\xaf\x1b\xa0\xf2\x73\x0d\x1b\x26\x6e\xeb\xc3\x66\xa8\x9d\x9c\xd8\x84\xe1\xf9\x7c\x25\x4c\xe1\x27\xf3\x96\xe8\xd1\xf6\xf3\x96\x98\xd4\xf7\xf2\x97\x68\xfc\x5b\x5b\x67\x4c\x52\xac\xce\x91\x3e\x9c\xf9\x04\xf6\xb4\x6c\x2c\xea\xb4\xfa\x64\x56\x34\xcd\x86\x2d\x2c\x4f\xe6\x70\x76\x63\x55\xd2\x54\x6d\xe9\x03\xca\x31\x7a\x3b\x2f\x90\x26\x49\xbb\x66\xa6\xf8\xa1\x2d\x76\xe5\x04\x32\x5e\x6a\x89\x86\xee\x1d\xdd\x90\xe8\x57\xea\x51\xec\xce\xc1\x63\x6e\xce\x5d\xbb\x78\x0c\x72\xdb\xb8\x78\x5a\x50\xd8\xdb\xc3\xd3\x92\xc0\x2d\xdc\x3b\x39\x81\xbb\x23\x07\x4f\x89\xbe\x67\x33\x64\x9a\xa3\xf9\xc4\x6e\x94\x8c\x09\x76\x03\xfc\x16\x72\xc5\x6e\x6d\xef\x35\x51\x8a\xf3\x6c\x1b\xcd\x47\x6d\x67\xdf\xb3\x37\xae\xf7\x8c\x18\x04\xe7\xf1\x54\x4d\x88\x89\xb1\x27\xe7\xab\x8c\xc5\xfd\xa9\xb7\x99\x90\x3b\x53\x17\xcf\x23\x9f\x0a\x92\x1c\x18\x4b\xd3\xf8\xda\x2a\x52\xf8\x19\xe2\x90\xfd\xd5\x6a\xa4\x5c\xfc\x03\xe3\xac\xb0\x23\x9f\x0c\x6a\xd2\x86\x37\x33\x34\xdf\x8e\x1b\xb3\xb0\x39\x00\x99\xe2\xdc\x54\x62\x67\x7e\xe6\x4c\x6b\x5a\x2b\x5a\xa8\x7a\x9a\x12\x14\x86\x06\xa4\x8b\x5e\x84\x6c\xe6\x56\x21\xbd\xed\xe9\xa3\x2b\x8e\x96\x02\x61\x6a\xaf\x87\x01\xbf\xf1\x9d\xb1\x2a\xbc\xb7\xc3\x28\x34\x43\xcd\x41\x74\x24\xb8\x4c\xa4\xc1\x52\xdb\x25\x46\x12\x93\xd5\x4a\x47\x76\x85\xf3\x76\x13\xea\xe2\x93\xfa\x40\xca\x60\xd4\xe3\xc2\xd2\xf2\x1c\x5f\x2c\x4c\xaf\x41\x23\x36\x7c\x4f\xe7\xe4\xf1\x5b\x9b\x86\x61\x51\xa4\x60\x16\xa5\x8f\x86\x05\x2e\x5d\x40\xe1\xde\xa4\x36\x73\xdd\xe6\x16\xac\xce\xe0\x48\xf3\xaf\x0c\xef\xa6\xcc\xdb\x88\xaa\x16\xd6\xdd\x3d\x0d\x8a\xd0\xa6\x8e\x01\x78\xaa\xd9\xaa\x03\x33\x48\x77\x7b\xae\xf9\x4f\x5a\xb6\xb1\x3a\x02\x8f\x0c\xde\x69\xcc\x6f\xcb\x97\x5a\x50\x9c\xaa\xad\xa6\x8d\xa7\x44\x2c\x5e\xee\xc3\x58\x4b\xa5\x18\xbd\x49\x77\xee\x4a\xad\x25\x19\xc1\xbe\xc2\xf1\x21\x94\x7a\x33\x2f\x0d\x4b\x06\x62\x22\xc1\x58\xdc\x09\xf7\xdf\x0f\x98\x82\xee\x06\x15\x17\x94\xd2\xa1\xda\xfe\x2c\x53\x83\x93\x77\x54\x29\x4c\x54\xf2\x54\x1e\xa5\x57\x77\x8e\x77\x39\xe9\x8a\x23\xc4\x29\x01\x89\xc2\x55\xdf\x60\xb8\xd6\x71\xdd\x1a\xb2\xc7\x18\x64\xd3\x45\xb6\x72\x90\x6e\x66\x97\x52\x55\xae\xea\xc6\x67\x97\x49\xb9\xa1\x37\xdd\x88\xb7\x1a\x3a\xae\xd5\x2d\x6e\x6a\x3b\x61\xc3\xce\x2e\x79\x15\x9c\xa8\x58\xe6\x4d\x2c\xd9\x39\x3b\x7a\x2c\xfd\x27\xe0\x09\x0a\x66\x99\x80\xc9\x5e\xc4\xbf\x89\xf7\xda\x8e\x04\xde\xc3\xbc\xcd\x4c\xb8\xab\x97\x3b\xe2\x64\x3d\x74\x2b\xcc\x99\x9a\xd9\x48\x03\x96\x77\x74\x2e\x2e\xde\x9a\x6a\x91\x36\x63\xd7\x60\xa7\x42\x8d\x91\x9a\x3e\x04\x90\xc7\x6c\xc5\xf8\x5e\x96\x20\x63\x37\xef\x97\x7f\xfb\x77\xa7\x03\xe7\x8b\xcf\xbf\xfc\x15\xfe\xf3\xc6\x66\xfa\x3d\xd1\xe5\xc3\xb8\xa4\x58\xde\xd6\x0b\x40\x1c\x09\x85\xfe\x75\xde\xd8\x2c\xba\x7e\x0c\xab\xec\xc1\xe1\x96\x56\x9c\x19\x90\xc0\x19\xa4\x0b\x1c\x58\x55\x60\xff\xc6\x8f\xf2\xe9\xcf\x98\x0f\xc0\xef\xd6\x05\x89\x1f\x85\x32\x85\x7c\x19\x46\x98\xe8\x18\xa6\xc9\xda\xda\x52\xf8\x8c\x9d\xf6\xf8\x28\xe9\xa6\xee\xe3\x4f\x56\x05\x92\xe1\x72\x6b\x19\xf2\x9b\x51\xaf\x19\x55\xdd\xa6\x0e\x01\xbf\xc3\x79\x1e\xaa\x9c\x0b\xbd\x6d\x9b\xb3\x50\x59\xe9\x95\x7b\x8e\xea\x1c\xc8\x94\x2a\x99\x51\x81\x4e\x09\x65\xe8\x27\xe5\x04\xf4\x88\x8d\x1f\x02\x77\x28\xfb\x24\xe6\x02\x26\xb5\x59\x58\x67\xda\x3c\x6f\x24\xca\xe4\x12\xb0\x0c\xf7\x87\xb6\xfe\xa3\xb6\xc6\x18\xdc\x80\x93\x66\x28\xbf\xa1\x36\x65\x4b\x8e\x88\x1b\xb7\xc8\x2c\x03\xf7\x16\x13\x78\x10\x94\x5d\x87\x22\x0a\xfd\xc0\x9f\xcb\x2c\x19\x7a\x6f\xfd\xf8\x97\x18\xb3\x9e\xe1\x4d\x1b\xb6\xf9\x7b\x11\x0d\xfd\x15\x25\x7c\x84\x3a\x45\x8f\x37\x00\x2a\x4a\xaf\x3c\xe3\x91\x21\xae\x2f\xdb\x3e\xc8\xc1\x32\x53\xf3\xf2\x1b\xc2\x06\xd4\x46\x5f\x8a\x2b\x9a\x90\x60\x86\x53\xa3\x7f\x1e\x43\x37\xb0\x4c\x98\x7a\x31\xbb\x8d\xd5\xb9\xeb\xd9\x16\xcd\xa3\x36\x2a\x0d\xdb\x87\x2a\xcd\xcd\xf9\xa1\xe5\xde\xac\x41\x14\x1f\x34\xc0\x85\x07\x2c\xaf\x73\x11\x35\xc7\x4d\x30\x9f\x16\x64\xb2\xeb\x2f\x85\xa7\xca\x45\x60\x79\x06\x2c\x44\x7d\xc9\xb5\xc1\x12\x55\x54\x6b\x39\xd0\x65\xa8\x62\x5a\x5d\xee\x06\xde\xe3\xc8\x22\xdc\x0f\x28\x53\x17\xfe\x46\x10\x87\x6d\x62\xfd\xb5\xbb\xbc\xc3\xe2\x66\x5c\xbe\x09\x05\x3c\x89\x3c\x49\x51\x91\x84\x72\x9d\x49\x55\x41\x69\x60\x94\x50\xd2\xce\xaf\x1f\x51\x76\xae\xc3\x80\x1f\x05\x24\x38\x8d\x2a\xc4\xcd\xb5\x1d\x11\x12\xb7\xae\xf0\x23\x2b\x60\xec\x81\xfa\x85\x75\x06\x63\xf2\xcd\x8a\x38\x0b\x4f\xa2\xf4\x2a\x67\x25\x30\xbe\xcb\x1a\x14\x30\x82\x8b\x02\x79\x3b\xb1\x1e\x1e\x5d\xeb\xe4\xdd\xcb\x2c\x47\x24\xf4\x18\xe8\x6d\xec\x93\x2c\xd3\xcd\x14\x47\x4a\x61\x4e\xa0\x47\xc4\x12\xb7\xc7\x2a\x15\x35\x9e\xf7\x39\x31\xcb\x32\x44\xac\xc2\x63\x56\x05\x42\x2e\x0a\x00\x8e\x22\x8b\x0b\xd0\x58\xa7\x0b\xb3\xac\xab\xab\xf8\x88\x15\xc6\xcf\x90\xfa\x2a\x61\x54\x22\x1f\x9f\xbd\x3b\x9e\x4e\xce\x4e\xc7\x67\x33\xe7\xdd\x68\x7a\x3c\xfa\xea\x64\xec\x50\x1b\x07\x5b\x70\xcd\x9b\xe9\xe5\xf9\xe4\xc2\x39\x1a\xd3\xf3\x8f\xff\xe7\xbb\xf1\x31\xfd\x35\x3a\xfd\xea\x18\xa0\x8c\xdb\xe3\xb9\xb0\x6d\x91\x6a\xc0\x96\xfd\x92\x55\x64\xb7\x1d\x9e\xba\xcf\x65\x13\x00\xa7\x54\xc3\x3c\xd6\x55\xcb\xbd\x1b\x2c\xa9\xbe\x08\x97\x5e\xf3\x73\x73\x2a\xf3\x1e\xb9\xab\xeb\xc5\xcd\xd5\x8b\x83\x5f\x55\x97\x70\x2f\xbe\xf3\x4f\xaf\xb0\x80\x0a\xe9\x3d\xaf\x92\xd5\xfa\x95\x72\x3f\x5d\x73\x6e\x98\xb5\x72\x7b\x1e\x4e\xe2\x5c\xbd\xc0\x9a\xc4\x83\xf0\x16\xeb\x17\x2d\xe2\xab\x17\x8d\x7c\xf9\x5f\x75\xdc\xcd\xd3\x7d\xe2\x07\xe9\x87\x57\xa7\xee\x9c\xff\x34\x90\xe4\xfa\x5c\x51\xd3\xaf\xdc\x20\xa9\x74\x61\x8c\x25\x43\x63\xaa\xd7\x1f\xc1\x86\xa5\x0c\x77\xa3\x45\xc1\xef\xd0\x68\x79\x1f\x3b\xaa\x24\x1c\x20\x13\x5d\xf0\x5c\xbd\xf8\xe1\xea\x2a\x8f\xea\x0a\x91\x5d\x99\xe8\xe0\x8f\x8f\xba\x9b\x83\xc2\x78\x1e\xde\x8b\xe8\xe2\x4e\x2c\x97\x1d\xc7\xd5\x0a\x1d\x8e\x2f\xc9\xcd\x48\x0d\xd0\x36\xb3\xdb\x66\x81\x3e\xe9\x4c\x01\xf0\x3b\x99\xb5\x4a\xfa\x28\x49\x6e\xc9\xcc\xff\x98\xb1\xaa\x19\xdb\x66\x6b\x71\xe5\x11\x8d\xdd\xbb\xd1\x1f\x63\x7f\x89\xca\xb5\x5d\x9a\xb4\xdf\x57\xad\x91\xc8\x39\x93\x78\xae\x08\x53\x97\xe9\xe9\x32\x9a\x22\x1e\x35\xa2\xce\xb0\xda\xc9\xcc\x3e\xb0\xb5\x1c\x75\xba\x1d\x20\x4f\x37\xdd\x9d\x36\xe7\x7f\x4c\xfb\x0e\xa7\xbd\x7a\x93\xf3\xc5\x43\xf7\x5c\x61\x8b\x82\x36\xd1\xca\xf0\x72\x55\xe9\x00\xd5\xe2\xd8\x1a\x79\x38\x92\xee\x08\x32\x34\x50\xd9\x67\x05\x95\xee\xdd\xda\xf0\x6a\x84\x91\xa3\xe1\x55\x30\xe0\x18\xfb\x0c\xd7\xd1\xf8\x76\x36\x3b\xc7\x6c\x8d\x0f\x0f\xaa\x1c\x39\x56\xd7\x56\x14\xd6\xd3\x44\xaf\x21\x49\x0c\x04\xc9\x29\x50\xe1\x61\xd3\xc1\xe3\x5a\x02\xfa\xbb\xfa\x46\x05\xb7\x94\xae\x64\xd0\xd5\xd3\x97\xa7\x64\x47\x8e\xbe\x22\x75\x2d\xbc\x7c\xd9\x00\xd2\xc2\xe4\xb6\xf1\xf4\x55\x8d\xa2\x8b\xa3\xaf\x92\xe0\x3e\x5e\x3e\x49\x08\xde\x01\xa5\x1b\x8a\xec\x65\x0d\x68\x53\xea\x2d\x23\x3d\x7d\x78\x5f\xac\x05\xde\xcd\xab\x37\xea\xec\xd2\x93\x68\xf2\x1e\x3d\xc3\x30\xd4\xec\xcc\x1b\x95\x3d\x79\xbc\x43\xba\xfa\xf2\x0c\x52\x9e\xd2\x95\x37\x7a\x46\x3f\x1e\x0d\xe9\xb9\xdc\x78\xa3\xe7\xf6\xe1\x15\x47\xb7\xad\x0b\xaf\xfb\x00\x3b\x3a\xae\xea\x64\xcd\xb3\x0d\x7c\x4b\x07\xde\x6e\x98\xb0\x2b\x6f\x55\x05\x27\x9e\xd7\x81\x57\xc1\x8e\x1e\x8b\xfe\x69\x78\xd2\xcd\x81\x37\xea\xeb\xbd\xb3\xe2\x6b\xe3\xbc\xab\xc3\xda\xd2\x73\x37\x0e\x36\x59\xe6\x2a\xb0\xe8\x9d\x2b\x3d\xe0\xce\xbd\x1b\xcb\xda\x9a\x89\x15\x3f\xbd\xfa\xf8\x23\x97\xb2\xc4\x6e\x49\x3e\x25\xe1\xe6\xe0\x04\xaa\xf8\xa2\xae\x8c\x64\xb5\x11\x93\x49\x5a\xae\xc6\xca\xa0\x66\x64\xcc\x9b\xcb\xe3\xa3\xbd\x03\x5b\x99\x26\x04\x81\xab\x88\xd6\x53\xb9\xb0\x66\x1e\x9c\x64\x94\x82\x58\x43\x13\x1d\x8f\x5c\xf4\x9d\x74\xce\x06\xec\x58\xd3\x2b\x89\x30\x61\x22\x97\x37\x59\x87\x61\xae\x92\xb2\xb3\x2a\x55\xfe\x52\x34\x8e\x33\x5f\xb7\x53\xbd\x5b\x3f\x18\x8d\x4a\x0e\xa6\xb9\x97\x62\x1e\x5b\x6e\x4c\xe6\xcb\x6d\x70\x26\xb2\x4a\x69\x63\x45\xee\xea\x11\xc2\xeb\x4d\xf5\xb6\x0b\x08\x6b\x2b\xa1\xe6\x91\xd4\x95\x39\x2d\x42\xad\x88\x86\xdc\x6f\x51\xcb\xbb\x80\xd0\x96\x48\xdf\x5c\xc3\x9b\xe9\xf1\x2a\x13\x44\x78\x79\x77\xa0\x46\x35\x1b\x6c\x82\xd2\x86\x92\xea\x54\x91\x36\x05\x72\x8b\xd4\xd8\xf2\x44\x5a\x14\xc7\x95\x34\x59\x43\x23\x1a\x28\xc8\x94\x7c\x53\xae\x82\x88\xeb\x87\x8d\x65\x79\x3f\x9c\x99\x1c\xaf\xc5\xad\x7b\x52\xd0\x8e\xce\xf6\xa4\xdd\x99\x22\xd1\xde\x1a\xae\xa7\x42\x9a\x77\x0e\x4a\x2b\xe4\x6c\x24\xe8\x8d\x5d\x19\x03\xda\x22\x16\xb6\xc3\xb3\xe9\x70\x28\xf3\x99\x8e\x82\x5e\xb8\x5a\x4d\xae\x0d\x63\xbb\xd9\xbd\xe5\xe6\xa3\x86\x27\x18\x95\xef\x2e\x5b\xca\xa8\xf7\x9d\x57\x9c\x33\x4f\xae\x1f\xb7\xde\x57\x65\x7a\x38\x2d\xb5\xf5\x39\x92\x91\xa3\x32\x4a\xcb\x84\xb4\xa6\x62\x7b\x81\x93\x91\xb3\xb5\xc8\x51\x44\x35\x74\x05\x28\x63\xae\xaf\xf3\x9f\x07\x5e\xd4\x8b\x32\x19\xdd\x26\xf0\xbd\x76\x4d\x14\x54\x24\x1b\xe4\x2d\x88\xdc\x29\x5d\xed\x48\xa9\x4a\x85\xe9\xbf\x56\xed\x80\xea\x48\x09\xa3\x7b\x37\x22\x6a\x50\x04\xd4\xeb\x75\x98\x8e\x12\xcc\xdd\x15\xda\xcb\x39\x44\x0c\x84\x23\xbe\xe6\xd6\x2b\x76\x0b\x2e\x65\x4a\x41\x74\x73\xec\x3f\x6f\xc3\xd2\x16\x08\x16\x7b\xb5\xf9\xf6\x15\x7f\xc2\x1b\x8c\x77\x2a\x95\x85\x85\xd7\x6d\x7e\xfe\x1c\x1a\xc3\x2e\x06\xe2\x71\xb5\xa2\xa6\x28\xad\x50\xc2\x69\x91\xae\x42\x0e\x9a\x53\x76\xb2\x76\xfc\x51\x0d\xfc\xa8\xbd\x30\x07\x99\x71\x48\x0a\xcc\xe4\x6b\xd0\x4d\xb9\xc5\x78\x2b\x22\xa8\x6b\x70\xd1\xa7\xa1\xa2\x4d\xf2\xe0\x5a\x10\x46\xe5\xfb\x91\x95\x7d\x78\xae\x6b\xd9\xb7\xc1\x84\xef\xf2\xd0\x37\x5f\xbe\xa2\x69\x6e\xc7\xf4\xd2\x3c\x67\xaf\xb7\xc0\x8a\x46\x69\x2c\x47\xc3\x49\x80\xb5\x4b\x34\x8f\x76\xfe\xf8\x17\xcf\x5f\x84\x95\x59\x7f\xf1\xdc\x8d\x12\xba\x84\xb6\x23\x42\xce\xb5\x0a\x2c\x62\x2e\x60\x74\x4f\x4b\x5a\x8c\xa8\xa0\x2c\xb0\xa8\x10\x20\xd4\x8e\x12\xae\xe2\xc3\x5d\x76\x04\x77\x6f\xd1\x99\x4c\xf5\x8a\x7b\x1d\x74\x2a\x28\x81\x22\x0b\x51\x4c\xcf\x0f\x95\xf9\xa6\x71\x78\x1c\x90\xc8\xb2\x4e\x9b\x5b\x00\x40\xfd\x60\x60\xc7\xc6\x77\x2e\xa9\x46\xff\xe5\x62\x72\xd6\x80\x23\xce\xba\x6d\xd0\xd3\x35\x80\xb1\x9f\x44\x26\xcd\xa8\x9d\x18\x31\xa7\x49\xd5\xa2\x4e\x12\xf0\x82\xf8\x80\xeb\x03\xe5\x50\x2d\xfd\x0a\x4d\xab\xce\x15\x79\x24\xad\xdb\x55\x30\x26\xd0\xf8\xe2\x96\x6c\x72\xb1\xb8\x52\xdc\x82\x49\x0a\xa6\x2c\x13\xd5\x16\xec\x3c\xab\xfb\x54\x0b\x5d\x44\xb8\xdd\xdb\x1b\x3e\x74\x48\x70\x6b\xbb\xc7\x3a\x0a\x95\xb9\x07\x63\x17\x90\xf7\xd4\xef\x93\x1a\x36\x92\xe0\xdc\xdb\x72\x3f\x54\x61\xd8\x1d\xc8\x4c\x84\xe0\x96\x11\x51\xe3\xfa\x94\xef\xa2\xb2\xa9\x42\x0b\x69\xb3\x79\xd8\xa5\xac\x0e\x29\x46\x82\x94\x0d\x44\xed\xf5\x18\x51\x61\x27\x6a\xa7\xbc\x28\xcc\xea\x82\xd7\x02\x93\xba\xca\x75\x01\x4b\x6c\xec\x00\x1b\xe4\x6f\x67\xf0\x6d\x67\x29\x8f\xa7\xfd\x14\xdd\xc2\x4b\x77\x74\xd4\x65\x79\xee\xcd\x22\x2b\x51\x9d\xd1\x39\xb7\x9d\xde\x6d\xc2\x14\xb8\xab\xed\x0d\x3f\x11\x35\x01\x76\xb7\xb2\xfc\x48\xc9\x40\xfa\x4b\xf3\x04\x2a\xc1\x10\x35\xce\x9e\x86\xaa\xb5\x06\x54\x18\xf2\xb3\xb8\xd5\x2e\xc6\xe2\x6b\xcb\x8d\xae\xd6\xd0\x7e\x2b\xf1\x8b\xb8\x42\x42\x50\xc9\xdb\xee\xa1\x24\xf2\x05\x61\x83\x25\x35\x7f\xdf\x4b\x37\x2f\x02\xd9\x56\x8e\xc5\xee\xc6\x94\x28\x5b\x42\xa3\x70\xce\xed\xd7\x64\xb6\x1b\xb6\x58\x94\x9a\x16\xce\xd0\xb9\xa6\x18\xf3\xeb\xe4\x61\x2d\xda\x19\x88\x14\x09\xe5\xd7\x1b\x2d\x45\x6c\x45\x2e\xdc\x6d\x5a\x75\x08\xcb\x5b\xc5\x18\x4e\xfe\x7e\xd3\xa6\x31\x58\x91\x8a\xed\x66\xa3\x48\xcb\x16\x73\x82\xbd\xba\x48\xed\x0d\xbb\x7b\x01\x64\xbf\xae\x20\xec\xee\x09\xf8\xde\x5f\xaf\x0b\xb3\xd1\xe8\xbe\xa1\x8e\xd2\xd4\xaf\xa5\x21\x02\x83\x30\x54\xda\x48\x30\x7d\x83\x13\xab\xb1\xfa\x2a\x57\x90\x75\x63\x8e\x05\x89\x16\x94\xef\xc2\x8e\xc5\x73\xbc\x35\xc0\x2b\x7b\xc0\xdb\xc4\xfc\x13\x45\xa0\x1f\x51\x42\x12\xbc\x9c\x88\x85\x88\xf6\x1d\xe7\x35\xea\xdc\xd8\x72\x3a\x7e\x08\x12\xf7\x03\xac\xd0\xe5\x7a\x40\x7d\x69\xfe\x30\xbf\x55\x51\x62\xd9\x2c\x0d\xef\xfe\x60\xad\xc7\x80\xc3\xad\xa6\xdd\xec\xf5\x8e\xe4\x63\x24\x08\x79\x51\x43\x4d\xbc\x8c\xb8\xc8\xe8\x1d\x80\x1c\x89\x8b\xf4\x0b\xee\xb9\xf5\xf8\x6f\x2b\x11\x85\x34\x0a\x3f\x0a\xf7\x9d\x73\x32\x7e\xf2\x75\x0a\xcb\xf9\xba\xdf\xa6\x54\x7a\x6e\xc5\x95\x45\x61\x5c\x62\xa0\x3a\xe3\xd4\x0d\xcc\x3e\x29\xb5\x87\x6e\xed\xd9\x7a\x80\x3d\xc8\xa9\x76\x2d\x55\x88\x6d\xca\xe8\x23\x70\x81\x08\xee\xa8\xb7\xd8\x4a\x68\x83\x91\x0a\x9e\xa9\x49\xea\x93\xf8\xf0\x70\xf3\x30\xfe\xce\xb9\x77\x79\x8b\x10\x4e\x98\xe0\xb9\xf3\x6d\x78\x43\xba\x30\x3c\x4a\x39\x51\x7b\xb8\x7d\xb0\xb4\x5f\x6c\xab\xdf\xcb\x14\x91\xf4\xc3\x34\x17\xcc\x3d\x0a\x39\x55\x52\x90\x8a\x1e\x83\x56\xef\xd2\x0d\x69\xbe\x4c\x63\x59\xf5\x0f\x16\xbb\xb8\x75\x01\x67\xfc\xf8\x53\x30\x8f\xc2\xc0\xcd\x63\xad\xa5\xbf\xc5\x1e\x6e\xdc\xaa\x9c\x7f\x18\x53\x02\x22\x9d\xfc\x9c\x1b\x28\x64\x97\x45\xe0\x0f\x86\xfc\xc1\x82\x5c\x87\xb0\x3e\xba\x9d\x4e\x1f\xd6\x7c\xc1\x36\x6d\x4d\x1c\x26\xe5\xb2\x0d\x28\xbc\xc5\x3a\x62\xaf\xb8\x43\xfa\xda\xf5\xa3\x58\xf6\x0d\x76\xc2\x39\xf5\x09\xf2\xcc\x4e\xaf\x30\xdb\x6e\x04\xc7\x3e\x32\xe8\xeb\xd5\xf2\x22\x00\x01\x23\x12\x64\x92\x65\xfc\xc4\x71\x6c\x64\x4f\xe1\x49\x86\x50\x81\x1d\xf6\x2d\x07\xd3\x69\x3b\x12\x2c\x19\x36\xac\x50\x65\xb1\x21\x75\x5a\xbf\x0a\x26\x94\x9a\x94\x52\x91\x49\xdc\xb5\x46\x63\x58\xbc\xa4\x51\xf3\xfb\x4a\x8a\x5a\x33\x24\xce\x71\xa4\xdd\x48\x62\x63\x28\x31\x8d\x65\x95\x0d\xa6\x01\xb5\x3e\x3d\x34\xde\x58\xa8\x89\x70\xfe\xf3\x55\xfa\xf9\xe7\xbf\x14\xdc\xb2\x7e\x40\x72\xd1\x4f\x28\x22\x81\xaa\xfe\xcc\xe0\x1c\xfe\xf8\xd1\x2a\xd6\x88\xc8\x8d\x26\x33\xc3\x74\x1b\x82\x20\xe6\x6c\xd5\xe0\xdb\x94\xec\xaa\x42\xf6\xb2\x37\xb0\xb2\x1c\x13\x5c\xd4\xd1\xc0\xd6\x38\x9e\xf3\x28\xc4\xb9\x78\x28\x8c\xeb\x26\x0c\x97\xc2\xb5\x16\x36\xcf\xf3\xb4\x0c\x46\x2e\x11\x05\x26\xec\x4f\x88\x5a\xea\x31\x28\x91\xc1\xc2\xda\x23\xb5\x25\x41\xc6\x9a\x8d\x61\xc7\x3e\xfe\x19\x6b\xdc\xd9\x9a\xa6\xb6\xa0\x2e\x48\x57\x37\x22\x2a\x4f\xb6\x7a\xbc\xf3\xa4\x17\xf0\xe8\xc9\x97\x87\x51\x71\x9a\x8b\x78\x2a\xc7\xf1\x7a\x74\x7c\x32\x3e\xb2\xd0\x70\x38\x39\x75\x5e\x8f\x4e\xde\x8e\x2c\xef\x8e\x47\xb3\xcb\xe9\xd8\x79\x7d\x32\x7a\x63\xcb\xc9\xbb\x38\x3e\x1b\x9d\x1c\xff\xd7\xd1\xe3\x3f\x3f\xfe\xf7\x31\x25\xcd\x4d\xc7\x87\x97\xd3\x8b\xc9\x85\x05\x26\xa5\x94\x3a\x5c\x35\x56\x79\x5d\xa2\x90\xf3\x49\x31\x46\xc1\x7a\x0c\x72\x86\x28\xfb\x9d\xb1\xfe\x2b\x25\xa5\xeb\xba\x35\x79\xcf\x8b\x9b\xd5\x6b\xb2\x9d\x9c\x92\x90\x5b\x91\xcc\xef\x72\x4a\x67\xdc\x26\x2a\x42\x13\x73\x93\xa2\x35\xd7\xfa\x76\x2b\xd4\xec\x0f\xec\x85\x57\xb9\xff\xfa\xa0\x15\x1b\x50\x8a\xe2\x56\x7a\x7e\x11\x2d\xbd\x1a\x16\xdf\x6d\x85\x15\x26\x6a\xc8\x71\xb5\xa8\x32\xd0\xcc\xb3\x9f\x6c\x0a\x1f\x67\xa1\xac\x53\x20\x8b\x9a\xf4\xe0\x48\x16\x49\x5b\x2a\x92\x21\xe3\xee\xf4\xb2\x69\x89\xb7\xed\xb0\xfa\xb1\x32\xef\xde\xee\xc3\x51\xb2\x05\x44\x5c\x54\x31\x5b\x07\xad\x09\xa0\xfa\x89\x74\x80\x47\x21\x26\xff\x62\x19\x81\xfd\x26\x13\x41\x25\x0d\x3d\x90\x53\x25\x83\xce\xd8\xc8\x3d\x5a\xb1\x8a\xc8\xc9\xb9\xfb\x75\x24\xf2\x7d\x4a\xf3\x2b\xa8\x1d\xce\xf6\xc3\x32\x77\x72\x1b\xe7\x78\x69\x6b\xca\xf8\x04\x2b\x98\x3a\x52\x92\x50\x35\xe7\xc6\x7c\x1e\xe6\xad\x2c\xf8\x7f\xad\x52\xdc\xeb\xac\xea\x9a\x18\x8e\x16\x23\x20\xc5\x04\x96\x3f\x86\x05\x98\x2d\x29\x52\xea\xe3\x00\x8b\x8e\xcb\x02\x04\xe8\x4c\x10\x95\x4d\x4d\x9a\x8f\x11\x26\x31\x83\xea\xaf\x8c\xe6\xde\xca\xed\x50\x19\x2e\xda\x70\xa4\x24\xa1\x72\x31\xd5\x39\x4e\x34\x1d\xad\x1c\x4c\x19\x68\x2e\xdd\xc1\xc6\xda\x96\x93\xa1\xea\x76\xe4\x27\x81\x40\x58\xb0\xc9\x3c\x08\x74\x07\xf3\xc7\xd7\x4b\x17\x2b\x31\xca\x02\x68\x9e\x4d\xa9\x99\xca\xd4\x86\xd2\x8b\x2a\x56\xcc\xb3\x69\x83\x56\x94\x9c\xa7\xd1\x1d\x63\x2b\x74\x36\xf7\x93\x84\x6a\x71\x35\xa1\x8b\x9c\x22\x8d\xf9\xba\x4d\xd7\x67\x6c\xa4\xb2\x72\xdf\x83\x6a\x89\xa3\xa0\xbc\x10\x7c\x4a\x7c\xf0\x29\x23\x2d\x91\x15\x30\xd6\x2e\x4c\x1b\xd0\x8a\x3f\xae\xeb\x9c\xf6\x23\x69\x34\xa2\x60\x64\xe3\x82\x4e\x1f\xa9\x5f\xd0\xc0\x99\x83\xf6\xe7\xdf\xfa\xb0\x06\x50\x89\xf4\x58\x8f\x14\x0a\x2b\xb6\xde\x70\x38\x26\x23\x9f\x5e\x54\xc0\x5f\x3d\xc4\x10\x7b\x7c\xdc\xc8\x70\x14\x6c\x56\x83\x97\x7d\x0a\x88\x8e\x56\x75\x16\xa9\x3a\x70\x1e\x97\x6e\x7f\xe9\x71\x11\x9a\x75\x14\x52\x91\x91\x30\xca\x01\xb6\x55\x45\x01\x18\x8f\xff\x8a\x02\xee\x83\xb2\x02\xbc\x24\xe6\x64\xf6\x79\x05\xa5\xae\xfb\xba\x41\x09\x5e\xaa\x3b\x8c\xac\x8c\x3f\x16\xab\x3c\xce\x3a\x94\xb2\x56\x0a\x27\xe5\x90\x3f\x7f\x47\x5c\x5d\xf9\x8b\xc8\xed\x3b\x18\x7a\x99\xe5\x41\xa7\xd1\x74\x29\x35\xa9\x70\x75\x2b\x34\xc9\x78\x60\x8b\xb2\xbc\xe3\x56\xc7\x6a\x84\xbc\x74\x1a\xf0\x45\x22\x8b\x0f\xd0\x68\x11\x0a\x8e\xd4\xdd\xf8\xb6\x34\x2a\xc6\x9c\x06\x3b\x5b\xfd\x6f\xc6\xb3\xd9\xf1\xd9\x1b\xe7\x62\x36\x9a\xce\xac\x97\xb1\xe3\xb3\xd9\x74\x72\x74\x09\x17\xa9\xff\x36\xb1\xc0\x39\x99\x7c\x35\x3a\x71\x26\xe7\xb3\xe3\xc9\x99\xb5\x84\xc9\xe4\x5c\xde\xc5\xe8\xf1\xe3\x0b\x4b\x50\xd3\x1b\x91\x60\xae\x81\xf2\x54\xe9\x86\x5b\x14\x21\x8a\x2d\xcd\x97\x78\xd6\xd9\x04\xe4\x84\x2c\xa1\x78\xa7\xe6\xd6\x5b\x66\x50\x0b\x9f\xf8\xfc\xbe\x88\x11\x98\x9d\x02\x14\x94\x65\x8f\x05\x9b\xb5\x70\xce\xeb\x1a\x50\x30\x0d\xa1\xb4\x87\x94\xa1\x70\xb6\x9d\xd5\x94\xf9\x46\xc5\x73\x61\x93\x12\x0e\x38\x91\x05\xbc\xe0\xf4\x7e\x2f\x12\x50\xe5\xe6\xc2\x9e\xca\x82\xd8\xd1\xd8\xac\xb3\xa1\x54\x00\x0a\x39\xc8\xe1\xbe\x4e\xa2\x16\x8b\xe0\x44\xee\x0d\xc6\x2d\x58\x33\x5a\xde\x64\x81\x65\xf1\xd3\x34\x85\x50\xb4\x12\x86\xa7\x6f\x02\xa1\x06\x64\x5c\x8a\xf7\xf7\xad\x91\xd5\x8a\xb8\xe2\xd3\xb5\xa0\xe5\x95\xb9\xa6\xe1\x63\x17\xbe\xe8\x5b\x74\xcb\xf6\x8e\x1d\x78\x20\x8c\x74\x25\x5d\x6b\xcf\xf9\xe1\xc9\xfb\x80\xa8\xa1\x29\x05\xd6\x8f\x73\x09\x4f\x99\x9d\x3f\x4f\xcb\xf3\x2d\x0e\xb6\x3e\x3c\x05\x47\x1a\x57\x9a\xb4\x5e\x3c\x0b\x13\x9a\x16\x32\x87\x0f\x3d\xff\xba\x90\x4e\xc9\xe7\x61\x42\x3d\x0b\x6c\xf2\xbf\xc6\xed\xad\x46\x61\x17\xfe\x35\x4e\xef\x37\xb9\x88\xd2\xed\x12\x42\x15\x21\xf9\x28\xd3\x9d\x26\x78\x96\xc8\xdd\x5d\x1b\x8d\x1a\xea\x77\xdf\x57\xa3\x3c\x8e\xa6\xae\x03\x3d\x7b\xf8\xd6\x8e\xaa\x53\x13\x82\xbe\x8d\x7d\xd5\x50\x3f\x41\xab\x1f\xbd\xbf\x3f\x75\xa3\x1f\x83\x07\xf1\x73\x0c\x98\x86\x1b\x3f\xef\xd8\x6c\x15\x05\x1a\x4f\xa0\x36\xc5\x00\x9a\x4e\x0e\xbe\x45\xc6\x59\xa7\x3d\x19\xce\x1d\x46\x3e\x80\x04\x00\x4d\xc2\x53\x46\x82\xc7\xb9\x86\x79\x66\x4c\x78\x4c\x40\xda\x13\xa1\x09\x78\x70\x6c\x9e\xe5\x32\xee\x7c\x18\xba\x63\x71\x00\x2b\x7c\x95\x7d\x54\x48\xa2\x6c\x2b\xb3\x55\xcb\xc1\x1f\x7a\xb7\x53\xc9\xd1\xd8\xa5\xd2\x84\x5e\xc2\xf4\x5e\x0f\x8c\x39\x0f\x40\x09\xb1\xd3\x66\x45\x2a\x2f\x40\x68\x78\x01\xfa\xad\x4b\x59\x0a\xb9\x17\x15\x91\x9d\x03\x2d\xd1\x56\x9e\xe7\x2d\xb5\xa6\x5a\x12\xfb\x63\xef\x84\xa6\x0d\x40\x1b\xc4\x7a\x0a\x53\xa5\x68\x52\x8d\xf3\xbc\x0e\xe1\xc8\x86\x32\xfc\xe5\x1b\xfc\xee\xac\xe5\xa2\x8d\xc4\x22\x72\xeb\x94\x86\x3a\xd0\xb5\x14\xe7\x69\x8c\xbb\x2a\x35\x99\x5f\xcb\x50\x60\xba\x2a\x2b\xea\xd0\x92\x05\x47\x7a\xe8\xd9\xba\x4c\x48\x5c\x6c\xf5\xd5\x61\x83\x17\xc8\xa0\x86\xed\xba\xe9\xd7\x57\xf4\x09\x17\x5a\x90\x2f\xf0\x25\x57\x8d\xfe\xbb\xdf\x45\xa1\x3c\x00\x39\xd7\x15\x14\x08\x8b\xd6\x6b\x92\xf0\xa4\xc3\x2f\x17\x7e\xf9\x39\xf0\x65\x50\xdd\x8f\xec\xe7\xcb\xb0\xa7\x5e\x25\x36\x76\x3c\xdd\x50\x9f\x76\x44\xbb\xa1\xfb\xd9\xd6\xe8\x73\xad\xb9\x9f\xc3\x6e\xfc\xd4\xfb\xee\xc9\x37\xd8\xee\x77\x92\xce\x03\x8a\xfb\x5d\xc5\xe4\xbb\x3d\x1a\x5e\xb6\xa6\x91\xf7\x60\xbf\xcb\x97\x7a\xb7\x8a\x9a\x4e\x2a\x67\x6c\x96\xb0\x94\xb7\x09\x5a\xd1\x2d\x4a\xec\x6d\x65\xcb\xd0\x95\xf6\x4a\x65\x2e\xdb\xd4\xda\xeb\xc7\xf1\x4e\x83\x7c\x96\x01\xb5\x25\xbd\xec\xd5\x79\xb2\x06\xa4\x6a\x74\x4d\xbe\xa0\xe7\xe9\x41\x5a\xe2\xc3\xf3\x0d\xfb\x79\xc7\x57\xd1\x62\x75\xd7\x66\x81\x8a\x86\xab\x3d\xa5\x6c\x46\x6c\x7f\x1b\x81\x41\x4d\x5f\x12\xe2\xaa\xf6\xae\xb5\x93\xdf\xec\x57\x51\xa5\x71\x6a\x1b\xba\x36\x4c\x75\xa3\xd0\xc5\x34\x42\x4a\xf5\xb8\xc0\x4f\x98\x5f\x92\x5b\xd6\xfa\x04\xdf\xb5\xc7\x64\xed\x63\x38\x55\x0e\xb1\x65\x95\x97\x49\xd8\x9d\xb3\x84\xb3\x28\x9f\x73\xc8\xd6\xcd\xfc\x94\xc3\xe4\xd8\xce\xea\x06\xc4\xaf\x6c\x9e\x83\xf6\xdd\xb9\xd5\x00\xb3\x20\xcf\xa6\x1e\xc4\xaf\xec\x9e\x83\x7e\x42\xab\x6e\x84\xbd\x84\x6f\xfb\xb1\x74\x23\x98\xaa\x90\x53\xd1\x00\xea\xf8\x34\x5f\xa6\x1e\x1d\xa0\x5c\x0b\x84\x33\x9f\x6e\x42\xef\x61\x80\xa5\xa9\xf7\xfe\x7e\x0f\x14\x03\xec\xac\x27\x3c\xe7\xe6\x01\x63\x65\x29\x58\x0e\x66\x1d\x5f\xc7\x0c\x77\x7a\x51\x17\x21\xe8\x64\x6d\x23\x52\x56\x22\xb9\x0b\x3d\xe7\xe5\x9b\xf1\x6c\x70\x3e\xb9\x80\xff\x5c\xce\x06\x47\xe3\x93\xf1\x6c\x3c\x10\xc9\xdc\x16\x3e\x76\xfa\xf8\x27\x34\x72\xeb\xba\xea\xb6\xf7\xf7\x2d\x81\x63\x6f\xc3\x38\xa1\x61\x70\x1b\xaf\xd5\xc3\x30\x4e\x6f\x38\x0c\xc1\x86\xf2\x0c\x93\xeb\x00\xe5\x1d\xbc\x5a\xe8\xe5\x95\x7f\xbd\x1e\xa1\xb2\xd9\x71\x03\xba\x97\x32\xc9\x52\x46\xea\xdc\xb9\xf8\x51\x86\x43\xd8\x08\xa9\x06\xd5\x80\x36\x95\x29\xa0\xb0\x5a\xb0\xf1\x95\x8e\x30\x73\x8e\x26\xa7\xa3\xe3\x33\x8a\x45\xa5\xa0\xc2\x07\x83\xba\x84\xba\x58\xd9\x8a\x57\x3e\x11\x46\x0e\xd5\xda\x02\x27\x2e\x6c\x0f\x2f\x2a\x26\xe4\x1d\xf0\xf2\xf8\xec\x62\x36\x3a\x39\x19\x1f\x39\xe7\x27\x97\x6f\x60\x04\x87\x93\xd3\xd3\xd1\xd9\x91\x2d\x99\x06\x7e\x86\x5f\xb9\xc5\x15\xbe\x31\x84\x57\x18\xc6\xe8\xc8\x96\x50\x73\xbc\x08\x30\xb7\x36\x57\x63\xc3\x16\x61\x86\x8f\x56\x14\x5f\xb5\x00\x96\x5b\x5d\x57\xa3\x90\x15\x5b\xd4\xde\xaf\xed\xe7\x48\x2f\xfb\xb9\xb2\x2d\x8e\x97\x35\x4f\x40\x11\x55\xd7\xe3\x11\x5e\xc7\xf4\xc1\x79\xe2\x5c\xc6\xee\x42\x60\x63\x09\x0b\xa2\xcb\x98\x84\x12\x3e\x9d\x84\xf4\x5c\x1b\x80\xfb\x6d\x21\xee\xb7\x07\xe9\x8c\x82\x2c\x4f\xda\x8f\x1d\x6a\x8c\x43\x4e\x42\xd9\x07\x93\x1e\x5e\x3e\x60\xa5\xb4\x65\x08\xcb\xae\x3d\x11\xce\xe5\xca\xc8\x62\xe6\x54\x67\x17\x56\x2e\x46\xf2\x84\xa9\xd9\xe7\x0e\x5b\x02\xcc\x39\xf7\x19\x5f\x75\x29\x52\xb8\xcb\x20\x0e\x75\xa5\xb1\x00\x96\xf8\xd2\x5d\xc4\x20\xf0\x3e\xcc\xc5\x3a\x71\x86\xb7\x9f\x61\xe1\x7b\x1c\xcc\x8d\x6c\x0f\x00\x7b\xe7\xfe\x0e\xc3\x9a\xb9\x79\xa4\xb3\x4a\x97\x89\xbf\x5e\x0a\x8e\x34\x63\xcf\x64\x7e\x69\xda\x4e\xb1\xc2\x80\xcb\x0d\xfe\x38\x71\x33\xc2\x64\x6b\x15\xd1\x49\xfa\x39\x66\xf5\x15\xbb\xb4\x10\xc5\xc0\x29\xa4\x18\x13\x88\x83\x0d\x86\xbf\xa3\x00\x46\x42\x9d\x8d\x3c\x27\x89\x48\x6a\xb4\x99\x60\xf1\x56\x0e\x17\x2c\xec\x0d\xcb\xa1\x58\xe2\xdb\xdb\xf1\xe8\x64\xf6\xf6\xfa\xf0\xed\xf8\xf0\x37\xd7\xb3\xaf\xcf\xc7\xc0\x8b\x98\x18\x75\xf5\x02\x0b\xe1\x5d\xbd\xc0\x85\x70\xf5\x22\x08\x03\x71\xf5\xe2\x0a\x66\xa4\xed\xdc\x97\x21\x7b\x62\xc3\xcd\xcb\x33\xd0\x69\x11\x74\x3b\xaa\xcf\xb2\xec\x78\x95\xbc\xef\xb5\x5f\x95\x67\x9c\x43\x9e\xad\xcc\x40\xa0\x95\x8a\xb8\xdb\x61\xc9\xd9\x88\x20\x8d\x11\x9e\xe8\x58\xda\xa3\x04\x7f\xaa\xaa\x12\xec\xc1\x84\x53\x3b\x50\x5c\x11\xd9\x07\x8a\x36\xda\x43\xa5\x4b\x91\x11\xb7\xe7\xc1\x94\x4b\x06\xd4\x83\x26\x85\x4b\xb3\x29\xee\xc0\x9b\x1a\xda\x77\x4e\xf1\x6e\xe8\x54\x9e\x35\x1d\x51\xbc\x2d\x9d\x15\x00\x77\x40\xe7\xe8\xfc\xdc\xb9\x18\x4f\xdf\x1d\x1f\x8e\xaf\xe9\x88\x3d\x3b\x1c\x6f\x47\x68\x25\xc4\xdd\x50\xca\xfd\x94\x50\x2c\x4b\x4d\xa8\x25\xa1\x5b\xa1\x2a\xcb\x9d\x6d\xd9\xc3\xb0\x45\x05\xe4\x5d\xb3\x69\xe7\x33\xab\x48\x7f\xda\x09\xce\x88\xec\x47\x5f\x9e\x98\x5d\xd0\xd1\x9f\x57\x79\x5a\xa8\x35\x58\x57\x82\xbe\xba\x3c\x3e\x39\x3a\x1f\xc1\x22\x41\x88\x03\xe7\x6c\xfc\xbb\xeb\xfc\x77\xdb\xcd\x6b\x0b\xf8\x3b\x98\x5e\xb5\x65\xb7\x58\x96\x7d\x51\x52\x21\x9e\x16\x53\xd9\x15\xfe\xc9\xe8\xab\xf1\xc9\xc0\x39\x9f\x4e\xde\x1d\x1f\x8d\xa7\x34\xb6\xd9\xe4\x37\xe3\xd6\x82\xa9\x7a\x3e\x8a\x60\x85\x04\xba\x83\x49\x28\x51\xbc\x4b\x3a\x77\x40\xdf\x64\xfa\x26\x27\xdf\x7b\xd3\x16\xc6\x06\x25\x04\x56\x48\xa0\xbb\x20\x6b\x1b\xae\x99\xb4\xec\x88\x65\x72\xdf\xfe\xf6\x72\x32\x1b\x6d\x4d\x5c\x0e\xd8\x0e\xe8\x9b\x8e\xcf\x27\xd9\x89\x84\x1d\xc7\x9f\x68\xb7\x5f\x60\xc1\x8d\xe3\xd9\xd7\xd7\xd4\x3c\x9b\xb0\x9d\x8f\xe0\x7c\x9d\x4d\xae\x31\xa1\xf8\x7a\x7a\x79\x32\xbe\xb8\x7e\x7d\x7c\xb2\xa5\xb8\x2c\xe0\x11\x56\x2c\x3b\x60\x5e\x1e\xd7\x40\x2f\xc4\x8b\xf3\xd1\xb6\xa7\x79\x15\x68\x21\x01\xef\x84\x72\x96\xf1\x5f\x4d\x41\x76\x4d\xf9\x50\xc9\x7f\xb7\x2d\xf9\x8d\xf0\x9f\x60\x14\x97\xf0\x05\xef\x8f\xf3\xd1\xc5\xc5\xef\x26\xd3\xa3\x41\x97\x25\xdd\x6e\x28\x36\x24\x3b\x1c\x8f\x3e\x79\xd5\x17\xbf\x19\x7f\xbd\x9b\x41\x54\x42\x7e\x0a\xca\x71\x1b\x98\x93\xbe\x1b\x1d\xb7\x04\x4d\x54\x23\x79\xaa\x11\x3d\xdd\x7c\x88\x9d\xcf\xc8\xe4\x72\x7a\x38\x1e\xe2\x7d\x6f\x36\x9a\xbe\x19\xcf\xe8\xe3\x76\x44\x57\x82\xdc\x05\xad\x2c\x2f\x77\x74\x84\x33\xb4\x5d\x1e\xe2\x19\x7d\x3b\x38\xc4\x15\x79\x3b\x3b\xc2\x09\xe0\x30\xbb\x55\xd2\x9f\x04\x7d\xb8\xfd\xed\xc3\x00\x2e\xca\xa0\x77\x45\x3d\x6b\x20\xb4\x95\xb3\x3f\xb7\xa7\xbb\x12\xec\x6e\x69\xde\xe6\x16\x6a\x25\xaa\x0f\x4d\xd9\xb1\x04\xaa\xc2\xc0\x99\x4e\xb6\x55\xa4\xaa\x00\xee\x80\x77\x05\xb0\xc4\x83\x27\x20\xd7\x84\xbb\x03\xaa\xdb\xdd\x50\xab\x29\x33\x8d\xcf\xbd\x70\xaf\xd7\xec\x9a\xde\x66\xad\x69\x20\xdb\xaf\x34\x00\x75\x8d\xa0\x06\xd2\xa1\x7b\x5d\x24\xae\xfb\xe4\x55\x83\xdc\xc5\xbc\xf5\x27\x69\x2b\xbc\xba\x4c\x80\x1c\x16\x55\xd4\x41\xe9\xbc\x96\x65\x7c\xb7\xe3\x57\x25\x78\x91\x01\xdf\x01\xe7\x28\x1c\x00\x29\x96\x7d\xc0\xb6\xa2\x97\x80\x09\x05\x6a\x07\xd4\x85\x4b\xcf\xd8\x17\x40\x65\x20\xee\x2b\x37\x4a\x0f\xdb\x84\x09\x5a\xe4\x01\xef\x88\x72\x0c\xa6\xe1\x89\x43\xe8\xea\xaf\xed\xc9\xb6\xc0\xdd\x05\xd5\xd1\x62\xd7\x7b\xbe\x1a\xe4\x0e\x68\x95\x81\xa4\x83\x5c\x50\xf0\xa0\x9c\xd9\xbb\x15\xf5\x6d\x91\xec\x62\x3c\x14\x4b\xb8\xf5\x09\x60\x80\xd9\xfe\x0c\xd8\x7c\xa1\x2e\x5d\xf8\x51\xdb\x18\xf1\xf3\xc9\xe8\xcc\xd9\x7c\x99\xfd\xfc\x25\x7f\xb5\x15\xb7\xbb\xa3\xeb\xcb\x77\x5b\xbd\xa2\x1c\x5d\x96\x62\x45\x19\x28\x55\x97\x70\xe5\x26\x07\x59\x41\x7e\xb4\x40\x61\x55\x36\x2c\xed\x7f\x95\xc0\xff\x0b\xde\xb9\x4b\xdf\x93\x4f\x73\x21\x36\x77\xb5\xa6\xee\x33\xdf\x5c\x05\x00\x1d\xff\xe3\xa0\x03\x3d\x0a\x93\x70\x1e\x2e\xaf\x00\xcd\xd5\x8b\x64\xbe\xbe\x7a\x31\x50\xbf\x79\xd4\xce\x83\x08\xe5\x9f\xbf\xf8\x7c\xff\xcb\x5f\xfd\x6a\xff\x8b\xfd\x2f\xfe\x93\xf1\x18\xfa\xe0\x63\x7e\xe0\x97\xbf\xfc\xfc\xef\xae\x5e\xe0\x0f\x40\xc8\xef\xed\xf5\xa9\x80\xfa\x90\x89\xcb\x46\xae\x42\x0f\x2c\x03\x1a\x73\xe8\x18\x65\x55\xc8\x18\x05\x02\xb0\x79\xfc\x11\x46\x1a\x3e\xef\xc0\x2c\x93\xc4\x15\xce\x0e\x4f\x8e\x65\x5e\x78\x47\x03\x27\xbd\x6e\x34\x3c\xfb\x01\x5b\xaa\xe3\x27\x6e\xab\x64\x0f\x81\xe4\x57\x65\x63\x71\xa3\x97\x5d\xf1\x6d\x3b\x5e\x10\x28\x75\xb0\xb1\x90\x40\x54\xff\xba\x73\x2a\x56\x61\xf4\x60\x8b\x3e\x14\x2b\xcc\x6f\x77\x31\x5e\x25\xab\x4d\xd0\x00\x51\x45\x90\x60\x25\xbf\x60\x18\x88\x05\x80\xdb\x08\xd5\x59\xc1\x56\x38\x30\x5f\xfb\x40\x46\x8a\x94\x5b\x1a\x70\xd4\x90\x04\x6a\xf5\x15\x6e\x68\x1b\xe1\x6a\xac\xec\x4a\x64\x2d\x9f\x28\xc3\xbc\xe8\x45\x3f\xe0\x35\x9a\x6b\x4b\x54\x8f\x70\x2a\x0b\xba\xe2\xbf\xf6\xca\xa7\xaa\x0a\x6b\x86\x20\x7b\xa5\x16\xfc\xc5\xc5\x89\x73\x28\x64\x3b\x5c\x0c\x33\xc1\x8e\x01\x14\x70\x32\xf3\xd7\xa7\xd8\xeb\xaa\x26\xea\xe4\x90\xab\x2e\x52\x94\x15\x02\x52\xd8\x65\xc2\x8a\x1d\x5c\x2d\x49\xdc\x3b\xa1\x0f\x8f\xcd\x0e\x08\x3d\x58\xdd\xa2\xeb\xd3\x8c\x7a\x3c\x95\xd3\xb9\xf4\xc8\x0f\xac\xae\x5d\xc6\xa1\x1b\xe9\x93\x0a\x0d\x92\x09\xe8\x92\x01\xac\xc3\x39\x45\x99\xed\x3b\xe7\x4b\xe1\xc2\xc0\xe5\x8f\xb0\xe6\x8d\xa5\x17\xde\x7c\x8b\xb2\x9f\xba\xc7\x11\xb5\x2a\xae\x18\x00\x27\xa0\xe0\x50\xf5\xb4\xf2\x0b\x36\x71\x71\xa8\xc8\x29\x2e\x1f\x20\x28\x10\x73\xfc\x24\xd3\x24\x8d\x60\x33\x78\x70\x38\xdf\xc7\x66\x26\x01\x46\x34\xe2\x8e\x42\x2c\x40\x0b\x61\x54\x6b\x20\x4c\x9d\xac\xea\x26\x41\x31\x82\xca\x90\x5c\x8e\xd5\xae\x7c\xd9\x2a\xa0\x78\x64\x59\xe3\x36\x4c\x42\xc0\xaa\x19\x1c\x5f\xbf\xe7\x0c\x95\xc4\xa4\x47\xbc\x10\xd4\x08\x8c\xd2\xa3\x32\xa0\x16\x1e\x1c\x51\x2b\x37\x3d\x83\x14\x9d\x59\x06\xab\x1b\xbe\x29\xa1\xca\xa1\x86\x08\x57\xac\x1a\xa8\xf5\xe3\xf7\x9c\xe6\x42\x07\xda\x11\xfc\x29\xb3\x66\xba\xd5\x37\x3e\x0c\xb9\x9f\x19\xc0\x9b\x1b\x73\xd5\x16\xe8\x96\x34\xee\x8a\xac\x26\x4a\xb8\x80\xd5\x90\x0a\x58\x0d\x75\x01\xab\x15\x81\xe3\xdf\x0e\xf1\x27\x2e\xf5\x6f\x21\xe9\xdc\x8d\x1e\xff\x65\x25\x12\x90\xed\x65\x70\xc6\x5e\xad\x04\x59\x4b\x9d\xa1\x73\xa7\x01\x37\xdd\x52\x87\x54\x7c\x88\x5f\xe1\x40\x8f\x73\x0f\x19\x87\x17\xdf\x9d\x1b\x0f\xae\x43\xdc\xcb\x0b\xb1\x72\x3c\x61\x1e\x61\x79\xd6\x96\xd1\x8e\x58\x08\x94\x5f\xac\x3b\xfb\x24\x49\x0d\xc7\x9e\x1e\xf6\x8a\x8e\x76\x6e\x49\x43\x64\xf0\x59\x7f\x82\x7f\xb7\x58\x2b\x27\xdc\xca\xc6\x23\x40\x52\x0d\xa8\x1c\x63\x58\x0b\xbc\x15\xad\x39\x2e\xe5\xa6\xa5\xf3\x84\x1c\x37\x4d\x02\xb3\xff\x49\x58\xde\x3c\x8c\x25\x26\x58\x27\x77\x6e\x60\x3e\x29\x57\xc5\xee\x07\x04\x77\x1d\x38\x7d\x64\x9f\x8e\x22\xb6\xda\x11\x91\x92\xde\x94\xee\xc2\xd2\x58\x5e\x08\xb4\x48\x36\x42\x93\xeb\x71\xe8\x60\x65\x27\x6b\x94\x03\x5f\xda\x0a\xa7\x9e\xca\xc7\x8d\x13\x1c\xde\xd4\x4d\x54\x52\xcc\x95\x5d\x5b\x95\x53\x89\xb2\x62\x4b\x6c\xb1\x1f\x4a\x3b\xa0\xe3\xf2\xdf\xfd\x0e\xdd\xc1\x9e\xb4\x10\xd5\xf5\x04\x6c\x49\x5c\xcf\x33\xd0\xac\x1d\xe5\x2c\x52\xdf\x23\x90\x6f\xe0\x43\xe7\xb8\x6b\x06\x88\xe5\x84\xa9\x46\xb3\x3e\xc0\x66\xfc\x4d\x8b\x79\x30\x8e\x30\x05\x26\x3f\xd4\x2a\x50\xb5\xd4\x64\xa5\x24\xa9\x3f\x6f\xae\xc3\x0e\xf7\xe9\xbd\xa0\xe6\x42\xef\xdc\x65\xab\x2e\x83\xef\xa8\xde\x64\x41\xe7\xef\x0a\xda\x46\x31\x35\x3c\x0b\x68\x3f\xc3\x81\xc6\x29\x82\x03\xfa\x46\x70\xcb\x83\x5b\x59\xb6\x9e\x0b\x86\xca\x9a\xf2\x94\x0d\x69\x35\xfb\xc0\xb1\x0a\x0a\x35\xd6\x2d\x77\x40\xd4\x0b\xba\xc9\x1a\xb9\x82\x82\x0b\xe5\x63\xb5\x6c\x2e\x79\xaf\x95\x56\x4f\xc0\xba\x00\x3d\xd6\xcd\x32\x7b\xed\x96\x1e\x0b\xe9\xb1\x58\xa2\xe2\x8e\x3f\xcc\x41\x54\x2f\xd8\x98\x27\xc7\x84\xed\xb3\x40\xe8\x70\x91\x6d\xda\x24\x71\xcf\x51\x48\x44\xf0\x2c\x3d\xb1\x4a\xf1\x49\x2a\x28\x80\x03\xd4\xb7\x8f\x48\x36\x95\x23\x65\x77\xe1\xc6\x64\xbd\xaa\x1e\xd1\x09\xfc\xea\x4c\x50\x22\x12\x05\xd5\x44\x3d\xfe\xbf\x4b\x58\xa5\x2e\x3f\x57\x53\x32\xfd\x04\xdb\x58\xa1\x65\x44\x55\x78\xce\xba\xc4\xf1\xe4\x59\x37\x3e\x16\x3f\xcf\x6a\xf3\x71\xf9\xe6\xac\x86\xa5\x87\x42\x01\x2d\x39\x8d\x78\x37\xae\xbf\xa4\x05\x24\xef\x09\x73\xce\xf2\xb1\x55\xf7\x2e\x22\xd6\x89\x35\x66\xff\x78\x1f\xaf\xaa\x98\x9b\xe3\x5b\xda\x24\x58\xd1\x13\x0f\x64\x43\x02\x38\xaa\x8c\xb2\x81\xb4\xb5\xf8\x1d\xcf\x33\x7f\xf2\xad\xad\x1a\x1a\x70\x67\x55\xa5\x5b\x8e\xd5\x78\xa1\x1e\x32\x16\x7f\x6c\x84\xc9\x39\xfe\xf4\x68\x3d\x34\x59\xef\x4d\x2e\x8e\x39\x67\xe6\xca\x44\x67\x99\x68\xa8\xbe\x34\x8b\xe7\xb4\x24\x80\xeb\xea\x19\x4b\x87\xfa\xc5\x52\xee\x58\x31\x57\x98\x7e\x69\x20\xb6\x50\x99\xad\x25\x67\xab\x0a\xb2\x35\x22\xca\x1b\xfd\xfb\xed\x1e\xe6\x41\xa6\xd6\xe5\x4b\xbf\xf4\xd9\x50\x59\x05\x05\x97\x12\xb8\x5b\x72\x40\x17\x48\x10\xdc\x76\x30\xc7\xf9\x26\x94\x9c\xf8\xff\xd2\x95\xee\x06\x9f\xf4\xc3\x88\x1b\x8c\x72\x6e\x9d\x13\x3f\xe0\xbd\x7c\x20\xb3\xb4\xc9\x2a\x02\xe4\xb1\x14\xc3\xda\x01\xf2\x67\xd0\x9a\x13\xcc\xe4\x73\xa2\x94\xea\xeb\x5b\xf3\x86\x8b\x2c\x94\xf5\x00\x5e\x22\xed\x5c\x0e\xe1\xf1\x4f\x78\x54\xc4\x64\x0f\x70\x0d\xdb\x34\x3c\x1b\x3d\xfe\x69\x88\x0d\x51\x93\x28\x7d\xfc\xc9\x0b\x25\x55\xbe\x34\x7f\xa8\x57\x88\x3a\x92\xdc\xcb\x01\xe9\xd7\x6b\x6c\x99\xad\xbb\xf2\x33\x75\xf5\x9c\xa1\x06\xb5\x24\x2e\xa4\x74\x6b\x21\x35\x8a\x33\x93\x2b\x7b\x6a\x8a\x39\x22\x1a\xe9\x6f\xda\xc0\x3a\x15\x58\x1e\xce\xd9\x2a\x09\x6f\xb7\xdf\xba\x74\x28\x97\xd7\x51\xa9\xc5\x59\x9b\xdd\xab\x2b\x0f\x50\x16\x6f\xeb\xc5\x6b\xaf\x2f\x50\x87\x4f\x8b\xfe\xf0\xf6\x56\x50\x17\x47\x85\xd9\xa8\xc7\x53\x4f\x41\x08\x2f\x52\xd1\x13\xe3\xc4\xa1\x7e\xa2\xe5\xba\x3a\xad\x28\x61\xa1\xaa\x7a\x50\xc9\x52\x2c\xf5\x24\xe8\xaa\x2b\x52\x4b\x32\x0b\xb0\xb4\x3d\x08\x35\xfe\x14\xed\xc1\xdd\xd0\xa6\x71\x6b\x3c\x46\x67\x04\x43\x50\x36\x4e\x73\x4d\x0b\x84\x56\x52\x51\x97\x79\x76\x4b\x42\xbb\x61\x8c\x46\xdd\x66\x94\x2b\xd5\x95\x9b\x6b\x30\xe7\x8a\xdf\xd6\xe3\xaa\x6a\x75\x57\x03\xb9\x58\x80\x54\xb2\x54\xb6\x7d\x2d\xfe\x4a\xcd\xd2\xd2\x20\x28\x74\xee\x6e\x4d\x92\x51\xa5\x34\x08\x73\x0d\x5f\x2b\x9f\x61\x0b\xb5\xd1\xcd\x16\xce\x14\x12\x9b\x4d\x5b\xd2\x36\xaa\xc4\x5d\x70\xb1\xa8\x44\xb5\x23\xd8\xd5\x10\xa8\xa1\x73\x44\xc2\xa3\x44\x76\x2d\xa1\xb9\x62\x7a\x31\x17\x4e\x69\xdc\x32\x99\x6d\x5f\xd6\x6f\x2a\x97\xce\x6b\x83\x34\x2b\x82\xd7\x24\x1f\x9b\x8b\xdd\xb5\xc0\x27\x8b\xd2\xd5\xe3\xaa\xa8\x5c\x67\x07\x8d\x93\x29\x7d\xaa\x70\x34\xb2\x2b\x34\xb6\xfb\x50\x09\x45\xae\x34\x37\x77\xac\x42\xcb\x94\xd5\x77\x7a\x82\xdd\xc8\x30\xb1\x9e\xd6\xcc\xbd\x1b\x79\x8e\x6e\x34\x86\x80\xf7\x9d\xd9\x1d\x08\x6b\xf4\xf0\x90\xc2\x71\x83\xa2\xe4\xd6\x0f\x80\x20\xea\x08\x4f\xf6\xbb\x10\x64\x44\x5d\x97\x5c\x06\xa7\x99\x0a\x97\x3f\x72\xaf\xb8\x9c\x73\x8e\xce\x1a\xc0\xef\x72\x67\x34\xb4\x63\xc5\x45\xbf\x0d\xa9\x14\x68\xc5\x23\xdc\xe8\xde\xa1\x16\xee\x94\xf0\xef\x3a\x1b\xf1\xbd\x7d\x74\xef\x69\x6f\x64\x3d\xdc\xb1\xe7\x60\x44\xfd\x43\x9c\x74\xed\xb9\x89\x55\xc1\xf8\x6a\x19\x82\x36\x83\xa7\x97\xf1\x36\x2d\x7e\xb1\xa1\x66\x65\x74\x52\xeb\x3a\x06\x36\x02\xb8\x4e\x90\x63\x75\xa5\x8f\x6f\x05\xc0\x81\x8b\x6d\x48\xee\x9f\xac\x0a\x50\x03\xc0\xd0\x5a\xb9\xc3\x80\x88\xe6\x97\x36\x20\x17\x30\x9d\xd8\xe4\x3b\x8a\x6d\x31\x1e\x68\xf8\x40\x25\x6b\x01\x8b\x2c\xc2\x15\x65\x89\xf3\x40\x60\x54\x33\x23\x4d\xec\x2b\x95\x29\xc4\xa5\x7a\x42\x34\xd6\xac\xce\xc5\x22\x42\x07\x37\x56\xde\x91\x7d\xd8\x75\x59\x0e\x72\xa4\xb1\xb4\xa8\xab\x99\x32\x63\x1b\xc8\xd2\x31\x81\xa9\xda\x1b\x81\xee\xa3\xc2\xe5\x27\x4c\xb7\xa2\x8d\xa4\xf0\x3d\x55\x7f\x5a\x93\xd1\x08\x11\x73\x78\xc2\x5e\xb9\x84\x7e\xde\x1b\x67\xb3\x47\x81\x52\x85\xdb\x03\xd9\x51\x84\x18\x14\x6b\xeb\x17\x20\x56\x52\x78\x8a\x4d\x0c\xb1\x50\xf6\xfa\x41\x75\x5d\x93\x8a\xd2\x1c\xb7\x11\x51\x89\x5d\xc3\x0a\xad\xe9\xdd\x20\x84\x9d\x12\xed\x3b\xce\x65\x40\xa6\xf9\x70\x03\x4b\xc2\x07\xb5\x3c\x18\xf0\xed\x15\x00\x0e\x35\x24\x2e\x32\x72\xef\x53\xdb\x02\x6e\xf1\x46\x6a\x7c\x06\xd4\x36\xfb\xaf\x5d\xf6\xbe\x02\x89\x8f\x7f\x59\xfb\xe4\x84\x83\x4f\x9e\xbf\x08\x87\xb7\xe8\x5f\x75\xb8\xd1\x95\x6e\xff\xa5\x5b\xd7\x73\x3d\xc9\x34\x89\xc2\x7d\x67\x44\x16\xfd\x98\x6e\x1c\xd4\x1e\x3c\x4e\x6f\x40\x64\x26\xf2\xaa\x12\x2a\x93\x47\x8e\x6c\xd5\x50\x0e\x8e\xb2\x5c\x53\x7c\xcb\xf2\x93\x9c\xc4\xfd\x36\xd4\x3e\xef\x72\xac\x9c\xd6\x0b\x81\x8b\x87\xaf\xe9\xc6\x63\xf3\x12\x90\x06\xe8\xdf\xf8\x20\x37\x44\x8d\xb2\x64\xfa\xb1\xc5\x32\xdb\xc0\x70\x04\x4a\x23\xd2\xe1\xeb\x1a\x92\x49\xe2\xd1\x49\xb3\x17\xe7\x82\xf0\x60\x52\x83\xe5\x83\xb3\xf1\x63\x1f\xe9\xc5\xd2\x4c\x39\x2d\x13\x87\x57\x73\x21\xb7\xa1\x34\xaa\xc3\xc8\x5e\xaf\x00\x27\xa5\x43\xff\x36\x5d\x02\x42\xb8\xad\xda\x82\x5d\x0a\xd5\x5a\xa8\xa9\x2b\xcd\xda\x0a\x41\xd0\xb9\x0f\x7a\x51\x1b\xcc\x7e\x6c\xb4\xf4\x2c\x98\x61\x3c\x1f\x63\xcf\x60\x53\x0e\x80\x0f\xb9\x30\x05\xe1\xe3\xaa\x97\x7d\xea\x38\x04\x30\xcc\x9a\xca\x5a\xa8\x9e\x94\xaa\xcc\xb0\x5f\xfd\x36\xf4\xcd\x56\x9f\x58\x0e\x15\x10\xcb\xcd\x4b\xe7\xc5\x80\xa7\x56\xc6\x1f\x04\x54\x5f\x8c\x7b\x1a\x52\xdc\x41\x7d\x41\xa7\x53\x77\x2d\x6f\xa9\xa1\xba\x26\xe0\x9a\x4b\xf0\x84\xb6\x77\xd9\x83\xb7\xf8\x18\x53\x37\x84\x61\xe4\xfa\xdf\xcb\xa3\x0c\x1b\xd4\x5b\x1b\xec\x9d\xba\x1f\x9c\x7b\xd7\x4f\xb8\xc1\xa0\x6a\x71\xa5\x17\x3e\xed\xfa\x74\x8d\x76\x01\x10\xca\x41\x6a\x3f\x4b\x67\xa8\x3f\x3a\xab\xc7\x1f\x3f\xf8\x2b\x75\xf5\xc2\x36\xf8\x44\x43\xa9\xc7\x63\x7e\x57\x90\x2c\x18\xe0\x22\x20\x1c\x36\x85\xb3\x4c\x6b\x76\x6a\x4b\xcd\x78\x5b\x42\x41\x6f\xc0\x7f\x25\x95\x86\x5a\xd0\x8a\x3a\x7f\x85\xc2\x6c\x45\xae\x75\x10\xcb\xd2\xb5\xc4\xeb\x4e\xcb\xe1\xcc\x4f\x0f\x3f\x50\xfb\x1f\x2e\x56\xf7\xc5\xe7\x5f\xfe\xea\x74\xe0\x7c\xf1\x06\xfe\xef\xf3\x37\x36\x6b\xcf\x6f\xe1\x50\x4d\x80\x67\x4c\xbf\x9b\x73\x38\xa1\x9c\x2c\x0b\x1c\x53\xb8\xe2\xe1\x80\xf7\xb0\x7c\x9d\x3b\xc4\xec\x20\x6a\x87\x70\x3b\x6f\x2c\xc6\x9c\x1d\x8f\x70\xdf\x19\x7e\x81\x67\x1f\x9c\x2d\xd4\x65\x0e\x1e\x4e\x03\x36\xfe\x7b\x12\x87\xed\x7c\x79\x1e\x2e\xe4\x09\xe4\xf3\xec\x3b\x89\xd9\x27\x42\x5d\xcf\xb5\x9e\x2b\xcf\xce\x2b\xe7\xe5\x91\xb8\x75\xd3\x65\x72\x90\xfd\xf6\x69\x97\x51\x3b\x06\x3a\x2f\xcf\x5d\x2f\x82\x0d\x77\xa0\xbf\xb4\x35\x06\x56\x5c\x25\x01\xf0\x12\x1d\x14\x02\x14\x3a\x2f\xfe\x8c\xa4\x01\xc6\xb4\x82\xac\x24\x11\x51\xb8\x1d\xb3\x20\x03\x9d\x81\x4e\x02\x8e\xd9\x83\x0b\x88\x27\x94\x0b\x33\x06\xb9\xfc\x40\x6f\xd8\xa2\x43\xf3\x72\xe3\xa5\x58\xd1\x4d\x1a\x3d\x2e\x9f\xa9\x48\x34\x24\xc0\x5d\x80\x62\xee\x91\x30\xf6\x83\xc7\x9f\xe6\x7e\xc8\xf2\x4d\x71\x6f\xc0\xda\x4d\xcc\x17\xee\x58\x7a\xbb\xf0\x99\x25\xd9\xc9\xb2\x90\x40\xe2\x33\x05\x18\xca\xd7\xad\xf6\xcd\x53\xc3\x87\x2d\xd7\xcf\x97\x7f\xfb\x77\xa7\x83\x6c\x15\xd9\x8d\xc7\x25\xb7\x75\x7e\x52\x01\x8e\x73\x9a\x9b\x5b\xdb\xd4\x70\x08\xa5\xf4\x75\xd7\x47\x67\x9e\xc2\x65\x1c\x83\x81\x0a\x0f\x57\xc3\xa5\xce\xc9\xa2\xc2\xcb\xa0\xb5\xdc\x5c\xf5\xf3\x4c\xcd\xb5\x21\x47\x80\x91\xd5\xd3\xc0\x1a\xa9\xad\xd0\x39\x4e\x5d\x35\x9d\x98\x7c\x67\xc1\x78\x36\x81\x9f\xac\x2f\xd9\xae\x63\xf8\x96\xe5\x06\x86\x77\x03\xdb\x5b\xa0\x6e\xd8\x5f\xa2\xcb\x82\xbc\xe2\x89\x28\xe7\xd6\xeb\xa4\x0f\x36\xc0\xc2\x7a\x83\xb2\xc1\x7a\xe6\x41\x94\x76\x7f\xd0\x63\xa8\x15\xb5\xe8\x56\x0b\xf4\x4c\xdc\x3b\xe7\xb2\xb6\x98\x75\xe8\x1b\xd9\xe9\xd8\x0e\x22\xa8\xe3\x1c\x76\x72\xb7\xb3\x2f\x74\xfe\x26\x66\xcd\xd3\x06\x80\x2b\xed\xfd\x4d\x6c\xe8\x87\x56\x58\xa3\xf3\xe3\xec\xba\x1b\x0b\x90\xde\x97\x31\x07\x77\x9e\xa0\x95\x60\xe6\xaf\xf1\x72\x28\x23\x22\xe0\x61\xf9\x05\xaa\x82\x6c\x2c\x86\xa5\xae\xde\xb7\x9d\x92\x92\xa0\x44\xdd\x8e\x61\x39\x23\x5a\x7d\x05\xc6\x88\xa2\x4a\xac\x69\x01\x2b\xad\x7d\x99\x8f\x40\x71\x63\x0a\xa4\xe5\xf0\xc3\x62\x81\x73\xbe\x74\xc2\x5d\x25\x80\xfb\xe6\xd7\x00\x93\x82\xc2\x3c\x3f\xa6\x7b\x94\xb4\x17\xe2\x6e\x85\xeb\xa5\xbc\xb8\xdc\x96\xfb\x21\xa8\xbd\xad\xdc\x35\xdc\xcd\x2f\xa0\x02\xc5\x81\x03\x3b\x19\xd8\x67\x34\xf2\xd0\x8f\xc8\x72\x98\xb8\x04\x73\x55\xed\xe1\xc7\x7a\x76\x81\x1c\x67\xed\x4f\xba\xb7\xf0\x80\x72\x8e\xc4\x46\xb6\xef\x8f\x65\x24\x46\xd6\xec\x23\x73\xbe\xc8\x60\x06\xaf\xae\xbf\x03\xb7\xf1\xd3\x1e\x67\xb3\xc1\xa0\x20\x1d\x13\x0f\x15\xb8\x14\x0e\x70\x9a\xe6\xc2\x43\xe1\xcf\x88\x94\x77\xa9\xea\xdd\x81\x23\x8b\x69\xd6\x55\xf4\xdf\xc5\x64\x49\x7e\x9e\xc3\x48\xe5\x80\x48\xe8\xfe\xfb\x9c\x39\xd5\xcf\x22\x3f\xa0\x7f\x87\xd3\xb7\xf6\x2d\xb2\x44\x05\x89\x63\x51\xe6\xbc\xcc\xd8\x81\xc8\x50\xc0\xb9\x93\x7c\x16\xbf\x63\xbc\x5f\x43\xf2\x5a\x77\x55\x96\x77\x79\x8a\xcf\x62\xa3\x58\xb7\x93\x41\xb6\x4c\x6f\x21\x9a\x11\x6b\x0b\xd9\x9c\x45\x97\xb4\x01\x9a\xdd\x41\x5b\x80\xe6\x00\xab\xd8\xb9\x17\x54\x0e\xda\xb3\x1e\x46\x6a\x45\x2f\x13\x15\xb6\x44\x96\x87\x5b\x01\xea\xb1\x15\xba\x72\x2b\xb6\xa0\x5a\x19\x0a\xd0\x52\x1f\x06\x64\xef\xb5\x82\xad\xe9\x02\x5e\x8f\x84\x7b\x78\xdb\xba\x57\x5b\xf1\x71\x45\x63\xad\x39\x50\xf1\xd9\x12\xe3\x9a\x64\x41\xde\xbb\x20\xb4\x8b\x02\xa5\xc2\x59\x8e\x9d\x4e\x20\x5f\xc1\x90\x34\xf4\x8b\xd9\x77\x1a\xe6\x14\x53\x54\x1c\x79\xa7\x95\x41\x6d\x80\xe6\x43\x5a\xbf\xb2\x30\x73\xe9\xa4\xce\xbd\xd7\x40\x78\x5e\x02\x18\x2e\x6c\x3e\x7f\x3d\x8c\xa4\xab\xc0\x57\x3c\xa3\xcb\x80\x70\x42\x18\x56\xed\xf8\x74\xd3\xe7\x8a\xe1\xbd\xe6\x0e\x05\x19\xda\x4e\x63\x81\x63\xa5\x34\x98\x5a\xe0\x75\x64\xee\x9c\x3a\x45\x92\xbb\x4b\x92\xec\xeb\xa1\x69\xfd\x36\x13\xd7\x7a\xee\xeb\x88\x6e\x23\x2c\x8a\xc4\x68\x39\x67\x97\x44\xf9\x66\xb7\x2d\xe4\x91\xee\x49\x6a\x74\xb6\x6d\x21\x4f\x75\x30\x4f\xf3\x18\x30\x46\xa7\x15\xe9\x32\x3c\x40\x04\x1b\x07\xf4\x05\x1f\x35\xa0\x98\x4d\x33\x37\x02\x23\x79\x45\xfd\xe1\xe9\xd2\x5b\x8f\x3f\x62\x3d\x74\xb4\x9b\xac\x6e\x7c\xf2\x43\xe5\x5c\xff\x24\x7d\xb2\x53\xb5\x99\x9a\x62\x40\x40\x13\x15\x95\x9d\xe1\xf3\x24\x18\x87\xba\x15\x7d\x8c\xc3\xa6\x7c\x3e\x8c\x29\x6b\x18\xbf\x1d\x4a\xab\x50\x44\x3b\xe1\x35\x80\xf3\x9d\xe6\xda\x1c\xd7\xdc\x18\xd2\xbc\xda\xb7\x58\x67\x0a\x11\x36\x8b\xef\xd4\x27\xbd\x61\xa9\x70\xff\xf7\x92\x9d\xa1\x73\x6f\xf4\x56\x84\xff\x50\xd9\xe5\x1e\xd5\xaf\xa7\x1d\x52\x15\xde\x6c\x23\x3e\xd5\x88\xb3\x58\xb6\x56\x12\x8e\xe2\xd7\x4c\xcc\x71\x1b\x61\x91\x75\xaf\x6b\x5e\x79\x7a\x48\x2d\x54\xae\x1d\x9d\xc0\x3b\x3a\x6f\xbb\xa9\x3b\x2d\xb4\x9c\x5a\xba\xec\xe7\x5a\xa3\xfe\x22\x83\x39\xdd\x38\xf6\x17\x81\xd5\xc2\x54\xa6\x01\x9e\x6e\x9c\x8d\x56\x73\xac\x60\xb6\x11\x29\x32\x96\x6b\xd7\xe7\x4c\x16\xc8\xe5\xb6\x3e\x65\xb2\xb8\xb2\x5c\xc7\xf1\x5e\x87\x8c\x19\x48\xd6\xea\x88\xa1\x80\xe7\xcc\xf9\xbe\x6b\x7e\x14\xfc\xec\x2a\xa6\xb9\x2d\x6b\x28\x32\x40\xc5\x43\xed\x9a\x36\x1d\xeb\x94\x0f\x01\x68\x49\x5b\x82\xf1\x3f\x0b\x6a\xc7\x94\xdd\xca\x0f\x5f\x93\x29\x2f\xbf\x35\xe1\x39\x7c\xc8\xe6\x04\xa0\xb8\x24\xce\x1a\xa7\xb0\x1d\xf3\x96\x5f\x86\xc7\x5e\x65\x33\xa6\xc9\x7a\x61\x4a\xc4\x01\xbb\xae\xd1\xb9\x82\xe6\x25\x27\x46\x77\x38\xfa\x5c\xac\x56\x58\xcc\xf3\xf6\xc9\x62\x12\x52\x50\xeb\x2a\x94\x46\x85\x75\x98\xce\x6d\xcb\x28\x5d\xdd\x60\xc0\xd4\x6d\xe6\x1e\xb0\xc1\x97\x19\xaf\xb9\xdc\x5e\x8b\x5b\x65\xf2\x9b\x4e\x8a\xce\xe4\x7c\x76\x3c\x39\xb3\xb5\x8d\x9a\x9c\x3f\xfe\xf3\xe3\x7f\x1f\x5b\x1a\x44\x61\x7d\xe3\xd1\xd1\xe9\xf1\x99\x2d\x86\x02\x7f\x3b\xbe\x98\x4d\x47\x47\x93\xa9\x73\x34\xc2\x2a\x7f\xa3\xb3\xe3\xff\x3a\x02\xa0\xff\x6d\x52\x03\xf3\xf2\xe8\x78\x36\x99\xda\xa0\xf2\xaf\x1d\xe0\x9d\x8e\xce\x46\x6f\xc6\x36\x78\xf0\xcb\xf8\x6c\x36\x6e\x0f\xcf\xca\xac\xec\x6d\x3b\xcb\xac\xd1\xd2\x93\xe6\xcb\xcf\x04\xaf\x6b\x94\x61\xc1\xc5\x29\x62\x33\x0e\xdb\xf0\x1b\xb6\xc1\x40\x0e\x53\x84\xf3\xf8\xa7\x55\x2e\xe4\xa8\x31\x28\x7b\x52\xec\xf3\xea\x2e\xb1\xf9\xde\x03\x17\x6f\xb0\x2d\xe1\x51\x5d\xd7\xd6\x6f\x1f\x7f\x94\xa5\x1f\x5a\xa2\xcc\x17\xa2\xa0\xe4\x2e\xfe\x9b\x6d\xb3\x18\x44\xd4\x87\x0e\xa3\x06\x45\xa1\xfb\x15\xd9\x43\xa9\x5d\x54\x2f\x0a\x6d\x42\xac\x2d\x35\x16\x59\x05\xcf\xda\x1c\x71\xd6\x17\x9a\xb2\x44\xda\xac\x43\x0e\xc0\x13\xba\x66\x8a\xc7\x2e\x7c\x15\xf4\xa8\x83\x9a\x2c\x28\x2e\x64\x44\x1c\x75\x71\x33\xea\x99\xe4\xa2\x92\x4a\x61\x8f\xf0\x0c\x39\xdc\x3b\xd2\xa4\xf3\x12\x9f\x92\x34\x23\xad\xa7\x1d\x95\x2a\x34\x11\x84\x7f\x21\x3a\x91\x22\xc4\x78\x4b\x63\x77\xb1\x28\x0c\xa8\x7d\x95\x7b\x8b\xa6\x89\x42\xa8\xe3\x7a\x29\xec\x21\x43\xc6\x50\x5c\x1d\x60\x68\x44\x33\xe5\x36\x3d\xc6\x9b\x66\xe7\xbb\x12\x00\xf0\xc4\xe3\x5f\x62\x8a\xd9\xc4\x64\xa5\x58\x0e\xd5\xa0\xa2\x7a\x98\xe7\xae\xef\xe5\xe3\xfb\x6c\x59\xd9\xd2\xf9\x64\x5e\x60\xd6\xee\xc2\x16\x32\x80\xbe\x54\xce\xfe\xc6\x0c\x62\xf2\x49\x50\x95\x1b\x98\x6e\x0e\xef\xc3\x91\x66\x96\x10\xcd\x3c\xa5\xfd\xb0\x86\x68\xcd\x10\x8f\x63\x4c\xee\xd5\x89\xe2\x31\x17\xa4\x23\x0c\xec\x2e\x88\x7c\x3e\xd4\xb5\x06\xa9\x14\x24\x8e\xf9\xae\xb6\x9a\xf4\x1f\x8a\xa1\x6c\x7f\xb2\xa1\x18\x8a\x79\xcd\xa4\xd4\x38\xb8\x2f\xec\xbe\x6d\xf5\xa6\xb3\x91\xa1\xc6\xb4\xfe\xb5\xe4\x5c\xb9\xc9\xfc\xce\x2a\x38\xd5\x3b\x3a\x36\x8f\x9c\xe8\x2c\x34\xa9\xf0\x1d\x46\xb4\xda\xca\x5b\xa0\xcb\xa6\xd0\x66\xb3\x8b\x18\x3d\x57\xb5\xa2\x30\x18\x58\x49\x14\x4a\xa6\x45\x6f\xd8\xf7\x3e\xbb\x89\xd4\xe6\xe6\xda\x4c\x49\x6c\x6c\xf6\x46\x39\x74\x68\x15\x3e\x32\x24\xb3\x58\x00\x0a\x91\x7a\x34\xcf\x80\xec\xf1\xdf\x64\x71\xa5\xfc\x7b\xf5\x83\xc9\x0d\x44\x8d\xa1\x33\x79\x40\x9a\x41\x52\x3d\xc6\x86\x60\xd6\x02\x92\xfa\x10\x54\x82\xd9\xb9\xe5\xaa\x05\x96\x88\xb0\x0e\x24\x55\xe9\x42\x19\xeb\x50\xb5\x23\x3e\x54\xd8\x49\x28\x30\x58\x84\xe3\x73\x65\xb3\x58\x19\xd0\xbb\x54\x6a\x90\x6c\xce\x69\x4b\x34\x50\x59\xa8\x9c\x26\x62\xae\x64\x46\x19\x2b\x33\x82\x74\x4a\xa2\xa5\xcb\xd1\x06\x61\xa9\xa2\x50\xe0\xee\xca\xec\xd5\x69\x19\x0f\x7a\xbb\x0b\x2a\x93\x5a\xfc\x36\x0f\xb8\x35\xc0\x98\xbd\xcf\xa6\xa6\x24\xe7\xc7\xea\x7f\xae\x21\x2a\x7b\xd4\xf0\x65\x67\x9d\x40\x6b\x6d\x17\xa5\x3e\x9e\xca\x7c\x11\x39\x86\x8f\xbc\x04\xbe\x2b\x35\x77\x9c\xde\x5e\x8e\xe4\xc2\x05\xcc\x61\x5e\x0d\xbc\xaa\x04\x1b\x70\xfa\x50\x1c\xa7\xbe\x35\xaa\x8b\x12\x1e\x29\x82\x77\x81\x37\x6a\x9b\xfc\x05\xa0\x07\xd5\x43\xad\x39\x74\x2d\x6f\x58\x31\xc4\x86\x6a\xcd\xed\xb7\xa9\x82\xd0\x3c\x5d\xba\x51\x9b\xe4\x63\x79\xd2\x6b\x3d\x1a\x8e\x19\x0c\xd9\xab\x70\xf9\xa1\xd3\xf3\xf1\x27\xdc\x10\x36\x6a\x28\x4e\x7e\x7e\x17\x86\x71\x16\x26\x8f\x8d\xc1\x71\xcf\x61\xf4\x07\x7e\xde\x77\xbe\x0a\x51\xc6\x93\x57\xd6\x8d\x04\x2d\xfd\x35\x6e\xa6\x24\x61\x21\x71\xc3\x7d\x1f\x85\x8e\xc9\x8f\x65\x99\x5d\x34\x19\xd8\xb3\xc6\xe6\x21\x66\xa7\x33\x24\x1f\xd3\x9d\x28\x4a\x03\x0d\x41\x6e\x64\x74\x97\xe5\xdf\xa9\x8c\x0b\x9d\xc5\x70\xa0\x72\x10\x45\xa1\xcb\x2c\x65\x1b\xc7\x2b\x9d\x16\x62\xd1\xf4\xe5\xa0\xd9\x24\xe2\xb8\x0b\xb7\x3e\x6f\x4b\xc8\xb4\xad\x00\xa8\xe2\x46\xbd\xb5\x60\x55\xce\x01\xc7\xbe\xa1\xd9\xd4\xc8\xc0\x30\x27\xd7\x2c\x8b\xd8\xe9\xee\xa9\x8b\x1b\x9a\x25\x11\x02\xac\xc6\x53\x4a\x34\xef\x7d\x31\xe5\x44\x44\xa7\x21\xce\x10\x8f\x45\x7e\xb2\x16\x0a\xa7\x28\x2e\xe5\xa8\x71\xc7\x63\xb2\xa3\x05\xae\xac\x12\xab\x15\x6b\x75\x17\xe0\xf7\xac\xc6\x30\x89\x8a\x72\x3b\x74\x4d\xd9\xca\xfb\xa3\x55\xc2\x04\x72\x44\xa5\xd2\xb4\xe5\x3b\x64\x77\x1a\x30\x7b\x43\xde\xed\x29\xca\xaa\x37\x15\x78\xbf\x47\xf3\x60\x1a\x5b\x6d\xaa\xe7\x59\x81\x05\x22\xc6\x73\xae\x5e\xe4\x92\xca\xae\x5e\x14\x0c\x0d\x3a\x63\x06\x6d\xf0\x32\x7a\x96\x5e\xb5\xed\xdd\x49\x3e\x67\xcd\xac\x38\x23\x60\x04\x5c\x8f\xa8\x8c\x35\x33\x4e\xb0\xb9\x9f\xc2\x69\x69\xc8\xd6\x4d\x25\x87\x02\x2b\x39\x46\x61\x23\x8f\x10\xec\x3c\x8f\xb1\xf4\x3a\x2d\x0b\xcf\xe0\x07\xb8\x46\x39\x93\x8b\x03\x5b\x1e\xd2\x44\x13\x19\x87\xb0\x13\x28\xce\x3c\x77\x78\x00\x54\x59\x3c\x21\x57\xc5\x80\x0e\xe5\x58\xa4\xce\xc5\xe4\xc0\x92\xa5\x74\x5e\xa8\x85\xac\x14\x00\x33\x41\x2a\x0d\x7c\x95\xe8\x6b\x67\xab\x6d\xda\x71\xca\xd1\x4f\xa1\xb2\x7d\xcd\xe4\xa9\x7a\xde\x15\x21\x6d\xe0\x8b\x77\x70\x4d\xf2\xb1\xea\x58\x9e\xc2\x46\xfa\xce\x2d\xd4\xe5\x61\xfa\x59\xa1\xe7\x16\x54\x46\x18\xb4\x86\x31\x66\x72\x92\x81\xf7\xee\x02\xce\x37\x38\x10\x49\x31\x88\x13\xcf\x9e\x07\x7b\xbc\x5a\x47\xfe\x0a\x8b\xef\xe1\x4b\x70\xc1\x86\xb7\xb8\xe2\x86\x9a\x62\x6d\x54\x40\x14\xba\xa1\x7d\xbd\x69\x81\x69\xc2\xc4\x5a\xec\x5b\x1e\x93\x69\x81\x83\xd5\xf0\xc0\x28\x5c\x53\x0a\xb7\x12\x57\xe7\x56\xeb\x8b\x8b\xcc\x3b\x53\xb7\xe9\x90\xcf\x82\xa3\xf1\xc8\xb9\x71\xe7\x20\x0b\xac\xa2\x50\x0d\x0e\x4f\x76\xa4\x23\x5f\xbb\x85\xca\xd3\x14\xee\x0b\x85\x5b\x4b\xae\x59\x7a\xa6\x0d\xd4\x0e\x1b\x69\xdb\xf0\x5c\x36\xd1\x45\xfa\x76\xdc\xc0\x46\x03\x1e\x32\xe3\x0d\xc7\x90\x62\xa6\xc4\xbd\xcb\x85\x9c\x12\x3e\x84\xad\xa2\xb9\x8c\x0f\x47\xf6\x86\x57\x57\x24\xd4\x61\xf1\xf8\x3f\x30\xb7\x64\x29\xd3\x30\xa4\x0b\x45\x16\xb6\xb1\x9d\x1a\x51\x08\xc2\x03\x81\xac\xe0\xd4\x86\xb9\xf1\xc2\xfb\x60\x19\xba\xe8\x86\x92\x22\x06\x4f\x6e\xb8\xb7\x67\x93\x6e\x15\x2f\x12\x98\x8b\x71\xa5\x04\x50\x50\x5e\xb9\x94\x29\x0e\x3d\x8d\x1e\x69\x14\xee\xa8\x5d\x49\x54\x85\x0c\x42\x44\x66\x95\x32\x51\xc8\x71\xb8\x7c\x91\x41\x79\x08\xea\x23\x39\x2f\x97\x07\xce\xdf\xc4\x58\x59\x92\x12\x82\x50\xe5\xb0\x53\xc9\xf1\xa8\xb7\x52\x79\x42\x72\xd8\x2f\x96\x41\x81\xa3\x36\x8a\xa4\x94\xb1\x92\x42\x85\xf4\xaa\xaa\xea\x65\x21\x9d\x59\xc9\x4b\xae\x30\xc0\x85\xf1\xd8\xc0\x0c\x6a\x55\xb0\xc0\x24\x9c\x74\x8d\xa5\x01\x30\xcc\x4f\xaa\x50\xcc\x3c\xc7\xe7\x92\x74\x09\xca\x79\x5c\x1f\x56\xa1\x04\xd8\x23\x5f\x78\xae\x2c\x8e\x5c\xa4\xc6\x88\x34\x08\x42\xb3\x0a\x67\x1c\x67\xa5\x62\x02\xa9\x6c\x52\xcd\x01\x20\x09\x8b\x15\x78\xd4\x80\x01\x68\x71\x87\x70\x4f\x74\x12\x99\x4d\xde\xa0\x06\xb2\xfe\x67\x4b\x3e\x21\xe5\x6d\x2e\xac\x05\xbf\xcf\xd3\x48\x3a\x62\xf9\x8e\x64\x14\x32\x95\x51\xc0\x35\xb5\x21\x56\x6b\x59\x5d\xdf\xbc\x3f\x96\x5f\x6f\x8b\x38\x77\xf3\xec\x8c\xb7\xf4\xb6\x05\x6d\x7c\x87\xa5\xf3\x65\x97\x19\x0c\x43\xc1\x12\xeb\x2a\xda\x93\x92\x79\x58\x65\x90\x15\x5b\x6c\xaa\x7a\xb0\x91\x56\xb8\x00\xd3\x38\x10\x16\x6e\xb2\x35\x82\x07\xb9\x08\x8b\x1b\x6b\xaf\xd3\x8d\x56\x45\x79\x92\x21\xcf\x91\x51\xc1\xac\x95\x04\x56\xd5\x8e\xc9\xc4\x9a\x04\x4b\xb6\x3a\xbd\xc4\x3d\x86\xf4\xe2\xbf\x7c\x54\xa8\xa5\xf5\xd9\x81\xb5\x42\xa2\x24\x53\x93\x26\xb1\x3f\xfe\x5b\x00\x52\xd9\x79\x89\x04\x21\xb5\x2c\xda\x73\xf0\x2a\xc9\xa2\xfa\xd5\xce\x11\x39\x91\x49\xbb\x06\xbe\xd3\x77\xdd\xdc\x49\xec\x85\xd6\x27\x25\x16\x34\x2a\x42\x6a\x72\x2b\x31\x25\x38\x5d\x14\x7a\xa1\x52\x05\x60\x5e\x41\xaf\x50\xf9\xe2\x18\x23\xf9\x52\x7c\x50\x65\xcf\xc8\x31\x1c\x52\xfd\x53\x34\xe2\xa7\xcb\x84\x0f\x58\x82\x40\x16\x5a\x38\x2f\x94\xef\x81\x2a\x31\xd9\xb2\xd8\xa8\xce\xb7\x2b\xab\x87\x70\x30\x87\x8b\xe7\x41\xfe\x36\x04\x7b\x1d\x2e\x42\x43\xca\x3e\x77\xb1\x46\x1b\x91\x22\xcf\x13\x2c\x48\x12\xae\xd5\x83\x48\x8c\x8b\xea\x82\x04\x97\xe7\x8d\x54\x1e\x2c\x89\x70\xad\x58\xc1\x57\xc3\xe7\x63\x86\x9b\x5d\x16\x4d\x36\x84\x4f\xcd\x86\xc2\x32\x6a\x75\x15\x1b\x55\xae\xc0\xc6\xeb\xd7\x74\xfc\xdb\xcb\xf1\xc5\xcc\xe6\xc5\xbb\x98\x9c\x1c\x1f\x1e\xcf\xd8\x21\x6d\xc9\xab\x9b\x8e\x2f\xce\x27\x67\x17\xd6\x94\x3c\xfa\xfd\x62\x36\xb2\xbd\x3e\x39\x19\x5f\xd8\x37\xff\xeb\xcb\x33\xf6\x67\x5b\xf7\xf3\x74\x72\x39\x1b\xdb\x7c\xe2\xd3\xc9\x6c\x64\x71\x85\x4f\x61\x97\x0f\xa9\xec\x43\x96\xa9\x83\x9b\xcd\x0f\x6e\x43\x3a\x44\xf1\x16\x16\xd5\x54\x6e\x1d\xb1\x4e\x80\xc1\x19\x78\xc8\x2d\x85\x0f\x07\x35\x07\xe5\x51\x1b\x1f\x95\xe2\x42\xea\x96\x2e\xc0\x57\x30\x37\x58\x47\x25\x5c\xbc\x5d\x78\x02\x5d\x6c\xf0\xca\x1a\x84\xbb\x90\x35\x8d\xe3\x5f\xf3\x89\xbd\x5a\xdb\x2b\x82\xe3\xfb\x4c\x17\xad\x54\x54\x04\x55\xc5\x3d\xa0\xe4\xf6\xf1\x8f\x79\x20\x2d\x68\x90\xd6\xda\xd3\x10\xfe\xe6\xd2\xfa\xfa\x4f\x25\x39\xb1\x9c\x2f\x68\x70\x0f\x68\xbb\x59\xe0\x36\x0c\xe7\xbe\xab\x74\x2b\xd0\x4d\x7e\xdd\x9a\xd8\xb0\x01\x15\x90\x93\x7a\x6c\xab\x41\x93\x0c\xaa\x8d\x12\x1d\xfa\x15\x1d\xa0\xf8\xd7\x3b\x19\xd3\xce\x28\xae\x27\x47\x1a\x72\x2b\xe2\x36\x73\xf5\xae\x39\x7b\x77\x2d\x6d\xc5\x93\xa5\x57\xb6\xeb\x26\x44\xc7\x99\xb8\x2f\xfd\xf4\xeb\xab\xf4\xf3\xcf\x7f\x69\x33\x4d\x65\x03\x5a\x71\xaa\x6f\x13\x29\x9e\x61\xe4\xae\xa4\x44\xf5\x8c\xa9\xa3\xa5\x8e\x27\x6b\x50\xae\xca\x19\xcc\x65\xed\x8c\x99\x72\xb8\x0c\x53\xcf\x79\x8d\x4a\x74\xf4\xd0\x3c\x6b\x4b\xd4\xbf\xa2\xda\x00\xda\x02\x16\x18\x6f\x01\x47\x7b\xe2\x55\x54\x6d\xd9\xdb\xb1\x15\xed\x55\xe1\xb7\xe5\xe4\xbb\xb6\x74\xcf\x05\x6c\x23\xbc\x81\x64\x9d\x84\xe6\xaa\x21\x50\x22\xcb\x23\xd9\x4e\x4f\x6b\xe3\x20\x38\x37\xc5\x8d\xcf\xa5\x2c\xad\x88\xe1\x32\x01\xa8\x81\x6b\xf2\x12\x93\x15\x5a\xe4\xf2\xda\x3e\xb6\x29\xa4\xbe\x37\x71\x05\xc3\xa8\x05\xc1\x0d\xde\x81\x94\x56\xb9\x72\xa9\x12\x95\xb4\x8d\xb0\x42\x5c\x88\x7a\xb7\x32\x99\xaf\xa0\x91\x24\x8a\x6f\x2d\x4e\x2e\x0e\x19\xed\x05\xdc\xe2\x26\x1e\xde\xfa\xcb\x3b\xf6\x74\xde\xc0\x52\x61\x13\xb1\x6a\x2c\x93\x27\x12\xd5\xd3\x5b\xf7\x7b\xbc\xbb\x65\x46\x16\x3c\x1e\xc8\x8b\x5a\x8e\xaf\xef\xc1\xac\xac\xf0\xd2\xcf\x85\x6b\xd6\xed\xf5\x89\x99\x28\x19\x57\x2c\xaa\x6b\x73\x86\xab\xf1\xa5\x2b\x9b\x05\xb7\x01\x91\xac\xcb\x8a\xad\xbf\x68\x26\xb8\x74\x56\x23\x36\xd7\xb9\x55\x8d\xc0\xcc\xaa\xac\xb4\x1e\xeb\x4b\xd7\x69\xcc\x69\x24\x0b\x70\x4b\xc4\x41\xcd\x75\xd0\x44\x4c\x6e\x5e\xc0\x74\x39\x3d\xd1\xe5\xc6\x2c\xde\x74\x85\x8b\xaa\xc0\x1b\x39\xb5\xec\x9b\x81\x25\xd5\x80\x4e\x67\x82\x4b\xe7\x0a\x99\xe0\x0a\xb9\xb4\xf5\x98\x83\x5c\x88\x71\x8b\xd1\x55\xc6\x15\x37\xe1\x40\xdd\x70\xcb\x29\x2c\x55\x9f\x6d\x37\x91\xc5\x80\x77\x14\xf2\xef\xdc\xc8\x3c\x42\x8a\x69\xa2\x78\x0d\x0a\x8b\x31\x81\xaf\xe4\x42\xc4\x33\x02\x3f\x28\xb5\x8d\x4e\x8d\x43\x0e\x20\xb8\x84\x51\xd5\x19\x2e\x78\x68\x01\x69\x59\xd5\xe1\xd9\x39\xe2\xbc\x72\x06\x6b\xb9\x0c\x6f\x81\x48\xb5\xd0\x0b\x64\x52\x04\x51\x15\xa1\xf5\x8c\x8b\x72\x0d\xf7\x98\x5b\x54\x28\x12\x7b\x6e\xd0\x12\x65\x48\x06\xc7\xf8\x6b\x20\x29\xcf\x33\xfe\x9a\x48\xda\x86\x6b\x7a\x41\x64\x44\x19\xa5\x28\x4b\x64\x55\x71\x2b\x4f\xa0\xc1\xaf\x3c\x89\x9f\x86\x63\x3f\x17\xc6\xf4\x1e\x7d\xca\x8b\x98\x7a\x1d\xee\x6a\x77\x21\xf6\xa0\xc1\x26\x68\xf2\x22\x92\x97\x79\x26\xe2\x09\x76\x51\x9e\xa0\x2e\x2c\xe9\x31\x80\x1a\x14\xdc\xa2\x38\xab\x07\x60\x05\x8d\x0e\x4f\x36\x56\x66\xcf\xd6\xc3\x6c\xa9\xbb\x18\x80\x5b\x2b\x10\x05\x0c\x0d\xf5\xc0\x0d\x1c\xdd\xaa\x80\x67\x88\x6a\x92\xc3\xcc\x11\xd4\xa6\x7a\x29\x68\xf5\x3a\x40\x06\xac\xe6\xc4\x57\x80\xec\xc5\xd7\x73\x63\x6e\x91\x58\x4d\x30\xa5\xb9\x3a\xbf\xd0\xf5\x8d\xf6\x69\xf7\x1e\x91\xcb\x16\xf9\x12\x09\xc6\x55\xf6\x19\x77\x9f\x64\x48\x56\x2a\x83\x6f\xda\x5f\xa9\xbf\x8b\xfc\x29\xfc\xd0\x72\xb0\x4d\xe0\x8d\xb1\x57\x20\xa8\x27\xbd\x34\x4f\xc5\xb9\xec\x35\x41\xb5\xac\x2f\x4f\x55\x1f\x9e\xe7\x45\x87\xe4\x4c\xcb\x31\xb4\x62\x7a\x39\x9f\x3a\x87\xa3\xcd\x28\x5a\x0e\xa1\x64\x10\x28\x5a\x88\x9e\x5c\x61\x34\xc6\x6d\xaf\x11\x54\xb6\x16\x3d\xaf\xb6\xa8\xb8\xa6\xc6\x8b\x26\x2d\x03\x5c\xc6\x34\xe3\xcb\x2a\x96\xf5\xe7\x8d\x31\x90\x02\x72\x93\x37\xc6\xd7\xf5\x9c\xe9\xca\x80\x75\xd8\x26\x72\xcd\xbc\xff\xda\x21\x45\x49\xac\x03\x94\x2f\x2e\xde\x72\x20\xd7\x32\xbc\xe7\x58\xc7\xa6\xe3\x6c\x89\x2d\x25\x63\x41\x6f\xe6\x42\x19\xd9\xc3\xd7\x70\xc6\x55\x62\xe7\x26\x73\x1e\x86\x91\x14\x4a\x89\xca\x80\x42\x11\x35\x1f\xe2\x26\x5d\x32\x2b\x0b\x8b\x63\x29\xc2\x8a\x47\x3b\xc5\x10\xfe\x99\x40\xe7\x2a\x81\xda\x09\x67\x23\x84\x35\x56\x62\x6a\xf0\xde\x16\xed\x30\x95\xf1\x40\xeb\x58\xa4\x5e\x38\x4c\x92\x07\xe2\x7c\x6d\x6c\xe4\x85\xb4\xa5\x60\x14\x6b\x68\xb4\x23\xc8\x60\xd8\x70\x61\x82\x48\xa3\x42\xb1\x42\x0e\x37\x29\x14\x2a\xd5\xe4\x59\xef\xb1\x41\x62\x3b\xf0\x9f\x49\xe8\x70\x0e\x56\x03\xff\x64\x65\xf6\x66\x06\x46\xe4\xee\xaf\x32\x94\x63\x21\xb8\xdb\xdc\xb2\xcf\x8d\xb6\xf5\x09\xc6\xa4\xf0\x19\x6c\x2c\xf6\x3c\xa6\x7c\x62\x57\x0e\x51\xfb\x43\x2c\x89\x7c\xc1\x66\x17\x3f\xf0\xfc\x8d\xef\x61\x90\x92\x0a\x85\xa1\xa6\x1b\xe4\x52\x02\xa4\x49\x6a\xf3\xd1\xa3\xb1\x14\x8b\x54\xb3\x0e\x9a\x2f\x6d\x65\x34\x3c\x32\x10\x50\xe4\x1d\x83\x6c\xa2\x8b\x5a\x6c\xaf\x97\x2e\xe7\x78\x4c\x46\xba\xa9\x8a\xce\x6c\xd0\x9d\xee\x30\x6a\xdd\xba\xf9\x32\x22\xd1\x95\xe4\xdf\x90\x27\x89\x01\x31\x50\xca\x2c\x8a\xe3\x86\x16\x58\x56\xca\xb8\x91\x26\x4c\xfd\x5e\x4c\x3d\x50\xf7\x1d\x67\x84\x45\x03\x49\x3a\x72\xb3\x6c\x2e\xb2\x45\xc3\xc6\xf8\xbd\x75\x9a\x65\x67\x50\x59\x73\x8a\xed\xc1\x72\xc4\xb1\x3d\xc8\xb1\x72\x18\x6f\x2e\x8f\x8f\xd4\xdd\xd5\xa8\x25\x16\xee\x3b\x33\x5d\xd2\x2f\x05\x40\xb1\x0c\x30\x24\xcb\xdf\x6d\x1a\x50\xd3\x34\xee\x81\x22\x14\x61\x12\x0c\x10\xe6\x62\x74\x24\x05\xb7\xc1\x1b\xd6\xad\x55\xcb\x0e\xd8\xdb\x55\xec\x28\x0c\x9e\x9c\xc1\x5b\x0e\xbe\x32\xbb\x40\x97\x54\xb3\xb2\xa1\xf8\xda\x6e\x86\x2d\x55\xc2\x16\x43\xd7\x17\xdb\xad\xe7\x3e\x33\xf9\xb7\x5b\x00\x61\xae\xd7\xc3\xee\x06\x3d\x7c\x2f\x1e\x9e\x71\xe0\x55\x15\x7d\x5a\xce\xfd\xee\x39\x80\x27\x54\x9b\xb1\xd3\xa1\xba\xfd\x94\xab\xc3\xb1\xf5\x8c\xab\x17\x76\x34\x5c\x6c\x22\xa9\x87\x6b\x1f\xad\xea\x35\xb9\xe5\x3c\x73\xb7\xc8\xd6\xfb\x9a\x1f\xef\x3a\x52\x1d\x50\x6d\x9c\x80\xb1\x79\x04\xe2\x8f\xc2\x9d\x73\xc2\xd1\xd0\xec\xa8\xdc\x38\x26\x23\x4c\xba\x90\x1b\xc4\xfe\x5b\x3a\x24\x29\xc8\x4e\xcb\x62\x2c\xbc\xef\xb9\xfa\x47\xdd\xdc\x32\xa6\xfa\xf0\x41\x6d\x11\x1f\x3d\xa6\xaa\xd4\xd4\xde\xc9\xd3\xd9\x70\x4a\x39\xa8\x3b\x48\x96\xae\xa5\xb9\x77\x96\xf4\x16\x34\x37\x67\x45\xe7\x48\x8e\xd2\xa5\xd1\xbc\x93\xe5\x5c\xbe\x32\x5e\x31\x56\x47\xcb\x83\xe6\xe5\x43\xdd\xaf\x22\x3e\xbc\x6b\x3b\xe2\x66\x11\x3a\xb1\x11\x5a\x57\x4b\x3e\x5d\xc9\xf5\x02\x47\xe2\x71\x7d\x63\xf5\x1e\xdd\x2f\xbc\x8b\x09\x89\x69\x26\x9d\x3f\x36\x16\xb3\xd1\x2b\x55\x76\x0a\xcf\x16\x71\xdc\xcd\x7e\x54\x41\x35\xbc\xfa\x9a\x89\x7d\x0d\xb4\x77\x34\x7a\x19\x14\x1b\x04\x97\x40\xf6\xa3\xb1\xdf\x0e\xec\xcf\xf1\x2d\xf6\xe5\x0e\x47\xd8\xbc\x5f\x9f\x6b\x84\xe6\x2e\xee\x34\x40\xe5\x8f\x79\x1b\xc6\x89\xb4\xc5\xc2\x5f\x47\x54\xc8\x58\x5e\xb5\xe0\xef\x31\x87\x67\xcf\xed\x37\xba\xde\xe0\x5f\xfd\xa0\xca\x4e\xef\x04\x11\x7d\x00\x58\xf7\x2e\x07\xba\xde\x50\x2e\x44\x52\xce\x7a\xae\x88\x4a\xc3\x1a\xdf\xbd\x90\xb2\x6b\xad\x65\xb4\x77\xde\x1f\xd7\x14\xd8\x5d\xc0\x61\xe4\x31\x76\x19\x99\x64\x7d\xf7\xd1\xc9\x12\xb2\x9a\xb3\xd1\x1b\xfc\x13\xcd\x1a\xaa\x0d\x58\x77\x98\xd6\x4b\x36\xf5\xfa\xb5\xbe\x87\x1b\x0d\x93\xc8\x2e\xa7\xc7\xaa\x3f\xa1\x4e\x59\x31\x93\x89\x55\xb1\x75\xdc\xa0\xf8\xac\x9b\x26\xb0\xdc\xb0\xe5\xe8\x72\xf9\x60\x63\x01\x3e\x08\x6a\x08\xc2\x57\x35\x70\xf9\xd6\x28\xbb\x18\xee\x3b\xd5\xc9\xc8\xa5\xe2\xeb\x61\x01\x67\x5d\xae\xca\x14\xcf\x52\xab\x34\xc0\x83\xd0\xf6\x1e\x0b\xd6\xb1\x21\x76\xde\x29\xb1\x43\x13\x64\xed\x31\xf9\x46\x1f\xa6\x6d\x44\xa5\x25\xce\xfa\x62\x7c\x08\x83\x9c\x7d\xed\xbc\x99\x4e\x2e\xcf\x6d\x98\xa6\x97\xe7\x13\xe7\x68\xec\x5c\x8c\xdf\x5c\x4e\x47\x67\x8f\xff\x3c\xb2\x41\x9b\xbe\x3b\x3e\x1c\x77\x29\xbf\x86\x40\xe1\xa5\xc7\x7f\xb6\x54\x36\x93\x20\x6d\x91\xdc\x96\x97\xce\x47\xdd\xa8\x98\x38\x63\x78\xc7\x4e\x04\xc3\x6b\x57\x00\xae\x15\xac\xa3\xf1\xbb\xf1\xc9\xe4\xdc\x5a\xfe\xed\x68\x7c\x31\x3e\x7b\x37\x39\x79\x37\x6e\x4f\x5f\x8b\x82\x72\x87\xc7\x8a\xeb\xcd\xf0\x6c\x2c\x97\x6f\x5a\xe2\xe7\xd1\x0c\xce\xa9\x46\xbd\xec\xe9\xf8\x7a\x65\x6b\xec\xb0\xa3\xe5\xfc\x02\x33\xd5\x9e\xd3\x74\x3c\xfa\x36\x95\x0d\x85\xf1\xde\x07\xd8\xdd\x4f\x17\xe6\x74\xa1\xf4\xf8\xb6\x12\xe4\x42\xab\xe3\x36\x39\x91\xaf\x66\x0a\x94\xa8\xbb\xc2\xf5\x42\x1e\x23\x2d\x6b\x03\x54\xd5\x39\xad\x02\xd7\x98\xa4\xd2\x82\x24\xf8\x8e\xfa\xf4\x5e\xaf\x1a\xba\x68\xbd\x69\x49\x54\x05\x40\x0b\x6d\x4b\x31\xd7\xf5\x7b\x9d\x97\x98\xa4\x86\xd6\x04\x07\x05\x33\x15\x64\x8a\xdf\xfb\xeb\xcf\xac\x09\x36\xf8\xba\x8f\xfd\xb8\x8c\x3a\xb8\x2f\xb1\xbe\x52\xc4\x66\x63\x01\x07\x06\x02\xe2\x8e\x90\x8b\x00\xeb\x7a\x7e\x66\x9d\x3a\xa6\x85\xd7\xfd\x36\xa4\x14\x97\x6e\x7f\x8a\xa8\x67\x1c\x71\x72\xc0\xff\x50\xb3\xdd\x03\xe7\x8b\xcf\x3f\xff\x72\xe0\xac\x54\xff\x33\x59\x73\x07\x55\x00\x23\x58\xf6\x46\xcc\xf1\x28\x97\x9d\xa2\x79\xcd\xad\x8d\xb2\x75\xf6\xf0\x93\x36\xe4\xc8\xfb\x14\xd3\xf3\xab\xcf\x7f\x59\x22\x10\xbf\xd2\x14\x7e\x4d\x95\xa5\xb8\x8e\x0b\xb6\x50\x0f\x23\xff\x7b\x2e\xe4\xb2\x96\xe5\x9a\xe8\xfa\xa4\x8b\x2e\x70\x7b\x20\x9b\x64\x8d\xa2\x5c\xd7\xba\x81\x6a\xf4\x4b\x2b\x93\xe8\x92\x24\x19\xdf\x23\x75\x06\x5d\xaa\x1b\xdc\x26\x9c\x3f\xfe\x39\x57\x2b\x12\xf4\x98\x88\x93\x94\x5d\xd5\xd6\x07\xcd\x3c\xaa\xc0\x93\xaa\xe3\x60\xc9\xef\xae\x67\xd2\x81\x33\xe2\x6c\x29\x52\x41\x02\xea\x34\x42\xbc\xa1\xb6\xae\x09\x97\xf7\x5d\x47\xfe\xc6\x5f\x0a\x99\x8c\xca\x24\x08\xce\xd6\x6b\xaa\x6f\xd3\x92\x31\x07\x59\x47\x22\x4c\x5a\x0f\xc4\x82\x8c\x8c\xef\x32\x5e\xc0\xe5\x4a\xd2\xf1\xf8\xa7\x85\x1f\xca\x8a\x14\x9a\x1d\xd4\xe0\xb5\xbe\xe6\x4d\x0d\x23\xf0\xd2\x13\x45\x17\xf4\xd5\x21\x7c\xf3\xf1\x63\x7e\xf1\xf0\xef\xa3\xb5\x8f\xe3\x89\xd4\x13\x2b\xa3\xdb\x1f\xfc\x90\xcb\xa7\xd9\x86\x1f\x55\xd4\x94\xd6\x8d\x8d\x24\xa3\xa9\x60\x89\x26\x2b\x5b\xf0\xe6\x42\xde\xa9\x19\x79\xaa\xe0\xdd\x13\xf7\x46\x2c\x59\x6e\xaa\x6c\xee\xd6\x55\x48\x27\xd2\xe1\x85\x87\x7d\x8a\x77\x75\xb3\x29\xbe\x19\x32\x52\x8d\xa4\xb9\x4e\xa9\x22\xf9\x2b\x1d\xce\x53\x99\x5a\x69\xa7\xaf\x3a\x5e\xa7\x9c\x64\xd9\x80\x5f\xdd\xec\x94\x2c\x23\xb9\xa6\x6a\x78\x5b\xef\x9e\x96\x1c\x0a\xdd\x58\xd9\xd2\x13\xbb\x9e\x94\x9a\x7c\xaa\xa6\x5b\xe2\x71\xdb\x94\xa9\xa0\x4d\xdf\x93\x2a\x82\x2a\x2f\xc2\xad\x4b\xda\x76\xec\x89\xd0\x61\xfe\x14\x8d\x07\xa5\xf8\xa5\x4e\xac\xaa\x78\xbd\x16\xad\xad\x0d\x45\x45\x49\xbd\xad\xcd\x0a\xa3\x96\xad\x28\x4a\x05\xf8\x3a\xf7\xa2\x68\xe0\xb5\xce\x99\xcb\x8f\xf2\x2a\x98\x1d\x9f\x1f\x38\xc7\xb7\x58\xb9\x88\x0e\xe4\x24\x7a\x20\x53\x5f\x28\x93\xee\x5c\x67\xf3\x45\x29\xf3\x6e\x40\x8f\x53\x7f\x3e\x65\x66\x18\xae\xc9\x98\x5c\x53\x1a\xb9\x22\xbd\xce\x18\xf6\x55\x70\x74\x7c\x38\x3a\x00\x8d\x5a\x1e\xc1\x2a\x11\x15\x25\x18\x5d\x0f\x64\xa2\x9e\xad\x53\xc6\xe6\x8b\x01\x7c\x01\x6f\xc0\x99\x6d\x18\x23\x8a\xa1\x0a\xc3\x75\x5b\x4e\x35\x6d\xdc\x89\x6d\x40\x6d\xf7\x68\x29\x6a\xaf\xad\xfc\xb4\xc7\xfd\xb5\xde\x7c\xe6\xa6\x69\x73\x72\x5e\x54\x6c\xb6\xf6\xa7\x9b\xb5\xa8\xb1\x62\x5c\xfd\xdb\x76\x1d\x5b\xbe\x6e\xd5\x97\x93\x62\x3a\x13\xbb\x6d\xea\x42\x84\x0e\xcd\x2e\x82\xb6\xac\x1c\x5d\xaf\xd5\x16\x42\x84\xa8\x55\xa9\x04\x5a\x0f\x62\x1f\x77\xd9\xc9\xe4\x70\x74\x32\xc6\x03\x6b\xef\xf0\x64\x3c\x9a\xee\x0d\xf0\x22\xb0\xf1\xc3\x54\xb6\x7a\x11\xac\x09\x62\x3a\xb5\x55\xab\x3b\x34\x4d\x6d\x4a\x33\x91\x95\x10\xa8\xa9\x80\xe7\x83\x26\xb6\x8f\x5b\x49\xe2\xc3\x41\x6b\x84\xa1\xa9\xcd\xf0\xb3\xc0\x11\xb8\x83\xf8\x2c\xf1\xc8\x1a\x3b\x5f\x62\xcd\x22\xbb\x2e\x97\xc8\x68\x97\x6b\x2a\xa6\x7a\x9d\x3c\xac\x65\x20\x11\x6a\xa8\x5c\xc4\x71\x0f\x63\x07\xb9\x7f\x6c\x00\xf7\x1c\x5b\x97\x98\x43\xfb\x5e\x2d\xa3\xa0\xeb\xbc\x02\x9c\x2a\xc0\x56\x1a\x01\xf7\xc6\x17\xf7\x59\x61\x43\x1f\x53\xf8\x5a\xb0\x35\x85\xf7\xe2\x54\xd6\x1f\xa5\xac\x3d\x6d\x18\xad\x2d\x5a\x98\x43\x7a\x97\xf5\xab\xc9\x75\xb5\xeb\x8a\xbf\xa2\x87\x5d\x58\xee\x5e\x63\x25\x48\x96\xad\x31\x73\x09\x49\x72\x8c\xe5\x9f\x75\xc6\x19\x4d\x13\xfb\xcc\xca\x3d\x39\x57\x15\xa0\x6a\x09\xc9\x6d\x46\xac\x95\xa4\xb3\xdb\xa8\x4b\x88\xfc\xe6\x9d\xbb\x4c\x05\xd7\x71\x2a\x37\x7c\x7c\x32\x53\x54\x6e\xb4\xb6\xad\x5f\xa0\x99\x57\x64\x81\x6a\x4b\xb7\xc9\xe7\x32\x62\x31\xa7\xbf\xab\xaa\x7e\x22\xab\x72\x54\x04\x59\xb7\xf1\xcf\x15\x18\x54\x55\x23\x45\x6a\x2f\x2d\x42\xa9\x5b\xb8\xe6\xd4\x50\x76\xe2\xfe\x2d\xac\xe5\xdd\xf8\x7f\x15\x85\x4f\xee\xfc\xcd\x53\xff\x6c\xde\xdf\xba\xf1\xed\xd4\xf5\xbb\xdd\xf8\xfa\xfa\x7e\x2f\xee\x50\xe7\x75\xc9\xb4\x81\x65\x19\xb8\x7b\x2d\x07\x6d\xd4\x26\x64\x1d\x86\x2b\xaa\x98\xbc\xbc\xe3\x58\x62\xdd\xcb\x96\x20\xc9\xb2\x93\x2d\x93\xb5\x90\x08\x56\xcd\x09\x79\xd1\xf7\x2c\xab\x7c\x6d\xb1\x69\x35\xa9\xbc\xf2\x35\xad\x45\x4c\x73\xca\xc4\xde\xd1\xd6\xbd\x0b\xef\xb3\x72\x65\xf9\x00\x19\x0b\xa1\xa7\x61\x9c\xc8\x3e\x4b\xb2\x1a\x59\xeb\x3e\x8c\x8c\x6d\xb9\x2c\x74\xc7\x6a\x54\xf6\x14\x4a\xdd\x14\xdb\xb2\xbe\x1a\x92\xf6\x09\xfd\x9d\x58\x36\xa1\x71\xbf\x4d\xad\x97\x02\x04\x21\x4b\x1d\x91\xeb\x87\x68\x97\x71\x75\x2f\xdd\x2c\xc0\x0e\x17\xab\x18\x72\xd1\x4a\x2a\xef\xc9\xcd\xcb\x06\xf0\xb2\x2a\xe4\x85\x2b\x17\xc3\x28\x58\x76\xca\x9f\xb9\xd5\x10\xfc\x04\x62\x89\xba\x55\xdb\x8a\x77\x29\x62\xf3\x75\x97\x3c\x36\x64\x73\xc0\xdd\xcb\xec\xe3\xe3\x9f\xa8\x9e\x87\xec\x68\x66\x16\x07\x5d\x47\x8f\x7f\x1a\x66\xf5\x2f\x43\x49\xa1\x8f\x8b\xd0\x78\x85\x28\xa5\x18\xe5\xe5\x20\x8b\x7d\xcb\x0c\xad\x44\xa9\x9d\x65\xaa\xc6\x54\xb7\xc1\xb4\xdc\x97\x12\x3e\x1a\x96\x62\xac\x73\x89\x66\xf4\xa6\xc5\x2b\xed\x45\x15\x61\xc7\x58\x72\x4f\x65\x65\xd7\x60\xa4\x82\x44\x9e\x48\x5c\x7f\x29\x57\xb0\x59\x9c\xbd\x78\x15\x6f\x20\x07\xe1\x2c\xef\x78\xfe\x10\xb0\xf8\x56\x3a\xf5\xe5\x7c\x56\xdd\xa4\x1b\x6b\xb6\x13\x99\xac\x5e\x74\x67\x3d\x57\x6e\xab\x01\x8c\x45\x6e\x82\x84\xc3\xdc\xa9\xeb\x77\x03\x7c\xee\xf0\x1d\xcb\xf7\x84\x0a\x6e\xaf\xc1\x50\x32\xeb\xf4\x59\x40\x5d\x32\x8f\x73\x58\xd1\xfe\xd4\x07\x61\xc9\x92\x54\x87\x8b\x83\x8f\x3b\x63\x69\x88\x23\x34\x60\xf7\x9d\x7e\xa9\x35\x66\x15\x58\x1a\x31\xf5\xdc\x7d\xd9\x15\xa9\xdd\xbe\x43\x59\xa9\x93\x4c\xe8\x26\xce\x49\x3e\xcf\x73\xf5\xe0\x01\x04\x44\x35\xf9\xc0\x29\x3b\xe5\x13\x7a\xc2\x25\x47\xca\x39\x2d\xbb\xb9\x91\xb5\x51\x5c\x32\x9e\xd4\x67\xb1\xec\x92\x3b\x6d\x34\x9b\xf7\xfe\x5a\x16\xc5\x54\x59\xd9\xe4\x5e\x4d\xc2\xba\x22\x36\xc7\xec\xda\x75\xca\x85\x2c\xed\x25\x6d\xe4\x35\xb2\xc1\x05\x81\xe4\xdc\x01\xab\x48\xb0\x50\xb5\xb1\xba\xf4\xc4\x8c\x0e\x7e\x54\x37\x5c\x92\xe2\x25\x24\x58\x35\xa8\x72\xdd\x9d\xe4\x4d\x00\x6d\x01\xca\xba\xb0\xef\x60\x57\x50\x10\xc6\xe1\x0a\xa6\xcb\x13\xde\x5f\x75\x73\x2a\xd7\x58\x48\xc6\xb5\x12\x83\x16\xdb\x13\x96\xa3\x35\x8a\x46\xfd\xd0\xad\x32\xad\x41\x9a\xcd\x94\x79\x98\xc7\x60\x33\x68\x72\x13\xe4\xfe\x4d\x23\x25\x07\xfb\x77\xe5\xb8\xa8\xdc\xd2\x6d\x98\x3a\xb1\x6d\xbd\x56\xdc\xb3\xf1\x6d\xdc\xc0\x2f\x4c\x23\xe1\xf6\x36\xb2\x45\x18\xa9\xcc\x54\x02\x17\x20\x90\x4d\x96\x7e\xa2\x70\x09\x4e\x3a\xc1\xee\xd2\xaa\xee\x31\x3f\x8e\x8e\x76\x59\x34\x17\xdb\x80\xc8\x43\xe2\x3e\x8c\xa8\xc4\x9b\x2e\xcb\x6e\xef\x32\xc3\x80\x91\xe9\xa0\xf8\xe6\x3a\x11\x72\xef\xb6\xac\x87\x1f\x2b\xcf\x64\xbb\x0d\xf5\x93\xd2\x37\x19\xe5\x72\x80\xd0\x90\xab\xea\xea\x6b\x72\xd9\x7c\x2b\xeb\xea\xe6\xab\xba\x1b\xed\xa5\xb0\xee\x9b\x29\x51\x6d\x82\x8e\xae\x1c\x2c\xd6\x9e\xf7\x0a\x72\x4e\x57\x0b\x2e\x20\x8c\x5d\x46\x7e\x36\x37\x0e\x69\xf1\x78\x8a\xa8\x53\xd3\x84\x61\x5b\xce\xcd\x09\xce\xc7\x2d\xd2\x9b\x25\x18\x38\x39\xb1\x09\x72\x98\x26\x57\x81\xf4\x03\x8e\x8c\xd0\x43\xf2\xee\xdd\x70\xb2\x94\x30\xbb\x46\x44\xfe\xe2\x2e\x41\xa5\x0a\x44\x3d\xfa\x20\x61\xeb\xe3\x39\x70\xe7\x46\x1e\xc6\x6b\x28\x6b\x11\x3e\xc0\x2d\x56\xf0\xaf\xff\xff\xf9\x64\x3a\xab\xb4\x14\xd9\x76\xcd\x0c\xf9\x81\x4e\x3f\x9f\xef\xdf\x7e\xf0\xf8\xd3\xdc\x97\x9d\x2e\xd7\x48\x32\x3b\x0c\x27\x79\xf1\xb5\xa1\x12\xb6\x38\x8d\x09\x9e\x3e\x38\xf5\xa0\x12\x50\x31\x7d\x6e\x24\x98\xb8\xfb\xce\x78\x05\xc7\xd8\xf7\x2c\xd9\x3d\xda\x4f\x11\x15\x46\x80\xfb\x11\x4c\x05\x6f\x12\xf9\x12\x0f\xc1\x66\x0c\xa6\x61\xd9\xb7\x0f\xb0\x39\x0d\xb2\xfe\x26\x9a\xcf\x15\x7d\xe6\x71\x7b\xaf\xc2\x48\x98\x36\x00\xeb\x1c\x33\x27\x56\xee\x12\x1b\x9b\x78\xbe\x17\x66\xec\xb0\xb5\xb0\x0f\x6f\x30\xca\x8c\x7a\x0b\xe4\x34\xf2\x1a\xda\x85\xc7\xde\x3e\xfe\x5c\xe3\x95\xf7\x29\x0d\xa9\xf0\xb0\x1d\xee\xb3\x86\x97\x1e\xeb\x24\xfb\x4f\xa6\x4a\xe3\x98\xd3\xb5\x8a\xd5\x1a\xb0\xcb\x1c\x96\x65\x8a\xd9\x63\x54\xe3\x9c\xbf\x50\xfe\x42\xae\x63\x20\x1f\xb7\x1b\xf5\x68\x50\xb4\x31\x72\xad\x60\x07\xa6\xf7\x9b\x28\x05\x44\xf2\xb4\x41\xad\x4c\xff\x26\xb5\x4b\x19\xb5\xa5\xc0\xd4\xb7\xa5\xc1\xa8\x28\x6b\x08\x72\x4d\xaa\xff\x45\x16\x5b\x45\x20\x3a\xa6\xb6\x5c\x24\xe1\xba\x5e\xee\x9d\xbb\x51\xa3\xd4\x0b\xd7\xeb\x67\x5d\x7a\x48\xd3\x27\x5d\x78\x74\xec\x0e\x65\x6c\x97\x67\x3b\x99\x5e\xcb\x80\x27\xdd\x84\x85\x4e\x49\xcb\x11\x84\xe2\xcb\x5a\xc2\x9d\x24\x90\xad\x04\x3b\xbf\x09\x7f\x53\x57\xff\xc3\xd7\xd7\x67\xa3\xd3\xb1\xd4\xab\x86\x78\x71\x1a\xaa\xd0\xad\xa1\xca\xac\xe7\xae\xa2\xef\xd9\x04\xa0\x7f\x56\x86\x94\xd8\xe8\xbd\x05\x0f\x1e\xbe\xa6\x93\xbb\x9e\x34\xf8\x25\x6d\x8f\x9e\x9b\x76\x52\x1f\x2e\xff\xc6\x67\x67\x6c\x66\x26\x53\x81\x62\xa8\x78\x98\x91\x62\x52\xb1\x03\x5a\x80\x26\x3b\x2f\x9c\x43\xd9\x60\xe4\xde\x07\x39\x40\x71\xb0\x70\xfa\x3e\x70\x88\xa7\x6c\x36\xa2\x3c\x48\x86\x62\x1f\xc3\x89\x92\xf8\x94\x76\xfa\x40\x01\x3b\xb2\xf7\xb4\x3d\x5c\x80\xcf\x85\x51\x6c\x74\x1d\x21\x85\x12\x75\xc5\x3f\x2a\xe5\x9f\xcc\xdf\xc6\x49\x1a\x17\x5c\x46\xba\x39\x09\x3c\x06\xb7\x06\x52\x9b\x62\x34\x26\xea\x5e\xd4\xc0\x07\xcb\x3a\x2c\x86\x18\xdd\x88\x3b\x50\xc9\xb0\x44\x25\x68\xa7\xf7\x54\xe9\x96\xfa\x03\x80\x16\x17\x51\x91\x92\xb7\xb3\xd9\x39\x06\xf2\x7d\x78\x18\xf0\x75\x93\x13\xd2\xef\x92\x64\x1d\x5f\xd3\xf7\xd5\x3e\x27\x0a\x88\x8d\x50\x1b\x5f\x62\x75\x63\x6c\xb0\xb3\x8c\xc5\x40\x36\x7c\xa5\xde\x6c\x81\x48\x50\x6f\x47\x19\x09\x93\x47\x77\x80\x4e\x92\x88\xc6\x72\x16\x4a\xe9\xa0\xdc\xfb\x83\xec\xd8\xbd\xe5\xa2\x99\xc6\xf1\x8b\xcd\x37\xe4\xfd\xac\xd6\xff\xcf\xf3\x74\x26\x82\x3b\x23\x78\x5d\xbb\xf7\x6b\x51\xc8\xee\xb2\xf4\x68\x73\xe5\x42\x1a\xc3\xa5\x84\x36\x5a\xfb\x79\x5a\xf1\x5a\xe8\x07\xa9\xd0\x4e\x30\xb8\x64\xa2\xf7\x26\x7f\xcb\xaf\x1d\x43\x35\x6c\x95\x26\x86\xd0\xf9\x68\x42\x4a\x8b\x21\x05\x88\x0d\xce\xa7\x36\xa4\x1f\xbe\xd6\xd0\x73\xd2\x95\x86\x21\x40\xef\x02\x9a\x69\xd2\x73\x31\x07\xba\xaf\x0f\x0a\x16\x71\x7b\x0b\xab\xa0\xd5\x60\xec\xd8\x78\xbf\xc7\xec\xa3\x8a\x40\x7c\xe0\x58\x70\x83\xb8\xe6\x9e\x43\xc3\x6d\x6a\xd3\x23\xb1\x79\x26\x6e\x38\xd0\x4b\xfd\x85\xad\x31\x53\x61\xf0\xb2\x60\x54\x41\x87\x74\x03\x95\x16\x49\x12\xe8\x69\x38\x51\x46\x4d\x3c\xf8\x2e\x05\xf5\x12\x06\xce\x77\x28\xd0\xdd\x17\x94\xf2\xfd\x69\xf8\x93\x5b\xd4\xbb\xe7\x41\x61\xe8\xcf\x35\xbc\x4c\x08\x5c\xae\x3d\x38\xba\x74\x11\xc9\xfc\x78\x53\xfa\x91\x73\x04\x9a\x8a\xc1\x16\xee\x0d\x35\x80\x79\xa4\x89\x8a\x4b\xa2\xa0\xff\x86\xf2\xb1\x33\x77\xc1\x6a\x1f\x7e\xe8\xa8\xf5\xcd\xe0\x74\xa7\xa0\x29\xc3\x2b\xb4\x0c\x17\x2d\xdc\xba\xfc\x66\x0a\x17\x2a\x76\x0b\xd0\x5b\x99\x7f\xa8\xde\x99\x3b\x33\x63\xb6\x4c\xbd\xcc\xaa\xf7\x4c\x0a\x85\xc8\x59\x64\xbb\xc5\x97\xeb\xb1\x55\xe9\x9b\xf6\x26\x5e\xc5\xe3\xa1\xfc\x62\x35\x36\xd5\xb6\x2f\x17\xa0\x62\x66\x1c\xea\xa0\x7a\x37\x31\xaa\xc0\xc0\x79\x2d\x3e\xd0\x31\xcd\x3e\xb3\x04\x8b\x5b\xc8\xa6\x69\xda\x8b\x96\x35\xc4\xd7\xd0\xb2\xea\x17\x40\x16\x43\xb1\x69\xa1\x32\xf2\xaf\xd8\x45\x24\x67\x9d\xcc\xeb\x24\x41\xe8\x3c\xfe\x14\x78\xe8\x53\x33\x0d\x63\x8e\x76\xec\xf9\x32\x86\x13\x53\x95\xed\x40\xb9\x18\x0b\xb7\x6d\x96\xf0\x2c\xcc\x83\x71\x90\xb9\xeb\x07\xd5\x7b\x54\x36\x7e\x07\x41\x52\x69\x09\x05\x55\xcd\x13\x5c\x1f\x47\x36\x47\xc8\x6c\x85\xf6\xc5\xa4\xad\x7a\x76\x34\x99\xc9\xb4\x60\xe4\xcb\x7a\x28\xec\x5b\x97\x00\x65\x7a\x79\x94\x52\xea\xdc\xdf\xf9\x73\x9e\x20\xbd\x8f\xb9\xbf\x36\xa9\x4c\xb0\x2a\xbd\x34\xca\x57\xcd\xc5\x74\xa8\x21\x36\xb2\xaf\x4b\xc8\x1a\x11\x06\x12\x68\x28\x08\xc3\xd8\x04\x4f\xc5\xd7\x94\x17\x81\xe2\x7b\x30\xb4\x83\x96\x13\xc1\xe5\xc9\xa5\xf4\xf1\xc7\x1f\x31\x79\x85\x7a\x59\x34\x88\x99\x3b\x76\x6f\x9b\xc5\x01\x8c\x0e\xe7\xaa\x56\x0b\xec\x68\xbb\x79\x9a\xfb\xef\x10\x6b\x39\xf1\x4b\x35\x37\x5f\xb2\xe0\xd3\x31\x22\xc6\xcd\xcd\x6a\x40\x69\x41\x10\xb7\x5b\xb3\x46\x18\x35\x13\x84\x87\x70\x9b\x38\x86\x2a\x5a\x60\xb7\x6d\xc9\x1e\x84\xb0\x63\x06\x95\x88\xea\xcc\xa2\x32\x51\x5d\x98\x14\x59\x0b\x4d\xc0\x56\x81\x03\x72\x5f\x9a\xef\xf8\xe6\xc6\x77\x12\x38\x61\xd0\x8a\xce\x92\x6e\x08\x77\x97\xc9\xc5\x8c\xae\x96\xd8\x0e\x1f\xce\xc7\xe1\x90\x8c\x00\xab\x21\x03\x87\xb3\x79\x21\x02\x11\x65\xe2\x93\xbf\xa7\x36\xa3\x77\x20\x69\xa9\x27\x63\x6d\xb3\xd1\xca\xf2\x19\x34\x7a\x2c\x9c\x1a\x87\xfb\xca\x14\x78\x9a\xa2\x47\x51\xb7\xf3\x26\x1f\x21\x0a\xbb\x1c\x95\x69\x15\x95\xc4\xb9\x85\x2e\xf6\x48\xf2\x93\x90\xc2\x65\x4a\xac\x28\x1a\xcb\xf7\xdc\x01\xdd\xc2\x44\xd6\x4a\xb2\xa9\x31\xe9\xcc\x8c\x88\x36\x6f\x13\x40\x56\xba\xf4\xb8\x58\x09\xde\x68\x5d\x10\x3f\xd6\xfb\xac\x15\x36\x5e\x1e\x29\xa5\x54\x1f\x6c\xea\x68\x92\x21\x8b\x38\xa1\xeb\xb5\x0d\x2e\x35\xfb\xbf\xa3\x45\xa4\x4e\x8a\xe2\x2d\xd8\x23\x95\x87\x60\x34\x10\x91\x84\xe4\x95\x79\x90\xfd\x14\x49\x11\x97\xc5\xd5\x74\xa7\x73\x8a\x68\x97\x6d\xf9\x71\x0d\xd9\x08\x7b\x0b\x34\xad\x52\x1f\x9b\xcd\x51\x5f\x44\x6e\xd1\x03\xd7\x77\x22\xce\xbf\xc1\x92\x67\x03\x80\xbe\x40\x4b\x79\x6d\x2f\x73\xa6\x0f\xd9\x10\xc8\x04\x4b\x99\x6d\x6b\xb4\x2a\x42\x33\x3f\x2a\x82\x58\x1f\xf7\x32\x5a\x82\xde\x77\x60\x2b\xa1\x8b\x84\xe1\x65\x13\xb3\x2a\xdd\xd0\x4c\x8e\xcd\xb7\xbe\x06\x3a\x11\x62\x64\x42\xdc\x29\x7d\x9c\x6d\x19\x46\xa8\xf8\xa0\xae\xe9\xaf\xad\xaa\x66\x17\x14\x51\x25\x8a\xbf\xb1\x4a\x34\xf4\xe8\x70\x0c\x27\x16\xc2\xc3\xd0\x52\x4c\x5c\x8e\xc2\x38\xd6\xe2\x15\x37\x27\x66\x77\xd0\xea\x4c\xd8\xf6\x13\x19\x2d\x7f\xb2\xc2\x61\xdc\x9b\x70\x40\x92\x81\x1e\x23\x4b\x18\x2e\x29\xb4\x26\x4a\xc5\x2a\xc3\x98\x06\xb4\x6d\xc8\xa3\x72\x15\x8c\xf8\xb2\xe3\xa8\x5b\x8f\x73\xef\x06\xd2\xc6\xac\x3b\xf5\x55\x87\x9b\xfe\xda\x36\xd9\xd4\xab\x58\x87\x8e\xb2\xc0\x99\x67\xa1\xa5\xa8\x77\xe1\x2d\xc6\x76\x0a\xec\x3b\x57\xa0\xc7\x50\x5a\xc9\x70\xa9\xbb\x53\x03\x0c\xfd\x3c\xb7\x53\x54\x55\xcd\x70\xef\xc1\x6f\x51\xe0\xe2\x43\xd8\x55\x5b\x5d\x2c\x49\x86\x89\x1c\x35\xa6\xd8\x47\x21\x0d\x0b\x0e\x9b\xad\x89\xef\x5d\x75\x17\x83\x9d\x2b\xbe\x75\x8d\xf6\x82\xb6\x20\xd8\x5f\x5b\x97\x26\xce\xa9\x0c\xe1\xc2\x44\xad\x60\x2f\x51\x8d\xa3\xb5\x3f\x19\xc5\xcc\x7b\xf1\x10\xdb\x3d\xc1\x49\x31\xe5\x54\x36\x7a\xce\x3b\x82\x05\x47\x63\x58\x0d\x6a\x44\x0b\xdd\x17\xd4\x01\x75\xe7\xd2\x8a\xe6\xb0\x14\x7d\x9b\xa0\x20\xad\x5a\x62\x94\x9d\x09\x0f\x91\x35\x2c\xd4\xd4\x27\x89\x5f\x0c\x78\xd0\x5d\x5c\xeb\x28\xa2\x55\xca\x25\x06\x54\xb5\x5b\x76\x6f\xa0\x7d\x72\xdf\xb1\xae\x49\x8e\xb6\x32\x6d\x2a\xb6\xae\x7d\xc7\x94\xa1\xee\x72\x8a\x9f\xd4\x2d\x09\x0f\x4d\x6e\x66\x89\xdc\x77\x6a\x96\x00\xc5\x57\x45\x05\x7c\xd5\xa3\x62\xf7\x28\xeb\x47\xd4\x14\x9a\x2c\x93\xaa\xa7\x5b\x1b\xc7\x25\x9d\xa4\x85\xf6\x6a\x40\x0f\xc1\x71\x71\xc5\x52\x53\x68\x5b\x95\x23\x10\x64\xf2\x66\xee\x7a\xde\x90\xef\x10\x43\x94\x4a\x7b\xcc\xd9\x05\x5e\x01\x22\x59\x2a\x61\x6d\x8b\xc4\x3b\x02\x1d\xda\x06\x46\xba\x85\x10\x10\xe7\x93\x35\x97\xa4\x9f\xc1\xda\x58\x3a\xa7\xb0\x81\xad\x2d\xde\xf8\x11\x18\xe7\xea\xff\x63\xee\x6a\x96\xe3\x46\x92\xf3\xdd\x4f\x81\x70\xc4\x86\x14\xe1\x26\x57\x52\xec\x69\xe6\x44\x51\x14\x4d\x87\x44\x72\x49\xb6\x36\x3c\xa3\x09\x2d\xba\x01\x92\x98\xed\x06\x7a\x50\x40\x53\xdc\x09\x1d\xfc\x28\xeb\xdb\xfa\x3a\xb7\xbd\xf2\xc5\x5c\xf9\x53\x85\x2a\x00\x59\x00\x9a\xe2\xcc\x84\xc3\xf6\x88\x8d\xca\xac\xff\xca\xca\xfa\xf2\xcb\x74\x0d\x92\x04\xb8\x27\x7d\x16\xaf\x8b\x9a\x72\x0b\xaf\x51\x66\xf4\x3c\xdd\xbf\xd9\x8f\x5e\xbe\x78\xf5\xa7\xf7\xb3\xe8\xe5\xb1\xfe\xdf\x17\xc7\x12\x52\xe0\xcf\x35\x5e\x46\x75\x77\xb4\x34\x46\xcf\xc1\x2c\xd1\x47\xd2\x7a\xb3\x2a\x66\x28\x2d\x02\x71\x11\xca\x8b\x8e\x85\x17\x7e\xa1\x4a\x86\x90\x04\xc0\x0b\x88\x93\xfa\x3a\x75\x64\x44\x48\x03\x54\xa4\x5c\x6d\x8f\xaa\x7b\x5e\xaf\x17\xc0\xcf\x7a\xcd\x27\x88\x68\xed\xfc\x6b\x9d\x96\x45\x53\xa9\x52\xa6\x1e\x6b\x0b\x6e\xe3\x67\x47\xeb\x70\x2d\xab\x41\x20\xeb\x55\x09\x3d\x3e\x66\xc5\x5d\xc4\x7a\xf6\x42\x76\x9c\xfe\x85\xd6\x2f\x7e\x7e\x70\xd0\xd8\x9f\x4c\xa6\x46\xf9\xa9\xe8\x8d\x14\xaf\xfa\xe2\x12\x67\xa7\x35\x08\x61\x7a\x34\xb0\x3b\xcd\xcd\x9d\xf2\x15\xd0\x43\x6b\xe0\xce\x01\x81\x85\x7a\x1d\xd3\x25\xdc\x7a\xb6\xac\xf7\xb6\x79\xf2\xc1\x9d\x75\x01\xb8\xc7\x12\x48\xd9\xa6\x11\xce\x79\x5a\x6c\x3e\xca\x46\x13\x4d\x13\xab\x43\xff\x70\x17\xeb\xdb\x7b\xb2\x1f\x5d\x6a\x33\x7c\xed\xdc\xc4\x40\x92\x81\x85\xe0\x63\xcc\xb4\x7a\x5c\x1e\x1c\x1f\x09\x25\xe6\x97\x02\xa3\x16\x16\x92\x5e\x2e\xe7\x57\x27\xef\x4e\xbe\x0b\xa6\xd3\x9e\x5f\x1e\x5d\x04\x09\xcd\xe6\x97\xf3\x87\xff\xb9\x38\x39\x8b\x3c\x66\x33\x59\x98\xc4\xee\x65\xe4\x08\xf4\x5e\xf3\xdc\xbc\x53\x72\x7a\xec\x3e\x77\xdf\x3e\x5a\xaf\x44\x2a\x22\x1a\xb0\x78\x4d\x81\x44\x1e\x85\xb9\xe7\xa2\xed\x83\x9b\x77\xff\xb3\x71\x4b\xec\x60\xfd\xe8\x1d\x0e\xa8\x89\x00\x1f\x84\x1c\x2c\x9c\xb8\x8d\x89\x7a\xc8\xd6\xd1\x07\xfb\x46\x4f\x4e\x31\xc7\x49\xb7\x9e\x09\x48\xce\xf0\x81\xaa\x09\x41\xd6\xc7\x71\x59\xb1\x4b\x3c\x26\xa1\xcc\x9f\x6c\x98\x77\x42\x2b\xa8\xa9\x76\x0d\xd7\xe7\x0a\xb3\xeb\x06\x6f\x78\x7e\x95\x0c\x41\x4a\x29\x18\x36\x8d\x02\xb2\x9c\x67\x7c\x5f\x7f\x66\xae\xdf\xcf\x46\x46\xed\x77\x75\xb3\x2d\x3a\x33\xe9\xdd\x1c\x91\xc3\x61\xfc\x6e\xbd\xe8\x09\x2d\x8d\x0e\x0f\xf1\x52\xfd\x21\x2d\x15\x62\x1b\x7b\x88\x21\xa7\xdd\xa9\x1b\x25\xc5\x02\xc0\xa6\xc6\x8b\x89\x0e\x8f\x6b\x3a\xa2\xd8\x31\x89\xf7\x23\xfb\xaf\x09\x93\x97\x70\x49\x8d\x97\x82\xdd\x97\x06\x9d\x42\x1a\x68\x7a\xb4\x55\x0c\xd4\x59\x4b\x50\xed\x4e\xa1\x67\xc9\xf3\x13\xfe\xa7\xee\xeb\xa9\x1d\x82\x06\x76\x14\x73\xfc\x03\x27\x2f\x0d\x73\x3b\x53\xf6\xd2\x36\xec\xdb\x35\xb3\x87\x5e\x6c\x8d\xde\x26\xa7\x52\x6f\x70\x2f\xd6\xe6\xab\xa5\x4d\xf4\x2b\xdc\xbd\x13\xb4\x94\x27\xd2\xf6\x33\x05\x5b\x3f\xcf\x17\x04\x0d\xf0\x03\x06\xc7\xf4\xf3\x9b\x54\x6d\xb3\x9c\x82\xa4\x74\x7f\xf6\xd1\xe5\x8d\xea\xe9\x40\x05\x88\xea\xbb\x22\x13\xc8\x67\xfc\x86\xd5\xd0\x87\xd6\x78\x44\x65\xf1\x29\xfe\xc7\x9a\x83\xb5\x7a\x29\xc0\x19\x69\x22\x80\x36\xbe\x7e\x0b\x9d\xbc\x42\xbf\x55\x0b\x1b\x98\xac\xc4\x1a\xe2\x34\xb0\x15\xe6\xc5\xb3\x08\x77\xf0\x89\xeb\x3e\x2c\x32\xf4\x16\xe9\x77\x84\xc8\xeb\x33\xf0\x28\xc9\x35\x58\x82\xd2\xd5\x6a\xaa\x05\x88\x85\x7b\xb1\x6f\xb4\x65\x48\x84\x34\x4f\x85\x8c\x6b\xfa\x44\xc0\xc7\x25\xa1\xe4\x76\xbf\x0a\x78\xae\xe9\xb3\x75\x7c\x1f\xe9\x93\x74\x9b\x12\xaa\x61\xad\xff\x2f\x31\x15\xb6\x9e\x0b\xb6\xf5\x0a\x1c\xfb\xfa\xf4\xf9\x36\xc2\xdb\x61\xd6\xbd\x29\xc9\xb4\x59\x8c\x3e\x53\xae\x21\x83\xa7\xf8\x9b\xc2\x73\x96\xe8\xef\x96\x69\x9a\x48\x1e\x92\xdf\x7b\xb5\xa3\xe7\xf7\x7f\xcc\x85\xfb\x6b\x53\xf7\xbe\xac\xc1\xe3\xeb\xf4\x54\xb3\x76\xa8\xd6\x6a\x98\x58\x15\x5b\xc2\x38\xdf\xd6\xa1\x81\x35\xa9\xd5\x40\xd6\xb0\xf6\xca\x19\xcb\x0a\x4b\x38\x9c\xa4\xc4\x7b\x71\xc3\xdd\xe8\xf3\x41\x38\xda\x9f\xa2\xa9\xf6\xf4\xf8\xb5\x9b\xba\x29\x53\xf8\xff\x4f\xdd\x58\xfd\x83\xd9\x97\x2a\x34\x2e\x81\xd7\x5f\x79\x09\xce\x9f\xae\xd1\x69\x58\xfd\xf8\x56\xa7\x9f\x37\xe9\x12\x1e\x20\xe8\x75\x04\x1c\xcb\xc5\x12\x63\x9e\x92\x6f\xf0\x22\xc9\xcf\x20\xd2\x9b\x2c\x22\x30\x6b\xfb\x2e\xa4\x2f\x26\x0a\xe2\x6d\x92\xc2\x2f\x2d\x68\xc7\xd5\xcd\x59\x55\x0c\x66\x02\x62\xf1\x38\xf4\x8a\xb0\x48\x51\x5c\xde\xd4\xf0\xd0\x28\x77\x22\xc9\xc1\x4b\xb1\xb9\x51\x50\x4c\x1f\xc5\x45\x19\x01\xec\xaa\x41\x04\xfc\x40\x95\x60\x26\x70\x8d\x2c\x30\xe3\x74\xc0\x98\x6e\x2a\x42\xa3\x69\xaa\xd2\x23\x40\x50\xbe\x2a\x20\x04\xcb\xc5\x67\x10\x9c\x0d\x2f\x39\x84\xf2\x0a\x58\x60\x8b\x55\xf1\x53\x9d\x62\x2f\x34\xe5\x69\x49\x50\x1a\xd0\xd2\xc2\xb9\x42\x6f\xf5\x73\x7d\xcb\xef\xd2\x48\x05\x9b\xbd\x0c\x12\x47\x05\x1a\xac\x76\x65\x64\x41\xa5\x5f\x8f\x94\x85\x6a\x12\xa0\x65\xc1\x25\xff\x08\x5a\x16\xbf\xbe\x03\xcc\x2c\x1d\x2e\x89\x9f\x77\xa4\x65\x21\x70\xdf\x88\x14\xf1\x07\x16\xe6\x37\x9c\x23\xde\x0a\x1d\x45\xf3\xe2\x49\x1e\xcd\xf0\xe2\xe8\x20\x3b\x20\xb6\x39\x22\xc7\xe8\x19\x41\x89\x3b\x52\x6f\x30\xff\xbd\xdf\x6b\x23\x13\xe0\x77\x54\x0c\x70\xfd\xbb\x4a\xa6\xf1\x50\x18\x4d\xb9\x13\x62\x90\xaa\xa2\x2e\x8d\x47\x61\x94\x46\xe3\x08\x30\x09\xcb\x6c\x6c\xc0\x68\xa5\x8e\x0f\x63\x92\x46\x9b\x0b\x6f\x94\xc6\xde\xa8\x91\xa1\xce\x0d\x49\xa4\x78\x38\xfe\x6f\xf1\x04\x34\x55\xe7\x88\xb8\xe6\x73\x59\x32\xf4\xc9\x1f\x54\x0f\xdf\x21\x30\xe2\xfd\x41\x49\x4e\x2a\xa3\x09\x36\x8f\xde\xe2\xb8\xd5\xa3\x80\xb0\xee\x98\xa0\x58\x1c\x82\xa1\xd0\x63\xb6\x45\x8c\x05\xfe\x21\x39\x3c\x74\x7d\x66\x00\x6d\xca\xd3\xbb\xb4\xdc\x07\xaa\xf2\xd2\x06\x44\x73\x94\x43\xa6\xb0\x2c\x1b\xd5\x7e\x51\x19\xd3\xe4\x9c\x43\xc6\x3f\xc6\xe8\x2e\x7c\xb2\x00\x50\xc9\x50\xad\x6a\x0a\x6f\x64\x9c\x2f\xc4\x50\xd7\x26\x98\x9d\xe9\x34\x1e\xfe\x19\xaa\xda\x40\x1f\xfd\x2a\x9c\x17\xee\x90\xfe\x26\xec\x16\xb6\xbd\x8d\xc1\xa0\x0b\x5a\x34\xf8\x90\xc5\xe3\xd7\x7f\x48\x46\xb8\x06\xbd\x3e\xce\xdd\xba\xb2\x9f\xab\x70\x97\x6e\x19\x71\x19\x18\x69\xea\xfb\x5d\x35\xd6\xd0\x1f\x6d\xc8\x37\x15\x6e\x9f\x97\x13\xf3\xb3\x78\xd5\x1c\x43\x2d\x3f\xd1\xd1\xd2\xae\xe8\xa2\x4d\x2b\xbf\xeb\xea\x09\xd2\xcc\xef\x36\xf6\xa2\x0b\xa2\x53\xd5\x29\x0b\x65\x04\xd9\x77\x4f\xad\xc7\x2e\xa3\xbe\x07\x83\xc7\x2e\xa4\x9e\x67\x80\x1d\xfb\xd4\x23\xed\xff\xf5\x3d\x91\xfe\x8c\x51\x4e\xaa\x60\x37\x26\xd6\x86\x76\xfe\x46\xbe\xc8\xcd\xaa\x88\xad\xff\x16\x70\x09\x0a\xaf\x1f\x68\x5f\x50\xe2\x40\x29\xaa\x22\xfe\x3b\xbe\xe5\xd4\x28\xc1\x23\xcb\x48\x08\xa1\xc5\xf9\x35\x58\xca\x80\xfa\xdd\xce\x84\x76\x25\x76\x3e\x17\x4c\x35\xdc\x23\x71\xbc\xda\xb4\x53\x6e\x58\xcd\x77\xd9\xe6\xad\xee\xee\xd7\xf7\xfa\x9a\x0d\x09\x3e\xf4\x9f\xe0\xdf\x87\x00\x0f\x82\x3b\x60\x26\x67\xaf\x0b\x74\xfd\xa0\x60\xa1\x66\x22\x75\xf5\xfc\xe2\x9d\x50\xe4\x51\x44\x13\x52\xb0\xdb\x34\x2e\x09\x23\xc5\x09\xce\x44\x7e\x6c\x64\x1b\xaf\x28\x26\x8f\x4d\x47\x58\xe2\x48\x35\x16\x78\xe7\x6b\x8b\xc3\x1a\x39\x6c\xd9\xda\x0c\x74\x48\x0e\x20\xe6\xae\x95\x33\xde\x01\x35\x86\xb9\x8e\xe6\x48\xfc\x51\xe4\xe9\x1e\xe2\x20\x36\xb1\x52\x77\x45\x89\x3e\x74\x4c\x81\x18\xa8\x20\x5c\x5a\x54\x9a\xdf\xc6\x3e\xc0\x81\x1c\xaf\x90\x45\x91\x82\xd2\x32\x21\x46\x67\xee\x6d\x8a\x55\x2c\x86\x65\x40\x54\x5d\x93\xb1\x44\x8d\x49\x59\x82\xb2\x01\x24\x8d\x5d\x4e\x3b\xcf\xe8\xcc\x03\xee\x46\xe8\x09\x18\x81\x58\x80\xdb\xd8\x44\x2e\x02\xa3\x4e\x02\xf7\x68\x91\x22\x36\x68\xb8\x28\x1c\x51\x12\x4e\x01\xd1\x08\x69\x34\x1f\xe8\x4a\x7a\x68\x71\xb9\xa2\xec\x5e\x2a\x06\x78\xcd\x95\xb1\xee\xdb\xec\x4d\x6e\xd9\x80\xc2\xd2\x4b\xf4\x8a\x4f\x24\x61\x55\xb1\x8d\x18\x71\x4a\x04\x14\x10\xd1\xd3\xcf\xc8\xd5\x31\xbc\xbd\x5b\x25\x44\xcf\xd4\x2d\xd6\xab\xe9\xc3\xd1\xc5\xe5\xc9\xd9\xa9\x34\x7c\xf0\xb3\x8c\xea\xfa\x00\xd4\x75\xd1\x7f\x5d\x9e\x9d\xea\xbd\xe8\x47\xc8\xd2\xc6\x74\x68\x8e\x95\xb6\x67\x42\x02\x9b\xed\x00\x61\x4b\xb0\x06\xd7\x80\x99\x51\xb3\x66\x89\x71\xca\x82\x2c\xdf\x5b\x01\x92\xa6\xc0\xe0\xb8\x18\x47\x74\x3f\x7a\x5b\x98\xb4\xee\xf8\x2e\x4e\x98\xef\x34\x09\xc8\x55\x29\x38\x2e\x97\xe8\x62\xa6\x5f\x4d\x9e\xfc\x00\x93\xab\xb8\xea\x74\x0b\xf5\x96\x83\xad\xdd\x3e\xfc\x63\x95\x71\x4e\x47\x3c\x5d\xb4\xbc\x87\xff\xd5\x6a\xcb\x42\x75\x51\x87\x0e\x93\x2b\x31\x62\x1a\xfb\x66\xe6\x92\x57\x28\xb8\x5f\x83\xe9\xc9\xec\x60\x7a\x03\x4d\x31\x34\xdf\x92\x91\x9d\x37\x9b\x3e\x6c\x6c\x36\xc1\x7d\x58\x39\x23\xdb\xb5\x0a\xa4\xa4\x51\xf5\x8a\x62\xfc\x4c\xbf\x58\x60\xc9\x00\x07\xad\x34\x81\xbe\xf6\x1c\xc8\xf2\xdf\xdf\xd8\x8b\x4d\xaf\x09\x80\x85\x29\x37\x9e\x69\x3b\x6e\xcf\xdc\x49\xf6\x30\xc8\xf6\x99\x49\x01\xb8\x48\x31\x9b\x1b\xa4\xd2\x11\x37\xf5\x6d\xbc\x2a\x4a\x43\x47\xe7\x67\xe0\xe8\x93\x9c\x13\x97\x31\x0d\x97\x91\x2e\xec\x90\x96\x1c\xed\x74\x68\xaf\x75\x42\xe3\x05\x51\x44\x04\x72\xce\xa7\xb0\xb4\x6f\x70\x5c\x69\x19\x5d\xc2\xf1\x2b\x8a\x52\xb2\xd5\x03\xbf\x8a\xcf\x02\x1f\xc0\x72\x01\xa8\xee\x0c\x91\xf2\x65\xc5\x11\x3a\xfc\x40\xa2\x88\x24\xcd\x84\x67\x88\x67\xc0\x87\xc6\x5e\x31\xc2\xf4\x8f\x08\xba\x87\xb8\x17\x77\x25\xc1\x2b\x66\x9e\x3a\xb1\x1a\xd2\xe1\xf0\x97\x83\x8b\xd3\x93\xd3\x63\x62\xb9\xa1\x83\x16\x96\x02\xda\x57\xd6\x76\x41\x9a\x17\xf3\x8c\x46\xf3\x1d\x03\xd4\xc0\x6b\x77\x9b\xdd\xdc\xae\xee\x21\x4c\x6d\xa9\xcb\xc4\x37\x69\x82\xa2\xfe\xdb\x13\x00\xb0\x02\x3d\xa9\xb4\xc1\x95\x19\x6c\x20\x6c\x9d\x0a\x7b\x81\x7f\x04\x9a\xa9\x92\x96\x14\xa9\x57\xb7\xe9\x6a\xa5\xe5\x2b\x08\x7d\x06\xae\x32\xe9\x36\xf6\xe1\xe4\xf2\x8c\x1a\x40\x96\x40\x4a\x16\x1c\x99\x52\x78\x69\xc2\xe7\x9b\x8d\x75\x3a\xe8\x26\xa0\x91\x65\x1e\xf1\x14\xf8\xf8\xe2\x55\x45\x71\x88\x60\x7d\xc5\xb0\xf7\xa4\xab\x5b\x9c\x5a\x28\xfa\xd2\x4a\xc4\x59\x4c\xd3\x45\x37\xc8\x89\x1a\xd5\x72\xf4\x49\x59\xe2\x60\xd8\xa9\x7e\x53\xc6\x5b\x08\xeb\xcf\x0b\x6c\x0a\x8c\xd6\x92\xd2\x09\x42\xf3\xb0\x59\xc1\x81\x89\x30\x4a\x86\x69\x11\x0b\x0c\xd6\xd1\xbb\x84\x22\x5a\x44\x42\x5e\x79\x1e\x10\x06\xd8\xfa\xd1\xb0\x5d\xee\x6a\x30\xdc\xf4\x2c\xca\x6f\xc0\x49\x6a\x19\x91\x0a\x9b\xe2\x93\xc4\xe0\x5c\xa0\x57\xb4\xe8\xd5\x8b\x17\xf0\xfb\x9f\x5e\xbe\x98\x99\xc0\xd3\xae\x5c\x78\xf8\x5d\xa4\xe8\xec\x59\x11\xc7\x0d\xa0\x49\x88\xf1\x76\x73\x8b\xde\x62\x18\x65\xb8\x02\x44\x87\xab\xa2\x4e\xf4\x90\xd5\x79\x52\xde\x3f\x03\x96\xe7\x2a\x5e\xc4\x4a\xef\x9f\x07\x7a\xdc\xff\x96\x17\x77\xab\x34\xb9\xb1\x0c\x01\x1d\x5d\x06\x7b\x4e\x51\x61\x09\xbd\xad\x79\x42\x5d\x6e\x49\xdb\x4d\xf4\x3e\xaf\x78\x01\x5a\x76\x6d\x31\xfc\x8a\xa6\x57\x74\x84\x21\xc1\x30\x0c\xf6\xa0\xd2\xab\x8c\xa3\x89\x7a\x9c\x46\x3c\x0e\x6c\xc2\x23\x0d\x67\x25\xba\x6c\x9c\xcc\xa1\x78\x41\x22\xfa\x28\xc6\xba\xd6\xee\xcf\x3c\x2e\x78\x8c\x33\x19\x0e\x0e\x4c\x4d\x03\xc3\x1c\x22\x92\x1e\x48\x55\x68\xd2\x34\xc5\x90\xf9\x2c\xfb\x8c\x66\x18\xc7\xf2\xc0\x42\xf8\xa5\xbc\xd6\xda\x70\x7a\x2c\x74\x37\xd3\x85\x27\xe6\x8c\x1a\x5e\xef\xee\x47\x57\x05\x9a\xa4\x7a\xad\xdc\xea\x13\x93\x9f\xc6\x45\xe5\x44\x33\x8a\xa3\x05\xd6\x48\x5b\x9c\xcb\xbb\x09\x24\x30\x4d\x38\x86\x73\xc0\x73\x88\x9b\xfb\x57\xe1\xa4\x7f\x92\xf5\x63\xd3\xbc\xf5\xaf\x1f\x5a\x18\x80\x44\xe8\x04\xbb\x50\x00\xd0\x13\x2f\x8d\xdd\x56\x44\x53\x47\x77\x49\x98\x75\x02\xcc\xcc\x51\x5c\x01\x82\xb2\xb2\x0a\xd6\x71\x92\x1a\xda\xa7\x78\xd9\xd7\x8f\xdf\x5a\x8c\x92\x9b\x72\x16\xf7\x12\x08\x8e\x83\x2b\x74\x59\xdc\x1b\xda\xcf\xd6\x18\x38\x31\x81\xdc\x37\x9d\xba\xea\x9e\xb8\x06\xd3\xb2\x57\x0b\xe6\x19\xd4\xa7\x8a\xc1\x91\x01\x73\x2c\x1b\xeb\xd4\xf9\x86\xad\x6d\x0f\xfc\xdb\x7b\xe4\x9e\x2e\x3a\x3f\x72\x6d\xb0\x9d\xeb\x8d\x0d\x81\x5d\xea\x71\xcb\x6b\x31\x22\xfc\xab\xee\x17\x72\xfe\xc3\xfe\xcd\x82\x14\xd8\xe8\x58\x21\x74\x0a\x26\x76\xbc\x6e\x76\x02\xf5\x44\x5b\x41\xb1\xd3\xe2\x97\x2a\x9d\x4a\xdb\xc2\x3e\xf3\x9f\xc5\x94\xf6\x51\x1b\x96\x31\xeb\xbb\xd6\xa3\xce\x70\x60\x88\x33\x06\xfa\xa1\x35\x4d\xda\xca\x50\xb8\x74\x87\xe2\xdb\xfe\x0c\xc5\xfa\xf7\x35\xcd\x5b\x8a\x05\xee\x19\x43\x98\xb2\x18\x67\x2a\x35\x81\xba\x14\x26\xef\xe6\xe1\x17\x15\xc5\x5d\x9a\x00\x56\x36\xf3\xe3\x1d\x60\x50\x29\xc1\xa5\xfe\xaf\xcc\xcd\xa1\x1c\x98\xcf\xb5\x30\x9f\x0d\xa5\x1a\x05\x35\xc7\x98\x22\x33\xfd\xbb\x74\x63\x92\xf6\x51\x74\xe3\x55\xe0\x0f\x41\x3e\x52\x6f\x34\xbf\x6d\x2d\x68\x87\xae\x70\x91\x9a\x4d\x03\xc2\xdc\x91\xc1\x8f\xa0\x04\xaa\x37\x77\xaa\x5f\x52\x9b\x68\x69\x09\x31\x66\xc8\x03\x52\x66\xeb\xb8\xbc\xc7\x10\xd5\x25\x84\xac\x34\xdc\x1f\x6e\x25\x31\xe4\x75\xb3\xc2\xb0\xe7\xce\x3e\x83\xd1\x6d\x19\xac\xed\x35\xe6\xa8\x82\xe5\xbd\x7d\x19\xb1\xb7\xde\xe4\x2a\x86\x27\x64\x36\x82\x82\x05\x5f\xe1\x97\x90\x73\x22\x05\xe0\x6c\xff\x1e\x8b\x7b\xb2\xd6\x01\xcf\xd4\x58\x3b\x5d\x0c\xff\x7b\x3f\x8a\xfe\x92\x36\x14\xf8\x10\xb9\x6f\xb6\x47\xfe\xdc\xc2\x9b\x90\xde\xaa\x26\x70\x55\x52\xdc\xe5\xe6\xa3\x66\xc3\x82\xfc\x90\x98\x0f\x25\x49\x90\xd1\x5e\x0f\x52\xab\x0a\x8b\x14\x73\x57\x10\x43\xf9\x7e\x74\x06\x16\x55\xe8\xd4\x5a\x67\x37\xc0\x3f\x92\xcc\x8c\x32\x65\x09\x35\x75\x65\xa9\x35\x10\xe8\x1a\x3c\x7e\x26\xee\x99\x7a\x0d\xf0\x1c\x33\x91\x3d\xad\x69\x06\x1c\x41\x3c\xc3\x3a\xe6\xd4\x96\xe9\x2a\x79\xbd\xe3\xbe\x85\xac\x42\x8c\x40\x61\x98\xa7\xb4\x54\x3d\xb6\x4b\x98\x77\xc8\x55\x19\x9d\xc1\x5c\x23\xa8\x81\x42\x88\xd8\x9a\x5c\x9b\xb0\x7a\xdb\x75\x57\xf5\x42\x55\x59\x55\x67\x02\xb0\x07\x97\xb5\x9d\x44\x31\x83\x15\xf4\x4e\xf3\xba\xfb\x29\x4c\x81\xc2\x95\xd3\x5b\x76\xfb\x6a\x46\x93\x2f\x8d\x43\x3b\x29\xa7\xf5\xc1\xfc\xb7\x8c\xec\xe3\x7f\xbe\xda\x8f\x2e\x60\x06\xea\x09\x18\xaf\x21\x70\x02\xb9\x14\x10\x84\x08\xa8\x0a\xf8\x9c\x51\x71\xe0\xf0\xd1\x53\xa4\xa4\x00\x70\xae\x94\x11\x97\x6e\x33\xa2\xf4\xf0\xe8\x09\xdc\xea\xc4\x49\x86\x64\xea\x99\xee\xd3\x37\xfa\x4e\xac\x57\x2a\xb3\xdf\x49\x95\xc6\xc4\xbe\xc0\x23\x03\xe7\x07\xce\x46\x3c\xb8\x0a\xe5\xd9\x87\x30\xac\x4d\xd3\xf4\x25\xac\x34\xd3\xc0\x9c\x3d\x3d\xa7\x97\xb0\xf3\xc5\x25\x98\x16\xdf\x00\xbb\x19\x71\x59\x42\xf8\xaa\x4f\x41\x43\x9c\x56\x80\xf1\x71\x3e\x51\xde\x37\x8a\x09\x57\x6d\x6a\x0b\xf9\x22\xab\xaf\x93\x85\xde\x68\x5b\xe4\x96\xa8\xd5\x30\x5c\xb2\x46\xc4\x09\x95\x66\xa4\x80\x3e\x90\xc1\x92\xc4\x0f\x6f\x8a\x29\x02\x06\x14\x4a\xbc\x65\x9a\x36\x32\x87\x12\x44\x33\x53\x56\x43\xf6\x12\xa9\xb4\xfa\x04\x89\x4a\xd4\xa7\xc5\xfd\x27\x03\x1f\x10\xa1\x45\xd4\x00\x0a\x2d\x25\xf7\xae\xef\x19\x72\xf0\x5f\x92\xe4\x70\x35\x09\x5e\x0c\x59\xae\xa0\xaa\xe0\x05\x09\x57\xc5\xb0\xcc\x78\x25\xfa\x55\x94\xc0\xbc\xa0\xeb\xa6\x0d\xdc\x22\x41\x46\xdd\xb7\x27\x90\x75\xb7\x21\xab\x57\x55\xa2\x6d\x57\x41\xe1\x31\xdc\xf3\x61\xb3\x29\x09\x91\x81\x92\xf4\x92\x39\xb8\xf8\xf3\xfc\xe4\xc3\x19\xd2\x34\x12\x7b\xbc\xde\xcd\x54\x0c\x66\x57\x98\x35\x9b\x2a\x64\xe8\xbd\xb7\xe0\xbd\xc3\xf3\x82\x93\x2a\x5e\x67\x12\xa6\x95\x6b\x82\x0e\xba\x54\xd9\x1c\xbf\x79\x3c\x2a\xbc\xfc\x3b\xc8\x53\x53\x2e\x6f\xb3\x6d\xda\x3c\xf0\xb0\x93\x74\x04\x02\xf4\xcc\x16\xfe\xee\xe4\x9c\x36\x51\x93\x32\x64\x18\x12\xfa\xfd\xfb\xf9\xbb\xab\x93\xf3\x83\x8b\xab\x3f\xbe\x3d\xbb\x78\xbf\xf7\xe6\xe0\xea\x20\x3a\x3c\x3b\xbd\x3a\x3a\xbd\x8a\xfe\xf3\xe4\xcd\x9b\xa3\xd3\x1f\x26\xf9\x3c\xbf\x3f\xbf\x38\xf9\x70\x70\x75\x14\xa1\xa4\x9d\x24\xf4\x71\x06\xab\x89\x32\x6e\x56\xc5\x42\xaf\x67\x66\x75\xfa\xc1\xde\x53\xbe\x37\x88\x72\xb5\xbf\xbf\xff\x43\xf4\xbd\xf9\xbb\xf9\x70\x92\x16\x5a\xc1\x42\x11\x8e\xf6\x96\x4a\xea\x6d\x5e\x2a\x78\x23\x23\x26\xf5\x45\x57\x28\x55\xd5\x12\x32\x5e\x97\x29\xee\xc4\x48\x34\x06\x98\xcb\x85\x47\xa4\x8c\x19\xca\x0c\x23\x07\xdd\x89\xdf\xeb\x63\x2c\x56\xb7\x62\xad\x91\xb3\x06\xdd\x7c\x52\xbd\x65\x8a\x71\xa1\x00\xc0\xae\x0c\xaf\xd4\xb5\xde\xbb\x44\xdd\xd7\x31\x3c\x9f\xe5\x6d\xf2\xac\x0e\xd6\xaa\x5f\x4f\xc3\xf9\x2b\x37\xcd\x52\xf2\x0a\x22\xf0\xe4\xff\xa6\x01\x49\x4d\x6a\xa8\xdd\x10\xa4\x27\x3d\xa1\xd8\x3d\xa5\xec\xbb\xcb\x01\x26\x21\x76\x0e\x7d\x86\x7f\x04\xbf\x0d\xc6\xf8\xc0\x35\x9f\xcb\xf5\xcb\x5e\x6e\x6a\x41\xdc\xa1\xfe\xa5\xbf\x48\x70\x7a\x04\xa7\x06\x16\x95\x33\x32\x62\x59\x31\xcc\x24\x69\x72\xe9\x4f\xea\x3e\xce\x13\x29\x94\x31\xd9\x1f\x85\xb2\x99\x0a\xaf\x61\xf0\x9e\x33\x07\x83\x58\xef\x4c\x49\xe7\x07\xb8\x18\xe0\x29\x41\xd6\x2e\x4e\x15\x2c\x27\xbc\xfd\x8e\x83\x2a\x0c\xe3\x11\x28\xac\x63\x5a\x67\xf7\x47\x82\x60\x46\x24\xa6\x7b\xa3\x4f\x66\xc4\xe7\xaf\x6f\xee\x77\xb9\xfd\xa3\x8c\xaa\x10\xc3\x3e\x28\xd5\x91\xfd\xd9\xa3\x5b\x9b\xd1\x91\xec\x87\xb9\x3c\xfc\xa2\x8d\x7a\x60\x80\x64\x0e\xc8\x8f\x39\xa0\x51\xfe\xba\xbc\xb6\x0e\x04\xac\xe6\x1e\xd5\xe8\xaf\x26\x12\x90\xfc\x07\x46\x8e\xf2\x15\x49\x2c\x64\x81\xde\xf0\x1b\xce\xbd\xe1\x77\xd1\xe3\x7b\xc3\xb4\xb6\xa7\x23\xbc\xfa\x07\x7a\x63\xa0\x1b\x8c\x86\x70\x0f\x88\x29\x9f\xac\x20\x71\x26\xdf\x49\xf3\x0f\x2b\xb4\x88\xb3\xcf\xc2\xb2\xa3\x00\xb0\x69\x51\xe0\xcc\x7b\x8e\xe0\xa9\xf3\x12\xee\xb7\xd5\xbd\x01\x51\xa9\x5b\x97\x80\x13\x32\xd3\x48\xa7\x48\x20\x2b\x7e\x5b\x68\x4e\xc7\xd7\x96\x1f\x8a\xeb\x95\xf0\x1c\x8b\xfe\x0d\x41\x1f\x25\x77\xed\x2f\x47\xa7\x69\xa4\xaf\x38\x94\x9e\xea\xfa\x1a\x71\x06\x90\x8b\x31\x5d\xde\x52\xc6\x34\xfb\x6e\x09\x4e\xc3\x7b\x27\x04\xf1\x4d\xb3\xe1\x8a\x07\x1d\x9d\xc8\x31\xba\x04\xd0\x17\x59\x6a\xc1\x05\xf3\x16\xa0\x9e\xc6\x1f\x99\xb0\x6b\x37\xbf\x8d\x45\x2d\xfd\xad\xd0\x8d\x08\x20\x91\x84\x42\x65\x8a\xbe\xa3\x4d\x9c\x49\x93\xe0\xa6\x04\xf6\x64\x78\xc7\xd4\x5f\xdd\x08\x5d\xd8\x0d\x19\xd1\x25\x04\x81\xdd\x6f\xf5\x82\x9c\x20\xd6\x98\x7c\xfa\xb6\x38\x5a\x43\xc3\x6d\x6b\x2f\x3c\xd2\x49\xd4\xab\x13\xd3\xfa\x51\x76\xa5\xd1\x3a\x1d\xa7\x7c\xa3\x94\x5f\x9f\x05\xd5\x90\x31\x73\xca\xf0\xd9\x87\x4f\xa6\x97\x43\xb2\x40\x41\x42\x93\x01\xcd\xd2\xc6\x79\x0f\x73\x61\x0d\x68\xcd\x99\xf8\xf8\x13\x00\x70\x00\xda\x54\x0f\x84\x2a\x72\x22\x35\xfd\x9c\x55\xde\x2c\x9d\xc1\xb1\x59\x7d\x52\x4d\xc6\x26\xf8\x84\x12\x38\x89\x2b\xa5\xa9\x4e\xbf\xc2\x75\x01\x18\x91\x9d\x14\x06\x9b\x37\xcd\x16\xb7\xa5\xa6\x99\xa8\x59\x8e\xa9\x52\x75\x9f\xdf\x6a\xd3\xb3\xa2\x84\x91\xfa\xe4\x33\xb8\x3d\x41\x98\xc9\xde\xa8\x47\x4e\x97\xa3\x88\x0e\x2d\x8a\x11\x5c\x79\x83\xfb\x0b\x6b\xdd\x5a\xb0\x8f\xd9\xc0\x0f\xdf\x7e\xba\xbc\x3a\x38\x3e\x39\x3d\xfe\x74\x75\xf2\xfe\xe8\x6c\x7e\x65\x36\x1c\x71\x7c\x08\xe2\xd3\x68\x67\xb0\x4f\xff\x5e\x1e\x94\xbf\x53\x5d\x2f\xae\xe6\xe7\x4f\x59\x57\x41\x7e\x6f\x5d\x57\xf1\x22\x95\x4e\x37\xa9\x04\xa0\xbf\xcc\x4b\x84\x50\xf4\xe1\x5f\xab\x2a\x5b\xbb\x7e\xe3\x80\x30\xc2\x84\xcb\x30\x58\x23\xcc\xdc\x77\x1e\xfe\x0f\x9f\xe0\xd1\x6d\x8c\x45\x05\x8b\x82\xf6\x0a\xe9\x44\xc0\x5f\xc5\xfd\x13\x22\xcd\x27\x5a\x14\xeb\x10\x07\x68\x98\xfa\x93\x8a\x4a\xed\x37\x65\x85\x66\x06\x8e\x4b\xa0\x11\x13\x0a\x15\xb9\xb6\xa8\x54\xb6\xb4\xcf\x1d\x82\x88\xd6\xf3\xec\xe2\xe1\x1f\x2a\x13\x6f\x31\x5a\xea\xb4\x93\x1b\x4e\x24\x5a\x2c\x06\x16\xc8\xce\x01\x6d\xc9\x04\xce\x91\x9c\x1f\x22\xbc\x45\xc1\x9c\xee\xc6\x5f\x20\x8d\xac\x1c\x33\x2f\x7e\x2f\xf5\xcd\x18\x66\x7f\x34\xfd\xe5\x3b\xe1\x46\x5b\x89\x65\x96\x26\x31\xc2\xef\xfb\x45\x80\x59\x63\x9f\xb0\xf0\x41\x4a\xb2\x93\xe9\x81\xc0\x7d\x5c\x00\x63\x47\xa8\x19\x6c\xdc\x93\x7a\x02\xc4\x07\x34\xa7\x3f\x4a\x7e\xb8\xe1\x3a\x0b\xe5\x80\x7b\x57\xde\x64\xe0\xe7\xc0\xde\xc2\x50\x56\xc9\x01\x58\x2c\xeb\x0d\x3b\x95\xd0\xfd\x99\x08\x6b\xf3\xa7\x50\xa2\xea\x25\xfe\xd6\x5b\x0e\x00\x91\xcc\x2e\x3c\xed\x5c\x6e\x56\x80\x0a\xe4\x97\x04\x14\x05\xbc\xdd\x0f\xcc\xf6\x96\x30\xa9\x1d\x1d\x69\x62\xa3\x28\xd8\x18\x80\x33\x65\xb6\x40\xee\x47\x70\x5d\x7c\xc2\x5e\x7a\x66\x98\x63\x27\xb7\xb7\x2d\xd3\xda\x26\x5f\x4f\x24\xed\xb1\x5f\x4f\x1e\x86\x05\xec\x28\x2e\x44\x45\x1c\x60\x1e\x66\x4c\x90\x34\x86\x03\x54\x77\xa3\xe8\x28\x46\x33\x50\xf0\x7e\x34\x74\x6a\x04\x0b\x0f\xb3\x56\xec\x4c\x54\x31\x92\xdf\x60\x0a\x5d\x44\x07\x44\x30\x28\x73\x04\xad\xb3\x03\xd4\x94\xb6\x18\x84\x2a\x8c\x16\x34\xb0\x49\x7b\x5d\x17\x1e\x9d\xbd\x20\xb7\xc7\x58\x3a\x8f\x01\xf3\xe2\xe8\x33\x26\xa6\x4e\x0c\x34\x45\xaa\x12\x3a\xcb\xc4\x4d\xb8\xf1\x6f\x49\xb3\x35\x93\xe7\x40\x92\x2a\xe9\xe4\x0d\x45\xde\x05\x89\x33\x9d\x28\x63\xf1\x7a\xb5\xc4\x0c\x0f\x4d\xec\xb0\xb0\xe5\xa2\x28\x51\x08\x97\x95\x9c\x6a\x4a\xdd\xda\xb4\x0c\x8e\xd3\x01\x7c\xdd\x01\x8f\x99\x89\x56\xd1\x63\xab\xcb\x37\x5e\x07\xe3\xf8\x91\x0e\x9b\x01\x6d\x70\x4b\xa4\x8e\xd9\x59\x2f\x5c\x14\xc3\x1d\xdf\x5f\x85\xb0\x87\x50\xd2\xbb\x4b\x63\x59\xd3\xce\x6d\xdd\xb1\xa1\xb6\x8f\xaf\xc5\x17\x4f\x5f\x63\xa7\x67\xc1\x86\x9e\xa6\x6a\x5a\x13\x1f\x3b\x94\xa6\x63\xa7\x35\x70\x72\xeb\x76\x1b\xbf\x47\x8d\x1d\x5c\x82\xdc\xf1\x1b\xa7\xd2\x71\xcc\xed\x32\x8a\xf8\x66\x94\xef\xae\x73\x84\xc2\x2a\xf0\xfc\x89\xd1\x91\xd2\xa6\xc5\x69\xf1\xc5\xf3\x95\x73\xd8\x8b\xa5\x27\xf2\xd9\x92\xaf\x6d\x62\x91\x02\x08\x44\x03\xef\x15\x49\xf1\x3c\x16\x98\x3d\xb9\x70\x14\x23\xd0\xfb\xa5\xbe\xf2\x52\x22\xc4\xa0\xb4\x28\x46\x64\xad\xfd\x1a\x30\x66\x6b\xf9\x35\x00\x62\xb4\x25\x1f\x6f\x21\x8d\x18\x65\xa6\x18\xef\x85\xed\xa4\xf0\x10\xc4\xde\x6f\xa6\x0d\x48\x9d\x43\x24\x40\x6e\x18\xf6\x2b\xc9\x34\xa2\xe7\x58\xbe\x3b\x2b\x86\x68\x4b\x26\x40\x9d\x87\xfd\x41\x80\x82\xa6\x2f\x84\xf2\x22\xdf\x80\xf8\xfd\xb4\x39\x05\x05\xc4\xf8\xed\x8b\x77\xd2\x11\x5f\xab\xf8\x46\xbc\xd7\xd5\x55\x66\x41\x6a\x62\x79\xd1\xc6\xbb\x44\x34\x97\x1a\x0e\xfd\xf6\xb8\xc5\xa4\xe7\x23\x13\x97\x3f\x26\x2c\x7f\x1b\x8c\x49\xec\x2f\x73\x2f\x1a\x99\x97\xd9\xba\xbf\xc8\xcf\x94\x08\x82\x01\x8d\x5f\xbe\x44\xcf\x11\x6c\x4a\xca\xbf\x21\x86\x8c\x8c\xe3\x23\x2f\x2b\x08\x90\xf9\xf2\x45\xca\x6b\xd3\x95\xb5\xa5\xd0\x49\x78\xa0\xd0\x62\x45\x71\x52\xcd\x0e\xdf\x1a\x0a\x97\x4d\x26\x81\x01\x75\x6d\x9d\x2f\x87\x45\x85\x98\x1a\xf0\x37\x26\x06\x19\x2f\xf1\x2e\xa6\x74\xa6\x15\x21\xc9\x8f\x0b\xaf\xfb\x8e\x0b\xcb\x28\x26\x77\x9b\x95\x05\x51\x5c\xf0\x96\x58\x95\x10\xbd\x41\x81\x0c\x71\x64\xba\xf1\xb8\xe8\x88\x14\x6b\x07\xc4\x21\x67\xd7\xe6\x4e\xa1\x45\x1b\x94\xb7\xf4\xd0\x2e\x17\x4a\xa4\x40\x2c\x28\x42\xf8\x18\x43\x80\x12\x86\xcb\x74\xbf\x0f\x02\x68\xe0\xbd\x3f\x53\x7f\x9b\xc3\xf2\x06\x3e\xb7\xeb\x88\xff\xc2\xfc\x42\xb2\x16\xb7\x18\x0d\xa7\x5b\x4c\x54\xa6\x77\x5c\x53\xb1\xc0\x5b\x7c\xeb\x4b\x48\x9f\x2c\xc6\x3b\xf7\xbe\xfb\x72\xd6\xd0\x26\x7d\xba\xe9\x70\x3f\x67\x37\x92\xa2\x38\x11\x67\x8a\x72\x43\x52\x06\xd4\x86\x16\x25\x30\x9e\x7d\xaa\xdb\xa9\xdb\x7b\x74\xb7\x19\x54\xaa\x02\xe0\x55\x1e\x1a\x3b\xef\xa6\x51\x6d\x88\x54\xe4\xd9\x82\xcf\x30\x1f\xf3\x8f\x15\xfe\x0f\x75\xc3\x6b\x3f\xd1\xb0\x81\x5d\x47\x77\x90\xfd\x14\xfc\xe1\x1f\xa1\xe4\x79\xad\x6e\x6d\x15\x3f\xfe\x3b\xda\xa9\x18\x28\x63\x82\x11\x60\xed\x71\xee\x4c\x9b\x54\x99\x22\x01\x19\xe1\xaa\x6c\x12\x3a\x26\xb8\x84\x3c\x36\x88\x05\x31\x9d\x21\xe4\x4e\x87\x00\xfe\xbe\x90\xff\x26\x85\xb1\x27\xa5\x9f\x5a\x47\xb7\x6b\x53\xdd\x72\xee\x15\xcb\xb3\x13\x1e\x3b\xb7\xab\x68\xd8\x5e\xb7\xb2\x26\x5b\xc4\x38\x40\xec\x99\x45\xa4\xb7\xbb\x1e\xfe\x69\xe2\x8a\x88\x99\x03\xcc\x4b\x40\xb6\xb8\xb9\xa2\x01\xa4\x6f\x00\xbd\x85\x49\xc8\xb3\x77\x5d\x60\xdc\x34\x86\xfe\x0f\xf6\x16\xcd\x9c\x36\x2d\x84\x9b\xeb\xd9\x72\x40\x48\x7d\xe6\x10\x0a\x79\x5c\x42\x18\xdc\x5d\xdc\x70\x5c\x1c\xe2\xd8\x20\x4a\x60\x78\xae\xe5\x7e\x9e\xfc\x9d\x88\x8f\x5c\x71\xad\xf4\xf8\x8f\xa2\x42\x02\x96\x27\xc2\xe4\xc3\xfe\x96\xaf\xee\xa3\xbb\xa2\xd4\xdd\x54\x63\xa6\xc4\xc3\xb7\x91\x73\x18\xc3\x2e\xf6\x3e\xfe\x9c\xad\xeb\x75\xc3\x51\x49\xc1\xf8\x0d\xd1\xa6\x77\xc0\xca\xf4\x9a\x23\x6a\x63\xb9\x3f\xbb\xb5\x30\x7c\x9b\x56\xcd\x7f\xec\x5a\x0f\xa6\x3b\x03\x1d\x87\xef\x3c\x1d\xb6\x28\x2c\x01\xe7\xb3\x56\x55\x5c\x25\xf0\xe5\x55\x11\x99\x74\x93\xcd\xe0\x98\xb3\x95\xda\x36\xc3\x18\xd2\x3c\xa5\xe4\x07\xf5\x06\x0e\x38\x2a\xc1\xe2\x21\x79\x54\x05\x11\xbc\xc4\xc0\xd3\x69\xad\xdc\x79\x2b\x0a\x0d\xb3\x6c\x60\x14\x99\x20\xcf\xa9\x6e\x01\x62\x7e\x16\x35\xbc\x4f\xd7\xfe\x69\xa8\xff\x30\x78\x18\x3a\x85\xe8\x2c\x74\x0a\x89\x8a\xf4\xde\xb8\xba\xd2\xb7\x16\x5d\xc8\xfc\xb3\x37\xa5\x7d\x40\xad\x2c\x62\x08\xc7\x0d\x9c\x79\xe6\x79\x9d\x25\x04\x91\xd2\x3d\xdf\x83\xe1\x84\xdd\x39\x5a\x03\xe4\x98\x2a\x8b\x9b\x52\x46\xda\xf7\x14\x4a\x21\xd9\x4b\x12\xba\x86\xf6\x14\x52\xf5\x12\x72\x5f\x4c\x69\xce\x22\x5d\xef\xe9\x62\xfa\xe2\x1b\x98\x1d\x3e\xde\xce\x66\xe6\x8b\x21\x4d\x20\x05\xa3\x23\x92\x8f\x50\x19\xb2\xee\x96\x18\x0b\xd8\x23\x0e\xb3\x9f\x6a\x06\x1f\x14\xc8\xe9\x4f\xe0\x0c\x2d\x76\xf7\x6a\xed\x5c\x1d\x56\x8e\x0e\x78\x53\xad\xb1\xb5\x18\x0d\x70\xec\x16\xed\xc0\x18\xe5\xa6\xbb\xe4\xb2\xcf\x69\xe5\x69\xb3\xe4\x1d\xdc\xb1\xbf\x7c\x79\xef\xf9\x19\x66\x2e\x4e\xca\xfb\x2e\xea\x45\x87\xcd\x2c\x7d\x97\x32\xdf\x99\x0c\xd1\x0d\x29\xa5\xfd\xc9\x98\x90\xb3\xc8\x7d\x4a\xc7\x7d\xfa\xb4\xc8\x5f\x03\x0c\xc2\x14\x39\x20\x08\x78\xf0\x9a\xe7\xb5\xab\x07\x90\xd6\x69\xea\x2c\x1a\x82\xad\x89\xcd\x9f\x71\x22\xe8\x76\x73\x67\x8d\x39\xea\xfc\x27\x3d\xf7\xf7\x75\x41\xb8\xa9\xd2\x08\x5e\xd0\x83\xa3\xd9\xa1\x69\xd7\xc5\xfc\xa7\x8d\xfd\x6f\x22\x6a\xc3\x8f\x93\x5d\x61\xb4\x1b\x77\x84\xf5\xa6\x9a\x17\x2b\x78\xc9\xae\x42\x23\x61\xc0\x75\xd8\x53\x62\xc0\x9b\x18\xd0\x81\x73\xfa\x0d\x45\x1c\x04\xe7\x8b\xa8\xb2\x2d\x21\x50\x83\xaa\xb5\x49\xef\xdb\x4b\x4c\xcf\x15\xa6\x28\xdd\x5f\x7c\x7b\x1e\xa1\x9d\x4e\x24\x39\x39\x3f\x03\xa6\xb8\x51\xee\x6e\xf6\xa0\x3d\x2e\x45\xf5\xb5\xa0\xde\x18\xc8\xcc\x49\x55\xb0\x72\x64\x3d\xb3\x40\x31\xd9\xa6\x35\xe7\x38\xd8\x0e\x68\xb2\xea\x7b\x08\x2d\x16\xfd\xc7\xcf\xee\x12\xea\xcc\x4e\xb9\x79\xbb\x09\xe5\x59\x8a\x55\xfd\xb7\x1f\xfe\x3f\x00\x00\xff\xff\xd7\xf2\xa0\xb2\xf6\xf0\x02\x00") + +func cfI18nResourcesPtBrAllJsonBytes() ([]byte, error) { + return bindataRead( + _cfI18nResourcesPtBrAllJson, + "cf/i18n/resources/pt-br.all.json", + ) +} + +func cfI18nResourcesPtBrAllJson() (*asset, error) { + bytes, err := cfI18nResourcesPtBrAllJsonBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "cf/i18n/resources/pt-br.all.json", size: 192758, mode: os.FileMode(420), modTime: time.Unix(1456502789, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _cfI18nResourcesZhHansAllJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xbd\x6b\x53\x1c\x57\x96\x28\xfa\xfd\xfe\x8a\x3c\x3a\x77\x42\x76\x07\x85\x6c\x77\xcf\xc4\x09\x45\x9c\x98\x83\x11\x92\xb9\x8d\x04\x03\x48\x3d\x0e\xd3\x41\x27\x55\x09\x64\xab\xa8\xac\xae\xac\x02\xd3\x1e\x4f\x20\x59\x48\x20\x81\x84\x6d\xbd\x85\x2c\x61\xeb\xd5\xb6\x05\xf2\xa3\x25\x1e\x42\xfa\x2f\xdd\x64\x55\xf1\xc9\x7f\xe1\xae\xc7\xce\x67\xe5\xce\xcc\x7a\x20\xa9\xe7\x4c\x4f\x8c\x55\x54\x65\xae\xb5\xf6\xda\x7b\xaf\xbd\xf6\x7a\x7e\xf4\xff\x28\xca\x27\xf0\xff\x8a\xb2\x4f\xcf\xec\x3b\xa8\xec\x1b\xca\x0d\xe5\x06\xbb\xfb\x0e\x0e\xe5\xf6\xb5\xf1\xf7\xc5\x82\x9a\x33\xb3\x6a\x51\x37\x72\xf6\x03\xe5\x4b\x4b\x95\x7b\x9b\xf8\x0c\x3c\xf2\x69\x5b\x18\x8c\x0f\x8d\x52\x41\xf9\xff\x06\x7a\x8f\x29\x66\xb1\xa0\xe7\xc6\x14\x73\x3a\x57\x54\x3f\x56\x74\x53\xd1\x73\x93\x6a\x56\xcf\xb4\x2b\x4a\x5f\xc1\xc8\x6b\x05\xcf\x4f\xc5\x71\xdd\x3c\xa8\x28\xe9\x51\xc5\xd4\x8a\xa9\x42\x29\x97\x83\x57\x53\x5a\x6e\x52\x2f\x18\xb9\x09\x2d\x57\x4c\x4d\xaa\x05\x5d\x1d\xc9\x6a\xa9\xb1\x82\x51\xca\x2b\xfb\x3f\x19\xda\x97\x53\x27\xb4\xa1\x7d\x07\x87\xf6\x01\xd8\x12\x7c\x6a\xab\xfd\xea\xd3\xfd\x51\xa3\x39\xfd\xa8\x72\xf3\x0c\x13\x6b\x3d\xbe\x56\xf9\xfe\xc1\xce\xfa\x8f\xd5\xb5\xc7\xe5\x9f\xae\x94\xaf\xdd\x2d\x5f\x99\xfb\xfb\xcc\xe9\xf2\xe3\x6f\x2a\x2b\xab\xf0\x18\x7f\xbf\xb3\xbe\xf9\xcb\xf3\x9b\x7b\x41\xe6\x9e\x32\xd4\x2c\xaa\x63\xff\x00\x0c\x6d\x29\x99\x12\x86\xfe\x4a\x19\x1c\xd7\x4c\x0d\xf0\x15\x26\xf5\xb4\xa6\xe4\xb3\x30\x0c\x65\x5c\x9d\xd4\x14\x35\xa7\xa8\xa6\x69\xa4\x75\xb5\xa8\x65\x94\xb4\x61\x16\xdb\x95\xce\x82\x06\x43\x04\xae\xab\xce\x1b\x7a\x0e\xe8\xcc\xc1\x87\x29\x3d\x9b\x85\xbf\xd2\x30\x3f\xc8\x6e\x7e\x43\xca\x9e\x5f\x29\xd5\x97\x37\x76\x36\x6f\x95\x97\x17\xad\xf3\x2b\xd6\xfd\x6b\xbb\xf7\x96\xac\xd9\x67\xe5\xe5\x79\x6b\xf6\xa7\xea\xa9\xcb\xc0\x92\xf2\xdc\x52\x79\xf9\x7b\x60\x92\x35\x77\xcb\xda\xda\x14\x4f\xae\x7e\xb5\xf3\xe2\x82\xf5\xe4\xec\xce\xe6\xc3\xca\xe5\x3b\xe5\xc7\xf7\x9c\xc7\x64\x63\xec\xc8\xe7\x61\xb1\xa8\x05\x18\x46\xc4\x76\xb6\x36\x2f\x57\x2e\x3f\xaa\x3c\xba\x60\x6d\x5e\xb2\x9e\xfd\x68\x2d\xad\x59\xe7\x1f\xc9\xb7\x36\x02\xfd\xe4\x93\x76\xf8\xe7\x18\x30\xfb\xd3\x4f\x95\x29\xd5\xb4\xb1\x28\x25\x13\x79\x24\xb8\x30\x31\xa1\xe6\x32\xca\x1f\xe0\xe1\x4e\xfe\xfc\xe9\xa7\x7f\x48\x48\x87\x1f\x03\x50\xb5\xb3\xfd\x12\x7e\xdc\xd9\xba\xbf\xb3\x7e\xc1\xfa\x7c\x7b\x67\xeb\x1e\xd3\x09\x8b\x26\x08\x5f\x42\xf7\x31\x43\x51\xf3\xba\xa2\xe5\x32\x79\x43\xcf\x15\x71\xa1\xc9\x27\xa9\xbc\xfc\x6d\x75\xf5\x45\x65\x7b\x75\x67\x6b\x6b\x67\xfb\x8a\xd2\xd1\xd7\xad\x54\xbe\x5b\xab\x9c\xde\x88\x60\x77\xbf\x51\x2a\x6a\x4a\xd1\x50\x46\x34\xa5\x94\x9b\x50\xf3\x79\xe0\x08\x70\x22\x67\x14\x15\x58\x1c\x05\x58\xc6\xd9\x69\x45\x7c\x0f\x8f\x15\xc7\x61\xad\xe5\xf3\x59\x3d\x4d\x98\xe5\xd4\x54\x1f\x9c\xb2\x2e\x5d\x2d\x3f\x9d\x2b\x5f\xbf\x6b\x3d\x39\x83\x9b\xe6\xd9\x9a\xf5\xe2\x8c\xb5\xfd\xa5\x35\xbf\x08\xb4\xf2\xf7\xd6\xdc\x13\x2f\x0f\x23\x28\x45\x01\xaf\x28\xc7\x61\xf9\xef\x87\x2d\x37\xa1\x16\x4e\x6a\x45\xd8\x00\xb0\x96\x53\xa6\x32\xd0\xd5\x7f\xa2\xbb\xb3\x6b\x3f\x92\x38\xa9\x6b\x53\x4a\x46\x33\xd3\x05\x3d\x8f\xf4\x98\x8a\x31\x0a\x4b\x3d\xa3\x4f\xea\x99\x92\x9a\x15\xbb\x06\xbe\x53\x95\x31\x7d\x52\xcb\xd9\x9b\x23\x82\xb3\x74\x74\xc0\xb4\xf1\x8c\xfe\x6d\x66\x59\x4a\xc1\xdf\x66\x6e\x5b\x97\xd6\xca\x77\xee\x57\x96\x2f\x54\xb6\x6e\x58\xab\x37\x79\x27\xc0\xf8\xad\xa5\x33\x3b\xeb\xdf\xf2\xe6\xc1\x0d\x73\xe9\x52\xf5\xe5\x93\xb8\x01\x77\x98\xa6\x3e\x96\x53\x0a\x46\x56\x33\x61\xd3\x16\xc7\x41\x8a\xc0\xda\xe1\x99\x01\x66\x14\x60\xa9\xa1\xf8\x31\x0a\x63\x29\x7c\x68\xbf\x82\xeb\x37\xfc\x19\x33\x0f\xb4\xf2\x53\xf1\x43\xdd\x9d\xb9\x59\x7d\x79\x0e\x86\x1a\x89\x0e\x87\xfb\xc5\x82\xec\x29\x17\x21\x3e\x37\x77\x76\x77\x76\xb1\xfa\xf0\x8b\xea\xfc\x8f\x91\x43\xa6\x29\x46\x78\x87\x07\xd5\xc2\x98\x56\x74\x36\x0a\xcd\x6e\x91\xbe\x53\x72\x30\xc7\x04\xbe\x8e\x49\x0b\x83\xc9\xf3\x05\x52\x1d\x67\xea\xea\x13\x98\x97\xca\xad\xd5\xf2\xdd\x73\x95\xbf\x6c\xee\x5e\xfb\x39\x19\x9d\x32\xfa\x80\x49\x75\x52\x17\x4b\xd5\xd6\x99\xca\xd6\xb9\x48\xaa\x4a\x62\x83\x64\x0d\x38\x8e\x94\x94\x4a\x62\x20\x95\x32\x4f\xea\xf9\x94\x69\x66\x53\x74\xea\x12\x21\xfb\x81\x40\x7a\x14\x45\x4c\xc4\x53\x30\x28\xb3\x94\xcf\x17\x34\x93\x8f\x66\x45\x2b\x14\x8c\x42\x7d\x9b\x25\x9e\x1a\x18\x72\x79\xee\x2a\x3f\x1d\x49\x90\xe0\xcd\x83\x53\xe5\xc7\x5f\x97\xaf\xbf\x00\x5c\x70\xac\xec\x5e\xbe\x51\x5d\x5b\x0b\x67\x0c\x7c\xea\x3c\x3c\x7c\xac\xe3\x68\x97\xa2\x96\x60\x03\xe1\x79\xfb\x7f\xb4\x8f\xd5\x89\x7c\x56\x6b\x07\x89\xaf\x0c\xed\x1b\x1a\x1a\xda\x97\x87\xf3\x73\xca\x28\x64\xf0\xf3\xd0\x3e\xe5\x2d\x10\x20\x6a\x5e\x53\xfe\x54\x32\x8a\xb0\xf5\xf4\x51\xe4\x2c\x88\xc6\x9c\x62\x3f\xf8\xb6\x84\x05\x0d\xe1\xfb\xe5\xf9\x9c\xf5\xe0\x74\xf9\xab\x65\x6b\xed\x6c\xe5\xee\xa9\x9d\xf5\xc7\xe2\xf4\xd8\x3c\x6b\x3d\xbf\x62\x5d\x7a\xf6\xcb\xf3\x85\xea\xda\x33\x6b\x6d\x83\xff\xac\x6e\x7f\xbf\xb3\x31\xff\xcb\xf3\xf9\x86\xc7\x3c\x31\xed\x8c\x04\x87\x8b\xeb\x46\x8c\x75\x14\xd6\x85\xfd\x93\x10\x3a\x2a\x6f\xb6\xb7\xa5\x47\x61\xbd\x08\x71\xbc\x0b\xb3\xd6\xd2\x77\xb0\xd1\xca\x77\x9f\xa3\x78\xa4\x81\xc3\x61\xc0\x03\xe7\x61\x96\x2f\x7c\x5f\xfd\x2b\x8c\x7d\x5e\x76\x46\x7a\xf0\xa6\x8d\xfc\x74\xca\x04\x8d\x13\x04\xf2\x40\xef\xf1\xfe\xce\xae\x54\x47\x5f\x9f\x32\xd8\xd1\x7f\xa4\x6b\x90\x3e\x7e\x94\x32\xec\x3f\x7b\xfb\x8f\xfc\x1e\xfe\x36\xed\xbf\x07\xfa\x3a\x3a\xbb\xf0\x9b\x54\xce\x48\xc1\x52\x47\xdd\xe0\xf7\xd2\xd1\xc6\xd2\xc2\xeb\xfd\x2d\x63\x42\x2f\xe2\xba\x29\x20\x3b\x48\x32\xdb\x1c\xc0\x5d\xc5\x0f\xc1\xb9\xae\x15\xd4\x74\x11\x8e\x22\x38\x69\x53\x29\x07\x06\xa9\x68\xf9\x82\x31\x91\x2f\xd2\x94\x8c\x18\xc5\xf1\x44\x13\x40\x70\x81\xc1\x95\xe5\x53\x95\x2b\xf7\x81\x97\xe5\xb9\x67\xd6\xd2\x22\x08\x6a\xb1\xb8\xb6\xee\xb3\x74\xdf\xd9\xbc\xb7\xb3\xf9\x45\xf9\x2a\xac\xa9\x4b\x95\x1b\x5b\x16\x28\x0d\x2e\x7a\xd0\xda\x78\x2b\x57\x5f\x7c\x69\xcd\x86\x80\x49\x36\x2b\x62\xe7\xc3\x26\x36\x94\xb7\x82\x43\x83\x13\x19\xd8\xa2\x94\x0a\x59\xe4\x87\x31\x52\x54\xe1\x59\x55\x31\x72\x5a\xaa\xa8\x03\xc7\x6a\xb8\x95\x60\xcf\x79\x10\x02\x0f\xfc\xa3\xd9\x79\x71\x4b\x39\xde\xdf\xa3\xd0\xc6\xba\x58\xbd\xf8\x0c\x54\x94\x9d\xf5\x99\xf2\xf7\x2b\xe5\x99\x87\xcc\x01\x67\x6c\x49\x47\x56\xaa\x5d\xeb\xa9\x7c\xc3\x32\x25\xf1\xfc\xd6\x83\xb8\x61\xe1\x92\x7c\x7e\x65\xc4\xec\x99\x94\xa9\x07\xef\x1e\x08\x9b\x48\xf4\x79\xf5\x9f\xff\x79\xca\xe8\x3f\xa4\xbc\x65\xe6\xb5\xb4\x3e\x3a\x2d\x91\x01\x70\x09\x01\x6d\xa1\x84\x77\x45\xb3\xf9\x41\xdb\x58\x61\xb4\xe5\x85\x73\xa0\x39\x84\xec\xfc\xed\x65\xb8\xb4\x5a\x97\x4e\x97\xaf\x3c\x49\x36\xce\x7c\xc9\x1c\x87\xb3\xb8\x8f\xff\xfa\x28\x35\xa2\xbc\x7f\xbc\xbb\xe7\x10\x48\xcb\xdf\xd2\x57\x28\x32\xd3\x4a\x67\xef\xd1\xa3\x1d\xc7\x0e\xe1\x1f\x19\xe5\x50\xef\xd1\x8e\xee\x63\xf8\x79\x54\x81\x6f\xbb\x0f\x77\x0d\x0c\x0e\xf7\x75\x0c\x7e\x40\xe2\x35\x63\xa4\x4f\x6a\x85\x94\x3e\xa1\x8e\x69\xf0\x68\xe7\x6f\xbb\xfa\x87\xbb\x8f\x76\x1c\xe9\x6a\x42\xda\x12\x91\xb5\xe8\xea\x07\xd8\x4b\x17\x06\x35\x0b\x82\xd8\x95\x4e\x59\xdd\x2c\xe2\x75\x81\x2e\x87\xa9\x8c\x96\xd5\x41\xaa\xe3\x6d\x48\x1d\x43\x85\x48\x2d\xb2\x38\x83\x0b\xd4\x54\x41\x2f\x16\xe1\x42\x21\xee\x49\x27\x3a\x3b\xfa\x86\xc5\xbd\x60\x40\xf1\x18\x06\x14\xdb\x30\x40\x9b\x40\xcd\x4d\x83\x6c\x2f\xc1\xc2\xf0\x5c\xac\x4c\xd9\x6d\x04\xbe\xc2\xe5\x7c\x69\x6d\x77\x06\x77\x28\x0b\xb5\xdd\x99\x6b\xb0\x7e\x51\xc3\xbe\x49\x77\xf1\xbb\xe7\xaa\xab\x4f\xac\xb9\x6b\xd5\x15\xb8\x6c\x2e\x80\x7e\xc4\x9f\x41\x08\x5a\x67\x6f\x80\x30\xe7\x1b\x62\x65\xeb\x73\x58\x25\xde\xeb\x17\x5a\x40\xfc\x54\x57\x2e\xae\x59\x5f\x7f\x66\x5d\xba\xbe\x7b\x4e\x7e\x39\x0b\xe7\x9c\xb8\x56\xa5\x78\x0f\xe8\x69\x60\x60\x6e\x54\x1f\x2b\x15\x68\x2c\xb0\x5c\x0b\xb0\x88\xe1\xec\x43\x5b\x10\xb0\x99\x34\x3c\xb6\xbf\x18\x23\x7f\xd4\xd2\x45\xf8\x3a\x95\xd5\x73\x5a\xfb\x50\xce\x33\xd7\xa5\x3c\xa8\x81\x00\x54\x18\x34\x60\xf1\x25\x36\xab\xa0\x99\x47\x36\xc9\xa3\x3a\xcc\x06\x10\x88\x27\x10\x19\xaa\x9a\x24\xbe\x5d\x21\x5c\x83\xe3\x78\x88\x81\x68\x13\x4b\xc2\xf3\x1e\x63\x54\x73\xb8\x70\xd0\x7a\x33\x62\x1a\x59\xbc\x8b\xc3\x8a\x28\x68\x38\xdf\x93\xee\xab\x4c\x5f\x1c\x23\x70\xd1\x0f\x0f\xf6\x0e\x1f\xee\xee\xe9\x12\x63\xed\x62\x11\x81\xcb\xb7\x86\xc4\x83\xf4\xc4\x27\xf4\x5f\xf8\xdf\xd0\xbe\x74\xb6\x64\x02\x69\xc3\x39\x03\x6e\xcf\xc0\x3a\xf7\x37\xfe\x19\xd6\x68\x11\xbf\xfe\xe7\x36\xdf\xf7\x13\xda\x84\x51\x98\x1e\x9e\x18\xc1\xdf\xde\x7d\xe7\xbd\xdf\xd8\xbf\x7e\x4a\x1f\x3e\x4d\xb6\x90\xad\xe5\x47\xe5\xe5\xf9\xf2\x95\x39\xd7\x0a\xb7\xb6\x51\xfd\x61\x05\x0f\xab\xad\xfb\x95\x5b\x3f\x97\x2f\xde\x2f\x5f\xfa\x02\x16\x2f\xeb\x2b\xbc\xf0\x2b\xf3\x1b\xb0\x84\xe1\x2c\x77\x6e\xd9\x70\xc7\xac\x6c\xaf\xb2\x88\x83\x05\xdb\xe2\xb5\x53\xbb\xf5\xf8\x60\x61\xd2\x03\x74\x47\x13\x87\xfb\xf4\xea\xb9\x9d\xad\xa7\x36\x95\xfc\x35\x7f\xe7\x9a\x4b\x2e\xad\x91\x01\x69\xd3\xf9\xbe\xb2\x75\x1b\x31\xd0\xaf\x70\x63\xaa\xdc\x5a\x77\xfe\x8c\x1f\x6f\xc8\x12\xa9\x25\x1d\x91\xdc\xdb\xdc\x79\x71\x01\x2e\x71\xaf\x6a\x8d\xbc\x06\xb9\x72\x50\x30\xc0\xe6\xd6\x88\x9e\xcb\x38\xbc\x72\x8e\x3c\x21\x09\x87\xbb\x8f\x0d\x0c\x76\x1c\xeb\xec\xfa\xbf\x58\xe2\x24\x67\x50\xb3\x92\x28\xaf\x15\x26\x74\xd3\xc4\x73\x10\x17\xcc\xd0\xbe\x82\xa6\x66\x52\x46\x2e\x3b\x0d\xea\xec\x6b\x16\x2a\xb4\x29\x5e\xd1\xc2\xf9\xc7\x12\x37\x4d\xad\x8f\x08\x31\xd4\xc8\xf2\x78\x03\xe4\x49\x1a\xdd\x2f\xae\xf4\x15\x7c\x50\xfa\x7a\x3a\x8e\xfd\x03\x49\x95\xd6\x0b\x95\x66\xf9\xf4\xdf\x6a\x4e\xac\x44\xda\xeb\xa5\xf7\x66\xcb\xa5\xe6\xf9\xd1\xa4\x7c\x7a\xd5\x4a\x52\x1f\xee\x2f\x73\xdc\x28\x65\x33\xb4\x0d\x95\x3f\xeb\x79\xda\x6a\x6d\xae\x71\xcd\xfb\x25\x5e\x3a\x95\xac\x91\x56\xb3\x4a\x46\x2f\xc0\x1e\x01\xb4\xed\x4a\x9f\x61\xea\x24\x14\x74\x13\x7e\xce\xd3\x5f\x93\x1a\xd9\x27\xc7\xb4\x42\x1b\x7a\x74\x4c\x90\x34\xba\x01\xb7\xdc\xe9\x36\xb2\x64\xc0\x93\xa6\x41\x4e\xd4\xd1\x82\x31\x01\x20\xa7\x34\xb8\x2b\x03\xb6\x71\x7d\x6c\x5c\x93\x7b\x94\x6d\x9a\xe1\xee\x59\x5d\xc3\x69\x25\xe2\xec\x75\x70\xca\xfd\x03\x77\x09\x1a\xec\x60\x86\xcb\xcb\xdf\x5b\xcb\x4f\x2a\xb7\x56\xad\xed\x2b\xb0\x56\x1c\x6a\x1d\x18\xe5\xc7\xdf\x94\xaf\xfc\x4c\xfb\x61\x41\x18\xf8\xd8\x1d\xfa\xfc\xba\x35\x3b\x57\xd9\x7c\x08\xdf\x5b\x1b\x4f\xcb\x0b\xf3\x3b\x5b\x17\x77\xb6\x2f\x5a\x73\x4f\x76\xbf\xbb\x8e\xcb\x71\x65\x13\xee\xbe\xe5\x8b\x5f\x44\x39\x20\x91\x64\x34\x33\x4c\x94\xb2\x45\x1d\x65\x0d\x5c\xd6\x1d\xb3\xd5\x84\x9a\xd3\x47\x61\xbc\xf2\x08\x14\xf8\x8a\x6d\xae\xe5\xf5\x59\x6b\xf1\x4a\xf9\xe2\xa3\xdd\x99\x53\xd6\xbd\x9b\xe8\x11\xf4\x5c\xc0\x69\xe9\x4a\x09\x20\x31\xcc\xa2\x3e\xc3\x42\xb5\x01\x6d\xae\xbb\x68\x2f\x15\x0e\x1c\x50\xd0\xfd\x8d\xe3\x29\x14\xd4\x69\x1e\x90\x47\x7a\xe2\xb9\x60\xe2\xd1\xc2\x0e\xd5\x11\x76\x95\x6b\x4a\xa1\x94\xd5\xa2\x6c\x14\x42\x6e\x35\xa5\x57\x58\xab\x9f\xf1\xe4\x72\xa8\xc1\xce\xfa\x0c\x70\x0b\x45\xc6\xd6\x19\x9c\xca\xd9\xa7\x20\x5c\x84\x5d\x8f\xa6\x9b\x3d\xaa\xd5\x87\x67\xac\xb9\x1b\x01\xf1\x1a\x35\xad\xcd\x72\x95\x21\xd0\x39\xe8\x61\x2c\x8d\xa0\x29\xe6\x32\x5c\x7a\xfc\x7d\xd5\xd4\x94\x5e\xa1\x6d\x98\xac\xe8\xa3\x6f\x01\x77\x1e\xee\x43\x54\x7d\xe8\x4d\xf3\x4f\x25\xb5\xa0\x29\x23\x05\x35\x7d\x12\xb7\x2b\xfe\xe8\x8d\x0b\x19\xd7\x81\x3c\xa1\xb6\xe0\x83\x05\xed\x4f\x25\x90\x00\x64\x83\x2e\x8a\x51\x00\x62\x21\xf3\x4e\xd0\x59\xfa\x47\x13\x76\x19\x0d\x4f\x18\x1c\x59\xde\x7d\x24\xa4\x93\x2b\xdb\x40\x31\x2b\x18\x45\x23\x6d\x64\x59\x2b\x2b\xa6\xf3\x78\x8c\xb8\x3f\xc3\x30\x8b\x7a\x8e\x96\x09\x3f\xf1\xee\x3b\xed\xef\xfd\xe6\x37\xed\xef\xb6\xbf\xfb\xbf\xfc\x4f\xe6\x41\xaa\x08\xdd\xee\xd7\xbf\x7e\xe7\x5f\x84\x5a\x67\x4b\xc2\xdf\xef\xd9\xba\x83\xc5\xc6\x4f\xf2\xc2\xe3\x65\xd8\x8a\xd5\x07\xe7\xbe\x03\x1b\x5f\x7c\x72\x96\x60\xb3\x8b\x46\x3c\x7b\x67\x13\x65\x1c\xbd\xc1\xa2\x6a\x67\xfd\xb2\x75\xe9\x5b\x3c\x79\xae\x6e\x94\x2f\x7c\x8f\x26\xbe\x2f\x16\x9c\x88\x1b\xeb\xf1\x12\x3f\x5c\xbe\xbe\x66\xbd\x9c\xdd\x5d\x9e\x81\x2f\x69\xef\x78\x0e\x2c\x87\x12\xc1\x00\xdf\xbd\xfe\xb5\x4e\xa1\x6c\x3b\x9e\xc0\xf0\x0d\xd0\x6a\x8d\x29\xb2\x90\xa2\xb7\x40\xb5\x43\x1f\xec\xf3\x9c\xbf\x94\x45\x31\x38\xb2\xf6\x6f\x33\xcb\xfe\x37\xd0\xc9\x4c\xa1\x19\xd6\xec\xa9\xea\xea\x3a\xab\x22\xbb\x5f\xdf\x96\x12\xf3\x51\x4a\x57\x8e\x1d\x3f\xea\x28\x07\x03\x68\xc3\x3e\xa9\x1c\xea\x1e\xf8\x2d\x7e\x9a\x50\x8e\x76\x1d\xed\xed\xff\x90\x2c\xdb\xe3\x86\x59\x24\x1b\xff\x07\xbd\x03\x83\xf8\x4d\x5e\xb1\xad\xde\xa6\x02\xaf\x77\xd2\x2b\x45\x65\xb0\xfb\x68\x57\xef\x71\x7a\xa2\xa4\x7c\xd0\xd5\xd1\x03\xba\x46\xe7\x07\x5d\x9d\xbf\x1d\x1e\xfc\xb0\x8f\x7d\x90\x05\x8c\xca\x49\x91\x9c\xe9\x87\x47\xbb\x62\xec\xd9\xaf\x89\x50\xe9\x49\xa5\x66\x50\x94\xc2\xac\x49\x67\xc8\x7a\xf6\x63\xf9\xd9\x96\x75\xfe\x2e\x6c\x4d\x09\x90\x8c\xa1\x71\x18\x92\xf6\x31\x1a\xe0\xd1\x57\x02\xe2\x2a\x6f\xc8\x40\xee\xac\x2f\x0a\xf7\xc6\xe3\xeb\xd6\xe9\x47\xd6\xe6\x97\xf8\x61\xf9\x91\x04\x3c\x5a\xde\x65\xa0\x78\x43\x4b\x5e\x44\xed\x28\x8b\x17\xce\x69\x3b\x82\x2c\x62\x90\x1c\xf0\x95\x04\x92\x81\x11\x56\x51\x90\x4e\x2d\x97\x1f\x7f\x2d\x87\xa4\x4d\xe4\x8b\xd3\x72\xde\x6c\x56\xfe\x22\x63\xb4\x88\xf6\xb2\x2f\x7f\xa0\x2f\xb6\x29\x20\xe5\xf1\xc8\xf1\xb9\x68\xdb\x14\xad\x7d\xac\x5d\x19\x2f\x16\xf3\x07\x0f\x1c\x98\x36\x4a\x85\x61\x9c\x0f\x74\x3f\x45\xcc\x09\x08\x27\x57\x12\x81\x2a\xc7\xae\x46\x16\xd3\xc1\x1f\x30\x56\xf0\xc1\xe9\x70\x0c\xd1\xb4\x4f\xaa\x7a\x96\xc4\x05\x9c\x63\xf8\x4a\xc4\xca\x5b\x7e\xe4\x2c\x10\xbc\x74\xad\x2f\x62\x34\xc9\xe5\x88\x39\x42\x04\x05\xcd\xcc\x1b\xb9\x0c\x1c\xd0\xa0\x27\x33\x6f\x26\xd4\x93\x70\xde\x96\xe0\x10\xd5\x8b\xac\x32\x33\xff\xf2\xd9\xd2\x98\xa0\x42\xaa\x1f\x95\x97\xbf\xb5\xbe\x5c\x84\x33\x86\x8e\x9c\x67\x95\x95\xd5\x9d\x97\xb7\x41\xdd\xf1\x32\x0b\x6e\x81\x78\x0e\xd9\xb4\xca\x35\x18\xa4\x6f\x14\xfd\x47\x52\x6c\xf3\x2f\x70\x98\x73\x4f\x24\x00\x0a\x70\xef\x98\x74\x74\x78\xe1\xed\x42\xfa\x41\xc3\x06\x65\x5f\x33\x23\x96\x25\xa8\xd2\xee\x7e\x23\x27\x13\x30\x75\xf7\xc6\x3d\xeb\xe2\x96\x24\x4c\x69\x5f\x1f\x31\x08\x8e\x06\x5b\x11\x71\x06\x60\x6b\x21\x82\xdb\x40\x52\x46\x2d\xaa\x32\x2e\xe2\x4c\x12\x13\x91\x59\x70\x63\x5c\x5c\x05\xd4\xce\x58\x41\xf6\x0b\x44\x18\x30\x14\xad\x04\xee\x77\xf7\x40\x41\x1b\xd3\xf1\xee\x46\x41\xb4\x14\x8d\xd5\xae\x0c\x68\x1c\x52\x35\xae\x65\xf3\xb2\x75\xb5\xdf\x5e\xeb\x3f\x3d\xb2\xce\x2e\xe0\xe9\x4c\x01\x9f\x3c\xbf\x70\xa5\xdd\xbd\x3e\xcb\xb1\x4d\x08\x04\x28\x0a\x27\xe4\x6d\x47\x20\x90\xd0\x93\x2a\xd8\x6f\x93\x44\x20\xf1\x26\x1d\xd4\xaf\x7e\xd5\x81\xce\x48\x7c\xe5\xa0\x22\x58\x41\x3a\x1f\xa8\x99\x2a\xce\xaa\xe3\xae\x1c\x99\x86\xdb\x1e\x3d\x4a\xc6\x24\xb8\x9c\x16\xf0\xfe\x9a\xa1\x48\x1e\xa3\x00\x9a\x68\x37\x86\x0d\x67\xb3\xa4\x4e\xa2\x0b\x3f\x6f\x83\x2b\x2a\xb8\x4b\x15\x63\x0a\x16\xbc\x6e\x9e\x6c\xff\xd5\xaf\x50\xfb\x38\x64\xe0\xd7\xca\x94\x9a\xa3\xcb\xa0\x2e\xde\x26\xcb\x11\xef\x8e\x4f\x3e\x69\x67\x92\x3e\xfd\xf4\x5f\x95\xb7\xa6\x51\xbd\x96\xc6\x76\xfc\xea\x57\xc0\xd4\xf2\x19\xbc\x1b\xf1\x9e\x00\x36\x57\x2e\xff\x00\xdb\xb6\xfa\xd9\x36\xef\xdf\x9d\x97\x78\x1b\x07\xf1\x5f\x9d\x99\xad\x3c\xbf\x6a\x9d\x45\x0d\x6c\x67\x73\xa1\xfa\xf2\x96\x35\xf7\xd4\xb1\x2f\x58\xab\xf3\xd5\x6f\x66\x51\xb1\x22\xaf\xbf\x80\x36\x3f\xc3\xd1\xc9\xa8\x0d\x7c\x73\x71\xf7\xc6\x5f\xe8\xfe\xf8\x43\xf9\xf4\xa3\xea\xb9\x6f\xab\x2b\x0b\xe5\xf9\x97\xe5\x0b\xb3\x42\xb1\xc2\xb0\x56\x82\xc2\x2f\x7b\x07\xa2\x58\x4b\xd7\x7e\x79\x7e\xe7\x97\xe7\x73\xd3\x78\x5f\x55\x72\xd2\x20\x92\x0e\x27\xd0\x18\xed\x86\xc0\x22\x23\xcb\x7c\xe2\x48\x20\x56\x76\x3a\xb3\x46\x29\xa3\x1c\xc6\x7d\x51\x90\x09\x76\x3e\xa8\x76\xd6\x2f\xfa\x9f\x56\x60\xdc\x40\x38\x87\xf7\x38\x6b\x11\xbe\xb1\x9e\xe1\x5d\x4a\x42\xd4\xa1\x43\x07\xfa\x41\x49\x38\x81\x76\x91\xe3\x47\xba\x8f\x49\x70\xf2\xb9\x7d\x80\xf7\x38\x73\x21\x21\x40\xa5\xbf\xab\xaf\x77\xa0\x7b\x10\xf4\x90\xe4\xb0\x1d\xe9\x22\x43\x72\x02\xd5\x9d\x43\x12\x80\x78\xc1\xdf\x7c\x28\x79\xb5\xa7\xbb\x63\x40\x26\x5b\xe6\xbe\xb3\x96\x16\x25\xef\xf5\x75\x3b\x11\xd9\x92\xd7\xdd\xd0\xeb\x78\x10\xca\x5b\xce\xb1\x6a\xc2\xa9\xa7\xe6\xf5\x76\x4f\x60\x87\x6c\x53\xb8\x18\x60\xbd\xf1\xb9\x09\xcb\x56\x02\x44\xbe\x10\x3d\x74\x1c\x4c\x80\xe9\x66\x02\x30\x1c\x06\xaf\x77\x89\xbf\x3f\x95\x19\x46\x7d\x70\x6b\xde\x69\x00\x8f\xf2\x16\xfe\x3e\xa9\x15\x4c\x12\x79\xfc\xf3\x09\xfe\xf3\xd3\x4f\x93\x30\xb2\x86\x0c\xe0\x2d\xfd\x3e\x3f\x07\x37\x33\xe7\x77\x07\x66\x32\xbe\x22\x25\x75\x73\x23\x9e\x15\x7d\xd2\xb5\xeb\xb1\x27\x49\x5e\x4e\xa7\x31\x98\x97\x22\xb0\xdc\x60\xf8\x3c\x28\xb3\x7a\xba\x94\x55\x0b\xca\x48\xc1\x38\xa9\xc9\x42\x7c\xe1\x30\x15\x26\xdd\xad\x6f\x2a\x4b\x67\x9d\xc8\x11\x27\xb2\xbd\xba\xfa\x72\xf7\xda\x6a\xf9\xf6\x67\xb1\xd8\x6d\x83\x2c\xdd\x46\x82\x44\xd8\x3f\x1a\xa3\xa3\x1a\x26\x0f\xc5\x91\xc3\xe6\x65\x90\xe5\xd6\x97\xa7\x50\x25\xe0\x0c\x94\xa5\xc5\xca\xc3\x27\x49\x88\x42\x43\x08\x1a\x60\x44\x66\x14\xa0\x4f\x97\xd0\xd2\xa9\x50\xf2\x8e\x49\xd7\x19\x98\x18\x3b\x92\xeb\x53\x69\x36\x51\xf9\xf1\x37\x70\x2e\xef\x6c\xdd\xe7\xa0\x6e\xf7\x05\x38\xf6\xab\x9b\xdf\xed\x6c\x6d\x73\xe0\x61\xf5\xe5\x12\x8a\xe4\xd5\x79\x6b\xf6\x51\x65\xeb\x4c\x1c\x5d\x22\xc1\x28\x40\x17\x92\xe5\x43\x12\x47\x94\xff\x69\xc5\x4b\x10\x9c\x9c\xd5\xb5\xcf\xcb\xf3\x5f\xa2\x59\x23\x86\xac\x0c\x68\x07\x14\xe4\xee\x51\x77\x49\x5d\x94\x1d\x55\x2c\xda\x39\x98\x3d\x99\x64\x27\x14\x68\xbd\x2e\xd8\x39\x2a\x68\x90\xcb\xe7\x65\xeb\x60\xe9\x73\xef\xca\x67\x7c\x64\x3c\x66\xeb\x8e\x14\x0b\x4d\x3a\xa1\x00\xd6\xc0\xf3\xc0\x15\xc4\x15\x4c\x19\x82\x41\x1a\x85\x31\xfc\xae\xb7\x30\x26\xbe\x3b\xc0\x01\x8b\xf8\xe5\x00\x7e\x10\x5f\xf3\x9c\x1c\x77\xb8\xdc\xde\x2e\x53\xe4\x7c\xd3\x72\x3c\x38\x2d\x30\x24\x8e\xf8\xf7\x61\x3d\xc0\xb9\x09\x41\xa4\xe8\x69\x81\x4d\x28\x4d\x48\x62\x86\x30\x2f\x9c\x91\x22\x65\xe1\x7c\xc9\xea\x30\x0a\x7f\x1e\x94\xad\x9e\x8b\x29\x1f\xd1\x90\x73\x42\xb9\xe3\xac\x21\x58\x12\x6c\x22\xed\x3c\x6c\xab\x38\x07\x54\x84\xd4\xae\x28\xfd\x1a\xed\x72\x04\x10\x00\x6b\x2b\x43\x31\xe0\x91\xff\x19\xad\x80\x93\x03\xa0\xe8\xb2\xc7\x16\x54\x7c\x80\xdd\x99\x42\x3f\x95\x71\xdb\x51\xde\x9c\x35\x28\x98\x46\xa7\x7d\x6d\x0e\x06\x5d\xc7\xbe\x2f\x2f\x6f\xe2\x78\x58\x89\x3a\xc0\xcf\xa2\x32\x09\x77\x0a\x09\xbc\x90\x6c\x0e\x7a\x79\xf7\xdc\x22\x7c\x80\xd7\xf1\xae\xbb\x75\x7f\xe7\xc5\x4b\xd0\x60\xad\x7b\x77\x02\x7a\x29\x1a\x0a\x09\x9a\x54\xb7\x0f\x9f\x1d\xe4\xbf\x8f\xeb\x14\x59\xcc\xdc\xdc\xef\x28\xaa\xbc\x1c\xf6\xc3\x8c\x7c\x08\x3a\x7a\x9a\x0c\xd6\xc5\x02\xaa\xfd\x82\x95\xc8\x76\xd9\x5b\xc4\x61\x98\xa4\x9c\x47\xa9\x07\xbc\xe2\x71\xef\x14\xe9\xb9\x49\x38\x43\x22\xa6\x1b\x08\xf8\xc0\x98\xd2\x26\xd1\xb5\x84\xb7\x05\x61\x3b\x1f\xd5\x0b\x70\x01\x1d\x2d\xf1\x4d\x04\x80\x61\xc2\x22\xe1\x54\xf4\x89\x3c\x6a\xc7\x70\x4e\xf8\x68\xc5\x9f\xe8\xba\x84\x7f\xd4\x52\xcc\xb4\x49\x2f\x91\x11\x53\x4f\x73\xc0\x3f\x79\x41\xc2\xaf\x62\xd9\x04\x56\x04\xdc\x18\xe0\x2e\x62\x3d\xb9\x5d\x5d\xbb\x62\x2d\xae\x57\xb7\xb7\x23\x40\xe0\x25\xe3\xcc\x53\x6b\xe9\xa2\xb8\x4e\x3c\xbe\xc7\x0f\xbb\x4b\xe3\xc9\x67\xe1\x89\x41\xf6\xc5\x72\x67\xfb\x2c\x50\x89\x96\x62\xb2\x55\xef\x3e\xb8\x6a\xcd\xce\x59\xab\x0b\x20\xb7\x77\x36\xcf\x56\x1f\x7e\xc3\x34\x54\x2e\x3e\x29\x2f\xcf\x87\xd2\x20\xd6\xec\xf3\x9b\xce\x05\xc8\xda\xfe\x01\xee\xd4\x11\xeb\xce\x93\x3e\x47\xfe\x06\x71\x46\xe3\xbd\xd2\xbe\xba\xaa\x74\xbe\xeb\x4e\x78\x2b\xbc\x03\x82\x53\x66\x44\x70\x9c\xc2\x70\x0f\xc3\x7c\x52\x52\x22\x76\x61\x5b\x3c\xfb\xb1\xb2\x75\x09\xef\x76\x2f\x6e\xf1\x4f\x2c\x0a\xf9\x6a\xc3\xa7\x79\xeb\x88\xa4\x55\x2c\xcf\xd7\x4a\x44\xe4\xe3\x7b\x2d\xa5\x10\x6e\xe9\xcd\x33\x12\x84\x14\xba\x26\x3c\xfc\x63\x92\xf9\xda\xdc\x7a\x1a\x1b\xe1\xa3\xa0\xd1\x66\x5f\x1d\x04\x1a\x53\xca\xc0\xc0\x07\x62\x2e\x05\x7e\x2d\x32\x2d\x90\xed\xfe\xa8\x32\xd2\x19\xca\x53\x45\x40\xa2\x51\x99\x86\x92\xd1\xb2\x5a\x51\xa3\x68\x6d\x91\x0e\x4b\x4a\x83\x6c\x3a\xac\xa5\x85\xf2\xb5\xa7\xd6\xdc\x5d\xb8\xcc\xf2\x68\x03\x89\xb0\x12\x54\xac\x65\x4c\x94\x40\x08\x8e\x68\x22\x9b\x50\x43\xb7\x3e\x0c\xcf\xfe\x5b\xe4\x74\x47\x8d\xf3\xe5\xec\xee\xca\x16\xba\xbd\x29\x87\xd0\x9b\x3d\x08\x22\x07\x63\xc2\xe7\x17\xe1\xec\xf1\xfd\x1a\x91\xf1\x88\xf9\xd3\x8d\xdf\x36\xe0\x65\x3a\xfa\x75\x36\xe1\x0b\x8f\xe3\xa8\xae\x65\x65\x26\x4b\x5f\x7a\x37\x69\xf0\xec\xe3\xb2\x56\xbe\xb3\x1e\x5f\x2b\xaf\xfe\x55\x8e\xc9\xa7\xf3\xf8\x7d\x08\xd2\x33\x40\xaa\x33\xe1\x2a\x8c\xb6\xb2\xd5\xa0\xa4\x41\x4e\x19\x85\x93\x14\x32\x71\x52\xcf\xe7\x5d\xfd\x92\xc2\x50\x10\x69\xbd\x74\xc0\xe8\xd9\xff\x68\x3d\xbb\xbf\xb3\xbd\x6c\xc7\x0a\x2c\x58\x4f\xce\x56\x9f\xfd\x54\x7d\x79\x4e\x78\x3b\x29\xf5\xbe\x0e\x42\xc5\x36\xe6\xec\x03\x38\xb4\x51\xa5\xe4\x6d\xce\x0f\xd5\xcf\x31\xda\xbd\x94\x56\x30\xf7\xa4\x06\x5c\x14\x17\xe1\xba\x4c\x39\x9f\xb8\x3e\x30\x88\x24\xa3\xab\x63\x39\x03\x0e\xf5\xb4\xc9\xbe\xf6\xac\x31\x46\x5e\x68\x19\x49\x4f\xce\xd2\xfb\xe8\x5c\xf8\xe1\x74\x75\xed\x7c\xf9\xea\xe3\xdd\x1b\x67\x40\xe5\x05\x4a\xca\xd7\xee\x5b\x2f\xaf\xb1\x1d\x50\x4a\x81\x9d\x7a\xa1\x8c\x6b\x6a\x16\xa3\x00\xc6\xb5\xf4\x49\xa5\x38\x9d\xd7\x84\x89\x66\x3f\xba\x34\x39\x6b\x36\x67\xe4\xb4\xfd\x32\x93\x82\x97\x3b\x7c\xc9\xab\x9c\x7f\x6a\x9d\xfd\x6b\xf9\x9b\x19\xf4\x3e\xfe\xb0\x65\x7d\x75\xc1\x6b\xb5\x11\x70\xd1\x66\xc8\x80\xe5\x76\x05\x0f\x95\x4e\x29\x07\x1d\xb4\xa4\x8f\x93\x6c\x24\x2a\xc6\x50\xf9\xf9\x6b\xeb\xf9\x15\x29\x78\x53\x66\x06\x0a\x44\xa9\x48\x00\x70\xb6\xba\xca\xee\x56\x71\x65\x93\x1f\x07\xe8\x96\x62\x99\x44\xb9\xe1\x51\xbe\x58\x07\x32\x5f\xb8\x18\x7e\x46\x1b\xd5\x73\x1c\x05\x44\x4b\x24\x4a\x22\xb2\x0b\x0c\x24\x1c\xe3\xe2\xcf\x8c\x11\x4d\x19\x1b\x32\x8e\xfb\xf1\x62\x2e\x3b\xe3\xc2\x3b\x74\x04\x2a\x4e\xbd\xf2\xa0\x8a\x4a\x7c\xb7\x91\xb0\xec\x6f\x08\x07\x6b\x1e\xb1\x38\x40\xee\x9e\xc0\x58\x3e\xa9\x36\x4c\xc0\x40\x0f\x9c\x79\x1e\x05\x86\x45\x5a\x96\x2e\xbe\xfd\xf0\x2f\x5f\x99\x91\x5c\xa5\xa6\x10\x80\x7b\x6f\xe6\xd4\x7b\xb8\xc7\xc2\xb7\xb1\x57\x62\x7b\x69\x04\x5f\x64\xd5\x9b\xc7\x5e\x8b\xcc\x5b\x64\xc0\x25\x4e\x7e\xcb\x4d\x30\x1a\x46\x1e\x39\x18\x8f\x19\x80\xbf\xa6\x7b\xb9\x63\x08\xf0\x91\x98\xd0\x16\xe0\x1f\x16\x9b\x03\x64\x3c\xf1\x18\x04\xfc\xe8\x83\xbc\xf2\x0d\xe5\xf5\xb0\xea\xd5\x70\x64\x8f\x46\x1e\x30\xbd\xc1\xab\xf6\x37\xc3\xf4\x0d\x73\xc3\x59\x0b\xa6\x98\x06\x97\x13\xf0\x8f\x9a\xd3\xff\x4c\x03\x74\x98\x51\xaa\xd7\x4e\x54\x63\xbe\xf3\xb1\x21\x80\x43\x70\xc2\x59\x21\x36\x51\xcc\x04\xc7\xcc\x17\x36\x98\x24\x1c\xf1\x48\x63\x80\xf0\x6f\xf8\x41\x68\x02\x5e\x4e\xec\x85\x71\xcc\x11\xe8\x41\x04\xb5\x02\x3e\x40\x9a\x7c\x5c\xc5\x22\x86\x51\x90\x51\x01\x14\x7e\x63\x2a\x97\x35\xd4\x0c\x3b\x4c\xa7\x39\x04\x8e\x7c\xe4\xe4\xa8\xcb\x69\x45\x0c\x74\xc1\xb2\x18\x71\x43\x60\x93\x00\xba\xca\x6f\xdd\xad\xcc\x6f\x54\xb6\x3f\xb7\x96\x9f\x58\xb7\x41\xa1\xbb\x00\x17\xf4\x80\x9f\x32\x21\x75\x13\xfa\x58\x41\x65\x9b\xa5\xd0\xb1\xba\x85\x42\x70\xc8\x2d\x7d\x13\xcf\x5d\x26\xad\xfa\xf2\x54\xe5\xe1\x56\x12\x58\x52\xca\x84\xa3\x99\x82\x29\xe1\xda\x48\x46\x9f\x3e\xf8\xc0\x2c\xff\x03\xde\x22\xed\x1b\xe4\x1f\x82\x7a\xe1\x1f\x6c\xff\xfb\x68\x41\xb3\xe3\x29\x1d\xf5\xe6\x0f\xb5\x54\xd9\x6f\x79\x8a\x58\xa9\xa2\xe6\x95\xd2\x89\xb9\x0f\x69\xe1\x97\x56\x33\x13\xa0\x20\x98\x30\xf2\x22\x68\x6d\xfa\x28\x19\x9a\xe0\x8e\x9a\x3b\xc9\x37\x55\xaa\x43\xc6\xf5\x4c\xa4\x6c\x72\x7c\xcf\x74\x77\x65\x3b\x8a\x8f\xfa\xbf\xcd\xdc\x76\xbc\x1f\xb6\x99\x45\xf5\xda\x8a\x30\x2e\xc0\x02\x81\xf3\xf3\x06\x07\xe8\xb1\x22\xe6\x83\xe4\x1f\x19\x5a\x79\x9c\x9a\x59\x4e\x5d\x2d\xca\xe0\x47\xaf\xf4\xea\x3d\x58\xfb\xd5\x97\x37\x00\x2c\xd7\x3d\xe1\x98\x1a\x8c\x0a\xfc\x69\xab\xb2\xba\x52\x59\x3a\x6b\x7d\x7e\x5d\xae\x6c\x97\xd0\x80\x57\x44\x3d\x52\x63\xd1\x0d\x4a\x67\xca\x57\x86\x42\xa6\x74\x6c\xdd\xdf\xbd\xfd\x95\xb7\x6a\x04\xd0\x52\x5d\x3b\xc5\x72\x36\x16\x1b\x46\xcf\xc4\x2c\x47\x86\x27\x5f\x68\x1e\x60\xa8\xa8\x83\x2c\xd1\x3e\xce\xe3\x75\x12\xeb\xc8\x71\x5c\x0e\xde\x13\x46\x54\xd0\xdc\x75\xd2\x0a\x0b\x5a\x4a\xf5\x0c\xb8\xdd\xae\x15\x48\xe5\x7b\xfe\xe0\x2d\x4d\x33\x54\x7a\xe7\x9d\x5f\xa7\x6d\xb7\x1d\xfd\xa5\x61\xae\x3d\x7f\x8f\x8c\xb2\xbf\x33\xc4\x77\x20\x6a\xed\xaf\x4c\xf1\x15\x89\x3c\xfe\xf2\x0f\xa2\x6a\x85\x43\x0d\xda\x31\x83\xe4\xc8\x2c\xd5\xc4\x07\x0c\xf2\x80\xcb\xcb\xf2\x1d\x0e\x23\xd9\x3d\xb7\x88\xfe\x13\x2a\x53\x81\x53\x41\x7f\xf2\x93\x22\x3a\x21\xba\xf6\x4e\xab\x07\xc8\x95\x78\xbc\x54\x59\x1b\x4f\x03\x54\xc9\xe7\xd1\x28\x88\x43\x8a\xe4\x02\xac\xc2\x8c\x9e\x11\xb1\x56\x9c\x94\xc0\x61\x10\x06\x06\x48\x60\x2d\x90\xb4\x91\x91\xa9\xad\xe5\x8b\x73\xe5\xdb\x9f\x09\x87\xdf\x8d\x47\xe5\xe5\x6f\x45\x7d\x0b\xbb\xb4\x07\x7a\x2a\xef\x9e\x62\x6b\x0f\x1a\xe1\xe1\x7a\xba\xf4\x79\x38\x69\xef\x77\xf7\xf4\x74\x1f\x3b\x82\xa5\x04\x3a\x8e\x74\xf5\x4b\xe7\xe7\x89\xb5\xbe\xe4\xec\x35\x09\x28\xbb\x52\x82\xcc\x53\xeb\x3c\x20\x79\x5f\xc7\xe8\xed\xa0\xd6\x11\x7b\xd3\xc1\x2c\x7f\xfb\x58\x77\xee\xe2\x51\xd6\x1d\x29\x1e\xb4\xa6\xd9\xf1\x60\x41\x77\xa8\x28\x19\x87\xf5\x4b\xd0\xf0\x66\x7b\x4d\xbd\x25\x0c\xea\xa1\xaf\xfa\xe0\x94\xc8\xd9\x60\xaf\xa8\xbf\x28\x81\xfb\x3c\x3a\x6b\x30\xca\x6c\xef\x46\x62\xfb\x59\x9b\x1e\x89\xcf\x9d\xda\xe4\x78\x02\xd5\x1b\x69\x0d\x90\x4d\xa9\xae\x0a\x17\x51\xe0\x22\x5d\xab\x4f\xce\x7a\xeb\x39\x3a\x43\x8d\xb7\xfd\x11\xc6\x34\x22\x41\x1f\x5e\xdd\xc4\xe2\x3c\x8c\x68\xc5\x29\x4d\xa3\x90\x31\xff\x29\x49\xf2\xd4\x6f\xee\x13\x12\x84\xac\x7d\x12\x64\xb5\x60\x30\x7c\xca\x6f\xf5\xdb\xb8\x00\x7b\x85\x72\x05\x70\xa0\x8e\x11\x30\x9a\xce\x09\x75\x1a\x46\x8a\xd1\x71\xc2\x84\xc5\x16\xe9\x5a\xcf\x32\x66\x96\x64\x39\xc4\x70\x64\xba\x76\x32\x64\x4a\x41\xbb\x12\x08\xab\xcb\x17\x8c\xb4\xa6\x65\xfe\x55\x26\x5c\x5e\x37\x5d\xca\x5b\xd3\x07\x72\x6f\x47\x33\xad\x96\x8a\xc4\x78\xeb\x77\xc8\x27\xbc\x75\x46\x53\x9c\xec\x0e\x98\xd1\x46\xd5\x52\xd6\x66\xb5\x2d\x1b\x5b\x11\xaa\xe1\x95\x39\xa1\xd8\x5d\x91\xef\x91\xa7\xb8\x98\x9f\x6f\x56\x96\x4f\xed\xae\x48\x42\xd2\xea\x1b\x9f\x23\x24\x5f\xf1\x90\x3c\x22\x35\x6e\x18\xbc\x8c\xa4\xab\xa7\x25\x21\x1e\xad\xb2\x63\x38\x02\x56\x4e\xaf\xcb\x83\x56\x45\x84\x48\xb5\x6c\x39\x0f\x5b\xc9\xbb\x16\x84\xc7\x84\x70\xed\xf5\x71\xcb\x2b\xc4\x82\x2f\x46\xdf\xc0\xcf\xba\xef\xfa\x7c\x27\x09\x70\x97\xf4\x6c\x26\x8f\xd7\x0b\x78\xdc\xf9\xc3\x66\xb3\x2f\x94\x5c\x76\x4a\x44\x41\x70\x82\xcc\x1b\xc0\x9e\xcc\xf5\x16\x09\x22\xde\xfb\xf6\xfe\x74\x11\xad\x4f\x70\xf0\xa0\xc4\xb2\x9d\xa6\x6a\xce\x4e\x5a\xb6\xf3\x73\x4b\x39\x9d\x54\xbf\x09\xb8\x21\x96\x0a\x1a\xd5\xe0\xca\xea\x27\x35\xe5\x68\x9b\x72\xf4\xfd\x36\xe5\x08\xe5\x44\x1f\x79\x5f\xa6\xff\x3c\xbe\x56\x3d\x8f\x59\xe9\xbb\xe7\x2e\xb1\x67\x15\x6f\xf4\xeb\x0f\xaa\xab\x2b\xf8\xcd\xe2\x95\x9d\xed\x45\xaf\x43\xe7\xe8\xdf\x67\x4e\x1d\x7d\x1f\xfe\x73\x84\x9c\x3a\x47\xde\xff\xe5\xf9\x3c\x25\x29\x60\x76\x72\xf8\x48\x9c\xe2\x99\x99\x4c\x8a\x23\x56\x52\x94\xc7\x82\x21\xd3\xfc\x0b\x2c\x10\xbc\xe2\x75\xfd\x7b\xc7\xd1\xbe\x9e\x2e\xce\xc1\xc4\x5a\xa9\x81\x17\xfa\x0a\xfa\x24\x5c\x2c\xfb\xf1\xb3\x48\xa4\x99\x98\xce\xf3\x97\x76\x32\xcd\x01\xfc\x70\xa0\xae\xe3\xcf\xa1\x0f\xbd\xee\xa2\xb0\xaf\x69\x8e\x2b\x54\x37\x93\x7e\x6a\x0c\x5c\x5e\x57\x3e\x82\x91\xc9\x32\x3a\xe3\xde\xce\x3b\x75\x46\x1a\x03\x80\xa5\x4a\x8f\x0f\x74\xf5\xd3\x5f\x7d\x1d\x03\x03\xbf\xeb\xed\x3f\x84\x6c\x6e\x08\x1c\x15\x40\xe1\xdc\x3d\x5b\x76\x72\x31\xbc\xda\x22\x03\x1f\xa5\x46\x6b\x73\xf1\xdc\x82\x7a\x7d\x1d\xfd\xf0\x79\xb0\xab\x7f\x60\xb8\x63\x60\x18\x13\x38\x7f\xef\x99\xfc\x81\x83\xb5\x75\x57\xfc\x68\xbd\xa5\x01\x27\xa6\xd1\x50\xc8\x55\xeb\x0a\x8a\x07\xe5\xc4\x34\x30\xb0\x09\x48\x69\x4e\x17\xc6\xfc\xe0\xa6\xa0\x60\xf5\x09\xca\x9d\xa2\x5a\x13\x04\xce\x2d\x35\xd1\x9d\x53\x7e\x07\xf0\x8c\x29\x53\xe9\x33\xa6\xb4\xc2\xc0\x38\x5c\x25\x28\x09\x25\x63\x94\xb0\xb6\x3e\x95\x93\xcc\xb4\x29\x5c\x5b\x93\x4b\x7f\x60\xd2\xe9\x27\x58\xfb\x92\xc1\x0e\x21\xe0\x21\x01\x1a\xfe\xfd\x54\x24\xa3\x7a\x60\x8b\x08\x2b\xa5\x07\x13\x32\x10\x3a\x27\x6e\x4b\xa0\xef\x8f\x02\x2e\x8b\x0b\x4e\xb2\x76\x44\x57\x06\x5b\x03\x12\x8d\x03\x06\xba\x3a\x8f\xf7\x77\x0f\x7e\x38\x7c\xa4\xbf\xf7\x78\x5f\xe3\xe0\x23\xc1\x2a\xbd\xfd\x47\x78\x3b\x37\x83\x20\xae\xf8\x8f\x64\x71\x37\x81\x52\xf4\x5d\xd8\x03\x96\xd9\xc7\x91\xec\xec\x8c\x7e\x9d\xc2\x07\x78\x1b\xd0\xe6\xb6\x45\x01\x6c\x7a\x4a\xec\x15\x29\xbd\xb2\x4d\xed\x7d\x7d\x62\x1a\xf7\xac\x6f\x13\x79\xfe\xf7\x3f\xbd\x3f\xd4\x03\x43\x10\x32\x6a\x18\x00\x83\x7f\xf7\x66\x8d\x1c\x80\x1f\x24\x23\x8f\x19\x63\x0c\x63\xa8\x02\x11\xf2\x41\x35\xa7\x73\x69\xaa\xf4\x0b\x10\xec\x74\x63\x58\x2b\xc3\x47\xbb\x8f\x1d\x1f\xe4\x1c\xe6\x14\xa0\x86\x15\xf5\x56\xb1\x50\xd2\x94\xff\x50\x46\xd5\xac\x89\xff\x22\xe5\x07\x8a\xc6\x01\x94\x40\x6f\xd3\x73\x69\x23\x0b\x67\xb8\xef\x39\xfe\x81\x0a\x9d\x00\x84\x9e\xde\xce\x8e\x9e\x2e\xf8\xad\xb3\xa7\xab\xa3\xff\xed\xc6\xd6\x9c\xa8\x24\x03\x82\x33\x65\x17\xfd\xf0\x96\x47\xcd\x2b\x07\x6c\xca\xd8\x5c\x8a\x0f\x52\x19\x1d\xb2\x98\x3a\xef\xb4\x4f\x4f\x64\xa5\x65\x0c\x12\x51\xe0\xac\x4e\xb7\x20\x2b\x2d\x29\x85\x52\xac\xba\x7b\x69\xa1\x71\x9c\xf4\x7f\xa4\x52\x19\xdd\xc4\x4f\x4d\x61\xcc\x18\x13\x58\x9e\x19\xc5\x84\x98\xe6\x26\x80\xe1\x5d\x01\x20\x35\x03\x82\xbd\x8e\xff\x76\xbc\x77\xb0\x83\x32\xdc\x07\xe1\x43\xcf\xb0\x9b\xe7\xae\x2b\xb6\xd4\xf1\x7c\x59\xe0\x84\xfa\x01\x91\xec\x1e\x10\x4f\xbc\xe2\x58\xc7\xc9\xab\xba\x23\xd0\x52\x14\x09\xd9\x14\xf7\x78\x93\x90\x7c\xf5\x48\x82\xd0\xe3\x3f\x99\x7c\xf0\x82\x9d\x98\x66\x95\x4c\x26\x22\x6a\xfe\x17\x21\x33\x62\xe1\x06\x35\x08\x3f\x5c\xfa\xaa\xbd\x85\xd0\x03\x52\x2a\x00\x3d\x89\x90\x7a\x93\x26\xa0\x29\xc6\xe7\xf6\x84\xe1\xb9\xe4\x8c\x4e\xb2\xd0\xa3\x95\x0c\xbb\xb2\x16\x9e\xfa\xc3\xfd\xc7\x81\xab\x54\x64\xab\x99\x9d\x95\xac\xaa\x97\x44\xf1\xe0\x42\x17\x1d\x47\x06\x9a\xda\xdc\xb6\x98\xc0\xfb\x44\xaa\x68\x9c\xd4\x72\x4a\x4f\xc7\xfb\x5d\x3d\x4a\x5f\x7f\xef\x89\xee\x43\x5d\xfd\x20\x9c\x7e\xdb\xd5\x94\xc0\xb4\x51\x70\x6a\x9e\x33\xbe\xf7\xfb\x01\x70\x7f\xed\x1d\x86\x12\x9f\x60\x25\x8b\x9b\x5a\xda\x00\xe5\xb5\x25\x43\x3c\xa9\x4d\xd7\x32\xd7\xfe\xe2\xb7\x5d\x1f\x46\x5d\x5f\x94\x57\x58\x27\xba\x5e\xb2\xdf\xd8\x02\x8c\x7b\x59\xd1\xb5\x01\x26\x35\x55\x7d\x31\x49\xe9\xce\x1a\x23\x47\x04\xb1\x13\xd3\x99\x11\xf8\x0f\x7e\x14\xf3\xe7\x87\xef\x03\x8f\xf3\x56\x0f\xb8\xff\x3c\x80\x61\xdc\xb4\x81\x0e\x14\x27\xf2\x07\x6c\x8f\xc4\x30\xcf\x20\xdd\x7b\x9b\xda\x51\xe3\x6a\x41\xcb\xd8\x6a\x55\xf3\x2a\x15\x8b\x76\x3e\xe0\xb0\xd3\x89\x68\x71\xf2\x27\xfe\x2a\x45\x8a\x52\x73\x22\x80\x64\x89\x5f\xed\x0a\x55\xb2\xbc\xd5\x86\x5e\x9b\xc2\x45\x91\x2d\x35\x72\xb1\x59\x88\x29\xbb\x52\x5c\xf0\xd8\xf1\x9e\x34\x79\xa5\xb3\xbf\xeb\x50\xd7\xb1\xc1\xee\x8e\x1e\x1a\x61\x56\x19\xf8\x70\xa0\xa7\xf7\xc8\xf0\xa1\x7e\x98\xe4\x61\x34\x78\xb9\xac\xb1\x8b\xed\xd3\xd7\x62\x4b\xf5\xa9\xa6\xe8\x46\x07\x02\x04\x37\x3c\x55\x6f\x83\xe5\xc2\x55\x3a\x5c\x19\x40\x99\x15\xa6\x37\x27\xd2\x8d\xe3\x51\x26\x8c\x8c\x16\xba\x87\x12\x8e\x84\x3a\x69\x10\x15\x6d\x2e\x19\x6d\x2e\xf2\x36\xc6\x3e\xb4\xcf\x47\x75\x08\x95\x94\x3d\x4d\x52\x01\x08\x65\x1a\x3c\x7e\xe8\x9a\xf0\xa3\x26\x69\x46\x39\x00\x7b\xf8\x5d\x57\x68\xbf\x4b\x82\x1c\xbe\x7b\xcf\xfd\xee\x3d\x8f\x24\x1f\x10\x6d\x3a\xd4\x80\xb4\xf4\x0a\x72\xb2\xfc\x34\x47\x58\x50\x76\x46\x89\xb9\x70\xa8\xa0\xc1\x65\x46\x52\x13\x68\xa4\xa2\xc9\xb1\x7d\x69\x6d\x9e\x6e\x27\x8d\x42\x73\x6e\xae\xee\x0c\x9a\xb5\xc6\xbd\x58\x80\x05\xe0\x97\x5b\x72\x3e\xab\x98\xd3\x66\xd6\x18\x3b\x78\xe0\x40\x8c\x8a\x2a\x85\xe8\xb7\x24\xc2\xae\xb1\xab\x5c\xf8\x00\x12\xc8\x1e\x3d\x57\xfa\xf8\xc0\x51\x35\xdd\x30\x4b\x71\xed\xd8\x4c\xa5\xb5\x42\x21\x84\xb4\x7c\x5c\x0e\x1f\xc4\x3f\xb8\xd9\x8a\x67\x11\x85\x99\x12\x1b\x9f\x59\xb2\x30\x3a\x94\xd8\x46\x46\xa6\x66\x08\xe9\x09\x74\xf9\x39\xc8\x5f\x08\xaa\x6c\x23\xa7\x8f\x30\xd7\x7e\xda\x04\x77\x9a\xa5\xaa\x31\xeb\x68\x1a\xeb\x00\x90\x79\x03\x8e\x9c\x49\x14\x9e\xff\x0e\x67\xcc\xe0\x07\xbd\xd4\x73\xe6\x03\xac\x4e\x07\x5a\xb6\xe8\x3f\xd3\x01\xe7\x1c\x1e\x2b\xb0\x6e\xf2\xa5\xa2\x82\xbb\xcd\x96\xab\xef\x4f\xdb\xae\x79\xb7\x98\x20\xc2\xde\x2f\x5a\x52\x69\x85\x51\xa3\x30\x01\xbb\xff\x48\xd7\xa0\xad\x6f\x09\xcd\x0d\x04\x30\x12\xd0\xae\x74\x8f\x52\x59\x2a\x82\x87\xb9\xcf\x76\xe9\xd0\x49\x5d\x55\x52\x19\x2c\xb9\xdb\x87\xa6\x30\xbb\x29\x8c\x80\x49\x19\xec\x66\x11\xd4\x91\x36\x3b\x89\x9a\x62\x55\xb1\x4f\xec\xe0\x74\x9e\x57\x8a\xfd\x8e\xa9\x15\x85\x93\xd5\x0e\x41\x3a\x80\x1b\xb1\x9d\x52\xb6\x31\xa0\xc3\x98\xd4\x0a\x05\x54\x38\xc7\x01\x20\xca\x57\x72\x74\x01\x23\x04\x68\x82\x66\xa7\x52\x81\x08\x1e\x37\x32\xe2\x91\x7f\x6f\x17\xac\x38\x0c\x4a\x22\x26\x4c\x65\x8c\x34\x75\x20\x22\x34\x4e\xe5\xb7\x49\xdd\xd4\x8b\xb6\x03\x49\xcd\xeb\xf0\x94\xd9\x9e\xc6\x22\x43\xa3\x5c\x63\x08\xe3\xcc\xdb\x6b\x6f\xc7\xe9\x51\x9e\xab\xa1\x7d\x07\x26\xdf\x3b\x80\x35\x72\x87\xf6\x01\x52\xe2\x27\xcc\x7f\x2e\xf4\x52\x8c\x84\x0f\xed\xf3\x72\xe3\xa0\x6f\xec\x1f\xa7\xa6\xa6\xa6\x52\xc8\xc5\x14\xc0\xd6\x72\x18\x0a\x88\xed\xa4\x22\x00\x66\x94\xfd\x7f\xfa\xdf\xb8\x48\x0f\xd2\x4d\xd6\xde\xa3\xe1\xe4\x65\x94\xff\x73\xc0\x6b\x50\x6c\x68\x89\x8a\xfc\x50\x8f\x31\x70\x14\x84\x55\x63\x2a\x0c\xc3\x0a\xb5\xf1\xa1\xe3\xa8\x19\x98\x3e\x75\xb3\x69\x68\xc2\x8c\xd7\x02\x38\xf9\x71\x35\xa7\x09\xb7\x91\xd9\x34\x3c\xbf\x92\xda\x1c\x2c\xb6\x9d\x24\x37\x19\x11\x42\xb9\xdd\xc8\x07\x35\xa9\xbd\x2e\xc2\x6e\x24\x85\xe7\xb3\xa4\x91\xf1\xdf\x07\xaf\xd6\xe0\xdf\x28\xd8\xe6\xfd\x08\xf5\x70\x7a\x54\x52\x3a\x36\x00\x2b\xda\x0c\xd5\xec\x9a\x88\x50\xfe\x5b\x02\x38\xc2\x92\xd4\x2a\x0c\xe1\x86\xa4\x56\x41\x4f\x60\x26\xf2\x6d\x92\xd0\x3d\x12\x7e\x37\x4f\xb6\x96\xea\x26\xc4\x5b\xcb\x3f\x19\x1d\x89\xf8\x11\x72\xc9\x6f\x9e\xc9\xbe\x9b\x7e\x0b\x60\x09\x79\xe9\x31\x14\xa4\xec\x33\xac\x29\xe0\xfe\x3b\x78\xe3\xd0\xd8\x7b\x95\x1a\x05\x45\xb5\x54\x80\x7f\xb3\xea\x98\x72\xb8\xab\x63\xf0\x78\x7f\x13\xb1\x27\x36\x54\xd3\xd3\xe1\xb0\x61\x40\xad\x0d\x8b\xe1\xbb\x7c\x8b\xc7\x2b\x80\x36\x3d\x5c\x2d\x37\xd9\x24\x80\x49\x6c\x78\xd9\x1c\x8c\xd6\xb2\xc6\x0b\xad\x31\x6f\x3f\xaa\x8d\xa6\x47\xf9\xb3\x35\x01\xd7\x3e\x86\x42\xa6\x48\xff\x47\xf9\x47\x28\x67\x06\x0d\x4e\x4a\xe0\xe2\x57\x78\xcf\x28\x0a\x40\x58\x0b\x8f\x22\xf2\x9d\xe0\x61\x83\x8b\x63\x1d\xd2\xb5\x31\x83\x32\x8a\xb4\x1c\xdc\x24\xa8\xdb\xb7\x4d\x03\xcc\xac\xec\x76\xf5\x26\x90\x09\xba\x37\x51\x18\xc9\xc7\x31\xad\x98\xe2\xfa\x0b\x29\xae\xbf\xd0\xd4\x2a\xc1\x62\xbb\xca\x47\x76\x77\xd2\x86\x40\x88\x42\x53\x22\xc6\x4e\x44\x11\xa4\x90\x6f\x07\x06\x7b\x0f\x88\xc2\xa6\xff\x41\xee\x96\xff\x40\xe3\x84\x1b\xb0\xc7\xbf\xd1\xe7\xb7\x9d\x53\x06\x10\xf4\x51\x4b\x67\x0e\x0d\x27\x53\x72\x61\x82\x7d\x01\xa5\x5c\x16\xeb\xd8\xec\x4f\x8d\xee\xf7\x5e\x2c\xc3\x6f\x59\x01\xba\xfe\xf3\xc0\x21\x91\xae\x6a\x1e\x10\xe1\x80\xa0\x76\x8d\xa8\x05\xc9\xf3\x21\x36\x14\xff\x7b\xc3\x59\xb4\xa5\x0c\xab\x13\x99\x7f\xf9\x8d\x04\x06\x8c\xf6\xe8\x74\x8a\x22\x0d\xc5\xab\x5a\x7a\x5c\xa6\xea\x45\x73\x19\xd7\x97\x37\x8c\xb1\xb1\x4d\xc8\x99\x6e\x1f\x71\x9b\x79\xdb\xca\x5a\x72\x0e\x20\xbb\xd4\x3d\x5b\x82\x7f\xef\x35\x92\x9b\x2c\xb1\x7f\xdf\x70\xe8\x1f\xa0\x06\xe5\xb5\xd1\x57\x9b\x14\x86\x13\x6a\x5e\xe8\xce\xce\xce\x6e\x85\x87\xdb\x05\x3b\x31\x8d\x11\x2f\xad\xb8\xad\x44\xc2\x6c\xee\xc6\x52\x27\xe8\xe6\x6f\x2d\x75\xb2\x3d\x66\x0e\x39\x9f\xdb\xd1\x35\x6d\x6f\x93\xa9\x4c\xbe\x6b\x7b\x08\xf0\xa3\x73\x0f\xc0\xcf\xe8\xe9\x9e\x7c\xcf\xfd\xf9\x3d\xfa\xaa\xe1\x45\x6c\xb8\xb7\x8e\xc6\xde\x6f\x22\xa8\x07\xde\x25\x75\xd1\x6c\x18\x02\xd9\x1d\xeb\xcb\x31\x73\x5e\xe5\x7a\xe6\x8d\xbd\x5b\x2a\x8c\xd5\x4e\x5b\xcd\x9d\xa3\x05\xb0\xed\x42\xb8\x4e\xa4\x03\x89\x33\xb1\x1e\x1a\x3b\xdd\x3c\x76\x92\xc6\xdf\x6f\x8c\x6f\xdc\x75\x20\x3c\xd8\x3d\x2c\xd0\x3d\xe4\x79\x4f\xac\x7b\x83\x2b\xbe\xc0\x45\x49\x9d\xfd\x7b\xac\xeb\x77\xc3\x4d\x89\x62\x06\x18\x66\xb9\x73\x11\xf8\xbf\x6a\x06\x8d\x6d\x7e\x43\xa8\x8d\x6e\x1b\x01\x4a\x6a\xd1\x40\xd8\x2d\x59\xcc\x7e\x44\x12\xfb\x83\x17\x1b\x7f\xd5\x14\x2e\xcf\x45\x99\x20\x37\x1c\xde\x8c\xeb\x2d\x65\xb7\x3d\xf8\xc8\xab\xe7\xd5\x5a\x31\xd2\xa3\xfe\xc7\xe1\x69\xcf\x4a\x6d\x10\x3d\xc6\x39\x6b\xcd\xa9\x09\x04\xa4\x50\x6c\x09\x10\x8a\x80\x75\x84\x9d\xb3\x7f\xba\x8f\x1d\xea\xfa\xf7\xc6\xe0\x8a\xd0\x77\x4f\x9b\xfc\x94\xdd\x26\x9f\x6d\x78\x0d\x81\x35\x29\xf6\xd7\x63\x94\x77\x6f\x3a\x11\x2d\x92\x1a\xb4\x53\xb4\x3e\x06\x5d\xb6\x2b\x9b\x01\xe6\xb1\x2d\x36\x26\xb9\x93\x9a\xd6\xa4\xe6\xbd\x86\xec\x7a\xf5\x60\x0d\xb3\xe5\x35\x62\xc4\xf3\xbc\x53\x1b\xbb\x92\x64\x78\x26\xa1\x4a\x3e\xb2\x70\x2c\x31\xc3\x11\x48\x62\x46\x52\x4c\x79\x0d\x37\x4a\xd7\xb1\x13\xc3\x27\x3a\xfa\xfd\x7f\x9c\xe8\xe8\x39\xde\xe8\xda\x92\xdc\xdb\x45\xd5\xc4\xff\xe0\xca\x86\x0d\xc3\x46\xf5\x90\x0a\x8f\x39\xd6\x44\x3c\xf7\xfa\x7b\x39\x90\xa2\x61\xb0\xac\xff\x20\x28\xd2\x81\x9a\x82\x15\x2f\xc1\x92\x47\x18\x36\x4c\x44\xad\x39\x97\x7e\x0a\x5a\x76\x9b\x84\x5f\x3b\x13\x7c\xc6\x36\x3d\x1f\x76\x36\xcf\xeb\xe3\x21\xda\xeb\x53\x22\x5f\xb2\x45\x29\x0f\x1e\x2d\xa4\xf1\xf7\xbd\x73\x3a\x4c\x13\xd9\xf8\x19\xee\x01\xd8\xe0\x09\x60\x1b\xba\x39\x74\x4f\xcb\x34\x6b\xf0\x66\x80\xce\xfd\xaf\x59\x66\x35\x38\x2a\x8f\x65\x9c\x34\x05\xaf\x8e\x93\xa2\x32\xab\x9c\x9d\x29\x2a\xd8\xe3\x1f\x3d\xca\x47\x98\x86\x36\x2c\x2a\xc1\x1d\xfc\x3d\x4a\xbb\x83\x78\xf9\xa7\xff\xe0\x5f\x64\x6f\xc1\x4a\xc0\x64\x13\x48\x51\x88\x2c\x51\xe4\xfe\x80\x77\x1b\x58\x6e\xda\xc7\xa0\x40\x38\xbf\x88\xf0\x8d\x54\xde\xd4\x4a\x19\x23\x55\x2c\x4e\xd3\xd7\xa3\x46\x01\xe3\x23\xfd\x5f\xda\xbe\x0c\xcf\xd7\x8d\xb2\x20\x15\x51\x68\x29\xfe\x65\x76\x32\x64\x9a\xd3\x31\x81\xe3\x70\x82\x50\x27\xca\x26\x81\x34\xb8\x10\x62\xa5\x50\xa3\x60\x9b\xd5\xbe\xb1\x4f\x64\x73\x10\xb8\x82\x78\x98\xed\xb3\x21\x70\xa5\x5c\x5d\x49\xcf\x32\x97\xbe\x54\x97\x0a\x85\x9f\x3c\xbb\xb9\xa9\x31\xed\x59\x32\xae\x40\xb0\x97\xe9\xb8\x0e\x8a\x98\x84\xdc\xa6\x80\xef\x59\xea\xad\xd3\xdf\xc3\x76\x35\xb0\x2f\xa5\x71\xd5\xa5\x94\xdb\x23\x1b\xb9\x17\x70\xeb\xac\xe4\x31\x50\x9b\xb3\x93\xd7\x0d\xbc\x79\x4b\x79\xdd\xec\x8f\x9b\xcd\xc8\xeb\x4c\x83\x2b\x64\x8f\xae\x19\x0c\xb8\x46\x87\x6b\xf2\xc2\xe1\x85\xba\x27\xda\x38\x20\xd8\x03\x55\xb8\x94\xcf\xc8\x92\x97\xbd\x6d\xa8\x75\x27\x8b\xf9\xf7\xa1\x69\xcc\x22\xad\xfb\x24\x7c\x55\xca\xe1\x87\x06\x0f\x2f\xa6\xa6\xfe\x44\xe2\x8f\x52\x39\xb2\x27\xda\xa2\xa2\x99\x24\x17\x74\x1b\xa7\x9c\x10\x92\x56\x25\xc1\x88\xa1\xbd\xba\x64\x4c\x07\x61\x44\x56\x0c\xb2\x0c\x1d\x54\xd2\x1a\x27\x4d\x66\x63\xfa\x69\xd8\x93\x6c\xcc\x00\x8a\x3a\xb2\x31\x9b\x42\x17\x1d\xa4\xa5\x2b\x47\x3b\xfe\x3d\x65\xb3\x3a\x15\x9e\x88\x95\x60\xc5\xbe\xc6\x85\xfa\x5f\x20\xb7\xaa\xbe\x91\xbc\x19\xb9\x55\x75\xd3\xfc\xaa\x72\xab\xea\x26\x2c\x51\x6e\x55\x24\xd4\x56\x24\x02\x35\x86\x2b\x59\xe6\x55\x2c\xc0\xba\x33\xaf\xe2\x20\x26\xc9\xbc\xaa\x77\xd3\x0f\xf6\xa3\x6a\xd2\xd5\xdf\xdf\xdb\x8f\x3b\xb9\x63\x10\x8b\x2d\xc3\xf6\xa5\x34\x1d\x6a\xa7\x0d\xbc\xf8\xf4\x53\x98\x37\xf8\xdc\x55\x28\x48\x6b\x4a\x4a\x30\xa8\x39\xaa\x3a\x47\xc3\xc1\x34\x60\xc5\x0d\xa4\x30\x46\x15\x94\x5a\xce\xde\x20\xa9\x25\x81\x5e\xbe\x76\xb7\xfc\xd3\x95\x9d\x17\xb7\xac\xcd\xcb\xd4\xe6\xfe\x7a\xf5\xe7\x0d\x51\x04\xd7\xee\x73\xcb\xd5\x70\xe5\x74\x34\x4b\x03\xf6\x95\xc3\x56\x80\xaf\x84\x06\xe5\xad\x43\x9c\x18\x75\xd0\x89\x67\xd5\x32\xd2\x0e\x47\x89\x29\xfb\xe5\xf9\x1c\x17\x1e\xb5\x66\x9e\xff\xf2\xfc\xa6\x0b\x5a\xda\xe3\x08\xa8\xc6\x09\x14\xe9\x34\xc1\x72\xb0\x6d\xce\x37\xe4\xf8\xc0\x90\xc4\x11\x2e\xc0\x68\x72\xfd\x3f\xee\x1f\x39\xa2\x09\x00\xb2\x78\x10\x9e\x5f\xd1\x9e\xcd\x53\xdb\x18\x9b\x6a\xd9\xbd\xd3\x7c\xbf\xae\x9d\xdd\xfd\xe2\xbe\xf5\xc5\x02\x57\x68\x8c\x24\x9d\x82\x25\x27\xd4\xc2\x49\xad\x08\xac\x4d\x3b\x83\xe0\x2c\x2d\x2c\x75\xa4\xba\x8d\xdd\xa2\x2a\x79\xdb\x44\x5e\xb3\xce\x6d\x96\x7f\x5c\xc1\x1e\x7e\x9e\x56\x6d\xc8\xe3\xf5\xd3\xd6\xf2\x26\x53\x18\x4f\x12\xf5\x65\xd0\x73\x98\x47\xc5\x01\x87\x18\x81\x58\x53\x3a\xb3\xd5\x34\x86\x14\xe7\xb4\xbb\x25\xec\xbc\x5c\x29\x9f\x5a\x8b\x24\xfc\x0d\xd8\xc7\x48\x86\x29\x0e\xb1\x11\x03\x8e\x30\xbc\x70\x70\xab\x59\xba\x7b\x28\x06\xd5\x81\x30\x65\x35\x2e\x77\xd6\xb1\xd5\x1e\xf7\x03\x2c\x2f\x9c\x83\xd5\xc3\x10\x60\x31\xd9\x10\x76\x67\xe6\x77\x57\x36\xa4\x65\x2e\xc3\x88\x40\xe9\xc8\xb6\x56\xb7\x12\xf6\x21\xbe\x1e\x65\xe4\x8d\xdb\x42\x68\xf1\x01\x42\x9a\x7c\x80\x12\xd3\xe4\xdc\xe8\x46\xb0\x2b\x2f\x12\x84\x23\x3b\xc0\x03\x94\x56\x40\xa5\xd9\x11\x84\xb8\x20\x76\xb6\x17\x91\x10\x0f\x00\x39\x19\xe3\x6a\x6e\x8c\x0a\x5e\x4c\xea\xda\x14\xb7\x89\xb5\xa3\x12\xd2\x46\x29\x57\x6c\x43\x71\x76\x52\xf8\x60\xc8\x4c\xc8\xf9\x97\x13\xda\x84\x51\x98\xe6\x6f\xb8\xbd\x66\x54\x05\xf4\xf2\xad\x9f\xcb\x97\x37\xca\x73\x57\xb1\x81\xdb\xf2\x85\x9a\x72\xee\xb8\x80\xaa\xab\x2b\xe5\x2b\x4f\xfe\x3e\x73\xaa\xf2\xcd\xa9\xca\xad\xeb\xa2\xdb\xd8\x17\x0b\xd6\xd9\x59\xeb\xf1\xf5\xdd\x1b\x4b\xd6\x9c\xa4\xf9\x9c\x18\x84\x77\x3d\x33\x49\x35\xe2\x2f\x9a\x3c\x6f\x8d\x76\xa7\x01\x3a\xad\xf2\x48\xbc\x94\xa5\x61\x2b\x35\x91\x18\x44\xcb\xb1\xb5\xb3\x95\xbb\xa7\x22\x40\x52\x07\x61\x01\x2f\xae\xfc\x2d\x03\x66\x90\xd2\x3a\xb7\x9d\xe8\x52\x46\xa8\x4e\xe5\xf2\x58\xb0\xd4\x6b\x8f\xdb\x22\xca\xc1\x62\x3e\xab\x72\x98\x13\x5a\x29\x19\x76\x92\x5b\xfb\x73\xf5\x5d\x6c\xf4\x0f\x7b\x42\x74\xac\x34\x95\xce\x1e\xdf\x03\x9d\x59\xfd\xa8\x8e\x6d\x71\xb8\x93\x32\xf6\x45\x4d\x73\x6d\xe7\xec\x34\xc6\xc1\xfb\x1f\x25\x58\xed\x18\x4b\x5f\xca\x8f\x15\xd4\x8c\xc6\x1d\x6a\x00\xa6\x3f\xe7\xf6\xa0\xa3\x64\x8d\x81\x20\x2e\x8d\x90\x85\xcd\x9b\x78\x0b\x7f\xe8\xff\xd3\xee\x4d\x24\x13\x7b\xb5\x23\x3b\xe1\x1d\xd2\xee\xf2\x4c\xf5\xc1\x29\x1a\xd0\x09\xcf\x48\xb8\x87\x31\xc8\x6f\x6b\x1e\x9b\xc0\x55\xe6\xe7\xb0\xfd\xf5\xf5\x35\xef\x10\xb0\x15\xc9\x83\x53\xd6\xe2\xb9\xca\xe6\x43\x04\x20\x7a\xcf\x50\xf7\x54\x38\xe0\xeb\x23\x3e\x7c\x56\x44\xfe\xfc\x07\x5a\x56\xda\x90\x80\x7a\x20\x5b\xeb\xab\xd6\xf9\xbf\x44\x03\xc1\x23\x27\x1a\xc8\xd2\x62\x34\x84\xff\x5b\x7a\xa0\x13\x37\xfe\x81\x7a\xa0\xcb\xe6\xe7\xbf\xbb\xa0\x37\xd0\x05\x3d\x62\xf2\xff\xbb\x0b\xba\x6c\xe5\x61\x77\xa9\x52\x0e\x0b\x74\xc1\xe4\x53\x22\x9a\x28\xc5\x45\x7d\x49\x61\xbb\x4e\x50\xcb\xe6\x71\xec\xeb\x09\x67\x77\xc4\x8e\x74\x9a\x34\x38\xc3\x42\x4e\xdc\x3d\x67\xbd\xbc\xc6\x57\x2d\x6e\x51\x6a\xdd\xbb\x59\xfe\x7e\x25\x8a\xae\x7c\x89\x5a\x54\x67\x70\x1d\xb1\x36\x64\x8e\xab\xef\x2a\x64\x94\xb1\x1b\x79\xdb\xb2\xc5\xed\x6a\x27\x23\x6c\x75\xa5\xb2\x7a\x0d\xb6\x64\xf9\xfa\x8b\xca\xbd\x4d\xc1\x27\x7f\xb7\x3a\x54\xf0\x09\x85\xb4\x63\x28\x53\x45\xa5\xd0\xf0\x39\x3c\xc1\x5d\x81\x26\x42\x64\xdb\x78\x03\x61\x65\x8b\xa2\x7a\x12\xed\x57\x53\xe3\x68\x22\x8a\x6f\x17\x86\x14\x96\xe7\x67\xc4\xf2\x21\x0a\x6d\x92\xf0\x64\x7a\x79\x03\xbb\x88\x7f\xb6\xcd\x07\xde\xce\xfa\x4c\xe5\xf4\x06\xa8\xbe\xa0\x98\xc9\x95\x02\x23\x97\xd3\xd2\x64\x8c\xcb\x94\x26\xb8\x7b\xb3\x96\xa6\x8a\xf1\x98\xa8\x43\x7a\x59\x6b\x9b\x1f\x48\x3d\x34\x70\x61\xa9\xbe\xfc\xaa\x7c\xf1\x3e\x36\xec\x8e\x6c\x85\x50\xdd\xfe\xde\x3a\xfd\xa8\xae\x66\x07\x11\xdd\xa6\x81\x59\x2f\x3f\x47\x79\x4e\x6d\x93\x99\xc2\x38\x5e\x15\x55\x9d\xe4\xd0\x9b\xcc\xa4\x67\x77\xaa\xeb\xdf\xb6\x88\x49\xc9\xd8\x93\x9f\xa6\x85\x0f\x9a\x5e\x5a\xf4\x8e\x14\x6c\x19\xa0\xaf\x00\x1c\x37\x8c\x10\x51\x19\xe2\x47\xee\x56\xca\x3f\xbe\xa6\xbe\x1a\x9b\x4b\xd8\xae\x32\x30\x7a\x2f\xd1\xd6\xbd\x45\x10\x02\x0d\x74\xd8\x60\xf3\x40\x10\xb4\x67\xc8\x11\x3b\x13\x8f\x46\xbc\x75\xa2\xc9\xc7\xdb\x2c\x28\x68\x62\x18\xca\x75\x61\x4f\xc7\x83\x4a\x8c\x0d\x91\xef\x9f\x4e\xd3\x0d\x49\x37\x91\xa1\x9c\xdd\x66\xf1\xa6\x03\x2f\x86\xc0\x34\xcc\xbc\x5f\xd0\x1e\x54\x6c\x8b\xa6\x11\x47\x0f\xb3\x36\x54\xdc\x02\x09\x3e\x30\x31\x64\x64\xd0\x41\x40\x56\x66\x14\xfc\xe2\x76\x42\xdd\xe9\x71\x59\x72\x9b\x3d\xb8\x05\xff\x8f\x68\xf6\xac\xac\x22\x7b\xb6\xbf\x84\x5b\x81\xe8\x3f\x0f\x37\x84\xed\x2b\xbf\x3c\x97\xdd\x01\x1d\xfc\xa3\xdc\x70\xcc\x2e\xb9\xc4\x3e\x64\x19\xb2\xf9\x17\xd8\xf0\x03\x9b\xfc\x90\xbd\xf0\xce\x9d\x64\xd0\x61\xcb\xe0\xea\xcd\x90\xd2\xe3\xec\xcf\xfd\xb8\x71\xec\x6a\xdb\x32\xc9\x01\xd7\xc4\xf5\x59\x6c\xdf\xb1\xfe\xd8\xc1\x0e\x4a\xcc\xce\xfa\x26\x2b\x0a\x0e\x34\xd1\xe2\x33\xb6\xdd\x59\x80\x36\x51\x79\x1c\x09\x3b\x9e\x33\x4b\x79\x8c\x06\xd4\x32\x3d\xf4\x2d\x29\x9f\x58\xda\xf3\x64\x0e\xae\x43\xe2\x51\x13\x6f\x91\x07\xeb\xf5\xd8\xfb\x91\x92\xf5\x80\x6a\x3d\xd1\x5d\xc3\x5d\xcc\x6e\x57\xd2\xb8\x19\x60\x1e\x84\xbe\xea\x1a\xef\x12\x11\x23\xdb\xa0\xd4\x6f\x4c\x6c\x62\x2f\xa3\xe3\x28\xc3\xe6\x7a\xa1\x2d\x72\x14\xc7\xe0\x51\x83\x2b\x19\xa1\x3e\x81\xea\xc8\x5d\xa7\x93\xb2\x90\x6f\x52\x0a\x61\x2d\xf9\x04\x21\x8b\x3b\x77\x4d\xfb\x05\x62\x3c\x51\xc0\x38\x1d\x6e\x2f\x7f\xd6\xbc\x06\xdb\x68\xa9\xb1\x79\x09\xad\xb0\x0b\x57\x23\xad\xaa\x21\x08\xd8\x0b\x24\x35\x5f\x06\xa0\xa3\xbd\xe6\xea\x93\x08\x1d\xd4\x46\x20\x8e\x34\x2e\x13\xc6\xc6\x87\x04\xa2\x98\x64\x8d\xb0\x20\x13\x3f\xa9\xb3\xa9\xf7\x75\x39\xda\xdc\xfe\xa2\xed\x00\xc5\x4e\xc9\xa2\x61\x33\xa8\x22\xa5\x3c\x9a\x1b\x62\x0c\xd8\xb7\xac\xad\x4d\xd2\x11\xcf\xef\x3c\xbf\x0b\xab\x69\x67\xfd\x67\x34\x92\x92\xd8\x8d\x41\x6a\xe4\xe1\x2a\xe8\x9a\x2f\x23\x54\x6a\x61\xf0\x9c\xff\xd2\x7a\x3e\xe3\x79\x23\x11\x96\xa9\x82\x0e\x23\xfb\xb3\x9e\x8f\x47\x60\x9d\xbd\x61\xcd\xde\xa7\x67\x23\x41\xdb\xde\x62\x87\x12\xd9\xea\x26\xee\x78\x1e\x8b\x06\x27\x62\x85\xa8\xe5\x2d\x69\x2f\x38\x09\x59\x6c\x40\x84\x96\x89\xb8\x1d\x84\x6a\x17\xe1\x83\x23\x80\xbd\x4c\xa8\x68\x2d\x5d\x64\xc3\x40\x32\xd4\x70\xe9\x2a\xda\xb7\x31\xea\xec\x39\x32\x8d\xad\x8b\x90\x18\x53\x79\x8b\x5c\xb9\x54\x15\x58\xea\xe0\x62\x02\xe8\xee\x55\xb9\xfc\x03\xdc\x30\xd0\xb1\xc1\xe4\x11\x19\x28\x06\xef\xdc\xc1\xa6\x4f\x5b\xb3\xbb\x37\xdc\x4e\xb0\x72\xb7\x96\x4d\x61\x4e\x9b\x22\x8b\xab\x6c\x02\xaf\x3e\x01\xcc\x51\x1d\x95\x1d\x48\xf0\x22\x0c\x57\xf4\x50\x44\x16\xd3\x25\x4a\x6e\xc4\x06\x99\x0e\xd7\x4a\xef\x29\xc6\xc3\xdc\xbd\x79\xa9\xbc\xbc\xc9\xb6\xd2\x18\x94\xfe\xee\x80\xd1\xcc\xb3\x5b\xfa\xc5\x82\xe4\x23\x82\x7a\x31\x45\xe5\x9e\x33\x58\x16\xf2\xdc\x5f\x18\xae\xca\x95\xf9\x85\x84\xf0\x39\x54\x27\x01\x6c\x6c\x16\xbc\x74\x36\xf2\x98\x0f\xc2\x8e\x31\xcf\x7b\xa1\x47\x3a\x9b\x1c\xb8\x51\xed\x7d\x09\x58\x54\x3f\x5f\x07\x0c\x56\x3a\xe4\xd5\x41\xb5\xc5\xf9\x8c\x4b\xba\x17\x09\x81\xb3\x17\xa9\xc0\x09\x2f\x91\x7a\xf7\x24\x17\x88\x71\xba\xa5\xb8\xbe\x16\xde\xa5\xd8\xc4\x7b\x04\x1b\xbc\xe6\x4b\xe6\x38\x3a\x1b\x4b\xe9\xb4\x66\x9a\x64\xfb\x92\x2f\x64\xb8\xf5\x95\xe7\x96\xac\xf3\x77\xca\x17\x1f\xed\xce\x9c\x0a\x68\x67\x62\x05\x7a\xbe\x61\x45\x2f\x8e\x50\x10\x0f\xd1\x5c\x27\x09\x10\x03\x25\x83\x63\xc5\x64\x5d\x2c\x2f\xc9\xc6\x18\xe1\xff\x6d\x13\x7f\x69\x7c\x4b\xe6\x7e\xe0\xa8\x14\x9a\xf2\xdb\x2d\x8f\x64\xe3\xa9\x90\x30\xde\x41\x7e\xb1\xc0\x4b\x8a\x8d\x65\xd6\xa5\xf3\xec\x9c\xe2\x6b\x29\xfe\x7a\xfe\xbe\xf5\xf9\x79\xe9\xe5\xb4\x86\x5e\xbc\x23\x8c\xe8\x6c\x4e\x54\xd3\xe4\x3d\xa3\x9f\xf3\xea\x34\x75\xcc\x43\x4d\x24\x29\xa1\x95\xe7\x3f\x57\x7f\xde\xa8\xfe\xfc\x00\xfd\x45\x5f\x00\x7d\xd7\xcb\xdf\xbf\x60\xcd\x24\x86\x20\xcc\xcf\xac\xcb\xf9\x85\x62\xcd\xb3\xb5\x04\x21\xe4\xaf\x8f\x40\x44\x83\x0c\x2e\x4d\xbc\xa0\xdb\xb7\x24\x53\x2b\x16\x29\xac\x00\x8b\x1c\xc1\x53\xd1\xee\xa6\xbb\x1b\xe5\xc5\xd5\xa0\x5b\x90\xae\x4c\xd5\xd5\x17\x95\xed\xd5\x06\x56\xa4\x68\x42\xfd\xfa\xdb\x6c\x2e\xd7\x69\x58\xaa\x19\x6a\xb2\x66\x96\xce\xa0\x47\x22\x9a\x42\xc6\x76\xd3\x0c\x68\x2a\x12\x10\xd1\x04\x08\x25\x02\x1d\xe1\xf4\x49\x8c\x0d\x57\x65\x0d\xf3\x5b\xc5\x65\x58\xc5\x21\x5c\x56\x1c\x4d\x28\x48\x4d\xfc\x28\xf6\x8c\x54\xaf\x2c\xf4\x61\x88\xa7\x89\x43\x58\xe1\x9d\x7f\xc3\x0f\x7b\x42\xd7\xee\xec\xe2\xee\xd7\xb7\x03\x38\xe2\x29\x73\x3a\x51\x7f\x20\x92\x11\x92\xae\x35\x3e\x14\x6b\xdf\x4c\x88\x8e\xfb\xbe\x86\x2e\xad\xa6\xf7\x75\x0c\x0d\x09\x5a\x3d\xb7\xa6\xbf\xb3\x5f\x1f\x0c\x43\x14\x4b\x69\x50\x47\x6c\x75\x03\x66\x89\x6e\x19\x3f\x91\x7e\xf5\x12\xe1\xef\xc9\xaa\xae\x55\x4d\x5d\x54\x4d\x10\xe9\x3b\x4e\x42\x96\x5c\x6b\x97\x9b\xb4\xb3\x7b\xa3\x87\x5b\xcb\xa6\xbf\xa1\x23\xce\xab\x75\xd4\x0c\x26\xf9\xa4\xa0\xc2\xe3\xbe\xfd\x5b\x6d\xda\x73\xdc\x44\xf0\x2c\xd0\x1f\xbc\xb5\x0c\x09\xe8\x54\x72\xb4\x3e\x4e\x90\xce\x15\x36\x96\x04\xcc\xa0\x3a\xb9\xb2\x93\xb7\xb5\x7b\xc9\x9a\xfd\x61\x67\xf3\xbb\x86\xce\x54\x5e\x8b\xa1\xa7\xd8\xeb\xd3\x0e\x78\x99\x36\x78\xee\x85\xee\xae\xb0\x8d\xf8\x2a\x76\x9c\xbb\xb7\x42\xb7\x5e\xfc\x68\x38\x94\xcd\xee\xc8\x20\xb5\x3e\xff\x83\x09\x1a\xb6\x06\x95\x2f\x2d\xc1\xbd\x5b\x6e\xe7\x4e\xc8\x1d\xc7\xd9\x96\x6c\x30\x5e\x0a\xc2\xde\x95\x61\xb4\xf3\x18\x94\x29\xad\xa0\xc1\x35\xf7\x8f\xc2\x4f\x2c\x62\xdd\x30\xd6\x46\x1d\x53\x23\x42\x52\xce\x3d\x86\x53\x18\x9d\xbb\x5f\x7f\x57\xbe\xf0\x45\x65\xeb\x36\x47\x9a\xed\x9e\x5b\xac\xae\x5d\x91\xdb\x9f\x5d\xcc\x6d\xee\x42\xd0\x73\xd8\x20\x4e\xa1\xd0\x03\x91\x7e\xd2\x46\x2e\x08\x8c\x99\xc9\x1b\xa6\xe6\x04\x5e\x9d\xe8\xec\xe8\xb3\x93\x86\x06\x14\x4f\x01\x00\xc5\x2e\x00\x40\x1b\x7d\x04\xc3\xd9\xbc\x3d\x2a\xea\x2c\x34\x20\xee\x98\x7d\xd1\x41\x97\xc2\xe7\x16\x15\x6e\x29\x00\xd9\xd1\x96\x4a\x46\x67\xeb\xfb\x84\x5a\x4c\x8f\x27\x00\x8b\xee\x89\x85\x0d\x90\x1d\x32\xf8\x66\x11\xee\xc4\x9e\xe8\xde\x69\x76\x2b\xbd\xa5\xb5\x8f\xb5\x63\x8e\x88\xf3\xd3\xdb\xd4\x42\x5f\x2f\x92\xa5\x88\x7f\xde\x1f\x17\x0d\xf8\x47\x75\x52\x75\x21\xb4\xc3\x63\xfb\x7d\x60\x44\xfb\xfe\x11\xa0\x3f\x3d\x8e\x3f\x14\xd5\xb1\xc6\x61\xff\xcf\xc9\x5f\xb7\xff\xba\xfd\x9d\xfd\x34\x83\xfb\xed\x3f\x00\xe4\xdb\x1c\x97\x09\xcb\x12\x9f\x2f\xa6\x74\x8f\x35\x1f\xee\xff\xb9\xec\x74\x9b\x13\xe8\xbc\x5f\x38\x33\xf7\x23\x39\xfb\x73\xa5\x6c\xb6\xce\x42\x33\xcc\x51\xbb\x6f\x0b\xc5\x88\xa5\xb3\xa5\x8c\x66\xaf\x40\x51\xf6\xa3\xcd\x17\x51\xe4\xf6\xa0\x99\x00\xdc\x3a\x76\xdb\xc3\xb6\xc9\xb2\x55\x87\x41\x79\x0b\xb3\xd6\xd2\x77\x18\x23\xb3\xf6\xac\xfc\xc3\x69\x11\xab\x85\x8e\xb3\xa7\xd6\xbd\x9f\x31\x56\xc2\x13\x5e\xc4\x11\xd8\x1c\x5e\x14\x4e\x36\xe7\xfc\x0e\xc8\x56\x94\xcc\x59\x7b\x48\x35\xc7\x47\x0c\xb5\x90\x39\xe8\xdc\x75\x64\x56\x9c\xad\x6f\xab\x2b\x8f\xca\xb7\x5f\xb2\x97\x9d\x1f\x0d\x87\x49\xd1\x55\xc2\x92\x5e\xd0\x44\x70\x05\x9d\xc9\x32\xf2\x28\x7a\xaa\x7c\xf5\x09\xb0\xa0\xfa\xd7\x33\xe5\xcd\x25\x3e\x2c\x13\xc0\xe7\x33\xa1\x6e\x2c\x2c\xd0\x93\xe0\xa2\x2c\x97\x24\x1e\x18\xcc\x45\x89\xf3\xc0\x38\xe0\x22\x3d\xed\x0c\x4b\x3e\x67\x36\x90\xc8\xc1\x12\x8c\x44\x43\xa3\xab\x6e\x24\x98\x28\xd7\x83\x03\xa6\x0e\x3f\x81\x9b\xb6\x13\xef\x27\xa8\x81\x1f\xe3\x27\x70\x61\xc7\xfb\x09\x6a\x60\xc7\xfa\x09\x82\xe9\x48\x09\xe1\xca\xab\xe7\xd5\xe6\x30\xc5\x81\xf4\x2a\xe2\xd1\x0b\xc8\x56\xa3\xe3\x20\x46\x3a\x33\x10\x52\x94\x33\xc3\x0f\x46\xa8\xde\x14\x60\xa9\xbb\xe1\xce\x39\x38\xfe\xf4\xb1\x9c\x68\xd7\xe5\x3e\xc7\x11\x57\xd9\x6c\x74\x55\x28\x2f\x11\xbc\xa2\x79\x2b\x63\x50\xe9\xc6\x53\xeb\xd2\xd5\xf2\xd3\x39\xe1\x01\xb4\x93\x9a\x7c\x0f\xcf\x9d\x95\x9e\x9f\x0e\xf5\x11\x1e\x3f\x81\x3e\xc2\xe3\x67\x43\x21\x07\x26\x37\x4a\x52\x44\xa3\xa4\xb7\xf4\x76\xad\x1d\xc6\x6d\x98\x1a\xbb\x53\x30\x0d\x81\x15\x80\x7c\x5e\xa3\xf8\x0a\xb6\x72\xcb\x3d\x9d\xb4\x40\x68\x78\xd6\xe3\x7b\x95\xef\x30\x75\x84\x37\x24\x7a\x37\x5f\x5c\xb0\x1e\x9c\x06\x91\x5c\x5e\xfe\xb6\x7c\xfd\xae\xf5\xe4\x0c\x86\x87\xf8\xcd\xdc\xf6\xc3\x12\xc7\xa7\x4d\x7c\x54\x7a\x8d\x58\x50\xb1\xf1\x35\x2e\xac\x28\x4f\x0d\xb1\x33\xc2\x53\x23\xa0\xa4\x71\x27\x62\x14\x6a\x34\x67\xbe\x5c\xdc\xd9\x5e\x06\x3d\x94\xd7\x41\x14\x44\x33\xb9\x83\x94\x86\x1b\xed\x20\x25\x98\x6f\x8c\x0f\xc0\xc3\xd4\xe4\xa1\x7e\xf5\xfb\x00\x9c\x41\x37\xe7\x03\xf0\x9f\x95\xf5\xf8\x00\x1c\x02\xf6\xdc\x12\x21\xce\xe0\xc4\x36\x08\x87\xb2\x37\xd1\x5e\x54\x7b\x72\xc9\x31\xe3\xc2\xa8\xdf\x52\xe4\x0c\x7f\x0f\xdd\x1a\x92\x35\x1e\x4f\xd3\x1e\xbb\x35\x5c\x55\x2b\xa9\x79\xc7\xa1\xcc\xf1\x33\xf4\xe3\x87\xa4\x7b\xc7\xf5\x69\x78\x5e\x4b\x88\x88\x34\xf7\x7a\xd1\x38\x2f\x45\x23\x79\x75\x1e\x0b\x9f\x80\x4e\xee\xb1\xf0\x50\x9a\xc4\x63\xd1\x8a\xed\x96\x50\xc5\x7d\x45\xbe\x8a\x70\xf5\x38\x81\xaf\xa2\x86\xc8\x37\xc8\x68\xd7\xd0\xe1\x57\xaf\x95\xce\x65\x80\xdc\xc6\xdc\x62\x51\xd7\x80\xdd\x38\x40\xa5\x63\x10\xf4\x87\xcd\xba\xdf\xb3\x5b\x69\x6f\xe7\xc3\x8b\x49\xe4\x18\x38\xf3\xe2\xa3\x2e\x7e\x54\x61\x16\xd2\xbd\xa1\xbe\x3e\x83\xea\x21\xcd\x4c\x17\x74\xaa\x33\x70\xd0\xb3\xa4\x3c\x5f\xcb\x85\xc9\xa5\x4b\xd5\x97\x4f\xd8\xaa\x12\xfa\x5a\x38\x42\xae\x00\x80\x71\x40\xd8\x93\x4a\x04\xe4\x38\x56\x28\x6f\x68\xb4\x04\x6f\xe5\xc1\x29\x18\xa4\xb5\xb6\xc1\xc6\x25\x9e\x2e\xbc\x2e\x50\xaa\x70\x22\xac\x54\x2b\xc8\x96\x07\x1e\xed\xc6\x49\x90\x37\xd8\xa8\x6b\x47\x76\xc6\x51\xb2\xb3\x3e\xb3\xb3\xfe\x6d\x79\xee\x2a\x88\xf5\xdd\xcf\x1e\x39\x24\xb9\xdf\xdf\xbb\x89\x1f\xfc\xe5\x21\xea\x26\xd8\xe1\x92\x97\xde\x64\x5c\x6a\x00\xb5\x5b\xf2\x17\xf9\x60\xa4\xe3\xe7\x64\xe7\xf9\xb7\x0a\x3e\x1e\x79\x71\x15\xd0\xb1\x26\x32\x87\x96\x6a\x5e\x73\x77\xf4\x68\xfc\xf7\x43\x65\x60\xe0\x83\x68\x24\x14\x78\xe6\x86\x4f\xe3\xa5\x9d\x33\x9f\x29\x74\x97\xf4\x5a\x2e\x35\x2a\x47\x5b\x7e\xfc\xb5\x07\x04\x0e\x72\xf3\x62\xe5\xf9\xd5\xea\xda\xe7\x18\x6c\xbd\x30\x1b\x4f\x00\x9a\x7f\x31\xd4\xcb\x6e\x06\xa8\x98\x06\xdf\xa8\xb9\x2a\xf5\xb8\x3a\xe9\x9b\xe6\x5c\x86\x6c\xb3\x25\x93\xdf\x16\x2f\x45\x12\xc8\xc1\x92\xe5\x3b\x4b\xb0\xc6\xac\xf3\x77\xaa\x9f\x6d\x63\xe4\x1e\x7f\x39\xf7\x0c\x23\xb7\x6f\x7f\xc6\x33\x8e\xc1\x7b\x5c\xb8\xc4\x4e\x86\xe6\xe7\xa3\x46\x21\xa2\xf6\x90\x3e\x2c\x90\x82\x5b\xe4\x13\xcc\x75\x55\x73\x21\xf7\x83\x9a\xc3\xb5\x55\x27\x8b\xbb\x9e\xc3\x8f\x3f\x37\x7f\x24\x40\x9d\xb3\xda\xe5\x32\x30\x38\x4c\x9c\x06\x6c\xda\x4e\xe5\x8b\x60\xcc\xd2\xc1\x8d\x7a\x64\x84\x67\xa4\xc9\x6e\x93\x9e\x91\x1e\x0b\x1f\xa9\x27\x38\x5c\x7e\xee\x53\x82\x0a\x5b\x59\xfc\xbb\x7b\x8f\xc6\x8b\x8b\x72\xcf\xae\x4a\xce\xd8\xc3\x7c\xb8\x7b\xcd\x83\x90\xa5\x1d\xc7\x8c\x37\x91\x11\x4d\xef\x02\x14\xcd\x22\xa9\x8c\x3d\x5a\xff\x64\xee\x8f\x1b\x87\x43\xef\xdf\x66\x96\xff\xc9\xe4\xb4\x36\x94\xcf\x4a\xf9\xf2\x5a\x79\x41\x5e\x80\x45\x8e\x95\xf5\xc0\xba\x70\xb3\x76\xd6\x00\x05\x58\x39\x8c\x9e\xf5\x68\x25\x8e\xc9\x57\x5e\xf1\xc8\x9a\x3d\x55\x5d\x5d\x77\x10\x57\x5f\xde\xaa\xae\x2c\x10\x9c\x98\xf3\xf5\xa4\x28\x0f\xc4\x1e\xc7\xf7\xfe\xf9\x5f\x8e\xb6\x29\xef\xbe\xf3\xde\x6f\xf0\x9f\x23\x32\x83\x2a\x57\xff\xe1\x72\x3f\x1e\x0b\xea\x02\xbe\xfe\xf7\x99\x53\xf4\x3e\xfe\x7b\x44\x6e\x31\xd5\x4d\x58\xe3\xd3\x0a\xf7\x53\xe1\x98\xf1\x22\x1c\x2f\x4e\x5e\xb5\x8c\xcd\x94\xa6\x1f\xb4\xce\x72\x69\x81\xf3\x4f\xad\xb3\x7f\xc5\xf2\x65\xe7\x9f\x96\x67\x24\xce\xe4\x43\x86\xc8\x5d\xcd\x1a\x05\x4c\x0c\x83\x1b\x7d\x5e\xda\xd3\x12\xf9\xba\xb6\x51\x7d\xf1\xa5\x75\x6e\x93\x43\x9c\x77\xbf\x5e\xae\xce\xff\x18\x09\x9a\x1b\x1c\x90\x53\x88\x3a\x1e\xd8\x55\x30\xe4\x38\xca\xf3\x0f\x81\xfc\xea\xcb\x65\x1c\x10\x15\x47\x88\x44\x30\xa1\xe6\x6d\x8f\x13\xa5\x55\x8b\x84\x18\x11\x6a\x8f\x0d\xe4\x6c\xc3\x39\x69\x19\xf9\x82\x36\xa9\x1b\xc0\x58\xca\x3d\x30\xb9\x42\x42\x4c\x0e\xcd\xa2\xf5\xe4\x2c\x1b\x2e\x1c\x83\x78\x20\xab\x86\xfd\x06\x3b\x5b\x17\x03\xdf\xe3\xa6\x9f\x9d\xb3\xe6\x17\x39\x67\x01\xae\x2a\x68\x64\xb8\xb8\x15\xe9\xfe\xe2\x71\x71\xeb\x00\x11\xaf\xae\x8e\x62\xf6\x06\x92\x2c\x57\x89\x18\x05\x66\x68\x00\xc1\x4b\x6b\xd6\xf9\x47\x09\xac\xeb\x46\xfa\xa4\x56\x48\xe9\x13\x94\x0c\x60\x38\xb9\x53\xbc\xfc\x51\x0d\x3a\x90\xf1\x3c\x92\x42\x49\x28\xdb\x05\x98\x49\x67\x27\x4a\x29\xde\xb7\xbc\x5b\x22\x1c\xa4\x7c\x5f\x18\xe9\x12\x86\x62\x10\x12\x4c\x6e\x89\x75\x2a\x97\xaf\x9e\x2b\xaf\x7c\x83\xa1\x04\xf1\x5e\x65\xb6\xf7\xf2\x58\x3d\xf5\x2d\xa5\x7e\x13\xce\xfe\xb2\x87\xe2\x79\x23\x82\x7e\x44\x61\x1e\x8c\x82\x28\xa9\x2c\x68\x37\xf7\x55\xd4\x22\xa6\x36\x82\xe8\x55\xf5\xac\x96\xb1\x13\xdc\x31\x17\x1c\x8b\x9e\x1e\xe7\x9a\x40\x14\x54\x40\x25\x36\xda\x9c\xa2\x34\x26\xad\x23\x75\x12\xde\xe3\x28\x16\x5c\xff\x28\x3c\xc7\xf4\x49\x8d\xb8\x29\xaf\x19\x77\xa1\xba\xbd\x2d\x0a\xba\xdc\xfb\xa1\xfa\xf3\x7d\x27\x11\xde\xc6\x2b\xb2\x0e\xa9\x08\x07\x86\x16\x50\xea\xba\xd0\x60\xb7\x2e\x56\xb6\x6e\x60\x7d\x37\xca\x20\xba\xf8\xcc\xba\x74\x55\x1a\xbd\x63\x0f\xd3\xa9\x0c\x22\x92\xe7\xf7\x9b\x0a\x75\x95\x32\x4b\x13\xb0\x98\x34\xd3\x0d\x71\xa1\x04\x1a\x65\x42\x2b\xaa\x19\x55\xea\xac\xe6\x11\xb8\x05\x8a\x6a\x4a\x98\x94\xef\xae\xec\x7e\xbb\x80\x79\x2a\xeb\x17\xad\xc7\xd7\xad\xd3\xb0\x5b\xbe\xb4\x66\x3f\x2b\x5f\x79\x52\x5e\x5c\x8d\x89\x91\x39\x54\x9a\xc8\xfb\x4a\x84\x20\xef\x35\x98\x2b\x94\x26\x5c\x15\x43\xb6\x49\xa8\x6a\x47\xa0\xdc\x06\x86\x39\xcd\x2c\x60\xa1\x3e\x2a\x57\x11\x8e\xb3\xeb\xd8\x89\xee\xfe\xde\x63\x47\xbb\x8e\x0d\x2a\x27\x3a\xfa\xbb\x3b\xde\xef\xe9\x52\xa8\xa8\xb7\x2c\x44\xa3\x72\x71\xcd\xfa\xfa\x33\xeb\xd2\xf5\xdd\x73\x97\xa4\x3e\xa7\x30\xb0\x03\xb2\xf5\xea\x85\x78\x50\x02\xcf\x29\xc2\x2b\x83\x61\x77\x36\x8b\x7b\x5f\xa9\xa9\x5a\x6b\x3a\x75\x6a\x33\x23\x58\x44\x77\xcc\xc8\x66\xe2\x9f\x4b\x53\x61\xdf\x82\x3a\x31\x3c\x36\x32\xb4\xef\xe0\x6f\xc2\x8b\xf6\x06\xdf\xf9\xcf\x03\x58\x33\x81\xd4\x8c\x03\xc5\x89\xfc\x01\xdb\xbd\x32\x4c\xfd\xbb\xc7\xa4\xb5\x7a\xfd\x70\x8a\xca\xd0\x3e\x2c\xc4\xd9\x66\x8c\x62\xbd\x94\x31\x73\x68\x5f\x1c\x5b\xfe\xab\x0e\x3b\x7e\xb6\x7b\xb0\xfd\xf8\x81\xa3\x6a\x9a\xff\xf4\x20\xf1\x35\x36\xa1\x2e\x2f\xbe\x41\xe6\xb1\xe2\x85\x89\x95\xf7\x4c\x2a\xd0\x5c\x80\xad\x48\xb9\xbe\x9e\x9a\xd4\xbf\x03\x10\xc6\x94\xa9\xd8\x95\x9c\x00\x99\x56\x0f\x9e\xa1\x7d\x9f\x0c\x0d\xf9\x51\x0d\x21\xb2\x21\x2f\x3a\xf8\xe3\x53\xa7\x7c\xb7\x8d\xb1\xcf\x98\xd2\x0a\x03\xe3\x5a\x36\x5b\xe7\xb8\x12\xa1\xdb\x4f\xcd\xfb\x73\xc9\x80\x26\x99\xdd\x04\xeb\xf3\x95\x4c\x14\xab\x7e\xa0\x09\x52\x01\x94\x57\x3a\x4f\xf5\x61\x7c\x7d\x33\xd5\xcc\x96\xe2\xaa\x09\x0e\xf6\xcc\x88\xf3\xd1\xd4\xb3\x93\xa0\x6c\xca\xa5\x48\xf2\xfd\x94\x18\x89\x98\x35\x81\x67\x88\x30\xd5\xb3\x91\xea\x19\x4d\x10\x8f\x3d\xa2\xba\x61\x25\x93\x95\x8d\xc0\x76\xe4\xa7\x52\xd7\xb9\xb1\xf7\xb3\x1d\xb5\x29\xf7\x6a\xb2\x9b\x41\xf5\x0f\x3c\xdd\xe1\x9b\x9b\xb5\x7d\xa7\xa8\x3e\xdf\xd7\x1d\x6b\xa7\x08\x24\xb6\xf3\xcc\xcd\x3c\x48\x23\x79\x0c\x9c\x6d\xc7\xe4\x70\x61\x2c\x5b\xfc\xe5\x22\xd6\xcc\x5e\x5a\x83\x4b\x9c\x8b\x83\x2f\xfc\x91\xf4\x7c\x30\x38\xd8\x87\xa1\xf7\x1f\x4f\xdb\x15\x7b\xb1\xfe\xac\x4d\x8d\x1c\x3f\x3d\x26\xd0\x33\x56\x82\xc4\x7e\xe4\x48\x8c\x8d\x3b\xa9\x18\x51\x7d\x4e\x2a\x3f\xd2\x16\xf9\xa8\x1c\x42\x5a\xef\xa3\x0a\xa3\xb7\x1e\x17\x55\x80\x47\xf5\x63\x86\xd1\x8b\xc6\x4d\x6c\x5b\x8a\xc4\x03\x23\x64\x43\x61\x94\x39\x49\x00\xae\xcf\x39\x25\xc6\x91\xd4\x39\x25\x70\xf8\x7d\x53\x1e\xab\x48\xbc\x5b\x8a\x2d\x9a\x0d\xb8\xa5\x3c\xa8\xf7\xd2\x2b\xc5\xf4\x85\x7b\xa5\xa8\xf8\xaa\x70\x4c\x2d\xcf\xbb\x8e\x29\x8c\x87\xa5\xde\x0f\x49\x1c\x53\x34\x8e\x37\xc3\x2f\xe5\x2e\xe2\x96\x5b\xe4\x83\xa3\x6c\xd6\x2d\xd5\xaa\x81\xee\x91\x5b\xaa\xa9\xe1\xee\xa9\x57\xca\x19\xfa\x5e\x7b\xa5\x42\x58\xf0\x26\x39\xa5\x9a\xe0\x43\xb3\x5b\xa0\x11\x9f\x94\x43\x6e\x9d\x1e\x21\x29\xd2\xe4\x2e\x29\x97\x53\x8d\xb8\xa4\xba\x72\x93\x6e\x56\x20\xb0\xec\x84\x6a\x7b\x88\xa7\x54\x53\x14\xd9\x2b\xca\x08\xf0\x5a\xcf\xfc\x2f\x97\x97\xbf\x65\x87\x8a\xd4\x4c\x4a\x96\x57\xb1\xf8\x42\x43\x62\x91\x0b\x47\x8e\x77\x1f\xda\x7f\x50\x56\xb6\x86\x27\x14\x05\xf9\xfa\x05\x7a\x14\x67\x39\x6c\xbd\x94\xaf\x3d\x05\x85\x6f\xf7\xf2\x0d\xa9\x6d\x9a\xa9\xa1\x53\x8e\x8b\x25\x93\xa2\x27\xe3\xfb\x57\x67\xb0\x66\x06\x69\x79\x0e\xe8\x28\xb8\x69\x3b\x79\xd5\xad\xd2\xa3\x67\x35\xe9\xb8\x44\x3e\x3a\xd5\xd6\x61\xf3\x6e\xd2\x01\x38\x88\xc4\x00\xe2\x3b\x50\x89\xfa\x1f\xfe\xb1\x78\x2a\xb4\xca\x5c\x0d\x01\x7c\x45\x51\xaa\x30\xb6\x5a\x2d\xe3\xf3\xd6\x25\xf4\x62\xad\x0b\x67\x64\x45\x44\x1b\x0f\x16\x42\xac\x6f\x8e\x42\x13\x8c\x13\xd4\xbd\x8d\x4a\x32\x76\x57\xa0\x5d\x0a\x32\xb2\xf8\x2d\x53\x94\x09\xcd\x23\xe0\x25\x9d\x88\x9e\xda\x0c\x82\xe0\x7e\xa8\x9b\x94\xf0\x8c\x82\x24\xb5\x31\xa5\xc9\x02\x01\x6a\xa2\x6b\x64\x0a\x72\xa4\x9e\xfc\xd8\xe8\x39\x12\x16\xbb\x2b\x1b\x7e\xf1\x98\x74\x7f\xc9\x11\xb3\xbc\x8e\x43\xef\x36\x94\x0a\xc1\x1d\x89\xd8\xa9\xe2\x4e\xfb\xda\xdd\x9d\x52\xaf\x04\xfb\x65\x02\x1b\xdb\xf7\x5e\x22\x74\x7c\xe3\x4e\x8c\x8f\x2f\xdc\x75\xe3\xd3\x64\xc7\x60\xec\x4d\xb3\xb9\xf9\x94\xe2\x8d\x9c\xce\xc0\x89\xdb\xc0\x74\x8e\x72\xbb\x37\x8f\x2b\x13\xf5\xe7\x44\x25\x66\xef\xdc\x2f\xcf\xbf\x80\xfb\x0b\x5e\x00\xe9\xa8\xab\x7f\xfb\xd4\x62\xe7\xd4\xc2\xd8\xc3\xc2\x87\x9c\xc6\x1e\x32\xd3\x49\x30\x37\x2e\x46\x04\x09\x2d\x11\x23\x36\x35\x31\x25\xb6\x19\xa5\x38\x8e\xeb\x99\xdd\xa0\x4a\xe3\x4a\xdb\x44\x31\xcf\x84\x36\x52\x9d\x91\x01\x6c\x82\xb6\x56\x90\x93\x8c\x82\xb0\xa4\x87\xa4\x54\x84\xa6\x2c\xd4\x4b\x87\x51\x98\x52\x0b\x44\x0a\x6e\x7b\xb9\x96\x09\x82\xed\xd2\xe7\x2c\x68\x2a\xdf\xad\x59\x97\xbe\x49\x2a\x5d\xc6\xb8\xfa\x22\x09\x87\x34\xb6\xda\x95\xa1\x48\x0a\x04\x8b\x57\xca\x3c\xd9\x1c\x95\x40\x8f\x71\x89\xca\x7a\xa9\xf4\x18\x9f\x40\x14\x4e\x4c\x50\xbd\xff\x48\x64\xbe\x4a\x90\x9f\x5f\xaf\x3e\x48\x2c\x77\x6d\x9c\x76\xc7\x28\x6a\xed\xc8\xd1\x4c\x1c\x32\x01\x13\x78\x18\xd4\x49\xee\xa3\x2a\xad\xb6\x70\x91\x63\x21\xfc\x4f\x8b\xf8\x0c\xd1\x19\x6b\xee\x1a\x56\x64\x48\xb2\x6b\x6d\x9a\xa8\xe2\x36\x72\x3a\x72\xec\xac\xbb\x06\x38\x9d\x04\x3c\x42\xe6\xa1\x4e\xbe\x77\x80\x26\x54\xc6\x64\x18\x9f\x72\xe2\xbd\x03\x8c\x83\xb1\x36\x36\xb3\x68\xbd\xc5\x4a\x1b\x9c\xc8\x15\xb9\x12\x05\x9a\xf5\x99\xf2\xf7\x2b\xe5\x99\x87\xdc\x66\xa6\x7c\x71\xae\x7c\xfb\x33\xb4\x61\xdf\xad\x7b\x86\xc5\x7c\xda\xc1\x2d\x3c\x72\x8c\x77\x89\x1a\xb6\x13\xbe\x22\x78\x4d\xb3\xec\x84\xb2\xd4\x4b\x02\x17\x24\xe1\x46\x11\x1a\x37\x34\x70\x72\x50\xa2\x55\xe8\x28\xe8\x94\xbb\x8f\xc5\xe7\x11\x45\x7f\x5f\xa7\x6d\x27\x89\xb8\xd5\xdd\xb6\x1e\x5e\xb0\x16\xae\xd2\xd3\x6c\xbf\x48\x3a\x14\xd8\x8c\xe6\xb8\x9a\xb5\xdb\x4c\x47\xf8\x1f\xa8\x89\x76\xe5\xf9\x55\x10\xd4\x89\x96\x25\x96\x7d\x77\x65\x14\x75\xc2\x21\xde\xc8\xe4\x2f\x57\x7d\xa7\xb8\x53\x6a\x58\x93\x74\x04\x36\x9e\x64\x15\xe6\xc3\x6b\xcb\x27\x1a\x50\x1e\x58\x15\xc3\xa7\xea\xc3\x6f\xca\x5f\x2d\x31\xab\xea\x82\x29\x0a\xde\x44\x82\xb5\xee\xfd\x9c\x0c\xa6\x56\xc0\x9e\x08\x09\xac\x0d\x1c\x3d\x9a\xdc\xda\x90\x2f\x18\xb6\x51\x05\x1d\xf0\xc8\x67\xea\x1f\x47\x0d\xd5\x48\x44\xee\x6f\x72\xed\x87\x61\x68\x1d\x48\x57\x4e\xe0\x96\xd2\x0a\xf2\x1d\x75\xef\x4c\x65\xe9\x6c\xf9\xf6\xfd\xea\x39\xdb\x97\x74\x03\x63\x35\xeb\x13\x13\x18\xd3\x50\x6b\x9b\x89\xd5\x44\xaa\x6b\x5b\x28\x9a\x24\x46\x9a\x64\x2a\x88\x8d\xda\xbe\x66\x45\xa2\x0a\x5c\xad\xea\x81\x4b\xdc\x8c\x1e\x07\x31\x91\x95\x9c\x9d\xed\xc5\xca\xf6\x2a\x1a\x52\x9b\xc4\x18\x37\x7f\x5e\xd4\xde\xf9\x0b\xe0\x8d\x9d\xbf\x51\xc0\x3a\x4e\x07\x9d\x9b\xa9\x1c\x21\x86\x9f\x95\xaf\x3e\x51\x7a\x3b\xf0\x51\xce\x38\x4e\x8e\x29\xa7\x4e\x34\x6e\x90\x71\xba\x46\xb6\xc6\x26\x23\xa4\x06\xa9\x2c\xf2\xe9\x85\xd3\xd4\x3b\xab\x9c\x37\x50\x87\x30\xf1\x60\x71\xd4\x08\xd4\x20\xfc\x13\xdc\xd4\xd6\xc7\xc2\x54\xd9\x49\x27\xff\x3e\xc1\xd6\x23\x41\x2b\xe2\xd7\x1b\xd8\x74\xc5\x82\xae\x11\x3e\xb3\x08\x73\xd0\x90\x56\x1e\x04\xd2\xac\xf8\x33\xd5\x49\xaf\x0c\x6a\x12\x1a\x85\x30\x36\xbe\x50\xb9\x3d\x4e\x6b\x56\xa9\x43\x0a\x27\x82\x0c\x53\x08\xf4\x70\x71\x3a\xaf\x45\xd9\x77\x98\x02\x9f\x71\xa7\xf6\xfd\xa4\xdb\x96\xed\xc4\x81\x2b\x4e\xa2\x7e\x3e\x6c\x3e\xf6\x5d\x73\x82\x76\xdc\x24\x76\x06\x97\x80\xc6\xe6\x83\xc9\x68\xcd\x7c\x60\x03\x1e\x52\x8a\x8d\x3a\x6c\xf6\xd4\x89\xa7\x19\x9b\xfd\x9f\xf5\x7c\x3e\x30\x01\x32\x5c\x17\x2f\x54\x9e\xff\x25\x94\xe5\x51\x08\x42\xed\x20\x98\x30\xc0\x39\xb8\x58\x5a\x92\xeb\x63\xaa\x26\x47\x5a\x14\xc6\x28\x0d\x83\x1d\x7c\x7d\x86\x49\x85\xb8\xf6\x03\x8f\x8b\xde\x3f\x9d\xb6\xd9\x2a\x76\x02\x2a\x6a\x63\x5a\xa1\x5d\x51\x0e\xa3\x46\x8e\x6d\x51\xcd\xe9\x5c\x51\xfd\x18\x96\x66\x36\xdf\x46\x2d\x31\xfe\x90\x1e\xb5\x43\xa4\xdc\xd9\x4a\x8d\xff\x41\x9a\x96\x00\xab\x0b\x38\xbb\x79\x96\x9b\xf3\x49\x86\xb1\xb3\xbd\xcc\xed\xdc\x6c\xc2\x44\x2b\xb7\x4b\xa7\x41\xd3\xa1\xf4\xdb\xb3\xfe\x1f\xb9\x53\x68\xf9\xca\xcf\xd4\xcb\xfd\x34\x7a\x85\x67\x7f\x82\x3d\x65\xdd\xbb\x59\x5d\x7b\x8c\x59\x0e\xd4\x75\x9a\x8b\x91\x02\x98\xdd\xeb\xb3\x00\x20\x9c\x76\x00\x17\xed\xc3\x93\xca\x4f\xa7\xe1\x60\xe4\xcb\xc7\x0c\x2e\xc6\x49\x25\x2f\x63\x92\xc3\x1c\x88\x6e\x97\xb7\x40\x6a\xd2\xd2\x62\xe5\xe1\x93\x48\x7c\x78\x82\x65\x30\xcc\x4c\x99\x52\x79\x2b\x10\x4e\x98\xca\xb4\xf2\x47\x63\x84\xb4\x64\x78\x94\xb2\x6c\xf6\xe3\x36\xc1\x2a\x6d\xa6\xac\x0c\xa9\x43\x51\xe5\xf1\xbc\xf5\x62\xd6\x7a\x7e\xba\xfc\xf8\x3e\xcd\xd7\x4d\x6e\xbf\x67\x83\xc2\x76\xbf\xab\x0b\xe5\xb9\x25\x5c\xce\xcf\x7e\xac\x3e\x9d\x85\x0f\x91\x84\xc6\x6c\xca\x84\xed\x1c\xbb\x38\x5b\xcd\xa4\x74\x35\x3a\xca\x39\xa7\x4c\x13\xbd\xcd\x80\x17\x18\xb2\xa6\xe5\x32\x79\x03\x56\x78\x7d\x87\xcd\xc7\x79\xbe\x52\x7b\x4d\x47\x1c\x5d\xa4\xb2\x49\xc7\x18\xc5\x4a\x4f\x07\xb8\x75\x6f\x5e\xd5\x0b\xa6\xe8\x6a\xa9\x18\x69\xea\x51\x92\xf1\xb6\x38\x54\x72\x9a\x5a\x80\xe3\x1f\xa7\xe0\xc3\x89\xec\x40\x0e\xa4\x86\x56\x84\x69\x90\xc9\x0a\x6f\x23\x19\xea\x9c\x0c\xdb\x64\xf7\xf2\xea\x01\x6b\xe6\x39\x5a\xe7\x61\x3d\x90\xf9\x67\x28\xe7\xb4\x48\xe4\x23\xc5\x3a\x3b\x6b\xad\x6e\xec\xde\x38\x53\x7d\xf9\xb9\x75\xe9\xf3\xca\xe5\x3b\x0e\x37\x87\x72\x3c\x6f\x5e\xfc\x30\x77\xc9\x19\x60\xfa\x38\x50\x0f\xe5\x4c\x6c\x0c\x26\x57\xf4\xdb\x68\x4c\xcd\xe6\xb3\xf2\xbf\x87\x4a\xef\xbc\xf3\x6b\x8d\x5b\x25\xb7\x91\x30\xd3\x8b\xe4\xc8\xa7\x2a\x2c\x83\x70\x6a\x7e\xfa\xa9\x4c\x16\xb9\x90\x1d\x8a\xb0\xd7\xf0\xd6\x19\xe0\xa8\x00\x0c\x7c\x65\x71\x63\xad\x7e\xb5\x7b\x63\x56\xf4\x57\x64\xb0\x72\x21\xe1\x21\xbd\xaf\x60\xc0\xbd\xb7\x38\x1d\x18\xc2\x88\x61\x64\x35\x55\x5a\x46\xb9\xf6\x45\x97\x67\xeb\x9f\x59\x4f\x2e\x03\x5d\xcd\xa0\xb7\x97\xaa\x09\x3a\x5d\x6e\x4c\xda\x44\x30\x8a\x8c\xc7\xd7\x2a\xdf\x3f\xd8\x59\xff\x91\xe7\xb0\x19\x62\x72\xa5\x89\x11\x6c\xa4\x1e\x9c\x3c\xfb\xf1\xd8\x49\x94\xd1\x08\x67\x01\x90\x19\x32\x7f\x7e\xc8\x52\xda\x0f\x77\x74\xf7\x74\x1d\x92\x5e\xc5\x31\xa7\x4e\xf2\x62\x57\xc7\xe0\xf1\xfe\x2e\xe5\x70\x4f\xc7\x11\x69\xf1\x5d\x8a\xc0\xe3\x72\xbe\x12\x28\x94\x2c\xa8\x70\x91\x4c\xdb\x83\x51\x30\x38\x53\x10\x7d\xf6\x72\x83\xe2\xba\xf0\xca\x73\xad\x10\x76\x61\x54\x1f\x7e\x51\x9d\xff\xd1\x49\x05\x8c\xc4\x39\xaa\x15\xd3\xe3\x3e\xf5\xcd\x4c\x12\x10\x50\x5d\x7d\x69\x3d\xbe\xee\x51\xdb\x18\x5b\xa2\x08\x80\x20\x66\x76\x98\xd5\x81\xd6\xba\x73\xa7\x09\x74\xda\x24\xe8\x46\x66\x22\x1d\x99\xd1\xed\x6c\x5e\x40\x13\xad\x0f\x63\xb4\x6a\x1c\x44\x09\xd3\x99\xe2\x78\x50\x3c\x8f\x69\x62\xd9\xcb\xd4\x0f\x1f\x07\x0d\x91\x4f\x2e\xca\x5d\x24\x66\x03\x4f\xb3\x1c\x92\x1b\x31\x24\x96\x48\xe3\x3c\x43\x0f\x6e\x1d\x1c\x63\xac\xcd\x70\x8c\x6e\xcb\x05\x2e\x23\xe7\xae\x8c\x38\x86\x3c\x5b\xab\x5c\xfe\x01\xed\x2c\x5b\x67\x6a\x06\x5b\x17\xe6\x7a\x50\xc2\x45\xbd\x61\x64\xe4\x27\x0c\x59\x1a\xe4\xfa\x6b\xd1\xe2\x90\xc1\x52\x9c\x3a\x5c\x4d\x2f\x0f\x76\xb1\xb7\xd7\xe7\x03\x16\x4b\x85\x28\x08\xc1\x9d\xc0\xeb\x2b\xc8\x00\x19\x29\xba\xca\x62\x52\x07\xf3\x51\xd4\x03\x1f\xb6\x73\x90\xa3\x8c\xd0\x78\x54\x04\x5e\x10\x59\x0e\xdc\xab\x8c\x6c\xe9\x91\x87\x40\x90\x0e\x5b\xe9\x6b\xc3\xca\xc7\x22\xe1\x1b\xed\xec\x5a\x68\xc3\x82\x08\x73\x9e\x1b\x2b\x67\x4b\x73\x51\x77\x88\xcd\x44\xde\x18\xc5\x38\x41\x0f\x24\x08\x4f\x4b\x1d\x6e\x96\x64\xa3\xe6\xe2\x07\x6c\xa0\x8c\x66\x35\x57\x3a\x10\x06\x4a\xc1\xe4\x28\x14\x22\xa6\x1e\x7d\xa0\xfc\xf1\x70\x56\xc5\x2a\x72\xa2\x2e\x54\x46\xda\x9c\x82\x8e\xdc\xda\xf7\xe0\x76\xc2\xf1\x4a\x72\x4d\x40\x86\x92\x63\xfe\x1b\xc1\xc8\x21\x35\x71\x18\xa5\x89\x27\x11\xf1\xfb\xe8\x18\xe6\x16\xd9\x74\xc1\xa4\x1e\xe5\xd8\x0b\x61\x42\x3d\x09\x17\x78\x1c\x06\x25\x19\xe0\x53\xda\xc7\x3a\xa5\x1a\x15\x45\x3d\x81\xbc\x0a\x33\x00\xd4\xe2\x8f\xf9\x28\x4f\x34\x36\x4f\x5c\xfe\xde\x5a\x7e\xe2\xdc\x4b\xed\x4e\xf7\x78\xc1\xae\xac\xac\xee\xbc\xbc\x0d\x4a\x18\x7f\x49\xed\x53\xb0\x98\x80\x5b\x39\xd4\x45\x40\xfd\x52\xe0\xf4\x5e\x96\xdc\x03\x0e\x1b\x58\xc1\x7f\x44\x84\x50\x60\x6b\x09\xbc\xc9\x52\xbe\x56\x74\x7f\xed\x28\x70\x19\xae\x25\xfd\x56\x86\xeb\x74\xe4\x0b\x06\x55\x67\xc0\xa0\x48\x0f\x60\x69\x11\x89\xe7\x9b\xd8\x8f\x81\xc2\xfb\xb0\x9a\xc4\xfa\x62\xf9\xd2\x52\xe5\xde\x26\x0c\xbb\xba\x7a\x4f\x5a\x48\xc2\x83\x1a\xaf\x8d\x75\x0c\xc5\x8b\x90\xab\x0c\x30\xaa\x28\x3c\xa2\x94\x04\x67\x6f\x90\x47\xba\x45\xbc\x9b\xd0\xc7\x0a\x6a\x63\x23\xa8\xbe\x3c\x55\x79\xb8\x95\x74\x04\xf5\x94\xc8\x63\xf8\x49\x4a\xe4\x31\x6c\xd8\x59\x2c\x9e\xb8\x4b\xa8\x3d\x12\x5e\x08\x91\x38\x76\xcf\x2d\x62\xb3\xe7\x9a\xe2\x2c\x3c\x2a\x5e\x08\x51\x98\x4b\xb9\x96\xad\xe5\x23\x5d\x83\x83\xdd\xc7\x8e\x28\x03\x83\x1d\xfd\x83\xf2\x8b\xca\xec\xfd\xdd\x6b\x92\xcd\x75\xa4\xa7\xf7\xfd\x8e\x1e\xa5\xb7\x6f\xb0\xbb\xf7\x98\xb4\x64\x84\x35\xfb\xc8\xfa\x61\x66\x77\x66\x7e\x77\x65\x43\x52\x32\xe2\x08\x5c\xc9\x55\xd7\x5f\xe2\x34\xb6\xa1\xc8\x42\x73\x5c\x49\x67\x75\xd4\xaf\x23\xce\x5a\x74\xb0\x5b\xab\x5f\x53\xe6\xd2\x66\x20\x28\x23\xaa\x97\x0e\x62\x46\x79\x56\x6b\x2d\x67\x1b\x0c\xce\x70\x54\x11\xfb\xda\xc0\x9e\x70\xdb\x3b\xdc\xb8\xa5\x04\x70\x34\x11\x36\x2c\x10\x2d\x83\xd9\x57\x04\x27\xeb\x49\xad\x08\xba\x55\x5a\x8b\x4f\x0a\xb9\x68\xad\x9f\xb6\x96\x37\x41\x1a\x8a\x10\x10\xca\x6d\x61\x27\xa1\x34\x97\xe1\x88\x1b\xc9\x64\xbe\x8e\x02\xf3\x4c\x6a\x33\x05\xe6\x63\x87\xe6\xb9\x81\xb6\xb7\x4b\x63\x71\x99\x4c\x11\x11\xe6\xb6\x0f\xa2\x37\x22\xc1\x8b\x6b\x66\x44\xef\xb4\x3d\xe4\x92\xcd\x8f\x3b\x77\x62\xd9\xa0\x79\xb2\x56\x9c\x8a\x62\xca\x27\xaf\xb9\xc1\x40\x03\xf3\x2f\xed\x2e\x40\x37\x0f\x8f\xea\x1a\xcf\x12\xba\xb2\xef\x05\x2f\x62\x96\xd9\xab\xe2\x06\x9b\x18\x12\x2c\x62\x0e\x78\xf9\xaf\xba\x28\x58\x89\x8c\x5d\x0e\xb2\x03\x20\xca\xe9\xea\x91\x1a\x31\xae\x57\x32\x04\x4b\xee\x52\x47\x7c\x81\x8e\x7b\x99\x23\x28\x97\x24\xb8\x5c\x28\x54\x32\x96\x4f\x0e\x95\xaf\xaa\x2c\xbf\x38\x61\xa3\xca\xf2\xbb\xe4\x27\xa5\x3d\xae\x8e\xf9\x5e\x75\xc0\x8c\x96\xe5\xe1\x05\xcc\xeb\x98\x9c\x37\xb1\x4b\x88\xd0\x47\xf6\xb0\x4b\x88\x67\xf4\xe6\x3f\xde\x50\x63\x87\x25\xcb\x14\x6f\xc1\x31\x93\xe0\x70\xe0\xdb\x9f\xe9\x76\xd5\xc2\x58\x64\x53\x2f\x1a\x05\x1d\x0e\x0d\x00\x10\x2d\x1d\x31\xe6\x5c\xb4\x99\x0a\x09\x51\x8e\x1d\xbb\x0f\xbb\x83\x79\x5a\x91\x79\x38\x5d\x75\x38\x0c\x5d\x34\xae\xd0\xe6\x0b\x24\x32\x5a\x2b\x7f\x43\x7b\x2f\x28\x09\x77\x38\x11\xd9\xba\xc2\x01\x5e\x8a\x62\x71\xfb\xec\xe7\x35\x24\x28\xcd\x2e\x49\xaf\xa5\x3d\xc1\xc2\x14\x25\x5d\xf7\x82\x0c\xeb\x45\x1d\x04\x34\xd3\xc5\x3f\x92\xd8\xc6\xb1\xd7\x85\x26\x09\x40\x19\xc4\x68\x0a\x4b\xb6\x5a\x49\xe5\x9a\xfd\xea\x82\x22\x3a\x5a\xf0\x97\x47\xf0\xbb\x63\x89\x56\x72\x88\x3a\x10\x02\x85\xca\x17\x3c\x3c\x63\xcd\xdd\x88\x5d\xd5\x7e\xc2\xcc\x3d\x51\x5a\xe2\x28\x10\x6d\x83\xb8\xb0\x44\x6b\xf7\xb6\xdd\x2f\x08\x33\xff\xcb\xb7\x3f\x4b\xc0\x0e\x1f\x31\xd4\xf7\xd8\xe9\x1c\xf4\x3e\x7d\xc2\x15\x96\xf3\x57\x5a\x12\xcb\xc5\xf9\xbb\xe5\x4a\x6b\xb0\xb1\x90\x43\x09\x96\xb7\xf6\xaa\x53\x5e\x12\x9c\xb2\x17\x7b\x31\xfc\xda\x32\x1f\x6f\x12\x5f\xfe\x3e\x73\xaa\xa6\xe2\xc7\x9b\xc7\xad\x57\xb6\x44\xc2\x78\xb1\x77\xe3\x7d\x35\xc3\x6a\x0d\xfd\xaf\x74\xb5\xee\xf1\xda\x7b\x33\xb6\xe4\xeb\xd9\x77\xaf\x60\x83\xb5\x7a\x13\x39\xb9\x27\xe6\x1e\xde\xc3\xbc\x9d\xf2\x12\x93\xc6\x9b\xba\xf5\xb7\xae\xda\x26\x79\x09\xf4\x28\x5f\x71\x41\xbc\x8f\x08\x67\x4f\x92\x1a\x6a\x7b\xc1\xd1\x5a\x5c\xce\x22\xe0\x4a\x52\x09\xaf\x32\x0d\x8d\x2b\x99\x7a\xb8\x27\x84\xd6\xba\x65\x5e\x5f\x77\x42\x2a\xb0\x5f\xa7\xdb\x84\x1c\x44\x5e\xfe\x24\x1f\xf8\x6b\x1b\x67\x63\x1e\xa2\xa4\xc3\x0b\xe9\xb9\xb8\x37\x57\xfe\xd0\xa6\x8b\xc9\x2f\xfd\x1e\x42\x5b\x7d\x3d\xf0\x52\x96\x8c\x0e\x33\xac\xdd\x63\xe4\xe4\x27\x13\x99\x49\xa6\x3f\x88\xcf\xdb\xf8\x31\x89\x24\xc5\xcc\x33\x4a\x58\x18\xc0\x4f\x98\xaf\xe0\x5b\xd9\xce\xa9\xfc\xda\x3c\x1d\x01\x0a\xa2\x37\xf4\xdd\xb3\xe5\xbb\x73\x1c\x7d\x2f\xc6\xf3\xb7\x99\x04\x93\x48\xe9\x77\xff\xf8\x03\x8f\x1d\x28\x47\x40\x86\xf7\x26\x3d\x20\x73\x01\xb4\xb0\x5f\xaf\x74\xf1\xfa\x86\xe7\x47\x2f\x16\x34\xc5\x4e\x36\x35\xc0\xbd\x15\xc3\x21\xcd\x57\xa3\x49\xa6\xa2\xce\x94\xa7\x4e\x6d\x6a\xd2\xd9\x52\x86\x4e\x4f\x2e\x35\xc1\x69\x36\x23\x46\x66\xba\x0d\xeb\x06\xef\xff\x3f\xfb\x41\x07\xc0\xbe\x5f\x5a\x46\x19\x99\xc6\x3a\xb8\x14\x93\x06\x6b\x00\x5f\xc7\xd4\x69\x7a\xd1\xc9\x7b\xaf\xcb\x80\x46\xa4\x4c\x68\xc5\x71\x23\xa3\xbc\x75\xa4\x6b\xb0\xad\xaf\x77\x00\xfe\x73\x7c\xb0\xed\x50\x57\x4f\xd7\x60\x57\x9b\x56\x4c\xcb\x42\xb7\xe8\xdd\xf2\xd5\x8d\xf2\x4f\x57\x7e\x79\x3e\x07\x2f\xc3\x35\x1b\x5f\xc7\x7f\x8e\xe3\x7f\x19\x84\x52\x79\x3c\x2f\x8d\xe3\xfa\xc0\x30\x8b\x34\x14\xee\x3a\x34\x31\x9d\x32\x4b\x23\x1c\x47\x20\x43\xbb\xb3\xbe\x55\x5e\xde\xb4\x96\x16\xbd\xcd\x87\xbc\x2f\xc6\x23\xb3\xcd\x70\xdc\x25\xeb\x2d\x91\xa7\x27\x22\x6c\xc6\x55\xfc\x28\x62\x19\xa4\x63\x0f\x05\x15\x83\xb6\x24\xb2\x08\xd3\xc6\x04\x36\xf5\x71\xe2\xbe\x94\x43\xbd\x47\x3b\xba\x8f\x51\xa0\x27\x95\xa5\x9e\xf6\x50\x87\x99\x1d\xba\xb4\x3f\xd8\x1e\x61\xe4\xc0\xaa\x26\x70\xe2\xc2\xce\xc0\xc6\xf1\x41\x6e\x01\x2f\xbb\x8f\x0d\x0c\x76\xf4\xf4\x74\x1d\x52\xfa\x7a\x8e\x1f\x81\x11\x74\xf6\x1e\x3d\xda\x71\xec\x90\x34\x33\xe4\xd9\x8f\xdc\x93\x49\x54\x81\x89\xe8\x9f\xd6\x3d\x96\xc3\xac\x4c\x5f\x21\x07\x19\xd4\x97\xdb\x95\x2b\xf7\xbd\xd5\x1b\x24\x20\xc5\xde\x76\xea\x1a\x88\x12\x20\xf6\x66\x8f\x6c\x2f\x87\xfa\x3b\x95\x9a\x47\x9f\xfe\xc2\xac\xb5\xf4\x9d\xa8\x47\x7f\xef\x67\x29\x36\xa3\x80\x65\x6a\x94\xe3\xa6\x3a\xa6\x61\xed\x7d\x09\x68\x94\x4f\x3f\x5d\xc1\x10\xbb\xc7\xdf\x54\x56\x56\xe9\xc9\x24\x20\xdb\x93\xc3\xa4\x48\xf3\xa4\x60\x95\x8e\x9c\x9b\x53\xab\x9b\x0a\x75\x0e\x21\x67\x9f\x68\xc7\x47\x0f\x67\xa7\x15\x0d\x18\x6a\xc0\xfa\xaa\x8f\x90\xca\xf3\x4d\xeb\xc9\xe7\x9c\xf0\x8a\xe5\xe3\xf9\xc3\xf2\xb7\xfc\x40\xf9\xc2\xf7\xd5\xbf\x3e\xab\x8f\xde\x4e\xa7\xf2\x54\x0e\x96\x6d\x56\x1d\x33\x41\x80\x7d\x9c\xd6\xf2\x45\x25\x35\xfa\x36\x16\x20\x47\xba\x47\x44\x4d\x76\xd8\x0f\x53\xe3\x18\x11\xcc\xfd\xea\x94\x89\x52\xb6\xa8\xe7\xb3\x1a\x87\x9a\xb1\x2f\xd1\xbf\xee\xa4\x25\x73\x6b\xc6\x86\x2e\x45\x6f\x15\x11\x6e\x7a\x47\x05\xf2\x03\x69\xd0\x4e\x64\x3b\x7f\xef\xb4\xae\xe0\xb4\x29\x10\xa6\xa9\x51\x05\x6b\x6c\xde\xbb\x0a\x02\x54\x1a\x4b\x5d\xc3\x8a\x0f\xba\x3a\x7a\x06\x3f\x18\xee\xfc\xa0\xab\xf3\xb7\xc3\x83\x1f\xf6\x75\xc1\xf0\x4c\x1a\xfb\xd0\x3e\xac\x8c\x36\xb4\x0f\xa7\x71\x68\x5f\xce\xc8\x69\x43\xfb\x86\x80\xc9\x75\xcc\x5c\x2d\x70\xeb\xe5\xec\xee\xca\x16\x27\x34\x23\x78\x50\xf2\x60\x4a\xe1\x0f\x84\x0f\x7f\x08\x04\xc9\x68\x3f\x66\xb8\xcb\xce\x3e\x04\xea\x5a\x59\xc0\xd0\xdd\xe5\x99\x9d\xad\xad\x9d\xed\x2b\xbc\xac\xea\x58\x44\x32\xec\xa4\x24\xc2\x13\x75\x16\x6f\xa8\x81\xdf\x6f\xa7\x9f\xef\x87\x75\x46\x7d\x05\x31\xf2\xcd\xfd\x40\x21\x3d\xfb\x51\x39\xb2\xc9\x30\xeb\x1a\x3c\xe7\x89\x03\xeb\x23\xc0\xc3\x8c\x70\xfe\x79\xdd\xdc\x89\xa0\x7e\x4f\x68\x6e\x05\xa5\xb6\xe7\xcb\x89\xd9\x6d\x05\xa5\x35\x40\x5b\x40\x69\x47\x5f\x9f\x32\xd0\xd5\x7f\xa2\xbb\xb3\x6b\x98\x8e\xd4\x63\x9d\x5d\xcd\x92\x1a\x0e\xb4\x05\x94\x72\xef\x18\x14\xb7\x42\x6b\x49\x48\x68\x53\xa8\x6a\x25\x4f\x0b\xd8\xc3\xe0\xad\x2f\x16\x42\xc0\xb7\x94\x51\x7b\x31\xb7\x2e\xf1\x7b\x38\xc9\x2e\x99\x0d\x53\xe8\x25\xa6\x15\x84\x34\xc5\xae\x66\x39\xf3\xfe\xf1\xee\x9e\x43\x7d\x1d\xb0\x48\x10\x5c\x9b\x72\xac\xeb\x77\xc3\xfe\xef\x9a\x9e\xda\x00\x38\x9c\xe0\x10\x2c\xcd\x0e\xc4\xde\xba\x4d\x2c\xce\x46\x51\x52\xfd\x95\x04\xb3\x59\x2f\xfc\x9e\x8e\xf7\xbb\x7a\xda\x94\xbe\xfe\xde\x13\xdd\x87\xba\xfa\x69\x6c\x83\xbd\xbf\xed\x4a\x2c\xa0\xa4\x53\x42\x90\xf1\x1a\x6d\x83\xc6\x49\x61\xd0\xcd\xce\x43\x0d\xd1\xad\x20\x95\xe8\x73\x40\x36\x4b\x62\x6f\xff\x11\x9f\xb4\x6f\x86\x3c\x84\x85\xc4\x09\x58\xad\x23\xaa\x49\xb6\x05\xe8\x6a\x01\xcb\x84\x80\xf8\xb7\xe3\xbd\x83\x1d\xad\x20\xcf\x95\x06\x0c\xb2\x59\x12\xfb\xbb\xfa\x7a\xdd\x03\x0a\x3b\x21\xef\xd1\xb6\x1f\xe8\xea\x3c\xde\xdf\x3d\xf8\xe1\x30\x35\x03\x26\x6c\x7d\x1d\x70\xd6\x0e\xf6\x0e\x63\xde\xed\x70\xff\xf1\x9e\xae\x81\xe1\xc3\xdd\x3d\xcd\x8b\xce\x00\x2a\xda\x05\x12\x54\xcd\xb2\xcf\x8f\xaa\xcd\x59\x8f\x03\x7d\x1d\x2d\x38\xde\xfd\xd0\x41\xf2\xd8\xeb\x93\xc1\x37\x4f\x3c\x4b\xfc\xf7\xfb\x41\x86\xf5\xf3\x29\xe6\xff\xae\x05\x23\xf0\x81\xb3\x4f\xb1\xc0\xd7\xad\x1e\xc8\x71\xf8\x82\xf7\x5d\x5f\xc7\xc0\xc0\xef\x7a\xfb\x0f\xb5\xd5\xb3\xb4\x13\x8e\x06\xe6\xc3\x46\x84\x87\x82\xc0\x44\x63\x44\x64\xad\x1a\x94\x73\x1e\xdb\x5f\xfc\xb6\xeb\xc3\x96\x8d\x24\x14\x78\xcb\x29\xc7\x1d\xe1\x9d\xf6\x96\xe9\xbf\x35\x00\x83\x0b\xac\x65\xba\x70\xe8\x98\xf6\x74\x46\xbc\x2a\x7d\x4b\x66\xa5\xf7\x78\x7f\x67\x57\x0a\xaf\x83\x83\x1d\xfd\x47\xba\x06\xe9\x63\xd3\x64\x87\x42\x6d\x9a\x56\x16\x9f\xad\x3b\xd8\x19\x60\x0b\x8f\x76\x97\xc2\xd6\x1c\xed\x2e\x81\xad\x39\xd7\x09\x5e\xca\xbd\x79\xd2\x9f\x04\x3a\xd5\x92\xeb\x89\x07\xbe\x73\x20\x79\xe1\xb7\x84\x7e\x56\x4c\x68\x3f\xbb\x7f\xb6\x84\xf2\x50\xc8\x2d\xa4\xb9\xc9\x8b\x6a\x0b\x89\x72\xcf\x42\x50\x1e\xda\x94\xfe\xde\x16\x28\x58\x9e\x63\xcf\xd6\x48\x08\x6e\x8b\x69\x25\x2e\xec\x09\xc9\xf0\x5f\x77\xc3\xb5\x84\xf4\x64\x77\x59\x19\x79\x4d\xe0\xcd\xe7\xd9\xe9\xdc\xe4\x8a\x73\xe0\x34\xcd\x88\x7c\x7e\x18\x01\xb5\x09\x5f\xed\x70\x90\xba\x86\xa6\xcf\x86\x4a\x13\xe6\x05\xdc\x34\xb9\x4d\x50\xd5\x38\x56\x27\x7d\x5f\xb0\x8a\x8a\xd2\xa0\x9c\xce\x8b\x7a\xaf\x4d\x33\xcc\x8f\x01\xd6\x3b\xa1\x40\xee\x39\x28\x9a\x65\xdd\xb8\x61\x16\x89\x68\xd1\xf8\xa9\x59\x92\x09\x9e\x3b\xbf\x4d\xd3\x67\x64\x33\x9e\xed\x01\x74\xe6\xb4\xa9\xd0\xfd\xd2\xd0\xdc\x5f\xbc\x83\x09\x83\xde\x92\x9f\x54\xa6\x16\xe3\xf8\xaf\x3e\xa9\xfd\xbe\x15\x83\xc1\x10\x1a\x5e\x2f\x38\x12\xfb\xaf\xd6\x8c\x44\x54\xae\xf3\x8c\xc1\xfb\x4d\xd3\xd4\x17\xc6\xf6\x40\x28\xd8\x50\x5b\x2e\x14\x44\x4c\x69\x9b\x2f\xfc\xb7\xad\x36\x65\xb7\xd9\x01\x08\x80\xb0\x3b\x7d\x71\xc6\x38\x9c\x1a\x5c\x4d\x8f\x89\xe2\x0a\x5b\x71\x54\x78\x20\x35\x4b\xd4\xe4\xbb\xf6\x4d\x0d\x3f\x3a\xa6\x4a\xfc\xdc\xd3\x71\x4c\x99\x7c\xcf\xfd\xf9\x3d\xfe\xaa\x59\x96\xd7\x8f\xb1\xa1\x31\xca\xea\x0c\x05\xe8\x92\xd6\x5b\x70\xc1\xd9\xa5\xfd\x26\xd4\xe2\x41\xb7\xb2\x3b\xda\xb1\xb0\x08\x1a\x96\x9a\x1f\x2a\xc2\xff\xe5\x4e\xa8\x59\x3d\x23\x9e\xe6\xba\x67\xea\x44\x9e\x7a\x9e\x7c\x34\x94\x03\xe8\xf8\x1f\x05\x9d\xff\x05\xa3\x68\xa4\x8d\xec\x10\xa0\x19\xda\x57\x4c\xe7\x87\xf6\xb5\xd9\xbf\x65\xa8\x29\x04\x11\xcb\x3f\xbf\xfb\x4e\xfb\x7b\xbf\xf9\x4d\xfb\xbb\xed\xef\xfe\x2f\xcf\x63\xe8\xe0\x37\xf9\x81\x5f\xff\xfa\x9d\x7f\x19\xda\x87\x3f\x00\x21\xbf\x97\x0c\x9a\x7b\xf2\xdc\x7d\x6e\x3d\xbf\xe4\x1d\xb9\x5d\x4e\xed\x66\xe8\x78\xb0\x32\xd0\x95\x39\xac\x54\xc1\xaf\xd3\xc3\x95\x7b\x9b\x3b\x2f\x2e\x50\x45\xe7\x96\x8e\x2a\x6a\x4c\x92\xf9\xe1\xd2\x63\x9d\x3d\xdd\x22\xff\xbb\x4e\x33\x29\xbd\xee\xe9\xa5\xf5\x09\x36\xb6\xc6\x4f\xdc\xcc\x27\xb6\x3f\xb4\x27\x7a\x2a\xec\x5d\x39\x56\x90\x25\xb2\xc8\x26\xaa\x06\x10\xfd\xaa\x72\x54\x9b\x30\x0a\xd3\x91\x10\xb0\x10\xf7\xe3\xeb\x31\x70\xec\x68\x14\x55\xc9\x19\xb9\x54\x4e\x1b\x03\x20\x93\x9a\x5d\x8f\x3f\x1a\xbe\x1d\x6b\xb2\x7b\xfb\xab\xea\xcf\x77\xb8\x22\xbe\x0c\xdd\x24\x6d\x0b\x5a\x42\x61\x6d\x6c\x64\x4c\xae\x69\x5f\x23\x8a\x61\x8a\x26\x36\x77\x61\x69\x46\x63\xec\x17\x05\x4d\xf1\xdf\x88\x9e\x27\x76\xad\x52\x7e\x4c\x49\x02\x79\x60\xa0\x47\xe9\xd4\x44\x4b\x53\x0c\x4a\xc1\x4a\xf4\x14\x9e\x32\xa8\xe7\x8f\x6a\x66\x64\x8c\x8a\xfd\xbc\xc2\xfd\x4d\x7b\x14\xcc\x3b\xda\x78\xc0\x78\x6b\x81\x44\x12\xc2\xe5\xf5\x9b\xe2\x2a\x97\xd6\x4f\xce\xd5\x04\xad\x80\xbc\xb9\x54\x0c\x32\x42\xc8\x32\x54\xaa\x4e\x37\x56\x12\x25\xff\x40\x94\x4c\xea\x19\x11\x76\x9a\x4a\x53\x1c\x59\xbb\xd2\x97\xd5\x54\x18\xa4\xf8\x11\x96\xad\x67\x61\x19\x23\x7f\x44\x49\x4d\x3d\xc5\x88\x3e\x3b\x1a\x18\x00\x17\x41\x29\xa1\xf2\x65\xb5\x2f\x48\xfb\x47\xac\x6f\x22\x5e\x0e\x00\x2b\x5f\x5a\xda\x79\x71\x0b\x58\x85\x45\xae\xb7\x57\x79\x44\x70\x9c\x61\x0d\x51\xfa\x29\x20\x27\xad\xb5\x8d\xea\x0f\x2b\x18\x4e\x47\xb1\x89\xfc\xab\xf7\x27\xa7\xda\x10\x66\x9f\x53\x19\x81\x88\xa0\x32\xa6\xd9\xed\xdd\x85\x69\x09\x58\xe1\x82\x43\xdd\xf7\x2b\x29\x5b\x7c\xd1\x23\x19\x43\xe3\xee\xf2\x54\x73\x53\x32\x3a\xce\x05\x70\x81\x60\xd8\x0c\x27\xc4\x88\x06\x5f\x38\x40\x00\xcc\xb2\x8d\xbf\xc4\xf2\x9b\x11\xf5\x33\x1d\x3a\x75\xf3\x24\x67\xa0\xd0\x19\x79\x08\xfe\x14\x49\x2c\xf5\x15\xe8\xad\x7c\x73\xaa\x72\xeb\xba\x9b\x09\xe3\x01\xa4\x78\x76\x4a\xd2\x6a\xbd\xc9\xc9\x6b\x01\x45\x71\x44\x70\xd9\xa7\x14\x95\x7d\x4a\x51\xd9\xa7\xbc\x5a\x50\x27\x88\x22\xfe\xad\x13\x7f\xe2\xb2\xf1\x12\x6a\x6a\x61\xb0\x76\x14\x0a\x23\x91\x4c\x73\xb4\xdc\xb4\x51\xca\x71\xa3\x24\xfb\xa4\x30\x3b\xf1\x2b\xe4\x51\xb7\xef\x21\xcf\x09\xc2\x37\xda\x84\xa7\x47\x75\x75\x45\x90\x1a\xc4\xe0\x70\xd2\xfb\xa0\x73\xd8\xc0\xb9\x9b\xe4\xa4\x71\x46\x32\x41\x07\xa5\x92\xd5\x27\x74\x1e\x10\x9f\x9c\x3d\xf8\x77\x82\x19\xf7\x1e\xa5\xbb\x37\x96\xac\xb9\xa7\x35\x30\xea\x9c\x79\x9b\x32\x1f\x77\x7d\x7c\x6d\x90\xa3\x7e\x78\x01\x2e\x36\xca\xbf\x78\x2a\xb3\x98\x55\x5c\x1c\x57\x73\xde\x27\xc5\x54\x36\x4b\xaf\xf5\xe4\xd2\xce\xe6\xc5\x30\xc0\x91\xc4\x93\xf6\x1d\x97\xf1\xe1\xed\xca\x57\xde\x5c\x72\x35\x5c\x8f\xfc\x8b\x46\x63\xc7\x24\xb7\x2b\x6e\xaf\x12\xf8\x52\x56\xfe\xd3\x6e\x72\x2d\x4e\x0e\xb7\xbf\xc5\xf2\x13\xeb\xd6\x8b\x18\x54\x21\xab\x38\xf1\x12\xae\x5d\xbc\x8d\xad\xdc\x66\xb7\x52\x0b\x37\x91\x84\x94\x7a\x4f\x98\x70\x92\x9a\x3b\x5e\xbc\x95\x8f\x94\xb1\x92\x9e\x21\xfa\x8e\xc0\x87\xba\x23\x96\x19\x20\x96\xb9\xa5\x8a\xc1\xce\x01\x31\xc8\xdf\x24\xe0\xb9\xfd\xae\x7b\x30\x38\xef\xd6\xc9\x71\xb7\xc2\x21\xb5\x3a\xf5\xf5\x41\xe1\x96\xa7\x03\xd4\xe1\x05\xee\xbf\x89\xfa\xae\xb1\xfe\xe1\x87\x23\x5a\x6f\xcd\x3c\x77\x14\xc6\x08\xb0\x32\x6a\xf5\x22\x5b\x19\x61\x77\x82\xf2\xcc\x89\x6f\x6d\xf4\x8d\xc6\xb5\xf0\x47\x45\xbd\x73\xae\x62\x29\xca\x91\x53\x8a\x9f\xd4\x8c\xb1\x7b\x7a\x06\x9b\x79\x6d\x3c\xad\xac\xae\x60\x3a\x3e\x25\xb0\x61\xb7\x97\xad\xfb\xd6\xa5\xf3\x5c\x5f\x9d\xeb\x8e\x8b\x86\x06\x30\x0a\x2a\x9b\x2e\x37\x53\x48\xe8\x34\xb5\x2c\xea\xb0\xf8\x43\x1a\x64\xea\x18\x9b\xa2\xc4\x00\xb0\x1b\x91\x99\xd7\xb8\xa6\x33\xad\x7d\x33\x8e\xe4\x2f\x16\x02\x24\xef\xce\xcc\x97\x2f\xfc\x05\x4d\x8b\xb7\x7e\x2e\x5f\xde\xe0\xe4\x76\x67\x28\xd5\xd5\x17\xa8\xdd\x5e\x5e\xc3\xae\x70\xb4\x2d\x64\x23\xe8\x51\x41\xfc\xf7\xc2\xe4\x31\x46\x99\x0a\x7d\x1e\xcb\x2a\x7f\xb9\xb8\xb3\xbd\x2c\x01\x83\xed\x81\xf0\x06\x6f\xd7\x15\x76\xbb\x67\xf1\x9c\xc8\x76\xee\xdc\x35\x20\xb1\x72\x6b\x15\xd4\x73\xe6\xb9\xd0\x5e\xb9\x80\x9c\xc7\xee\x1b\x87\x77\x52\xd5\xb3\xb4\x2e\x84\x0a\x2d\xda\xa6\x4b\xcb\xe1\x13\x62\x81\xe6\x12\x4d\x3c\x60\x8d\x4d\x9f\x92\xe2\xa3\x41\x73\x96\x19\x66\xc2\x78\xea\xd6\x51\x1f\x6c\x7e\x27\x93\xf1\xfe\xa4\x4b\x6b\xf5\xc7\xe0\x76\x0b\x1c\x27\x18\x9c\xfb\x74\x0c\x54\xac\x39\x98\x00\x1e\xdb\xb1\x63\x60\x89\xc2\x62\x62\x1d\xa4\x39\xbd\x54\xe4\xdf\x8a\xf4\x37\xfb\x4b\x6f\x9d\x96\x48\xf4\xd6\xf6\x97\xd6\xfc\x22\x2f\x12\xbc\x90\xf1\x9f\x44\x8d\x77\xcd\xf0\x25\x2c\x86\xbe\x40\x01\xb0\x24\x6b\x24\xba\xae\x97\x07\xb2\xdf\xd0\xdc\xba\xcd\xe0\xad\x31\x19\x47\x84\x93\xb4\xaf\x52\xa6\x70\x34\xbe\x1a\x16\x32\xee\x38\x1c\x9c\x53\xfe\x96\x2a\x0c\xd8\x3a\xf6\xe0\xca\x17\xb8\x31\x22\xe7\x77\x29\xe6\xb4\x59\xd4\x26\xda\x44\xf6\x2f\xdd\xdb\x73\xd8\xe5\x1c\x85\x0d\xa6\xa5\x8b\x9f\x41\xeb\x2c\x62\x36\x99\x52\x28\x51\xdd\x75\x69\x3e\xaa\x6f\x42\x28\x23\xfc\x97\xe7\x73\xfc\xa1\x7c\x7d\x0d\x3b\xb1\x3d\x5c\x84\xcd\x0c\x32\xb0\xfa\x72\xa9\xba\xb2\x10\xa8\xd1\xbe\xfb\xf5\x99\xf2\x57\x67\xb0\x15\x0a\xdf\xd8\x7f\xda\xaa\x6c\xdd\x01\x99\x09\x77\xfb\xf2\x85\xef\x59\xbc\xd9\x5f\x4a\x92\x6b\x9d\xe1\x53\x83\x4c\xda\xcf\x42\xde\x24\xd8\xd6\x5e\xf2\xcb\xcf\xb6\xac\xf3\x77\x5d\x99\x63\xd7\xae\x4c\x80\xd6\x53\xb5\xcf\x33\xd9\xc6\x68\xc3\x5b\xca\x5e\x00\xde\xd9\xaf\x6f\x3f\x39\x69\xe9\x94\xef\x59\xff\x82\xa3\x53\x2d\x0a\x87\x23\x6d\x8d\xd1\x51\x8d\x3a\xd0\xd9\xd8\x3c\xb5\x59\xa2\xc7\x6a\x17\xcb\xa7\xae\xa0\x28\xf0\x77\x36\x1f\x5a\x5f\x4a\x7a\x04\x04\xb0\xb2\xe4\xb2\x9b\xfb\x88\xb2\x1c\xd1\xe8\xf8\x4c\x21\x5e\x56\xff\x7a\x06\x6e\x26\x6c\x6e\x48\x84\xae\x84\xf6\xc2\x3a\xb0\x5c\x7e\xb4\x7b\xee\x52\x2c\x7c\x4f\xe1\x7a\x8f\x40\x8a\x9d\x2d\x16\x47\x9e\x39\xb3\xee\xdc\x89\xc0\xe2\x54\xe4\x55\x6b\x64\x61\xf4\xb6\xf0\x88\x37\xa7\x50\x6e\x04\x1e\x5f\x65\xd2\x48\xc8\xde\x22\xa3\x11\x00\x83\x45\x21\x05\x9b\x44\xeb\xc8\xe0\xaf\xd4\x1d\xaa\x94\xcb\x05\x3a\xf6\x46\x53\x42\x8b\xee\x62\xa8\x6c\x72\xce\x97\xdd\x5b\x67\xe1\x3a\xe3\xfd\xa6\x01\x9a\x8b\xea\x18\x17\xf3\x29\xda\x35\xde\x93\x11\xe8\x23\xea\xf9\xd5\xea\xda\xe7\xe5\xf9\x2f\x41\x3c\xd6\x49\x94\xaf\x52\x99\xc9\xa5\x2b\x62\x84\xa2\xbf\xa0\x18\xeb\xaf\x49\x70\xb8\x05\xc5\x12\xc1\x77\x8d\xd9\x09\x80\x8b\x92\x60\x09\x00\x7b\xcb\x7b\xc9\x01\xe3\x94\x08\x57\x15\x9c\x1b\xec\x63\x32\x63\x5d\x53\x3c\x31\x76\x86\xbf\x73\x62\x48\xdd\x52\x3d\xd8\xbd\x49\x41\x07\x1c\xce\xfd\x94\x5a\xc8\xd8\x7a\xa9\xe8\xea\xad\x0c\x8e\xc3\x61\x8d\x76\x78\x3a\x74\x47\xb0\xc3\xd0\xa8\x9e\x03\x92\xa8\x61\x33\xd9\x80\x0c\xd8\xae\x52\xba\xa8\x8d\x53\xe5\xbb\x35\xeb\xd2\x37\xd5\xed\xef\xad\x4b\x9f\x57\x1f\x9e\xa9\x2e\x7c\x86\x99\xc2\x8f\xef\xb1\x9d\x9d\x4f\x61\xb8\x48\xed\x6c\xcc\x5b\xf7\x6e\xc2\xed\x41\x6a\x16\x07\x7a\x4f\xd2\xaa\x75\x9b\x40\x62\x9b\xb3\x02\x35\x6b\xe0\xde\xe8\xd2\x13\x75\xf7\xf2\x29\xc0\xe1\x79\x13\x90\xee\x5e\xdf\x2a\x3f\xfe\x9a\xbb\xa3\xcb\x30\x72\x21\x15\x45\xea\x66\xdc\xd9\x7e\xc9\x67\x52\xe5\xc6\x96\xb5\x7d\x25\x06\x8c\x21\xad\x6e\xe0\xc0\x29\xff\xf4\x68\xf7\xf2\x8c\x14\xce\x18\x30\x5f\xc3\x0b\xb1\x29\xf3\x74\x57\x57\x9f\x00\x21\xa8\xc4\x44\x77\x8c\x46\x60\x54\x54\xa0\x54\x8c\x5b\x59\x4c\x53\xc4\x3a\x1a\x1b\x2b\xa0\x23\x11\x04\x88\xdd\xfa\xd8\xa9\x59\x40\xee\x0b\x76\xf4\x44\x95\x90\x10\x5e\x16\x52\xb7\xf0\xf0\xa0\x12\x05\x8a\x17\x32\x2c\xa3\xca\xe9\x0d\x19\x05\xc6\x49\x2a\x7a\x93\x27\x63\x05\xe2\x61\x97\xec\xfe\xda\xe2\xe0\x7e\x4f\x4a\xf4\x8e\xb2\x75\xad\x70\xdf\x49\xf9\xce\xfd\xf2\xfc\x0b\xfe\xcd\x45\x29\xed\x6f\x7c\x14\x7b\xa4\xa9\xc0\x8b\xfc\xb4\xdd\x1b\x4a\x68\x09\x69\x23\x23\xdc\x78\xd8\xe5\x28\xd0\xff\x59\xcd\x19\xb0\xe6\xb1\x53\xfa\xf1\x1c\x99\x5e\x8d\x49\x58\x00\x3a\x68\x94\xb9\x36\xbe\x1f\x01\xc0\x94\x03\x89\x0b\x31\x4c\xe9\x54\x8c\x9d\x1b\x51\x91\x06\xea\x69\xd6\x2f\x13\x53\x4f\xce\xfa\x4a\x24\x6c\x2e\xa1\xb0\xba\x0b\x52\xf0\x22\x28\xcc\x81\x02\x0a\xd6\xbd\x45\x6a\x1b\xf6\xc4\xba\xf4\xa0\xf6\x57\x0c\xfb\xb8\x71\x6f\xf7\xf6\x57\xd8\x9c\xfb\xc1\xd9\xca\xad\xab\xa8\x3c\x2f\x3d\xb0\xe6\x6e\xf8\xc8\xe5\x0b\x34\x20\x96\x75\xbe\x92\xca\x02\xc1\x4c\xdc\x55\x29\xc7\x71\x58\x1b\x27\xe4\x28\x4a\xc0\xc8\xce\xc3\x74\x65\x88\xdd\x80\xb6\xe3\xcf\xab\x67\xa0\x94\x7a\x71\x0b\x41\x78\xa9\xe3\x77\x22\x08\x24\x61\x45\x67\xc3\x7e\xd3\x17\xd3\x04\xb3\x98\xcb\x4e\x2b\x93\xba\xa9\x23\x75\x58\x83\xc6\xa7\x6c\xe1\x60\x22\xee\x7f\x32\x94\x9e\x92\x19\xa2\x33\x24\xc0\x29\xd1\xe9\x3a\x5a\xca\x02\x42\xb8\x3e\x45\x1b\xab\xb9\xa9\xde\xb3\x1f\xcb\x73\x4b\xd6\xf9\x3b\xdc\x0f\x12\xe7\x8e\x1b\x43\x5e\x7b\x0a\x4a\xaa\x54\xa2\xf8\xf1\xeb\xa6\xa7\x51\x60\xe0\x7e\x9f\xd1\x31\xc4\x06\xb6\x63\x1b\x70\xc3\xe7\xdf\xd5\x74\x5c\xec\xa2\xad\x16\xc7\x3a\xc1\xde\xb7\x0d\xef\xf2\xd2\x30\xe2\x82\x72\x6b\x15\x64\x1f\x5d\x50\xec\xd6\x81\x9e\x61\x71\x03\x41\x9e\xdf\xda\x40\xc1\xf2\xdc\x55\x7e\x58\x36\xb8\xbc\xb8\x53\x19\xb6\x82\xcc\xbd\xdf\x75\x33\xa2\x03\x18\x2c\xed\xf2\xdd\x0d\xd0\x83\xcb\xd7\xef\x5a\x4f\xce\x20\x41\x8f\xef\xc5\x1b\xab\x8e\xaa\x1f\x53\x43\x7d\xee\x78\x66\x37\xdf\x71\x96\x35\x6d\xeb\x52\xbe\x8d\xda\xbd\xeb\xb9\x92\xfc\xd8\xf3\x0d\x93\x57\x32\xed\x31\x5a\xde\x33\xbb\x57\x5e\x72\xa7\x7d\x7b\x62\xe7\xb0\xbb\xdd\x17\xf2\x4b\x6d\x2d\x5d\xee\x81\x2a\x54\xc9\x04\x44\xb9\xef\x78\x35\xc7\xc6\x49\xd2\x27\x4a\x13\x8a\x3a\x41\xce\x49\x10\xac\xc2\x55\xc0\x4b\xc8\x91\xa4\xae\xa7\x13\x7e\x18\x57\x27\xed\x12\x5b\xef\xbe\xf3\xde\x6f\x8e\xb6\x29\xef\x1e\x81\xff\x7f\xe7\x88\xd4\x9e\x50\xcb\x47\xd6\x5b\x66\x9f\xe1\xad\x94\x48\xb7\xee\x3d\x14\xee\x05\xec\x8d\xea\xd6\xe2\x22\x0c\x7f\x9f\x39\xf5\x2e\x46\xbf\x03\x8e\x57\x35\x94\x76\x25\xf5\x2e\x9e\x7c\x70\x0c\x50\x33\x2b\x78\xb8\x94\x23\x23\x32\xfa\xad\x08\x87\xf4\x28\x68\xed\x70\x41\x8a\x03\x29\xd5\x95\x47\x95\x7b\x9b\xce\x3b\x58\x2b\x86\x0c\xce\x11\x32\xfe\x95\xf3\x43\x79\xeb\x90\x36\xaa\x96\xb2\xc5\x83\xee\x6f\xaf\x68\x4d\xc4\x32\x09\xde\x07\xb5\xa8\xb2\x7c\x8a\xfb\x45\x39\x3f\xc5\xae\x27\xda\xac\x6f\xa1\xd5\x59\x03\x45\x2c\x63\xbe\x4d\x3b\x17\x23\xe8\x40\x80\xd1\x76\x0e\x5c\xfd\x58\xc0\xb4\x29\xa4\x78\x88\xd0\x22\xc5\x44\xf1\x2c\xdc\x4b\x26\x48\xe4\x69\x7a\x43\x16\x91\x86\xd0\x79\x23\xfb\x25\xad\x4f\xf8\x38\x7b\xbc\xf2\xf0\x0b\x18\x05\x9e\x33\xb3\x4f\x77\xb6\xae\xba\x91\x4a\xdf\xad\x55\x9f\xa2\x28\x00\xce\x56\x3f\xdb\xde\x9d\x39\x2d\x3f\x6f\x3d\x0e\x42\x31\xff\xef\xfd\xf3\xbf\xe0\xf4\xdb\xab\x40\x3a\x8f\x1e\x9f\xa0\x77\x8e\xf0\x75\x9a\x1d\x7b\xaa\xe4\x8c\xe6\xb8\x2d\xe1\x97\x8c\x0e\x04\x2b\x3f\x9d\x2b\x9f\x5a\x63\x4f\x57\x4c\xbc\xd7\x51\xea\x86\xaa\x85\x58\x8a\x1d\x5d\xd1\x17\xbe\xec\x2a\x8b\x11\xa7\x91\x47\xa9\x71\x14\x3b\x6f\xd9\x63\xee\xa3\xea\x55\xec\xbc\xbf\x86\x13\x8a\xf9\x3d\x32\x94\x74\xb6\xca\x5f\x93\xf6\x05\xa5\xf7\x24\x1d\x41\x51\x09\x6f\x04\x1f\x69\x13\xa0\x79\x83\x14\x18\x83\x5b\xb6\x56\xf0\xf9\x5f\xea\xd2\xb5\x62\x60\x61\x81\x33\xd1\x0c\xd9\x75\xf5\x08\xfb\x2f\x28\x0c\xd4\x71\x56\xab\xaf\xa0\xe0\x31\x6d\x4a\xe9\x13\x25\x8f\x64\x6b\x0b\x54\xe8\x88\x76\xa6\x08\x21\x27\x67\x1d\x29\xe0\xc8\x3d\x45\xf2\xba\xa1\xfc\x93\xc9\xfa\x9c\x0c\x82\xad\x75\xc1\x83\x52\x18\x1d\x7d\xdd\xee\x2d\xd1\xd4\x40\xe6\x1e\x07\xfd\x0f\xaf\x65\x70\xdb\xd3\x73\x83\x7a\x1e\xaf\x6d\xc2\xed\x0c\x0f\x8b\x2f\x50\xd7\x62\x3b\x24\xac\x74\xfb\x7d\xb9\xe1\xe1\x5b\x36\x0c\x71\x29\x32\xc2\xc9\xf7\x47\x2c\x11\x47\x5a\x3b\x5f\xdb\x5c\x94\x4e\xe1\x34\x0f\x56\xfc\xee\xf6\xfd\xca\xca\x2a\xfa\x79\xd9\xba\x69\x03\x91\x0e\x4f\x4d\xf3\xc5\x0d\xd4\xff\x1c\xdc\xd9\x3e\x34\x4a\x1c\x38\x93\xe1\x06\xe2\xb6\xad\x0b\xf7\x2a\x5c\xd1\xc4\x5d\x60\xb4\xb6\x1a\xb9\xbd\xb3\x6d\xe3\x3d\x37\xfa\xca\x51\x71\xd3\x9c\x02\x82\x01\xb8\xe7\xa9\xf0\xef\x3c\x22\xca\xee\xe1\xca\xf3\x55\xe4\x86\x1f\x23\xb8\x55\x9e\x7f\x58\x5d\x59\x60\x6e\xb1\x7b\x03\x6d\x34\x70\xf7\xa5\xa8\x1c\xee\x60\x6e\xad\x6d\x78\x1d\x7b\x18\x3f\x53\x43\x35\xcb\x0a\xd7\x2d\x4b\x42\x03\x03\x1e\xc9\x5e\x07\x42\xb5\x72\xe6\xa9\xb5\x74\xb1\x7c\x71\x6e\x67\x73\x0e\x00\xc2\x2d\x71\x67\xf3\xac\x9f\x52\x61\x41\xde\xb8\x60\xdd\xbb\xea\x1a\xfe\x6d\x9c\x8e\xe5\xaf\x35\x93\x20\xf8\xd4\x07\xf3\x20\xd0\x93\x28\xfd\x2f\x38\x23\x81\x61\xbe\xb6\xa9\xc9\xeb\x92\xed\x6f\xc7\xb6\x62\x11\x56\xff\x36\x6f\x64\x97\xc3\x4d\xcf\xbb\xd1\x1d\xbb\x0d\x46\x81\xd1\x4b\x51\xf6\x24\xa2\x33\xef\xf4\x3e\x15\x37\x58\x8a\x83\x61\xb3\x52\x7d\x92\xdb\x10\x95\x2d\x93\x88\xce\xf8\xcb\x21\x80\x73\xfd\xfa\x09\xe5\x71\x8c\x6b\x1f\x40\x72\xf0\x89\xa9\x4c\x69\x54\xf4\x35\x23\x3d\x25\x80\xe9\x2f\x6f\xb9\x4b\x93\x82\x4a\xa4\x50\x6d\x4f\x52\xb2\xa1\xcb\xdc\x45\x00\x28\xa2\x21\xaf\x0c\xec\x8f\x2b\x81\xc0\x10\xdf\x5b\xd4\x38\x93\x86\xc0\xad\x70\xa5\x98\xb9\x9c\xa9\x73\x8a\x53\x9d\xca\x1a\x66\x45\x6d\xe4\x85\x73\x68\xdd\x66\x6e\x91\xc9\x1b\x37\x72\x18\x17\xa3\xb6\x0d\x26\x1d\x52\x44\x10\xf9\x17\x6d\x23\x51\x1b\x1a\xc0\x68\x5d\x8a\x0a\xac\x35\x27\xa5\xef\x3d\x19\x91\xd7\xee\x7a\x7d\x77\x18\x42\x44\xde\x48\xb6\x97\x78\x77\x91\x83\x25\xe4\x64\xf4\xbf\x1b\x39\x10\xa7\xc9\x6a\xc8\x38\x0e\x73\xf9\x70\x77\x3c\xc9\x88\x86\xb3\x5b\x4a\x74\x10\xa4\xd4\x42\x2b\xc8\x6b\x1d\x55\x7b\x43\x8c\x7c\xaa\xa5\xcb\x30\x96\xac\xb8\x89\x8d\x59\x9b\x09\x77\x78\x54\x48\x10\x00\xf2\xf7\x90\x4c\x04\x31\xde\x65\x6b\xc3\x4d\x0e\x50\x1a\xc5\x80\xa0\x84\x27\xd7\xdf\x33\x9d\x8c\x0e\x23\x1a\x86\x15\x6a\x52\x23\xe5\x93\x9b\x81\x03\x8b\xdd\xbb\xde\xbe\xe4\xb1\x68\x83\x6e\x5c\x39\xba\x50\x5c\x31\x4e\x59\x40\x64\xe2\x48\x28\x9b\x66\x5c\x35\xe3\x86\x24\x87\x92\x28\x6a\x0a\x56\x65\x02\x82\x02\x5d\x97\x12\x4d\x62\x52\x5f\xab\x07\x3e\x76\x47\xae\xab\x3d\xb0\x7c\x50\x89\x7b\xfc\x8a\x07\x23\x02\x18\x02\x04\x7e\x12\xda\xbe\x19\xd5\x93\x96\x90\xee\x67\x5f\x9d\x03\x08\x23\x2e\x76\x50\x6e\x90\x4e\x3d\xf3\x1a\x11\x8e\xe3\xc2\xae\x0b\xa4\x1c\x58\xeb\xce\xa9\x56\x1c\x4f\xf5\x1d\xff\x09\x4f\xfd\x06\x0e\xfb\xe8\x33\x5e\x04\x9a\xa9\xa6\xa9\x8f\xe5\xa4\x66\x0e\x90\x50\x68\xdb\x9f\x5d\x64\x09\x95\x0c\x66\xb2\x63\x26\x06\x94\x08\x7a\x69\x85\x0c\xf7\x79\x30\x92\x48\x72\x37\xe2\xc6\xd7\xf2\x36\xb1\x20\xf7\x22\x4c\x20\x3d\x29\x70\xd2\xf5\x90\xb6\x64\xc8\x14\xf8\xe8\xb8\x49\x13\x8d\x9a\xfc\xb4\x76\xf0\x48\x4b\x88\x20\x5f\x2d\x87\x8d\x24\x24\xa2\xa8\x64\x39\x7e\x42\xcf\xb9\x97\xce\xce\xc3\x64\x02\xf2\xef\x1f\x78\x0e\x1f\x92\x4f\x08\x07\x7b\xd4\xde\x32\x83\xd0\x30\xbf\xc1\x7e\x54\x4a\x96\x76\x90\xbd\x88\x68\x52\x47\x8b\x85\x62\x1a\x13\x6c\x69\x97\x11\xf0\xd3\xa3\x5f\x9e\xdf\xac\xbe\xbc\x21\xac\xe2\x54\x60\x01\x6d\xb5\x9b\xb7\xd8\xa2\x2e\x41\x55\x9a\x18\xc1\x18\x94\x51\xd7\x90\x1c\x99\xae\x25\x4d\x19\xeb\xfd\xad\x2c\x5b\x92\x44\x84\xe4\xa5\xbe\xc1\xee\xde\x63\xb2\xbe\x24\xbb\x33\xf3\xbb\x2b\x92\x6b\x24\x56\xba\xea\x38\x74\xb4\xfb\x98\x0c\x2b\xdb\x1f\x28\xeb\xc1\xfa\x5c\x92\xff\x4e\x40\x8e\x1f\xea\x1e\xec\xed\x8f\x04\x63\xad\xae\x54\x57\x57\x22\xc1\x1c\xed\x38\xd6\x71\xa4\x2b\x1a\x0c\x53\x53\x9d\x99\x95\x82\x91\x71\x22\x4a\x45\xee\x95\x46\x60\xc6\xbc\x25\x02\xa7\x39\x2b\xda\xf4\x06\x75\x7a\xbc\x3e\xb2\xc5\x40\xf9\xcc\x2c\xf7\x03\xa1\x88\x71\x58\x7d\xb6\x23\x35\x8b\xbd\x99\xa6\x39\x47\x59\xb6\xf2\x42\x9a\xf9\x29\x18\xd1\x16\x91\x84\x5c\x83\xc8\x9f\x0d\x4d\x59\x15\xfc\x37\x1b\xe7\x30\xe0\xa2\x0e\xec\x4e\x0a\x34\xdc\x30\xf1\x33\x6c\x39\x32\x73\x35\x44\x8c\xb4\x8f\x49\x14\x62\xa9\xec\x80\x67\xa5\xe5\x4e\xc4\x3d\x4f\xb6\x19\xe3\xe3\xbe\x23\xe7\x96\x23\x90\x34\x27\xed\x3e\xc3\x4e\x53\x3b\xce\xcb\x09\xef\x90\x85\xa8\x51\x48\x10\x3b\x33\x39\xf0\x8b\x03\x37\x9c\xcc\xf8\x3a\xd1\x3a\x89\x3c\x75\x63\xe7\x08\xc9\x46\x68\xb0\x83\xab\x40\x9c\x06\xe2\xab\x28\xd8\x85\x77\x17\x9c\x74\x7a\xc1\xc8\x51\x4b\x13\x75\x14\xef\xb6\x81\x60\xad\x7c\x56\x93\xc7\x49\x30\xa1\xb0\x02\xfc\x31\x53\xab\x0b\x18\x9c\xb3\x74\xd1\x1b\x33\x25\xd4\x32\x3a\x05\xb1\x3f\x92\x7f\x9f\x46\xe5\x63\xf5\xa9\x7a\xc6\x1f\x9a\x24\x93\x03\xcf\x7e\xdc\xd9\xba\x5e\xfd\x79\x23\xde\x1f\x88\x6e\x2a\xce\x5e\x84\xd1\x71\xa7\x5c\xca\xb4\x85\x29\xe3\xa8\x24\x74\x9b\xb9\x17\x69\x87\x45\xb6\x52\xc0\x3a\x51\x44\x98\x1a\x25\x37\x72\x7d\x20\x86\xbc\xf3\xfc\xee\xee\xcc\x17\x22\xab\x8d\x62\x95\x6a\x2f\xd7\x52\x3d\x29\x09\xb9\x1e\x9d\x71\x4f\xc8\x95\xe9\x91\x91\x44\x47\xb8\x02\xa3\xfc\x80\xf6\xab\x0a\xac\x65\x27\xd8\xd7\x95\x54\x13\x6a\x31\x3d\x1e\x09\x76\xf7\xdb\x05\x8c\x8e\x06\x01\xb5\xb0\x01\x7b\x47\x86\x05\x36\xa9\xbf\x85\x59\x3d\x56\x84\x3e\xbb\xa2\x47\x3e\xef\xee\x68\x4a\x09\xc3\x2a\x1f\x7f\xd6\xd9\x3a\x6f\x6f\x3f\x3c\xda\xc8\x40\xec\x6e\xc7\x58\x39\xe0\xdb\x24\xfe\xbd\x8f\x59\x63\x35\xbf\x62\x9c\xc0\xea\x06\x7a\x52\x10\x7b\xa0\x96\x47\xf4\x20\x7c\x03\xb0\x69\x97\x09\x5e\x42\x06\x14\xd4\x8f\x26\x26\x4c\x8e\xc3\xdb\x62\x01\xd5\xdd\xb0\x4e\x02\x4b\x2b\x60\xf5\x2c\xdc\x3b\x3a\xca\x39\x85\xca\x56\xb0\xd8\x86\x6d\x36\x81\xad\xc2\xa6\xc6\x35\x0e\xf7\x13\xad\xf6\x44\x7c\x60\xd6\xd6\x12\x44\xc7\x33\xe9\x7d\x0f\x5d\x64\x95\xd5\x19\x8c\xf0\xfb\x66\xa6\x7c\xe7\x3e\xef\x28\x56\x43\x79\x9c\x1c\x17\x58\xbe\xbe\x86\xd1\xa7\x11\x5a\x04\x7a\xc6\x82\x9a\x83\xbd\x78\x65\x9e\x40\x69\x0e\xac\x38\xb8\x23\x9c\x71\x91\xd2\x33\xcb\xa5\x15\xc4\xab\x1e\x9f\x9d\xdb\x47\x2d\x99\x3f\x85\x90\x84\x82\xaa\x17\x33\x1a\x03\x73\x46\x48\x24\x0a\xae\x3a\x0e\x53\x91\xed\x32\x39\x11\x0a\xbb\x68\xe0\xf2\xc2\x41\x27\x81\x98\x5b\x39\x8d\x07\xc3\xc7\x14\x45\x80\x48\x2d\x4f\xce\x07\xd3\xa3\x2e\x72\x9f\x51\x38\x21\x8a\x7a\xba\x94\x55\x0b\x89\xf2\xe6\x30\xe1\xea\x87\xca\xfc\x06\x1a\x4d\x48\x97\x62\xbd\x31\x76\xf2\x29\x1c\x36\x3d\x6e\x18\xa6\x1b\x0d\x8b\xed\x4e\x71\x2f\xa0\xff\x1a\x3f\xb7\x2b\xef\x1b\x28\x5d\xc9\x35\xa5\x16\x34\x5a\xb4\x79\xdc\x54\xc5\x22\x6f\xde\x11\xee\x8f\xa5\x39\xa1\xb7\x26\x06\xac\x88\xf0\x70\x99\x1a\x0a\xb7\x59\xce\x16\x17\x18\x51\x08\xd9\x28\x31\x70\x02\x56\xd5\xec\xa9\xea\xea\x3a\xc6\xdb\x2e\x2d\xc0\x8d\x93\xe3\xb7\x51\xe1\x58\x5a\x80\xab\x27\x1f\x6b\x70\x31\xdd\x59\xbf\x87\x81\x43\xb6\xb7\x2b\x72\xa8\x7c\xd9\x56\xd4\x31\x55\x9a\x64\x81\x74\x91\xb2\x13\x73\x99\x0e\xd4\x8a\xe2\xe8\x1b\x34\x98\x79\xe2\xab\xbd\x53\xe7\xad\x13\x55\xd7\x9d\xc8\x09\x23\x76\xb2\xdd\xa2\x6e\x49\x11\xd6\x28\x4e\xed\x51\x22\x02\x9a\x44\xd6\x67\x44\x58\x93\x80\xa1\x73\xbe\x90\x18\x18\xee\x4e\x4c\x1e\x8a\x86\x4a\x89\x42\x78\xbf\xba\x74\xb5\xfc\x54\x52\xfc\x44\x80\xa7\x50\x6c\xa7\xe0\x5d\xe8\xed\x26\xc1\x08\x6a\x20\xc4\x54\x98\x8a\x42\x8e\x81\xd7\xe2\x4e\x49\x81\x1e\x8d\xa0\x87\xb1\xef\x9e\x3b\x27\x0d\x2a\xec\x73\x33\x76\x89\x86\x8c\x32\xb4\xcf\x97\x08\x32\xb4\x2f\x70\xaf\x75\x02\xda\xd1\x32\x2b\xa2\xf1\xe8\x55\x69\xa8\xed\xd2\x22\x77\x6f\x0c\x26\x98\xd4\x66\xfc\x3a\x17\x61\xaf\xad\x96\x23\x26\x79\x78\x11\x1b\x43\x8c\x83\x9a\x29\xc3\x30\x84\x3c\xc7\x26\xb8\x18\x4f\xeb\xa4\x49\xe0\x91\x37\x0d\xf7\x0c\xa5\x77\xe0\xa0\xb4\xd0\x1b\x2c\xfe\x1f\x4e\x3b\xe4\x09\x3f\xbb\x48\x94\xbd\x58\x3e\xfd\xc8\x9b\x1f\x8d\x5e\xf6\xcd\x85\xea\xcb\x5b\xd6\xdc\x53\xa7\xee\x64\x24\x91\xc1\x29\xf2\xe5\x2f\x94\x72\xba\x9d\x16\x27\x35\xcf\x05\x6a\x33\xba\x33\x2d\x72\x1a\x16\xd7\xab\xdb\xdb\x71\xac\x0a\xbe\x3e\x09\x5f\x9c\x80\xcb\x81\x8e\xf5\x60\xfc\x34\x35\x4a\xd1\x09\x1f\x48\x97\x3e\xda\x94\x72\xfa\x0a\x18\x38\x83\xa1\x2e\x76\x6b\xec\x8c\xae\x8e\xe5\x0c\x13\xce\x26\x3a\x8e\xcd\x62\x46\x9e\x66\x06\xb7\x11\x7a\x97\xe7\xb0\xba\x76\xbe\x7c\xf5\x31\x5e\x3a\x16\x9f\x60\x94\x88\x78\x35\x02\x2f\x96\x96\x51\x95\x2c\xd9\x55\x46\x45\x7c\x0c\x0a\xef\x80\x8a\x1e\xd0\xc8\x55\x27\xaf\xd0\x51\xda\x45\x82\x87\x7d\x0b\x34\x58\x38\x1f\xea\xea\x50\x46\xd4\x34\x6c\x66\xb9\x72\x83\xc4\x3a\x79\x1e\x4e\x51\x3d\x6b\xee\x5a\x75\x05\x6d\x34\x7c\xe2\x3a\x6a\x33\x2b\xed\x51\x43\x42\xbc\x93\x3c\x0d\xd1\x38\xe7\xe7\xca\xcb\xdf\x27\x84\x84\x43\x3c\xc2\xd1\x65\x18\x09\x3d\xa5\x72\xe9\xf1\x22\x1f\x73\x72\x51\x49\x98\xe8\x15\x51\x7f\xe0\xda\xd3\xf2\xfc\xcc\xce\x8b\xdb\xe5\x45\xd4\x1c\x10\x66\x34\x1d\x06\xec\x62\xcc\x77\x9b\x80\x23\x10\xf8\x9a\x31\xa6\x72\x59\x43\x45\xd3\xbf\xd8\xeb\x78\x0c\x6a\x13\x9e\xdb\x91\x74\x9f\x63\xf3\xdb\x8b\x5b\x3b\xeb\x3f\x03\x11\x0e\xc3\x77\xd6\x2f\xc0\xee\xa9\xdd\xd5\x14\xa3\xfd\x79\xe5\xf2\x1d\x50\x71\x76\xbf\xbe\x2e\xdf\xe4\x05\x83\x43\xef\xe8\x06\x40\x09\x4a\xa0\x5c\xa1\x9f\x48\xcd\x1e\x54\xfe\xc9\xc4\xd2\x5a\x14\x90\x8f\x47\xb6\x4c\x00\xbd\xbc\x05\x87\x6b\xf5\xeb\xef\xb8\x96\xd7\xce\xcb\x15\xeb\xd2\xb3\xca\xd6\x5c\xf9\xf1\xd7\x80\xf7\x9f\x4c\xac\xb5\x05\x72\x7d\x66\xc6\x3a\x47\xb9\x4b\x1b\x4f\xad\xf5\x07\x20\xa3\xa4\x14\x51\x45\xa2\xb0\x32\x47\x6e\xec\x97\x5b\xfa\x8b\x73\x62\xb9\xa4\x10\x5b\x16\x41\x85\xc9\x8d\x61\x84\x7c\x29\x8f\xc9\xb4\x18\x23\x24\x34\x11\x9a\x07\x78\x8a\xeb\xfb\x14\x51\xd4\xe2\xfc\x4b\xcf\x82\xe5\x47\x7c\x47\xe3\x0c\x26\xd8\x92\x3b\x9b\x67\xad\x1f\xbe\x2a\xcf\x3c\x94\x54\x4f\xe2\x4c\x5a\x2e\x3d\x84\x47\xe9\xd9\x45\xeb\xd2\xb5\xf2\xe5\xb5\xf2\xc2\x29\xf6\x4e\xa0\xf9\x61\xf6\x29\x4f\xa5\x13\xe3\x07\xca\x54\x75\x2d\x42\x8d\x62\xfd\x49\x5a\x4d\x94\x34\x1f\xa9\x6d\xbb\xaf\x54\x10\x0e\x2e\xbe\x2b\x78\x6a\xb9\x31\xd9\xb1\xd9\xa6\xeb\xb3\x40\x2f\xdf\x04\xc2\xdf\x4e\x8a\xd7\x77\xf9\xaa\x17\x6d\xcd\xcb\x12\xac\xe6\x38\xd6\xd2\x15\x15\xee\xd1\x0b\x8f\xc5\x59\xed\x00\x31\x0a\xc9\x67\xd5\x40\xe4\xff\xcb\x68\xa0\x46\xd5\x81\x0a\xf6\xd8\xa2\x7a\xee\x2a\x46\xed\x73\xe9\x26\x50\xb2\x1f\xdf\x47\xff\xe6\xc5\x27\x89\x6a\x1e\x09\xe2\x30\x0f\x97\xbb\x6b\x2b\x6f\x51\xb7\x7b\xa0\x12\xff\x65\x61\x6e\xaf\xec\xb7\x0f\x4a\x4b\x4b\x89\x2e\xda\xb8\x2e\xbf\xf5\xd3\x37\x67\xa7\x4d\xa2\x6d\x5c\x7c\xa6\x15\x4c\xe9\x1c\x37\x65\xb5\xa4\xa8\x84\xa6\x72\x08\xfd\x81\xdc\x12\x01\xf8\x4d\xdf\xd5\xe3\x2b\xe0\x32\x16\xec\x02\x0c\x02\x88\xf1\x19\x30\x7e\x9c\x1c\x72\x51\xdb\x81\xc0\x30\x8b\x70\x9e\xdb\x89\x93\x18\x7d\x85\x5d\xcc\x45\x41\x1a\xf2\xd1\x19\x54\x11\x0e\x8d\xbf\xa5\x6c\x91\x8f\x3e\x82\x40\xf6\x40\x90\xf9\xb6\x45\x9a\x2a\x72\xc8\x12\x4e\xb0\xf6\x3f\x39\xbe\x2b\x5b\x37\x70\xc6\xd9\x00\x68\xbb\x53\xb8\xe4\x2c\x8c\x0c\x73\xdf\x1e\x9c\x2e\x7f\xb5\x4c\x86\x36\x2a\x2a\xfb\xf8\x1e\x3b\xca\x50\xaa\xc1\xc6\x66\x20\xb6\x19\x9d\x5e\x91\x08\xb9\x44\x03\xe6\xbb\xd2\xab\x1d\xb2\x5d\x42\x66\xaf\x86\x1c\x58\x17\x89\x2e\x2c\x6e\xb9\x57\xef\xab\x31\x37\x95\xfe\xae\x7f\x3b\xde\x35\x30\x28\xcd\xca\x27\x85\x4b\x7a\x2c\xf6\x77\x0d\xf4\xf5\x1e\x1b\x90\xa7\xc3\x50\xa5\x66\xf9\xeb\xbd\x3d\x5d\x03\xf2\xfd\xcb\xe5\xae\x23\xf6\x63\x7f\xef\xf1\xc1\x2e\x99\x47\x32\xca\x60\xd8\x0f\xdb\x34\x45\xa9\xcc\x6e\x48\x3d\xee\x1b\x3d\x37\x6a\xd0\x99\x87\x57\x9a\x42\x44\xd5\x3a\x4e\x96\xb3\xd6\x36\xc4\x4d\xfa\xe5\x4a\xf9\xd4\x1a\x16\xab\x3b\x7f\xdf\xfa\xfc\x3c\x55\xe0\xf9\xb6\xba\xb6\xe5\x84\x96\x4b\x47\xa0\xa9\xa8\x8b\x67\x34\x74\xa8\x00\x09\x79\x10\xc0\x9a\xa8\xcd\x68\xfe\x2b\x1f\x9d\x13\x79\x79\x85\xd2\xca\x32\x5e\x55\x68\x99\xde\xc5\xd3\xf2\xf1\xbd\xca\x77\x17\x1c\xb3\xab\xb5\x74\xed\x97\xe7\x77\xbc\x50\x12\x10\x21\x4c\x87\x47\x0d\xf8\x5b\x94\xe4\xb5\xff\xb4\xc5\x1c\xd6\x28\x04\x8d\x71\x1a\xad\x13\x63\xb8\xaf\x8c\xb4\xae\xda\xda\x0f\xa8\x0d\xff\x9a\x8c\xda\x18\x34\x5c\xe9\x6f\x67\xfd\x22\x68\x02\xd6\xec\x4f\xd5\x53\x97\x51\x7f\x5b\x9f\xb1\xe6\xce\xb1\x7a\xcc\xc3\x6b\xc9\x98\x5a\x43\x71\x02\x82\x84\xd5\x31\x24\x3c\xcd\x57\xba\x93\x53\xe5\xf2\xc2\xb0\xd9\x9b\xcd\xd4\x5a\x21\x61\xc9\x62\x82\x80\x36\x55\xf3\xd3\xbf\x0e\x95\xde\x79\xe7\xd7\x52\x43\xbd\x33\xa4\x27\x67\x63\xc9\xd8\xd9\xba\xe8\x5a\x42\x43\xc9\x70\x12\xef\x64\xd4\x24\xe1\x4a\x1e\x94\xa0\xda\x84\xc1\x5a\x2d\x8a\xd9\xd2\x99\x35\x4a\x19\xe5\x30\xea\xb8\x85\xe9\xd8\x99\x83\x21\xf8\xdf\x50\x50\x4d\xf5\x68\x4d\xb5\x55\x7e\x1b\x25\xdc\x0e\x0b\xac\xb5\xa0\xef\x05\xdd\x1c\x4f\x58\x8b\x2b\x9a\xec\xb4\xa6\x4f\x92\x79\xd5\xed\x0e\x90\x06\xdd\x9c\x1d\x6a\xa2\x9c\x87\xcc\x43\xb0\x75\xd1\x29\x43\x5c\xbe\x8c\x55\x34\xc2\xba\x02\x48\x11\x97\xe0\x8a\x39\xa9\x01\xd3\xc4\xf5\xc2\xad\x9f\xc5\x55\x44\x75\x6c\x59\x44\x95\xee\xcd\x10\x7e\x51\x9d\xe4\x11\xbc\x9d\xd8\x3a\xe0\x84\x4a\xc5\x53\x84\x3d\x81\x95\xd6\x40\xdc\xad\x74\x20\xf7\x77\x67\xbe\xb0\xb6\xbf\x28\x5f\xdd\xc0\x26\x23\x35\x9c\xe6\xda\xca\xd6\xe6\x97\xc0\x72\xbe\x84\x94\xef\x2c\xb9\x39\xa5\x5f\x2c\x58\x8f\x97\xb8\x3c\x3e\xda\xb4\x66\x16\xf0\x90\x5d\xdb\xa8\x0d\xdf\xc5\xd2\x41\x7f\x7d\xc6\x87\x68\x03\x7c\x71\x0b\x82\xfc\x83\x31\x88\xd3\xca\x5b\xca\x26\xc1\x9a\x60\x31\x42\x99\x97\x54\x10\x95\xa4\xf6\xa0\x03\x5b\x14\xc1\xc3\x4e\x1c\xc4\x5e\xae\xd3\x12\x89\x40\x14\x51\xb2\x35\x42\xd6\x58\x62\xd0\x94\x0a\xa2\x7e\xa8\xc0\x92\x8b\xb8\x5f\xa1\xfc\xf5\x56\x6e\xb1\xb9\x4d\x1d\x83\xa3\x35\x1c\xc6\x46\x15\x6b\x3d\xa9\x6b\xec\x2b\x80\x65\x11\xcd\x37\xae\xac\xea\x66\xa6\x09\x0f\x01\xcd\x65\x34\xc2\x9c\x2f\x4e\x32\x9a\x79\xb1\xd1\x8f\x2e\x50\xd4\xce\x1a\x9c\x19\xf6\x62\xc5\xcd\x4c\x30\xb2\x16\xe5\xea\x09\xb5\xe0\x95\xdf\xc1\x0c\x2e\xbc\x54\x18\xc1\xc8\xa9\x03\x62\x19\xa1\x58\xc6\x0f\xb6\xce\x64\xe2\x37\x9d\xec\x28\x3e\x0e\xc4\xc7\xdf\xec\x61\x13\xd6\xbc\xa3\x54\x37\xbf\xdb\xd9\xda\x86\x65\x11\x12\x7b\x75\x80\x17\x61\x10\x35\x6a\xa3\xd2\x74\x32\x67\x45\x79\x27\xc3\x37\x76\xa9\x0d\xc1\x61\x5b\xc1\xd7\xbb\x86\x79\x45\x75\xc3\xb0\x8c\x37\xad\x37\x41\xbc\xcb\x2f\xfe\x1a\x28\xf7\x73\x8c\xbf\x26\xe2\x5b\xce\x33\x31\x4c\x87\x6d\x1e\x12\x3c\x8c\xf3\x53\x80\xa6\x5a\x5a\x47\x35\x43\xc1\x33\x3a\xd0\x8d\x67\xcf\x19\xf5\xca\xf8\xd1\xfa\x71\x97\x58\xe5\xe5\x5e\x42\x2d\xda\x4c\x48\x51\x2e\x91\x8d\x4c\x70\xc1\x7d\x61\xef\xb6\x11\xcb\x64\x67\xac\xf5\xf2\x26\x6e\x24\xf5\x22\xe1\xfe\x7d\x9e\x3c\x5a\x89\xc8\x3c\xb7\x68\x7d\xbe\x6d\x2d\x2d\xc6\x65\xdc\x3a\x10\x13\xa9\x11\x0e\xd8\xa4\x89\x4d\x35\xe0\x63\x2a\xab\x06\x10\x44\x05\x60\xb8\xa0\x23\x92\x4b\x1c\x78\x51\xce\x6f\x1b\x52\xd4\xb9\xed\x00\x8a\xb7\x76\xba\xe0\xe4\x95\x6a\x5d\xba\x22\xc2\x5b\x09\x90\x30\xd7\xfa\x57\xa7\x73\x55\x7c\x7d\x5b\x0d\x2e\x9b\xc9\xb7\x9a\x28\xc3\x2b\xdd\x6d\x0e\x3b\x30\x32\xd1\x3b\xb2\xe8\x9d\x80\xbc\x71\x8b\x78\xf1\x85\xf6\x7d\xfb\xef\x20\xab\x02\x3f\xc4\x56\x31\x85\xcb\x74\x1c\xec\x10\xb2\x43\xb0\x44\xd3\x5f\x33\x6f\xc1\xb9\xdd\xdb\x09\x6b\x86\xf5\x7e\x91\x21\x78\x94\x70\x14\x8d\x0e\xa1\x56\xf0\xf8\xf1\x4a\x87\x93\x70\x2c\x35\x97\xef\xa0\x55\xe6\x75\x6b\x8a\x0d\xec\x3b\x89\x2f\x29\x8c\x57\xc9\x9c\x4d\x2e\xd7\xec\xf1\xa2\x25\xc9\x83\xd7\x65\x9a\xe7\xcb\x30\x96\xbd\x0a\xde\x08\x2e\xb8\x1c\x0a\x10\x1b\xc6\x06\xf7\xe7\x08\x26\xe4\x8d\xa8\x80\x29\x37\x5c\x26\x22\x66\xaa\x9f\xcd\xd2\x4e\x00\xea\xc0\xc0\x07\x1c\x4f\x94\x35\xa6\x38\x66\x2e\x26\x79\x92\xcc\xd3\x22\xac\xd4\x8e\x89\x73\x3a\x31\xb0\x23\x0c\x81\xd6\x85\x9d\xdb\xd5\x64\x30\x18\x22\x50\xe1\x4e\xc4\xa9\x51\x21\xe2\xc8\x73\xdc\x47\xd7\xf2\x23\x7f\x89\xba\x0d\xeb\xc6\x23\x51\xf9\x6b\x5d\xf4\xb0\xc1\x0a\x2f\x91\x64\xb2\x6d\x40\x1a\x23\xe0\x30\x5b\xee\x9a\x10\x51\x2a\x79\x53\x2b\x65\x8c\x54\xb1\x38\x4d\x5c\x8e\x0d\xaf\xfb\xe1\xf4\xce\xf3\x6f\x15\x7c\x9c\x7d\x3e\x32\xe8\x18\x98\x1f\xaf\x43\x60\xec\xa0\x37\x71\x32\x81\x32\x61\x47\xfc\xbf\x39\x97\x55\x5c\x62\xf5\x88\xa0\xe8\x71\xfb\x06\x15\xb1\xdb\x38\xcd\x25\x01\x83\x6b\xab\xf7\x46\x82\x44\xde\x86\x19\xa8\xb1\x32\xd2\xa8\x6f\xf5\xfb\xb8\xdf\x92\x03\x4d\x46\xb0\x1f\x15\x55\xb1\xaf\x6d\x5c\x27\x1b\x55\xb1\xa0\x6b\x6c\x63\xd1\x73\x19\x7d\x52\xcf\x94\xd4\xac\x13\x28\x42\x45\xd4\xc9\xab\x03\x60\x8a\x25\x69\x49\x84\x6f\x66\x2a\x3f\x7f\xcd\x4e\x31\x36\x11\x57\xce\x3f\x2d\xcf\x9c\x42\x52\x96\xce\xa0\xfb\x9d\x42\x3d\x38\xb2\x36\x96\x10\x6a\x7d\x99\xcf\xaa\x1c\xc2\xdf\xdb\xe1\x94\xc0\x77\x42\xdb\x9d\x86\x3b\x18\xe9\x2c\x0f\x80\x62\xaa\x36\x9e\x96\xaf\xbf\xc0\xea\x94\x14\x53\xbf\xf3\xfc\x66\x75\x0d\xa3\x14\x05\xe0\xa8\x62\xf9\x52\x9a\xb8\x17\x17\x4c\xf6\x7e\x93\x5a\xa7\xb5\x2b\x4a\x07\xd6\xcd\x22\xb1\xc8\x2d\x2d\xb9\x7c\x0d\x31\x0d\xc3\xcf\xf2\x25\x37\x30\x9f\x8a\xe2\x9a\x14\x77\x53\xd0\x30\xd8\x59\xba\xb5\xfc\x03\xe0\xce\x5d\x81\x30\x5d\xe5\xc8\xf1\xee\x43\x14\x34\x73\x3f\xd8\x71\x81\x8b\x52\x72\x93\x13\x4e\x2b\x3a\xff\xd4\x3a\xfb\x57\x2c\x76\x43\xb3\x53\x7d\xf1\x25\xb6\xcf\xfa\x8c\x0e\xc2\x07\xa7\xb0\xa8\x3c\xe1\x91\x46\xd8\xc4\xf0\x03\xc4\x4b\x18\x3f\x02\xa3\x27\x3f\x6b\xc3\xa3\x77\x4b\x86\xb9\xe3\x76\xbe\xf3\x8d\xb8\xc5\x83\x13\x1a\x5f\x82\x01\x3a\x77\xd7\x86\x07\xe9\x16\x3f\x73\x07\xe9\xe6\x60\xec\xfd\x20\x53\x27\xb5\xe9\x57\x38\x50\x2e\xc4\xf1\x3a\x86\x8b\x07\x4f\x92\x81\xd2\x21\xd9\xc4\xa2\xb5\xc3\x45\xbc\x8b\xd6\x69\xc0\xb7\x97\x03\xc4\xce\x55\xce\x00\xe5\xe3\xb3\x1b\x5c\x35\x2a\x92\xa8\x43\x55\x40\x18\xd9\xdf\xb5\x66\x7c\x4e\xec\xae\xe7\x60\x32\xbd\x27\x13\xfe\xa8\xa9\x69\xce\x2e\x49\x79\x1b\x28\x4a\x73\xf7\x6f\x56\x5f\x9e\x2b\xaf\x5d\xc2\xe3\xe9\xd2\x1a\x9c\x4d\xd8\x82\x82\xce\x29\x54\xff\x49\x42\x8a\xd1\x7a\x0e\x2f\x1c\x10\xc5\xec\xc6\xd0\x1b\x96\xdd\xd7\x70\xee\x28\x93\x11\x9a\x1a\x1a\x13\x2b\x1c\x49\x4f\xc3\xc9\xa1\x4c\x4f\x44\xee\x67\x3d\x54\x15\x4a\x59\x4f\xb3\x2f\x96\x2b\xfe\x6a\x51\xc1\x00\x13\x67\x4b\x46\x92\xb7\xb3\x7e\x91\xf7\x98\x13\x3b\x12\x68\x74\x47\xa6\x6c\x98\xcd\x1b\x91\x44\xd2\xbd\xd5\x59\x61\x48\x22\x2e\x30\xac\xc7\xe1\xf4\xe7\x6c\x95\xc9\x85\xe9\x16\x54\x3e\xfb\x31\x74\x45\x46\x68\xbc\x21\xe4\x02\x96\xc3\x4c\xe5\x61\x20\xba\x85\xd6\x21\x26\xb5\x16\x7e\x5d\x74\x36\xb6\x47\x5a\x3c\x86\xe8\x5d\xd5\xe8\x30\xe2\xb7\x56\x8b\x87\x91\x64\x33\xca\x07\x63\xfb\x20\x3e\x30\xcc\xa2\xb8\x59\xc1\x5f\x87\xa8\x0a\xa6\xb8\x55\xc0\xdf\x5d\x18\x7c\xa8\xf1\x65\x22\x9c\xd2\x86\xc1\x1f\xf8\xc4\xae\x51\xda\x12\x44\xf4\x01\x60\x4d\xa9\x1c\x36\x39\x42\xf1\xf0\xc5\xda\x4c\xd0\x90\x00\x28\x20\xae\x31\xa4\xec\xdc\x4a\x14\x03\x1c\x70\xe0\xc4\xc5\xfd\x06\x50\x78\x32\xc8\xea\x19\x98\xe0\x7c\xfd\x83\xb3\x9b\x44\xdb\x8c\x2d\x1c\xc1\x3f\x81\x10\xa7\x51\x4a\xfd\x30\xa3\x39\x23\x7f\x11\x37\x15\x86\x25\x1c\xef\xef\xb6\x7b\x35\x39\x69\x0b\xde\x94\x4c\xbb\x1c\x2f\x6e\x46\x7c\x56\x2d\x15\x61\xb9\x15\xe1\x6e\x9e\xcd\x4e\x4b\xeb\x99\x50\xfb\x26\xae\xcd\x68\x63\xe1\x7c\x04\x6f\x1e\x27\x76\xdf\x3c\x07\x37\xda\x47\x5c\xd8\x09\x74\x1d\xf1\x9c\x84\x6a\x3c\xdf\xa4\x11\xae\x11\xe7\x8f\x90\x84\x5d\x1e\x11\x72\xc2\x16\x21\x34\x03\xf2\x5e\x5a\x61\x32\x4d\x6a\xea\x1a\xe8\xea\x04\xfa\x07\x3f\x54\x8e\xf4\xf7\x1e\xef\x93\x59\xcc\xa2\x6b\x76\x0d\x74\xf5\x9f\xe8\xee\xec\x8a\x2c\x78\x24\x54\xfa\xe8\x82\x47\x02\x90\x2c\xa8\x37\xaa\xec\xdd\x40\x5f\x47\x0c\x05\x42\xe7\x8e\xa1\x80\xc1\x44\x17\x5d\x62\xc5\x22\xba\xe8\x12\x03\x3a\xd4\x75\xa2\xab\xa7\xb7\x4f\x5e\x78\x89\x41\x3d\x9f\xc1\x20\x28\x59\x72\x0a\x83\x8a\xa9\xe0\xe4\x19\x5c\x34\x20\x69\x0d\xa7\x08\xa7\x27\xda\x7a\x39\x2b\xa4\x21\x03\x2f\x2b\xdb\x64\x31\xae\xbe\xfc\xaa\x7c\xf1\x7e\xa0\x64\xb4\xd7\xca\x2b\x21\x00\x76\xee\x9b\x65\xd7\x2c\xcf\xff\xc5\xfa\xe1\x4a\xcb\xbc\x9a\xd2\xd3\x79\xc0\x56\x87\xa3\x37\xbd\xb3\x43\xe5\x1b\xdd\x5f\xbb\x0f\x90\xdb\x9a\xf6\xf0\x98\x90\xe8\x89\x12\x0d\x1c\x4c\xa1\x20\x62\x12\x0e\x12\x10\x01\xdf\x51\xaf\xc0\xe1\x89\x98\xa6\x24\xd1\x84\x84\x80\x91\x50\xc4\xad\xec\xed\x44\x12\xb8\x89\xd0\x25\x18\x94\x37\x3c\xfb\xf0\x20\x39\xa9\xe7\xdf\x96\xf1\x9d\x4b\x0f\xd8\xd5\x28\xe7\xb0\x1f\xd7\xc2\x3c\x48\x6d\x7c\x77\xf7\xf2\x6a\xf5\xd9\x4f\xb0\xf2\x39\xaf\x28\x1a\x3f\xaf\xe3\x06\xd1\x8b\xc2\x59\x0d\xa1\xa7\x3e\x39\xc4\xaa\x36\xfe\x87\x3a\xfb\x1d\x54\xde\x7d\xe7\x9d\xf7\xda\x94\x09\xbb\x4b\x8c\x28\xe3\x61\xda\x4d\xbe\x39\x9c\x69\x44\x4b\xab\x25\x4e\x1c\x77\x2a\x96\xe5\x3d\x15\xa6\xe4\x41\x0d\x49\xc8\x11\x57\x19\xa6\xe7\x37\xef\xfc\xba\x86\x40\xfc\xca\xa1\x10\x1b\x26\xd8\x65\x25\xb0\x71\xaa\x51\xd0\xff\xcc\x75\x25\xf2\xa2\xaa\x0b\x5d\x31\x9c\x74\x72\xee\xb7\x10\x79\xd4\x80\x54\xb2\x1b\x52\x0a\xab\x69\xe5\xee\x29\xe0\x25\xd0\x02\xdf\xf0\x4f\xdc\x6f\x10\xbe\x24\x7a\x30\xfb\xcd\x6e\x96\x83\x59\xe5\xd7\xee\x96\x6f\x7f\xc6\x35\x5f\xdc\x14\xf4\x88\xca\x56\xd1\x0c\x38\xa8\x74\x70\xc6\x0a\xb0\x3a\xa3\xe5\xa8\xb2\x3b\x8d\x3b\x63\xd0\xb0\xa9\x2c\x65\xbe\xa0\x4f\xea\x59\x4d\x64\xf2\x69\x1f\xc3\xce\xa0\x24\x08\xdd\x8c\x2b\xa5\x91\x60\xd0\x37\x39\xa9\x05\x2f\xa8\x17\xbe\xa8\x6c\xdd\xe6\xfe\x0e\xde\x61\x62\x6a\x27\x55\xd8\x90\xea\x44\x11\x63\x44\xf5\xbf\x50\x18\xa0\xaf\x3a\xe1\x9b\x4f\x3f\xf5\xcf\x39\xff\xde\x91\xd7\xbb\xf0\x4b\xfb\x89\x09\x4f\x2b\x23\xf8\xc1\x97\xc4\xd0\xd0\x50\x6b\xc9\xa8\x9d\xee\x30\x52\xbc\xb3\x1f\x46\x8b\x94\x1d\xa8\xbc\x93\x43\x62\x90\x3c\x1d\xf0\x6e\x8f\x3a\xa2\x65\x59\x8e\xd9\xa9\xad\x89\x2b\xf3\xd5\xb6\x03\x96\x43\x8c\xaf\xd8\x67\xd3\xf7\xbe\x13\xb9\x11\x9a\x97\x16\x4d\x4c\x30\x08\x23\x98\x9f\x16\x8b\xdd\xbe\xc7\xd8\x52\x86\x24\x8e\x5d\x22\x36\x7a\x92\x85\xf7\x18\x0b\x2a\x05\xba\x65\x46\xa3\x8c\xc8\x44\x89\xbb\xfb\x48\xab\x52\x07\x6a\x5a\x27\xc6\x1f\x5e\xcd\xba\x9e\x19\x88\xab\x8c\x9d\x7c\x2a\x6c\xba\x0e\xd6\x44\x89\x24\x20\xc0\x57\xd3\x28\x09\x17\x64\x25\xc4\x43\xea\x5e\x35\x7d\x0d\x16\xd5\x40\x5a\x55\x49\xbc\x0e\x9e\x3a\xc9\x43\xfe\x61\x0d\xe5\x06\xbb\xfb\x0e\x2a\xdd\xa3\x58\xe0\x84\x4e\xb7\x62\x61\x9a\xcc\x4e\x86\xc8\x3e\x52\x95\xc9\x77\x6b\x52\x90\xda\xe8\x71\xea\x1e\x64\x5f\x83\x53\x79\x32\x5d\xc6\xec\x52\x4a\x2a\x72\xa8\x1e\xca\xc1\x4e\xa9\xdc\xdb\x84\x39\xe3\x0c\x57\xca\x1b\xbb\x5d\x5d\xbb\xc2\x99\x48\xca\x89\x77\x15\xef\x8b\x98\xee\x4a\x9d\x7e\xf8\x6e\x8c\x38\x63\xca\x29\xd5\x0c\xbf\xce\x8d\x15\x55\x55\x7d\x40\x16\xa5\x55\xcf\xae\xa9\x7d\x3b\xf1\x9c\x7a\xb7\x47\xf2\x23\xc9\xb7\x3f\x92\x9f\x1e\x52\xdf\x7c\xd4\x95\x59\xbc\x2a\x53\x2e\x1d\x82\x64\xaf\x17\x83\x09\x1f\x6c\xc8\x8f\x4c\x69\x59\xf7\x75\xe1\x17\x5d\x8d\x62\x53\x41\x10\x97\x9d\xb3\x8d\x71\x38\x59\xad\x1d\x37\x45\x4f\x6f\x67\x47\x4f\x17\x1e\x09\xfb\x3b\x7b\xba\x3a\xfa\xf7\xb7\x51\x67\x75\xdd\x28\x99\xe2\x31\xd6\x94\x30\x0d\x54\x5e\x40\x8c\x69\xa0\xf4\xec\xea\xda\xe3\xea\xa3\x19\xa6\x07\x2b\x72\xd0\xaa\xb7\xd1\x60\xc8\x97\xc0\x63\x27\x76\x53\xda\xed\xec\x1c\x76\xf1\xbd\x79\x26\xf0\xb2\x7c\x24\x1c\x23\x30\x4c\xb5\x05\x87\x8b\xd3\x79\x11\x69\x81\xda\x1a\xd7\x4e\xdb\x8f\xa1\x56\xdc\x4f\x2e\x67\xe4\x34\x59\x99\x7e\x0c\x3b\xad\x85\xc5\x5b\x4e\xd4\x1d\x5f\xdf\x64\x58\x70\x33\x10\xa0\xa4\x54\x01\xb6\x49\x5d\x9b\x72\x0b\x8a\xe9\x98\xac\x14\xc9\x34\xbc\x6f\xdc\xb9\x5f\x59\xbe\xc0\x19\x42\xc2\x6a\xd6\x93\x00\x87\xb7\x69\xb4\xb7\xbb\x4e\x3d\xe8\x02\x4d\x74\xa4\x58\x45\x15\x0b\x6f\x1e\x14\x85\x1c\x76\x89\x3f\x93\xc5\xf7\xba\xe9\x50\x0e\x6b\x6b\x81\x44\x92\xe0\xdb\x29\x58\xb8\xc5\xc9\xb2\xa1\x02\xee\xe2\x9b\x13\x6a\xb6\xa4\x71\x19\x97\xda\xb6\x51\xaf\x31\xe9\x68\x7d\xb3\x75\x21\xdc\xe8\x00\xf6\xec\x79\xae\x13\xe3\x70\xe3\x6f\x33\xb7\x1d\x16\x3b\x3f\x09\xb6\xc0\x6f\xb1\x7c\xfe\x53\x58\x11\x05\x91\xe3\x1f\x12\x50\xda\x82\x4c\x92\x50\xde\x28\x3c\x88\xd0\xc2\x0c\xb1\x63\x78\x05\x5e\x3c\x71\x48\x37\xe0\xc5\xb3\x89\x7c\xcd\x2e\x3c\x61\x81\x6f\xcc\x85\x17\x35\x86\x57\xe8\xbf\xb3\x0f\x9f\x26\xfc\x77\x03\xe3\xa8\x17\xaa\x74\xef\xc7\x24\x6e\xd1\xe7\x9d\x9c\xe5\x91\x79\x25\xe8\x23\xe7\xfe\x01\xb3\x3f\xec\x00\x35\xeb\x5f\x62\x69\x3e\x59\x3f\x3b\x44\xc3\x0a\x2a\x81\x0f\x7a\x08\x45\x8d\x9e\x3d\xdb\x61\x61\xb9\x5a\x0a\x13\x0e\x24\x07\xc9\x89\x60\x96\x31\xe5\x56\x17\xf2\xc7\x1a\xc8\x28\xe3\xf8\x41\x2e\x24\x14\xe3\x08\x21\xe8\xd9\x6c\xa0\x5b\x48\xac\x56\x24\x50\x04\x0a\xa0\x73\xa3\xca\x78\xdd\x08\x91\x8e\x6b\xd9\x18\xe0\xeb\xab\xd6\xf9\xbf\x44\x40\xc0\xea\x27\x85\x09\xb6\xec\x13\xc1\x22\x30\xe8\x2d\xd5\x8d\x10\xc2\x45\xa6\xa5\xb8\x28\x1c\x15\xc5\xe3\x56\x2d\xd8\x3e\xdf\x2e\xbf\x83\x2b\x2e\xaf\x15\x54\x96\x62\xe2\x67\xee\xe4\x00\x3f\x81\x74\xa0\xb6\x92\xb2\x92\x3b\x82\x56\x3b\x7a\x88\x2b\xab\x60\x81\x1d\xfa\x06\x2e\xf0\x3b\xeb\x33\x95\x87\x8b\xdc\xb3\x5c\xb4\x07\xf3\x73\x6d\xf7\xeb\x33\xa2\x0a\x1d\x57\xd3\xa3\x82\x8e\xa8\xae\x2d\xcc\x96\x2f\x7c\xef\xad\xf2\x28\x2d\xc2\x43\xec\xb0\x0b\xc2\x44\x12\xea\xad\xff\x12\x03\x0b\xed\x15\x26\x96\x8d\x43\xbb\x69\x02\xa0\x6c\xa9\x40\x9b\xee\xc2\xbc\x5d\x0a\x27\x8a\x5e\xaa\x16\x92\xd1\x8a\xaa\x9e\x15\x0b\xce\x5b\xfb\x37\x78\x41\x8c\x26\x80\xab\x11\x7a\x2e\x58\x4e\xfd\xdf\xea\xda\x83\xca\xd6\xd9\xd8\x01\xf3\x09\x1c\xcb\x3e\x3e\x1a\x63\xa1\x15\xb4\x34\xf5\x22\x00\x5d\x88\x3b\x6a\x46\x02\x2d\x2f\xcf\x54\x5f\x7e\x1e\x50\x3f\xa2\xda\x65\x12\x8e\x1a\xd3\x41\x2c\xf1\x3e\xe3\x52\xdc\x10\x4c\x8f\x31\x23\x29\x64\x32\x2b\xc4\x43\xe6\xe8\xc4\xd8\x95\xca\x69\x1e\xc9\xa0\x25\x9c\x3e\x86\x99\x70\x12\x19\x72\x1d\xbb\x80\x1d\x9a\xf5\xed\x02\x94\x39\x4e\x74\x38\x5d\xff\x38\x2a\xff\x0d\xd1\xa1\xbd\xfb\x3b\xa1\x1a\x1d\x1d\xe8\xcf\x75\xe2\xc9\x13\x19\x79\xe2\x21\x5f\x6a\x03\xd3\x5b\x73\xc1\x68\x41\x0c\x53\x8b\xd9\x12\x1a\xee\x2e\xe7\xcf\x49\x3d\x2f\xaa\xc3\xd9\x29\x96\xe4\xda\x2a\x1a\x51\x65\x26\xd8\xb3\x86\x8a\x3f\xf7\xf4\x12\x75\xe2\xe2\x8a\x4d\x10\xb2\x71\xc3\x2c\x92\x24\xa0\x22\x3c\x91\x39\x45\x02\xcb\x56\x79\x79\x93\xe5\x01\x77\xb1\x88\x00\xee\x6b\x8f\x21\xf4\x59\x6f\xf7\x7a\x6c\x05\x5c\x44\x91\x6a\x4c\x80\x5e\x9b\xd1\x32\xff\xa3\x3e\x07\x5d\xc4\x25\x3d\xf2\x1a\x4e\x0b\xa8\x25\x25\x14\xbd\x62\xa7\xa1\x42\x8a\x1e\x5a\xa4\xad\x88\x3c\x38\xe4\x06\x30\xee\x6b\xb8\x37\x5d\xaa\x62\x79\x19\xdc\x8c\xc9\x59\x17\x7c\x35\x09\xbb\xa2\x19\x15\xc1\x22\x2c\xa1\xcc\x8d\x08\x44\x67\x15\xd2\x1b\xa9\x7a\x23\x80\x20\x2b\x1e\xfd\x44\xce\x65\xbb\x5f\x75\x9b\x53\xe0\x93\x1f\x47\xd7\xa5\xa8\xf7\x88\x2d\x93\x84\x84\x9f\x32\x0a\x54\xe2\xc8\xa9\x0a\x2c\x15\x3f\xd4\xcd\x9a\x8d\xfb\x5c\xc5\x31\xd0\xa1\xc4\x31\xf5\x39\xad\xaf\xf9\x7b\x61\xe6\x5b\x7e\xc4\x92\xd6\x7a\x76\x1f\xb5\x47\xbb\xac\xb0\x00\x45\xa5\x43\x19\xa0\xdc\xea\x47\x1a\x34\x8b\x94\x57\xab\x51\x63\x2d\x31\xca\xec\xc4\xf3\x82\xb4\xe8\x57\xae\x4e\x8b\xdb\x74\x03\xa1\x6c\x11\xf7\x62\xf9\x92\x8b\x4f\xfd\x4b\x9a\xf4\x27\x40\xc1\x11\x89\x8d\x0d\x8d\x52\x71\x28\x27\x1c\x32\x1d\x9e\x30\x28\x72\xb3\x8c\x70\x92\x82\xe6\x2d\x0c\x5e\xd0\xc7\xc6\x8b\x0a\x9a\x5f\xdb\xc9\x7d\x09\xfb\x13\x25\x32\xdc\xa3\x33\xe8\xce\xb6\xad\x0f\xf8\x00\x37\x45\xc5\xbf\xfe\xdf\xbe\xde\xfe\xc1\x50\xcb\x83\xbc\x18\x7f\x70\x34\xd5\xa7\xb3\xe5\x6b\x4f\x91\x58\xd7\x7f\xe3\x0d\xb7\x22\x1f\x0d\x1e\xc8\x2f\x1e\x58\x4b\xdf\xc3\xe1\x5c\x59\xc1\x42\xdd\x95\xef\xd6\xac\x4b\xdf\x70\xcf\x0c\xf4\xf4\xac\x6d\xf0\x37\x95\x95\xef\x61\x22\xc8\xeb\x8d\x75\xbc\x70\xd9\x70\xae\x30\xd3\xea\x9d\x98\xa8\x0d\x00\xac\x2c\xe5\xdc\x22\xf4\x0e\x2f\x43\xda\xc1\xa2\x9c\x98\x30\x0a\x9a\xf7\x52\x1a\x39\x7a\xae\x42\xef\x1b\xb1\xac\x2b\x2c\x36\xc3\xbb\xf8\x0c\x9b\x47\xdc\xfa\xd9\xba\x77\x33\x52\x71\x45\xa2\xb5\x0c\x3b\x72\xf8\xb3\x3c\x1a\x09\x84\x28\x91\x22\x1c\x38\xce\xe3\x72\xc8\x6f\x56\x40\x9b\xe8\xc9\xb6\xf7\x01\x6d\x38\xf4\x52\xde\x8e\x45\x69\x63\x0f\xa5\xa1\xe4\x4a\x98\x00\x62\x60\xcd\x5e\xfe\xc2\xf6\xf7\x70\x2e\xaf\x78\x5c\x32\x3a\x1b\x28\x47\x9e\xe0\x3a\x75\x6c\xf4\x04\x17\x26\x7d\xf7\xdc\x22\x7f\xc3\x9e\x1e\x01\x96\x5f\x90\x52\x2a\xed\x10\xc4\x4a\xa5\xfc\xbd\x92\x69\xaf\x9a\xa2\xdc\x2f\xce\x40\x9c\x05\x53\x94\xfb\xc2\x8b\x46\x3e\x46\xa4\x9d\x5a\x2e\x3f\xfe\x3a\x89\x48\x33\xf2\xf9\x37\x6c\xe1\x11\xe9\xaf\x60\xe1\x71\x5b\x61\x11\xfb\x92\x91\x9e\x39\xfe\x4e\xc1\x54\xc5\x59\x72\xd4\xa0\xf8\x92\xd7\x1f\x27\x41\x74\x50\x56\xfb\x97\xdf\x85\xbf\xa9\xa9\x6f\xe7\xe1\xe1\x63\x1d\x47\xbb\x84\x96\x93\xa2\xce\xc3\x76\x70\x4b\xca\x4e\x3e\xe5\x6e\x69\x27\xf9\x16\xed\xb6\x47\x36\xed\xd6\xe1\x6e\x47\x14\x78\xb0\xf3\x30\xa9\x05\x71\xc4\xc1\x6f\x8e\xa0\x4c\x42\x04\x0b\x50\xbb\x80\xba\x1b\x49\x23\x6c\x16\xf0\xd3\x8b\x5b\x88\xdb\x67\x7c\xa1\xa7\xe5\x6c\x50\x3a\x45\xe1\xf9\x29\x1d\xb6\x2a\x85\xef\xc1\xf1\x3a\xcd\xd1\x6b\xa2\x08\xbd\xed\x56\xf0\x28\xd5\x26\x1c\x27\x45\x9d\x92\xc6\xa6\x29\x34\x42\x74\xb7\x8c\xea\x69\x22\xce\x06\xae\x45\xcf\x0a\x4f\xe0\x36\xb9\xb3\x35\x8b\x95\xb6\x3c\xb9\xf6\x3b\x1b\x17\xac\xa5\x8b\x65\x4a\x1e\xe7\x27\xb9\xb2\xbd\xf4\xac\x0b\x86\x6c\x8c\x68\xe3\x3a\xdc\xba\x55\x50\xf0\x0a\xda\x14\x15\x65\xa4\x22\xd3\x7f\x2a\xe9\x05\x4a\xbd\xff\x60\x70\xb0\x0f\x63\x99\x3e\x9e\x6e\xe3\xfb\x1b\x67\x71\x8e\x17\x8b\x79\x73\x98\xbe\x0f\x77\x45\x50\x44\x5f\x01\x95\x5f\xe0\x16\x48\xcd\x76\xa5\x2b\x6b\x6a\x6d\xa2\x69\x1d\xb5\xc4\xc9\x69\x45\x54\x93\xf1\x82\x92\xd3\x28\xe0\xb1\xbe\x14\x10\x1a\x4b\x54\x0f\xf7\xd1\x60\x4b\xf9\xe4\xbd\xdc\xed\xd9\x88\x6f\xea\x1e\x44\x52\x5f\x73\x77\x1a\x83\xdd\x3b\xbb\x23\xaf\xfb\x69\xc5\xab\x9b\x9e\x2b\x69\x8e\xc3\x04\xae\x71\xe8\x16\xf0\x5f\x9b\xe3\xc6\xe0\x25\xd7\x8b\x82\xf7\x4b\x65\xeb\x61\x65\x4b\x54\x58\xc1\xf8\x11\xf6\x22\xdc\x3c\xe3\x71\x2a\x27\x20\xbd\xf3\xb0\x03\xd6\x27\xf1\x68\x18\x1a\xa8\x56\x40\x33\x4d\xba\xcf\xd1\xec\x74\x75\x40\xc9\xa1\x8d\x8e\xc2\x2a\xa8\x67\x30\x32\xa4\x62\x60\x2b\xab\x3b\x2f\x6f\x7b\x35\x40\xde\x1b\x95\xcb\x77\xa4\xc5\x80\x03\x63\x12\xd5\x50\x02\xda\x9f\x9a\xb3\xd3\x9b\x50\x8a\xb5\x7a\x80\xa0\xda\x8a\x8e\xec\x5b\x9f\xe3\x12\x0a\x18\x8b\x7d\xc3\x0f\xd2\xd7\xaa\x81\xfb\x16\xe1\x9e\xcd\x5e\x8b\xa8\x76\xb7\xfb\xf1\x7c\x06\x0e\x07\xa7\x72\x99\x7f\x18\x25\xfa\x91\x63\x8d\xe3\xaa\x0e\x86\xd3\x2b\x85\xcf\x03\x40\x72\xaf\x3e\x29\x3f\xbe\x17\x57\xaa\x70\x50\x1d\x63\x0d\x0c\x3f\xd4\x99\x48\x38\x08\xc7\x28\x05\xa4\x78\x9c\x0f\x59\x63\x2c\x81\x1f\xaf\xfa\xec\x4e\x75\xfd\x5b\x0c\x53\xa9\x71\xe8\x39\x6e\x89\xf2\xb5\xfb\xd2\x32\x28\x83\xde\x90\x18\xaf\x2a\x24\xd5\x32\xbc\x91\x30\xc1\x37\xa2\x51\x84\x69\x76\x71\x68\xc2\xf4\x31\x29\x22\xbb\x59\x92\x2f\x2c\xc0\x9b\x3f\xe4\x84\xf4\xaa\x45\x4f\xd5\x02\x38\x2a\xb5\x8f\xe9\x84\x64\x5f\x4c\x51\xe7\x66\xc6\xd8\xad\xc6\xf1\xce\x84\x34\xb0\x76\x93\xc3\x81\x2c\x86\x22\xd3\x95\xb1\x24\x11\x55\x66\xf8\xf9\x6b\xeb\xf9\x15\xeb\xde\x19\xee\xc3\x14\xaa\x0f\xd8\x51\xab\xd8\x91\x49\x18\x52\x6e\xad\x5b\x4b\xff\x3f\x73\x57\xfb\x1b\xc5\x91\xe6\xbf\xdf\x5f\xd1\x3a\x29\x22\xa7\xb3\xbd\x10\xed\x27\xf2\xe1\xe4\xf0\xe2\xe5\x14\x0c\xc2\x86\xd5\x6d\x88\xd0\xd8\x33\xb6\xe7\x32\x9e\x99\x9b\x9e\xb1\x63\x45\x48\x76\x08\xc6\x21\x60\x93\x2c\x04\x08\x10\xc3\x26\x40\x8e\x60\x70\x12\x42\xc0\x36\xcb\xff\x72\xeb\x1e\x8f\x3f\xe5\x5f\xb8\xe7\xa5\xaa\xba\xba\xa7\x9f\xea\x9e\x01\x67\xa3\xd3\xad\xc2\xb8\xab\xea\xa9\xb7\xa7\x9e\xd7\xdf\x73\x41\xb5\x7d\xfc\x3c\xee\xb5\x05\xb1\x81\x9a\xb4\x5e\xde\x40\x73\x0a\x83\x61\x5f\xf8\x52\x58\x24\xa0\x97\xcc\x3e\x1f\xe9\x3a\x6b\x07\x28\x5e\x1f\xef\x7e\xa2\x61\x0f\x64\x9e\x7c\x81\x71\x1b\x14\x18\x76\x68\xfd\x92\x45\x51\xb2\xdd\x38\xc6\xc0\x4a\x42\x04\x96\xad\x6d\x5b\x9f\x19\x9b\x20\x48\x39\xe2\x0e\x53\x82\x47\x9e\xf2\xbf\xbc\xe9\x89\xe2\x28\xaf\xbf\xb9\x99\x5c\xe5\x93\x84\x11\x38\x6f\xf9\x46\x2d\x0a\xc1\x88\x49\x99\xbd\x58\x56\xd7\x95\x87\x11\x7e\xce\x59\x97\x58\x32\xf7\xe7\xcf\x9a\x37\x97\xe1\x20\x72\xf9\x5c\xab\x47\x12\xd7\xd7\x44\xdd\x67\x78\x82\x8b\x85\xdb\x29\xb4\x56\xbd\x54\x0d\x42\x00\x77\x4f\xcc\xd8\x7c\x7c\x97\xfd\xa0\xb0\x3c\x5b\xeb\x4b\x2c\xee\x2a\x3f\x3d\xdb\xfe\x69\xd3\x5d\xc5\xf6\x33\x10\xc1\x15\x6c\xc4\xb0\x8d\x64\x22\x56\xbe\x7d\x15\x0a\xe0\xa2\x76\xb9\x10\xf0\x92\xae\x2d\xda\x4b\xc0\x54\xa1\x94\xb3\xf4\xf8\x95\xc9\xc8\xbc\x14\x4c\x86\x5e\x84\x4e\x68\xa8\x89\xe9\xd5\x70\xaa\xe1\xdd\xeb\x53\x66\x2a\x56\x52\x58\x30\xaf\xf8\x75\xf4\x60\x31\xcf\xe9\x05\x01\xfe\xc8\xd0\x30\xa9\x4e\x40\x32\x3e\x95\xbd\xbd\x40\x67\xbe\x32\xd9\xcb\x9d\xc3\xcb\x38\x5e\x28\x17\x6a\x21\x23\xe3\xdf\xa9\xbe\xda\x04\xf0\xbc\x2a\xd5\xbc\x72\x55\x59\x4b\xc8\x19\xc7\x5a\x72\xc4\x90\xe8\x8a\x9a\xe7\x54\x25\x5b\xda\x54\xf1\x23\xaf\xdc\x48\x97\x2e\x72\x85\x2e\x65\xc3\x8b\x91\x8a\x92\xc0\xc2\x25\x60\x62\xc6\x00\x6e\xaa\xaf\xe1\xc3\x4b\x35\xb5\x64\xc5\xc7\x8e\xea\xb4\xa5\x67\x10\xb2\x1b\xa5\xbc\xa7\xea\x40\xd7\x10\xa9\x45\xd6\xd2\xc4\xbe\x51\x59\xa2\xfc\x2e\xf3\x9a\x84\x25\x9d\xe9\x41\xc0\xbd\xab\x56\x45\xed\x8f\x6a\x7e\x62\x7a\x52\x94\x63\x2b\xbb\x37\x31\x6a\xd7\xd4\xd4\xf0\xf5\x0a\xd5\x2c\x9f\x51\x35\xa6\x7c\x2e\x95\x4e\xd8\x3b\xa6\x8e\x2a\xc5\xe1\xaa\xda\xbd\x78\x50\xc4\x5d\xbd\x37\xa7\x9c\x9f\xc0\xb9\xa8\x62\x14\x6c\x5d\xf0\xed\x57\xac\x02\x21\x5e\xce\xd9\xbb\x29\x55\x52\x99\x30\x9c\x79\x59\x65\x4a\xa9\x6c\x37\xab\xf8\x03\x1a\xa4\x51\x7a\x43\x6c\xc4\xe3\xb5\x12\x08\x6b\x7b\x45\x6c\xc4\xc7\xcf\xc3\xb2\xae\xf4\x2d\xea\x5a\x56\xfe\x5a\x58\x33\x51\x25\x4e\x49\xb6\x91\x2e\xe9\xe2\xb4\xa9\x4a\x0d\x05\x0b\x14\xdf\x8a\x55\x51\x7a\xeb\x64\x88\x5a\xe2\x10\x6f\xf8\x12\xf1\x18\x36\xce\x81\x6e\x08\x8c\x84\x11\x76\x98\x30\x58\xab\xf8\xbe\x61\x8d\xc0\x18\xf6\x63\x64\x39\x1d\xc4\x3a\x1b\x2f\x6a\x56\xe1\x85\x10\xb7\x86\x0b\x3a\xf5\xd0\x7d\xa7\xcf\xc8\x8a\x83\x67\x08\xad\x70\x4a\x70\x09\x47\x6c\x94\xe9\x86\x90\xcd\xff\x64\xb9\x9f\xf5\x02\x4f\x2b\x08\xde\x74\xae\xac\xec\xa3\xa6\xba\x51\x72\x4c\xde\x7f\x48\x9b\x8c\x77\x60\x79\x19\x1f\x7d\x8b\x6f\x6f\x3e\xff\x8c\xe0\x72\x30\xa2\x8e\x38\x0a\x57\x61\xe4\x18\xf7\x4d\xe0\x2b\x56\x6d\x08\x03\xaa\x13\xba\xc9\x9e\x3f\xc5\xef\x1f\x6f\xb4\xce\x3d\x51\xd6\x21\x1a\x04\x83\xb8\x48\xd3\xb2\x2f\xdd\x36\xd7\x7d\xd4\xbc\x99\x46\x53\xf5\xef\x4d\x2d\xab\xf6\x98\x3e\x67\x69\x1b\xda\x31\x1d\x65\x83\x09\x1e\xe5\x5d\x75\x5d\xdb\xd2\x78\x1b\x91\x4b\x7c\x50\x98\xf1\x65\x53\xa5\x2e\xae\xf3\xec\x22\xd7\xa3\x64\x17\x1f\xbb\xde\x1d\x57\x10\xc7\x26\x71\x5a\x3f\x1d\x58\xaa\x38\xa7\x8b\xce\x19\x61\x9b\xe2\x6a\x1c\x83\x2b\x34\x00\x10\xbd\x28\x9c\x00\xb7\xc6\xf2\x43\xbb\xc7\xa7\x73\xc5\xc9\xb8\x1a\x65\x90\x8d\xe9\x68\x12\xeb\xf3\xc4\x53\xc4\x61\x32\xb6\x66\x2f\xd5\x26\x6a\xbd\xbc\x6e\xb6\x38\xb2\x9b\x96\xad\x0c\x68\x34\x1b\xc9\x71\x29\xb1\xc0\x6f\xd7\x16\xb2\x8f\x8d\xc5\x0f\x2a\x48\x49\x76\x31\x5d\xc0\x46\x62\x58\x1b\x1f\x37\x57\xee\xf2\xa7\xaa\x40\x30\x79\xbf\xa4\x31\xaa\x4a\x99\xcd\xe5\xf3\xbd\x2c\x41\xf7\x22\x6f\xd8\xc5\xab\x35\x8e\x3e\xbc\x9a\x4a\x14\xae\x8a\xe1\x4f\x6d\xaa\x6b\xac\x37\xa5\xac\xfe\xf4\x5d\x30\x7f\x21\xa5\xfe\xcc\x30\x1c\x89\x92\x77\x18\xf8\x86\x58\xcd\x06\xe3\x7f\x57\xae\x35\x67\xd7\xc5\x10\x50\xee\x24\x37\x59\x69\x70\x79\xc3\x49\xea\xce\x7b\xb3\xd0\x37\xde\xe7\xed\xd9\xfd\xd6\x1f\x0f\xf7\x78\x7b\x06\xe0\xff\x77\x0f\x48\x7e\x62\x7b\x10\x2c\x91\x09\x4a\xcb\xbd\x8f\xe1\x62\x53\xeb\x7f\xcc\xce\xed\x19\xc0\xff\xd9\x3d\x20\xba\x79\x05\x1a\x74\x62\x3d\xfa\xaa\x29\x3d\xb9\x13\xa2\xd4\x85\x20\xf7\x34\xe3\x8b\xaa\x70\xe8\xd7\x40\x69\xb9\x31\x39\x82\x60\x78\x63\x8a\x3d\x3b\x05\x2f\x18\xad\x79\x45\x80\x65\x8e\x77\x17\x0f\x25\x74\xa7\x66\xb1\xdc\xe1\xec\xbf\x86\xeb\x97\xe5\x2e\xb0\xf9\xc1\xbe\x0b\xc9\x3d\x1e\xef\xef\x0f\x45\x33\x85\xa3\xc3\x75\x39\x46\x2b\xe5\xb1\xe2\x38\xa9\xa4\x12\xe2\xc0\x59\x74\xa3\xb1\x46\x89\x9e\x18\x02\xcd\xf1\xb0\x47\x97\x1d\x13\x0b\x16\xc1\x05\x63\x25\xd1\xd8\x52\x8c\x81\x2f\x34\xe9\x13\x1b\x1b\xc1\x10\x7c\x60\xa4\x93\x62\x66\x6f\x86\x51\x4c\xe1\xab\x70\x24\xde\x68\x33\x06\xfc\x61\x3a\x07\xfa\x6b\xbe\xcf\x1b\x02\x81\x74\xd2\x52\x39\xb0\x27\xed\xd7\x27\x33\x7c\x67\x74\x0c\xf5\x0f\x1c\x90\x82\xee\xf9\x71\x3c\x73\x36\x98\xff\xd9\xd1\x5a\xf2\x4e\xd9\xcd\xf7\x4a\xed\x0f\x1c\x73\x03\xe1\x70\x71\x24\x37\x10\x0e\xf6\x22\x42\xc5\x50\x07\x42\xbb\xb2\xf6\x40\xa9\xe2\x9a\x49\x76\xa6\x3e\x92\xed\x38\x77\x5e\xce\x87\xbc\x7a\xbb\xf9\xd3\x15\x16\x11\x12\x2d\x4f\x24\x37\xd8\xfd\xa4\x12\xc4\x1e\x97\x4a\xb9\x40\x01\x1d\x84\x29\xa0\xea\xd1\x28\xbc\x08\x16\x13\xe0\xd5\xac\xc2\x61\x14\x1d\x17\x44\xd8\xe6\xfa\x62\x73\x71\xa1\x79\xeb\x0c\x97\x39\xe5\x98\x82\xcd\x67\xb3\xcd\x87\x77\x9a\xb3\xf7\x19\x26\x20\x95\xa2\x06\xaa\x7f\x75\x2a\xbe\x27\xca\x05\x6a\x19\x30\x99\x5f\x14\x01\xc2\x2e\x59\x2a\xec\x51\x1a\xe6\x2e\xad\x30\xee\xca\x9a\xf5\x4a\xa3\xb1\x0c\x86\x5a\x08\x71\x3f\xd6\x08\xa8\x1f\x78\xd9\xd2\x13\x60\x6d\x6a\xb8\x66\x7a\xc1\xdb\xb7\x8f\x34\xc2\x13\x5c\x6a\x3e\x11\xb5\xab\x33\x85\x30\x1c\xa4\x32\x82\xb1\x77\xda\x1e\x46\x8a\x39\x5e\xe4\x82\xb1\x72\x91\xc4\x6f\xfe\x95\x76\xe0\x68\x23\xf1\xf9\x66\x38\x0b\x63\x3b\xb3\x7b\xa0\xec\x6f\x2e\x2f\xe7\x00\xec\x0f\x49\xac\xe6\x6a\x7e\x7c\x0d\xd8\x1d\x75\xf4\x90\xfa\x27\xec\x51\xa7\xf3\xe7\xb2\xc8\x39\x15\xaf\xad\x6a\xa3\xb9\x5c\x6e\x18\xf5\xf2\x74\x01\x63\x20\xf8\x61\xe5\xa8\x55\x5d\xc8\xd8\x3d\x4e\x58\xc2\x21\x31\xbf\x8e\x46\xdf\xd9\x22\x32\x51\xe2\xdb\xa2\x18\xf5\x64\x6c\x99\x39\x6b\xda\xdd\xf1\xf2\x08\xbb\x68\xa3\x19\x41\xd9\xd7\xd4\x24\x06\x19\xe0\x51\x2a\x3e\x87\xde\xa5\x2e\x46\x64\x1c\xd4\x3a\x4b\x13\x51\x38\x54\x3c\xd9\x49\xce\xf0\xec\xd4\x51\x18\x64\x62\xb0\x9f\xf9\x6c\xfb\xc6\xfc\x0e\x92\x6f\x15\x29\xe8\x96\x7c\xa9\x3e\x40\xd7\x93\x88\x65\x7f\xa8\x7d\x27\x26\xda\xe1\xad\x74\x77\xe9\x8c\xe1\xa1\xc9\x46\x41\x4b\x16\xe3\x71\xc1\xe9\xd3\x19\xc5\xe1\x4a\xa5\x4e\x65\x27\x6a\x9c\x18\x19\xc4\x57\x5b\x42\x53\xf8\xe7\xc5\x0d\xf1\xd9\x70\x54\x65\xeb\xa0\xbe\x1b\x56\xd7\x15\x00\x1f\xcc\xaa\xa7\x70\x0f\x5c\xbb\xc9\xdc\x8c\x07\x0f\xdb\x54\x81\xdd\xd6\x93\xf0\xbf\x0c\x41\x15\xb3\x32\x4f\x35\x4a\x68\x0f\x86\xd7\xe1\x6d\x8f\xf4\xa1\x62\xbb\xde\x20\x43\x8f\xa8\xa0\x1c\xdf\x96\x1f\xe8\x51\xdd\x5f\x89\xe8\xf6\xf0\xdd\x68\xa1\x90\x97\x14\xfa\xdf\x3b\xd9\xde\x9b\x33\x7f\x28\xff\x5b\xda\x92\x27\x95\x17\xcc\x4e\xd3\x4e\x9d\xde\x34\xaa\xfd\x74\x20\x3c\x9a\x89\x0a\x82\x8c\xf1\x7d\xa2\xa4\xd1\x51\x39\x91\x46\xf2\x73\x9a\x86\xe6\x17\x79\x2e\xf0\x26\x50\xf0\xe4\xf6\x9d\xe7\x99\x78\x51\xd7\x33\x35\x4f\xc4\x6f\x3e\xd3\x48\xc8\xf9\x4e\xce\x17\xfe\x00\x27\x2f\x57\x56\x4a\x07\xa3\x20\xfb\x91\xe2\xa7\xbf\xcd\xbc\xdd\x94\xa4\xce\xbb\xf0\x61\xb5\x30\x8a\x56\x6e\x36\xc1\xa3\xe5\xb3\x32\x4a\x29\x1a\xf9\xbd\xa4\x9e\x29\x5b\xbb\xf8\xe8\xa1\x33\xa1\xf9\xc9\x52\xf0\xed\x97\xc6\xa5\x10\x69\x27\x8c\x4b\x77\x5b\x61\xc6\x6b\x57\x38\x26\x16\xa9\x1c\x11\x8e\x1b\xf1\x72\xb5\xf1\x06\x06\xcd\x49\xa3\x5f\x7c\xd6\x7a\xf1\x82\x83\x80\x83\xa5\x8f\x9b\x57\x56\xd1\xfd\x4f\x49\x45\x46\xc2\x4f\x21\x00\xf7\x5c\x8d\x6f\x1c\xec\x83\x99\x04\x5d\x1e\x9c\x07\x49\x6a\x2b\x8c\x5b\xaa\x60\x2a\x89\xed\x68\xe7\x08\x22\xd2\x35\x38\x02\x47\x46\x1c\xfe\x66\xfb\xf2\x9c\xd5\x10\xed\x6a\x54\x53\x8b\x03\x6b\xa4\x21\xfd\x04\x10\x95\xd4\xd9\xd1\xe9\x53\x20\x13\x61\x9c\x9b\x63\x62\x7e\xb7\x40\x06\x5a\x33\xe8\x04\xce\x80\x87\x73\x00\x1a\xd0\x25\xdd\x31\x40\x83\x18\xc9\xaf\x0a\x6b\xc0\x51\x53\x19\x6a\xbd\xf2\x3e\xa7\x45\x4f\x99\xee\xb2\x01\x24\x50\x9f\x29\xd0\x08\x56\x97\xaa\xec\xbf\x29\xec\xe4\xec\xb6\x1d\xcb\x30\x63\xff\xce\xda\xb4\x76\xdf\xe9\x85\x69\xdb\xfa\x4e\x2b\x68\x67\xf5\xee\x42\x35\xd6\xfd\x96\xad\x38\xe7\x82\x5f\x69\xd4\xb4\x92\xed\xec\x5f\x05\x31\xff\xfc\x49\x73\xed\x92\x53\x81\x6f\x1f\xc5\xd2\xe3\x33\x0c\x61\x2b\xd4\xce\x21\x12\xe3\xd2\xd3\x16\xcb\xd5\x23\xa7\xde\xa8\xff\x76\xa5\xde\x30\xb9\x9c\x49\x11\x7e\x2e\xf7\x8c\x8b\xf0\x86\x9f\x00\x9e\x85\x38\x4c\x6f\xf8\x92\x25\x26\x44\x83\x4a\x6c\xcc\x54\x30\x6a\xd1\x1b\xfe\xff\xcd\xba\x56\x8b\xd8\x29\x07\xc0\xa8\x48\x70\x9f\xb8\xe4\x14\xf9\xc3\xe9\x87\xfc\xbe\x7d\xb6\x79\x08\x83\x4b\xca\x85\xe9\x42\xad\x0f\x21\x5f\x6b\x26\x0d\x52\x05\x5b\x17\x7d\x6a\xab\xe4\xd3\x68\x53\x91\x47\xf1\xcd\xa5\x10\x9a\xed\x9b\xb3\xad\x7b\x73\x6c\xa0\x92\x69\xc0\xd8\xc6\x1b\x4f\xb6\xbf\xbf\xb6\xf5\x29\x68\xaa\x0f\x19\xfe\xd5\xa4\xa2\x73\x98\x20\x66\xdd\x9c\x90\x48\x91\x8d\x86\x66\x55\x7e\x0f\x29\xe9\x7c\xfc\x77\x3c\x27\xc5\x4c\x3a\x52\x3d\xb8\xc3\xea\xc3\x71\x9e\x2e\x74\xe1\x26\x20\xd1\xa8\xf7\x7a\x97\xb3\x43\x93\x9c\xa6\x2c\x83\x40\xfd\x5a\xc4\xe5\xd8\x33\x96\x34\x50\x2a\xa5\xf1\xa7\xed\x75\x03\x48\x08\x4f\x62\x96\x45\x8c\x97\x5f\xde\x91\x2d\x76\x81\xfd\x66\x27\x32\x41\x6d\x6f\xa3\x36\xdb\xd5\xb0\xa8\x1d\x94\xa8\x6d\x03\x7a\xcd\x4c\x6e\x82\x35\xfc\xf5\xf3\xa0\x24\x6b\x76\x16\xea\x22\x00\xc9\xbf\x43\xf3\x5d\x37\x2c\x36\x29\xe7\xac\x93\x8d\x2b\x55\x72\xc6\xc4\x89\x3e\x6e\x9f\xa4\x7c\x12\x32\xb8\xfe\x50\xca\x64\x16\xb9\xbc\xe9\xe6\x0b\x4e\x25\x3d\xbf\xb9\x71\x3b\x12\xe3\x4f\xbe\x22\x96\x42\x54\x7f\x29\x84\xbc\x0a\xdb\xe7\xf1\xbb\x65\xfb\x9a\x82\xf8\x33\x95\x61\xc4\x8c\x2f\x9b\x35\xc2\x5f\x8a\xd5\x83\xb0\xdc\xef\xcc\x80\x6a\x8a\x80\xed\xf0\x13\xfe\x7b\x1f\xc6\x8a\xa0\xaa\x55\x94\x8b\xe4\xc4\x47\x8e\x76\xf5\xeb\xc6\x85\x58\x5f\x9b\xcf\x1e\xf0\x36\x08\x64\x89\x88\xa6\x22\x6e\x69\x42\xc6\x4e\x07\xf9\xe9\x1d\xa5\xa1\xcb\xc2\x91\xa2\xc1\x4a\xf8\x22\x1c\x55\x02\xbd\xae\x73\xde\x90\x92\x03\xf1\x36\x13\xc8\x8f\xc3\x67\x65\x13\x65\xa7\x73\x31\xba\x2a\xc8\x78\x0a\x96\xd0\x4a\x2e\x41\x20\x1d\x47\x8e\x1d\x12\x98\x43\xcf\x7a\x2f\x79\xd6\xab\x39\xdf\x9f\xae\xd4\xc8\x86\x5c\xaa\x8c\x17\xdd\xab\x63\xbc\xe6\xc1\xe3\xf9\xad\xdb\x73\x5c\x68\x49\x1c\xc7\xe2\x6a\xf5\x9c\x18\xa1\x1e\xe7\x15\x54\x4e\xcf\xd1\x27\xc6\x9a\xd2\x02\x2a\x26\x95\xcd\x5d\xce\xa3\xb4\x35\xce\xe0\x22\x47\x55\x29\x35\x15\x39\x3a\x07\x57\x2a\x32\xf6\xe7\xee\xc6\xd9\x14\x1f\x1e\x67\xeb\xe0\x92\x50\xcc\xfc\xb8\xcf\x0e\x04\x1b\xae\xc5\xb0\x3f\x39\x23\x85\x6f\x35\x07\xb3\x58\x00\x2a\x91\xa6\x8e\xf1\x6a\x91\x5a\x6f\x64\xf9\xcf\x30\x52\x18\x44\x6f\x35\x73\x8c\xc2\x28\x2d\x1f\x51\x72\x7e\x66\xae\x4c\x23\x31\xc0\x4a\x42\xd3\xc4\xd1\x4e\x1c\x38\x36\x74\xe8\xc8\xa0\xb8\x7f\xa4\x6a\x09\xd1\x3e\x27\x10\x43\xca\xfb\xcf\xa1\x23\x83\x5e\x65\xe4\xbf\xb1\x94\x8c\xc2\x22\xb2\x04\xaa\x5e\x05\xac\x33\xaa\xe2\xbb\x1a\x35\x8e\x73\xa9\xe6\x6a\x40\x58\x1d\x54\xb3\x9e\xf0\x4e\x29\x08\xea\x62\xb9\xb7\x84\x71\x1b\x15\xca\xee\xc9\xd1\xc6\xf6\x79\x07\x09\x58\x50\x97\x63\x55\xf1\xb5\x85\xbc\xa3\x5f\xbf\x80\x86\xbc\x51\x32\xc2\xf2\x5f\x75\xdd\x59\x07\x3c\xa1\x08\x75\xc2\x80\x49\x84\x4f\x68\x80\xfa\x39\x7e\x01\xd8\x15\x1b\x70\x49\x30\xf8\xb4\x79\x65\x81\x17\x25\x78\xfc\xbc\xf5\xc3\x1d\x78\x27\xe0\xe9\xde\x02\x91\x63\xf1\x6e\x73\xe9\x8b\xe0\xec\xdd\xe6\x97\xcf\x83\x8d\x25\xbe\x5b\xc0\xf0\x50\x8d\xd2\x31\x6d\xfc\x23\xaa\xb6\x14\xe9\x1c\x2c\x5d\xe5\x60\xe0\xd8\x28\x5c\x09\x96\x43\xf5\xe1\xc7\xed\x6b\x67\x13\x81\x13\xa1\xdb\xe6\x9d\x6f\x44\x46\xf0\xda\xf7\xaf\x58\xfe\xfd\xed\x9b\x38\xf5\x06\x87\xea\x10\xfc\xf9\x2e\x90\xca\x7a\xb5\xe8\xdf\x4b\x09\x7c\xbb\x74\xd9\xa1\x91\x82\x57\x2e\x8c\x43\x7f\x53\xa2\xcd\x8d\x50\xcf\x31\x14\xb7\xad\x17\x78\xdb\x70\xbb\x66\x37\x10\xd7\x06\x43\xcf\xd7\x5a\x4f\x96\xc5\x70\x4b\x03\x4d\x34\x28\xf3\x44\xce\x9d\x75\x85\xfe\x9c\xe0\x34\xfe\xa3\xea\x1d\x94\x82\x29\x09\xcd\x8d\x5f\x3d\xb1\x1f\x47\x8d\x7b\xe6\x0c\x42\x4b\x94\x0f\x30\xd4\xb2\x87\x42\x99\x6b\x75\x95\x80\xa0\x6c\xf9\x3e\xa3\x14\xe9\xc8\x75\x99\x53\xb3\x48\xa0\x83\xd3\x41\x10\x33\x39\xac\xff\x98\x9d\x6b\x9e\xbf\x1b\x7c\x7e\x1e\x64\x03\x16\x18\x24\xa6\xfd\xe7\xfe\x63\x83\x87\x06\x07\x18\x6f\x82\x5f\x3d\x3c\xde\x24\xb6\x18\x51\x01\x43\xe6\x8d\xdf\x86\xcf\x30\x65\xd8\xa0\x65\x6b\xa2\x38\x3e\x51\x9a\xc1\x3c\x9b\x51\x68\x93\x1b\x2f\xe4\xa9\xab\xff\x8a\x74\x80\x5e\x6c\x38\x28\x53\x45\xce\x1f\xc3\xc8\x30\x64\x65\x3e\x4d\x5b\xfd\x11\x81\xef\x6a\x7c\x4d\x78\x78\x7f\xa2\x50\x2a\x41\xff\x3e\xa6\x50\x22\x80\x90\xe4\x3a\x59\xb9\x07\x33\xe5\x19\x04\x1b\x6b\x5b\x67\x16\x82\xf5\xb5\xd6\xa3\x47\x0a\x2b\x09\x03\xe3\x71\x17\x37\x5f\xdc\xc4\x12\x07\xe4\x50\x6a\xdd\xb9\xc0\x49\x3d\xcc\x50\xb8\x29\x7d\x85\xc2\x1f\x1c\xc4\x8d\xaf\x5a\x7f\xfb\x9e\x2b\x64\x6f\xae\xad\xc1\x32\x07\x0b\xab\x2a\x97\xc2\x7c\xf0\x68\x15\x64\x21\xe0\x4e\x8a\xd0\x60\x71\x3e\x58\xfa\x91\x7f\x05\x56\x45\x04\x3b\x97\xdc\xa3\xec\x00\x05\x20\x56\xa1\x94\x04\xb8\xd3\x3e\x03\x88\xd9\x75\xdc\x95\x65\x40\xc5\x3e\x46\x33\xf0\xda\xd1\x51\x51\x36\x82\xd3\x55\x1e\x87\x26\x21\xee\x48\xc5\x14\x01\xe3\x6e\x68\x97\xd9\x7f\xe3\xbd\xb5\x7b\x37\xfe\xfd\x8f\x7b\x76\xf7\xe8\xc4\xb7\xf6\x7e\xd1\x7b\x38\x52\x28\x94\x75\xcd\x86\x1e\x0a\x4b\x60\x5c\xc6\xea\x04\xd9\x4a\x71\xff\x7c\xdc\xbe\x7d\xa5\x4a\x23\x0f\x9c\xad\x51\xce\xd7\xb0\x60\x3d\xe8\xbd\xb9\x91\x9c\x5f\xe0\x52\xe7\x1f\x94\x2b\xd3\xa5\x42\x7e\xdc\xe4\x0a\xb7\x8d\xa5\xc3\x80\x39\x67\x27\xcf\x0e\x9f\x48\xa7\x36\x0a\x9b\x59\x26\x76\xf3\xfa\xea\x2e\x19\x58\x57\x31\xa9\x84\x0f\x0e\xc2\x5c\xac\x7c\xcb\x78\x69\xc1\x1c\x21\xcc\x3d\x59\x6e\x3d\xf9\xc6\xa4\x9c\xb0\x15\xc2\x68\xb5\xb6\x09\x05\xa5\xc9\x79\x4c\x97\x21\x51\xec\xcb\xd6\xec\xd9\xe6\xcd\x07\x2a\x7d\x0f\x57\x15\x7e\xc3\x65\xf5\x54\xc6\x31\x85\xa3\xaa\x84\xe5\x67\x97\x55\xfe\xce\xda\x7c\x6c\x24\x7a\x11\x17\x5b\xb3\x17\xf0\x6c\x45\x66\x4d\xb1\x8d\x57\x56\x9b\x17\x1f\x05\x6b\x7f\x45\xad\xfb\xca\x75\x4c\x08\x06\x0e\xf0\x3d\xd2\xc7\x67\xcf\xbc\x8e\x09\x13\xa0\x14\x21\x56\x68\xb8\xd8\x3b\x0c\x14\x1b\x02\xba\xe5\x7c\xa2\x10\x4a\x8e\xdf\x72\x72\x35\x03\x3f\xb1\x31\x70\xc5\xb7\x73\x47\xce\xb8\x29\x45\x93\x7c\xc6\xf9\xf0\xa2\xe3\xb9\x2d\xce\x9f\xf3\x1b\x76\xf8\xf8\x76\x77\x6a\x43\x1a\xed\x63\xab\xcf\x32\x62\x82\x7a\xb9\x7a\xbd\x30\x59\xad\x9b\x01\x26\x73\xf9\x82\xc6\x47\xc9\x8d\x26\xad\xe3\xdb\x26\x20\xc5\x2e\x2e\x47\xf7\x1d\xf3\x78\xf2\xa0\x0f\xd4\x2a\x33\x1a\xe6\x2e\xb6\x07\x56\xbe\x92\x5a\x9b\x36\x5a\x61\x25\xc6\x30\x1b\x27\x71\x14\x2a\x70\x04\x3c\x5d\x07\x0d\x21\x0e\xa2\x12\x5d\x79\xf1\x35\x62\x51\x2f\x5a\x63\x7b\xd9\x1a\x5b\x69\xfb\xa3\xa2\x86\xe6\x39\x59\x35\x09\x75\xa3\xb0\x6f\xe5\x86\x98\x4a\x9a\xf1\x4e\x87\x32\xa0\xf3\x4e\x27\xdc\x55\xba\x42\x3b\x7a\x5d\x5f\xf1\xa2\x2a\x5c\x03\x7d\x51\xf9\xde\x32\x74\x20\xc2\x24\x51\x91\x28\x4c\x11\xfc\x69\xbd\x7d\xee\xbf\x6e\xdc\x20\x93\xce\xc5\xad\xdb\x4f\x82\x5b\x4b\xed\x1f\x20\x6d\x94\xe1\x00\x13\xe1\xc8\x23\x53\x54\x10\x89\x5c\xbb\xbf\x75\x79\xd9\x4c\xd0\xa6\x07\xcb\x35\xc7\xbe\xbf\xb4\x88\xe9\xce\x1f\x7f\xc7\x2f\x2a\x3c\xd5\xfc\x81\xe3\x90\x20\x3b\x4d\x3e\x25\xcd\x5b\x77\x83\x47\x17\x30\x3f\x9a\xca\x5f\x75\xcc\x97\x8a\x78\xf1\xeb\xa8\x6d\x13\xd2\x5d\x64\xa5\xdf\x8e\x5d\x10\x0b\x0d\x6b\xa4\xa0\x2f\x21\x26\xa1\x12\x74\x14\x3b\x89\xfd\xc4\xaa\x67\xd1\x96\xb9\x12\x0c\x88\x29\x2e\x94\x6f\x5f\x2b\x4e\xe6\x60\x57\xf1\xd6\x8d\x62\xf8\x7d\x98\x63\x6f\x13\x49\xa9\x70\xd5\x12\x25\x34\xb6\xdd\x5b\x4a\xae\x29\xe2\x5d\x99\xa4\x9a\x19\x78\x5d\xa6\xf6\x78\x43\xd1\x2a\x81\xe8\x46\x54\x0f\xbf\xb3\xe1\x5b\xf4\x25\x02\x82\x17\x30\xea\x30\x99\x67\x11\x8f\x83\x31\xd0\x5b\x4a\xd4\x41\x33\xfa\xef\x3e\xcf\xfb\x73\x21\x04\x33\xc6\xbc\x5a\xcd\x6e\xd4\xe7\x26\x98\x84\xf0\x5c\x1a\x1c\xc6\x92\xaf\x4c\x97\xf5\x47\x21\x03\xc0\xca\x51\x84\x33\x9f\xcf\x13\x38\x31\x6c\x52\x8c\x84\x91\x02\x01\x8c\x33\x12\x6d\x9f\x77\x04\xa5\x08\xd7\x2b\x30\x59\x1c\xc7\x9c\xff\x7c\x8f\x1e\x2c\x84\x6a\x03\x62\x79\x36\x98\x17\xe7\x64\xe7\xa9\x3c\xa8\xf5\xf2\x7a\xf3\xda\xe3\x76\xa6\x10\xcc\x9f\xdd\x3e\xf3\x1d\xb3\x27\xb8\x72\x7c\x33\xe5\x3b\xa9\x78\x10\x7f\xc6\x88\x01\xb1\x87\x9d\x43\x0d\x90\x95\x68\xae\x87\xd9\xbd\xcf\xd6\xe1\x52\xa1\x11\xef\xef\x9f\x01\x19\x8c\x3e\x00\xb7\x34\x12\xc6\x0c\x6c\xe5\xc4\x1e\x4f\xf9\x99\x19\x49\xe0\xda\xed\x60\x15\x54\xe8\x55\xef\xc4\x5b\xea\x0f\x0a\x6c\xf7\xd1\xd7\x5b\x8b\xab\x56\x65\x39\xdb\x97\x44\x61\x44\x49\xec\xb4\x79\xe3\x65\xf3\xe2\xdf\x50\xf2\x56\xcd\xdf\xd2\xdf\xda\x5f\x21\xe9\x0b\x9f\x6f\xae\x3f\x64\xd1\x1d\xfd\xf8\x86\x2c\x03\x18\xa9\xe2\x86\xe8\x47\x96\xb6\x80\x6d\x6e\x5f\x5d\xc1\x4f\x63\x2b\xb6\xb9\x7e\x77\xfb\xda\x3a\xe2\x2e\x32\x12\x30\x59\x72\x0d\x27\x42\xab\xe6\xd5\x7b\xad\x97\x73\x5b\xf7\xd7\x91\xa7\x47\xb9\x79\xb0\xfa\x03\xe7\x35\x3a\x78\x6e\xb8\x0a\xc0\x68\x99\x22\x99\xe7\xe4\x6a\xf8\x48\xee\x45\x54\x1d\x86\x2f\xc3\xbc\xb5\x28\x0a\x03\x83\xad\x60\x54\x85\xf5\x89\x1f\xf9\xc6\x57\x48\x7a\x06\x1e\x3c\x45\x21\xc2\x37\x90\x20\x59\x60\x2b\x23\xc8\x66\x94\x84\x18\x86\x7d\x21\xe8\x16\xeb\x4b\x6c\x1f\x8b\x7c\x37\x64\x7d\x28\xea\x33\x7a\x7e\x0a\x21\x04\x33\x16\xb9\x6c\x91\xb2\x1e\x80\x5e\x7b\x0a\x81\xdb\xfd\x53\x23\x33\xa7\xb4\x73\x57\x0a\xe4\xb0\x1e\x70\x34\xda\xa9\xa2\xb6\xe7\x97\xe1\x89\x30\x86\x84\xc4\x0e\xc5\xa0\x0e\x43\x1f\x87\x41\x62\x1d\x0e\xa4\x11\x15\xf0\xd4\x0b\xcc\xa8\x51\xa4\x53\x23\xbc\xc2\xb9\xb5\xed\xcb\xd7\x85\x51\x6a\x45\xe0\x65\xb0\x77\x20\xa2\x55\xf2\x04\x91\x78\xf0\x10\x56\xc0\x0b\xe1\x85\xfd\x7a\x1e\xa4\x2f\xc9\x70\x01\x47\x9e\x5a\xc3\xb5\xdd\x7c\xf1\xd7\x60\xfe\x3a\x99\xc2\xd8\x6d\x85\xe0\xbe\x24\x97\xe0\x8f\xba\x1f\x07\x19\x1a\xa0\x75\x0a\xed\x38\xc4\x97\x55\x31\xa5\xb1\xa2\x18\xa9\xb7\x3a\xcf\x11\xb5\xc1\xec\x06\x8f\xc3\x46\xb5\xe4\x61\xfe\x82\xc8\xfc\xb5\xd1\x89\xe2\x54\x21\xb4\xc7\x2b\xf3\x58\x86\x58\x37\x6c\x1e\xbc\xf8\xa2\x79\xe7\x1b\xd0\x97\xd8\x74\x98\x16\xf8\xf6\xde\xe1\xe3\xef\x0e\x1f\x3a\xda\x7f\x6c\xf8\x0f\x07\x8f\x1c\x3b\xdc\xbb\xbf\x7f\xb8\xdf\xdb\x77\x64\x70\xf8\xc0\xe0\xb0\xf7\xa7\x43\xfb\xf7\x1f\x18\x7c\xbf\x23\x1b\xd7\x7b\x47\x8f\x1d\x3a\xd1\x3f\x7c\xc0\xa3\x9e\xba\xea\x21\x09\xfa\xd1\xef\xb0\x8f\xf1\x52\x65\x04\xde\x33\x05\x59\xf2\xbe\x91\xa2\xdf\xd3\xf1\xb1\x7e\x5f\x5f\xdf\xfb\xde\x7b\xfa\x77\xfd\x61\x47\xa3\xf0\xcd\x94\x4e\x3b\x5d\xb1\xe6\xad\x33\x52\xdb\x7a\x45\x0a\xd6\x0b\x96\x80\x97\x82\xec\x7b\x56\x68\x5a\x92\x5c\x7a\x2c\xe0\x8a\xad\x2a\xd3\x62\x8e\x4c\x70\x76\xae\xf5\xe8\x99\xd4\x32\x03\xd2\x7e\x0a\xa6\xbe\x23\x09\x28\x15\xc2\x17\x9d\xd7\xa3\xb5\x9c\x3f\x21\x53\x6f\xe3\x97\x01\x21\x4f\xfe\xb7\xb9\x26\xad\xbb\x8c\x11\x9b\x81\x12\x8c\x73\xd1\x40\x2b\x63\xc0\xf1\x44\x8a\x38\x58\x85\x73\xd2\x83\x6f\x7f\x68\x3d\xb9\x9b\xdc\x63\x08\xf9\x28\x59\x3c\x93\x00\x1b\x85\xbe\x48\xb2\xdb\x1b\x06\xa0\x48\x3e\xc8\xc8\xa3\xfe\x55\xf8\x79\x72\xaf\x9a\x81\x48\xde\x1a\xf3\x81\xe8\x70\x1b\x41\xdf\x35\x09\xa1\xe8\x22\x97\x77\x71\xe5\x6a\xeb\xfc\xc7\xb0\x7f\xa8\x05\xbd\x78\x91\xdc\xd7\x68\xb5\x21\x34\xdf\x77\xf4\xb8\xd0\xc4\x7d\x76\xdc\xe7\x85\x1a\xcb\x05\xa4\x5c\x4d\xf3\x61\x31\x5b\x11\x57\x63\xa9\xf5\x52\x30\xa8\xab\xd2\x56\xd2\xf9\x4a\xad\x4b\x95\x2f\xfa\xee\x2b\x8f\x2f\x9f\xe3\xd6\x43\x7b\xe9\x9d\xd9\xfa\x66\x6e\xeb\x86\x90\x46\x8f\xcd\x44\xbf\x1e\xb5\x13\x8f\x49\x36\x0f\x74\xba\xab\x99\xe3\xdb\xa5\x0d\x93\xe2\xe3\x85\xa8\x78\x2a\x59\xa1\xf0\x90\xf8\x93\x1e\x46\x6c\x2e\x7b\x70\x9e\xcd\x8f\xa2\x03\x2f\x01\xd6\x07\xb4\x06\x13\xf0\x6e\x84\x10\xf8\xb1\x75\xee\x01\xda\x2c\x96\x97\x29\xcf\x5f\x23\x9c\xed\x3d\x59\x36\xd1\x0b\xa3\x63\x46\x51\x27\x8a\x7a\x79\x70\x8e\x65\xd0\xc5\x79\x55\xcf\x29\xcb\x93\x38\xd1\xe8\x9c\xd4\x44\xa3\xb3\xef\x70\xa2\x66\x4e\xf6\x44\x6d\x1a\xd3\x26\xda\x3e\x43\x7b\x99\x5c\x33\x14\x8b\x6c\x10\x35\xe2\x19\x9c\x16\x4f\x0e\xc1\xb6\xb3\x35\x25\xb9\x31\xa7\xa4\xb8\x18\x0d\xa5\x9e\x48\x8d\x09\x05\x97\xa2\x5e\x8e\xd6\xd0\x3c\x51\x9f\xd1\xd1\x2f\xfe\x84\x0d\x27\x87\x00\xff\xd2\x0d\x6b\x2b\x32\x1b\xed\x4a\xa1\x19\xac\x5d\xe6\xac\x72\x81\x92\x29\x39\x7f\xc8\x55\x57\x8e\x1f\x44\x0f\x54\x14\x2e\x0a\x32\x36\x86\xb2\xab\x8f\xb5\xa5\x0a\xa3\x13\x15\xb2\xbd\x18\xdf\x15\x0c\x51\x9b\xb1\xf2\xa5\xb2\x14\x0c\x67\xbd\x94\x3d\x4a\x8c\x15\x87\xba\xf1\xe2\xfd\x60\xe1\x69\xb0\xb4\x1a\xdc\xf8\x1a\xc3\xd3\xe8\xb1\x8d\xa4\x54\x65\x28\x2a\x8e\x4e\x63\x47\x48\x08\x2b\x0c\x62\x48\xc8\x58\xad\x40\xf6\x96\x6a\xae\x28\xcb\x57\x17\x5b\x4f\x9e\x23\x0a\xe1\xfa\x35\xf8\x8f\xe4\x7e\xda\x03\xec\xe1\x52\x0a\x1d\xb6\x7f\x0b\x5b\xda\x41\xb7\x5a\xa8\x03\xa5\x2f\xf3\x08\x88\xc1\x48\x56\x83\x0e\xc6\xa1\x32\x47\x5c\xdf\x22\xf3\x38\xa0\xbd\x18\xeb\x84\x30\x54\xc5\x17\x4f\x28\xa1\x3e\x26\x37\x33\xae\x30\x85\xd5\x54\x2a\x4e\x16\x45\xcd\x91\x0d\xbe\x84\xbd\xb4\x7d\xfd\x12\x9c\x31\x77\x9f\x24\x77\xe9\x64\xdb\x43\xe8\x86\xc7\xc0\x3f\x58\x64\xbf\x52\x66\x08\xbe\x0f\x8b\xf5\xc8\x51\xec\xc1\x87\xae\x7e\xca\x0f\xab\x67\xe0\x27\x5c\x4c\x43\xbe\x03\xca\x9e\xf2\x55\xfb\x68\x68\x64\x59\x5c\x0e\x6e\xdc\xe6\xbf\xb6\x8d\x07\x7f\xdf\x9e\x9d\x05\x6d\xdb\x2e\xc3\x11\x19\xd2\x39\x41\x51\x6c\x76\x24\xfc\x98\xb6\x22\x2f\xd6\xd3\x91\xda\x53\xc9\x38\x50\xf7\x27\x0a\xa0\x82\x73\xe5\x2c\x78\xbc\x74\xf8\x95\x74\x5f\x29\xc2\x8a\x73\x14\xb6\xd6\xef\x37\x3f\x7d\xa9\x50\xad\xae\xde\x16\x61\xbf\xf5\x50\x53\x26\x48\x43\x73\xe4\x7d\x07\x4f\x0d\x0d\xf7\x0f\x1c\x1a\x1c\x38\x35\x7c\xe8\xf0\x81\x23\xc7\x87\x35\x6f\x91\x0b\x9d\x58\x7c\x38\xa1\xbd\xc7\xe1\x19\x4c\x8e\xd5\x59\x57\x84\x1d\x1b\x3e\x7e\xf4\x55\x08\xb3\xdb\x77\x44\x58\x29\x37\x52\x10\x35\xd1\xdb\xe7\xb6\x56\xfe\x2e\xb5\xc3\xa8\x1c\x6d\x7f\x17\xaf\xf1\x79\x0c\x91\x24\xab\xab\xa3\x9b\x46\x95\x55\x0a\x11\x3e\x8a\xba\xe1\x68\xda\xe6\xd5\xa7\xae\xd2\x6d\xc4\x0c\xe4\xd7\x7b\xe9\x2a\x70\x01\xa1\x65\x05\x01\x9f\xe5\x67\x7f\xfb\xf2\x9c\x98\x4f\x3c\x99\x0e\x84\xe7\x6a\x28\xde\x2b\x6a\x29\xce\xd5\xf1\xd6\xb9\x82\x7c\xca\x95\xb2\x37\x92\xf3\x8b\xa3\xc6\xb0\x2f\xc5\xf9\xdc\xfa\x3a\x58\x5e\x6b\xde\x54\xce\x33\xb1\x37\x07\xe2\x94\xd4\xa6\xce\x55\x24\x4d\x74\x96\x52\xc7\x41\xf0\x70\x3c\x0a\x0c\x97\xcc\xea\x38\xdb\xf0\xe1\x8d\x70\x71\x03\x39\xf7\x96\xa3\x83\xc5\x56\xb2\x1e\xef\x68\x86\x42\xb7\xa4\xe8\x91\xb4\x9b\xdc\x0e\xe5\x0d\xe3\x8f\x21\xef\x8a\x7c\x06\x59\xee\x50\xc6\x75\xb2\xac\x4b\x7d\xd6\x27\x3a\x32\x82\xe1\xb8\xd2\xb0\xae\x71\x5c\xe4\xba\xda\x55\xfc\xa2\x33\xfa\x5c\xb6\xae\xaa\x88\x41\x31\x45\x96\x82\x96\x44\xab\xdb\xff\xb8\xca\x67\xa6\x14\xce\xc4\x78\x34\x05\x97\xd9\x19\xb0\x5e\x78\xb8\x7d\x47\x6d\x2e\x73\xae\x5d\x45\xba\x62\x5d\x49\x33\x89\xf5\xe5\x98\x12\xa7\x4b\x62\x18\x45\xad\x38\x42\xd8\x6b\xa8\xfb\x9f\xa2\x75\xda\xa5\x51\x16\x3b\x9e\x6d\xbc\x4f\x23\x41\xbc\xbe\x2e\x99\x73\xbe\xbe\xfe\x28\x6a\xba\xcb\xee\xd2\x91\x38\x85\x86\x1c\x22\xe2\x8c\xcc\x76\xa9\xaa\x99\xf2\xdc\x53\x32\xdc\x15\xe7\x91\x68\x70\x70\xfe\xec\x29\xf1\x19\x93\xe1\xb3\xe6\xa9\xa7\x66\xa8\x77\x83\x65\xea\xee\xe9\x83\x82\xf4\xba\xdb\x21\x5f\xee\x3e\x1c\x3c\x36\x9d\xa3\x47\x63\x3a\x3a\x3a\x9e\x29\xaf\xbc\x73\x8b\xc9\x68\x24\x6a\xc3\x68\x00\x12\x1a\x16\xe5\xfd\x83\xc7\x50\x68\xd4\x65\x95\x66\x2b\xa3\x51\xae\xc9\x9a\xa5\x34\x32\x75\x94\xd2\x85\xdc\xd8\x9f\x30\xd0\xdd\x96\x6a\x8e\x16\x5c\x87\x3d\x69\x68\xe8\x4f\x9e\x02\xed\xfe\xe5\xc7\x2d\x0a\x49\xe8\xaa\x7b\xd4\xa7\x78\x1d\xd2\x07\xba\xf9\x9d\x8e\x8a\x5e\xe9\x6e\x50\xb7\x89\x2c\x32\x25\x97\xb1\xcc\xdd\x7b\xf7\x33\xea\x60\x4c\xb3\x7c\x63\xa2\x1f\x6f\xfb\x8b\x05\x2a\xbc\x85\x29\x94\x8c\xa8\xe4\x75\xbb\x69\xbf\xe9\x66\xe9\x65\xec\x7e\x66\x1d\xac\xe3\x6f\xb9\x67\xa8\x3d\xd8\xfb\x26\x8d\xe5\x9c\x5e\xf3\xe6\x83\x0e\xd6\x92\xfc\x19\xe5\x57\x1e\xd1\x39\xc9\xba\xc3\x3b\xa7\x4b\x60\x4b\xac\x47\xd5\xe5\x75\x0a\x12\x0c\x75\x2f\x76\xd0\x55\xcd\x58\xb6\x7a\x75\xd5\xb0\x82\x60\x7d\x0e\x23\x3b\xd9\xe9\x9d\x8d\xbd\x1c\xc5\xd9\xee\x01\xe5\x91\xab\x49\x49\xbd\x61\xc5\x08\x04\xc5\x85\x4f\x9b\x0f\xef\x6c\x9f\xbb\x88\xc1\xda\x97\x3e\x0f\x2e\x2d\xa6\x0c\x84\x49\xa1\xa2\x6e\xfb\x54\x7c\x8f\xea\x04\xad\x9e\xc5\x3a\x69\xd9\x25\x5d\x40\xf9\x68\x4f\x95\x16\xf9\x87\xf5\xe0\x6b\x41\x78\x69\x94\x31\x1e\xbb\xac\x61\xa2\xeb\xb2\x08\xf3\x60\x6b\xf9\x6e\xf3\xd6\x19\xd1\x36\xd2\x28\xbb\xed\x2a\xa0\x84\xbb\xac\xab\x8d\xce\xd3\x97\xa1\x89\x74\xae\x9c\x6d\xa4\x1b\x04\x8d\xc4\xeb\xd3\xf0\x73\xe3\xa2\x2a\x65\x43\x97\x3b\x7a\x10\x65\x32\x17\xea\x78\x04\x79\xc8\xd9\xde\xce\xa6\x4d\xee\x6b\xaa\xeb\x94\xab\x19\x59\x34\xbc\x26\xb8\xa5\x3f\x62\xf8\x72\x15\x7d\x77\xfa\xb4\xf7\x26\x81\x00\x31\x09\x7b\x39\xd5\xbe\xa8\x92\xc0\x86\xea\x98\x97\x70\xfa\xb4\x54\x2d\x21\xde\xd7\xaf\x1b\x0b\x14\x57\x47\x14\xb3\x79\xbb\xbd\x33\xb1\x4a\x02\xe6\xab\x1f\xd4\xc8\x0f\xd5\xa2\x3c\xa6\xf9\x0a\x06\x4b\xef\xca\x95\x0d\x6e\x7f\xe7\x4a\x02\xb7\xbf\x9b\xce\x71\xa9\xc9\x3a\x87\x1b\x0f\x54\x22\x8b\x37\x50\x31\xc0\x43\x19\xc6\x0c\x2b\xdb\x0f\x1c\x21\x04\x23\xab\xb9\xd7\xfc\xfa\x93\x60\x1d\x0b\x35\xc9\x34\x21\x04\xc1\x91\x31\x15\x09\xed\x43\x1b\x1d\x00\x2c\x79\x89\x13\x1b\x6d\x3e\x7b\x80\x9e\x25\x8a\x1b\x15\x7d\xba\xd8\x92\xe3\x38\x34\xf0\x41\x4a\x58\x07\x05\x66\x6c\xae\xcd\x7b\xed\x2d\x81\x95\x8b\x83\xec\x2f\xfa\x1f\x1c\xc7\x5b\x8d\xf8\x53\x63\x9e\xfa\x45\x81\x90\xc8\xb3\xb2\x9a\xc1\x29\x04\xfd\x26\xd6\xd2\x75\xea\xf6\x03\xa7\xd5\xa4\x39\xfc\xcf\xb1\x2f\x61\x12\xe9\x1e\xe9\x44\x17\xa8\xaa\xef\x16\x56\xa4\xd5\x7b\x11\xad\x6d\x4a\x78\x0b\x56\xde\x8f\xcf\x05\xbe\xb8\x3e\x5d\x88\xb8\xe0\xd8\xea\xa4\xa1\x85\x9a\xbb\x6d\x24\x44\xf0\x19\x4c\x99\x3b\x8d\xc9\xc0\xae\x1d\x3b\x6b\xc4\x75\x70\xc8\x87\x71\xb2\x7c\xb2\x4e\xff\xc7\xb3\x7f\x27\x5a\xb4\x51\x47\x0a\x7b\xd3\x58\x9e\x0e\xed\xca\x27\xb1\xe5\xd1\x86\x3f\x61\x48\x3a\xf9\xaf\x24\xaf\x12\x2a\xbe\x8e\x5c\xc7\x3b\xa8\xea\x9e\x99\xba\x94\x9c\x86\xa5\xc2\x36\x7d\x53\x9d\x48\xe1\xdc\x61\x0d\x86\x3e\x8c\x7a\xd0\xeb\x2f\x94\x96\xc5\x7c\xe4\xa4\x0c\xe6\xb0\xda\x64\xa4\x97\x64\xb0\x0e\x98\x57\xb5\x3e\xa1\x8a\x0e\x18\xe4\x0e\xf7\x96\xd9\x4b\x15\xee\xd6\xfa\x22\x07\x94\x46\xe0\x5f\xd6\x2e\x71\xd9\x07\x34\x17\xaa\x42\x9a\x2b\x2c\x30\xa9\xe0\x03\x7b\xf9\xb0\xae\xda\x55\x8c\xba\x35\xf1\xd3\xe1\x5c\x54\x20\x88\x7d\x26\xc4\x8a\xb8\x74\x24\x4c\x8e\x3a\x4a\xca\x91\x82\x98\x9c\xa5\x9e\xd0\xa1\x04\x46\xd2\xfc\xe5\x07\x15\x49\x40\x01\xc9\x29\xc0\x24\xd6\x1a\x95\xa3\x95\x82\xbb\x42\x4b\xb1\xbb\xcb\x52\xd0\xb8\x1d\x42\x45\x24\xf3\x20\x47\x8b\x23\x1f\x2b\x97\x66\x3c\xac\x8a\xee\x7b\x8d\xaa\xaa\x95\x6f\xbd\xba\xc8\xaa\x0e\xe7\x3e\x2c\x4e\x36\x26\x43\x00\x3d\x4e\x35\x0e\xa1\xf6\x22\x6f\xa9\x0c\xb0\x97\x81\x1a\x83\xfe\xd7\x4e\x85\xc6\xe0\x33\xc3\xfc\x7b\xb7\x74\x30\x3c\x1f\x0e\xb1\xef\x5d\xc6\xf7\x33\x4d\xf0\x74\x87\x7f\xd6\xf0\x7f\x76\xa7\xf8\x45\xeb\xde\x9c\x7a\x1a\xc3\x4d\xd0\x68\xa5\x14\x36\x8f\xde\x74\x42\x10\x6c\x9d\xfb\x29\x58\xfd\x1c\x03\xcd\x55\x77\xc1\xc5\x73\x5b\x6b\xf7\xf1\x7c\x27\x4d\x49\x5e\xa1\x12\xe7\x03\x19\x90\x20\x8e\xa8\x97\x0f\x4e\xbc\x01\xbe\x08\x8e\x50\x53\xdc\xe5\xc2\x64\xf4\x6d\x83\x1f\x52\x9f\xb6\xb0\x51\xf8\xb2\x85\xed\x5c\x0f\xdb\x61\x60\x75\xa5\x61\xd0\x40\xb8\x94\x3a\xfd\x33\xb1\xc8\xaf\x63\x70\xb9\x8b\x94\x88\x63\x44\xd8\xd2\x3e\x66\xd5\x81\x33\x62\x37\xe1\xfb\x94\xd5\x8c\x7f\x8e\x25\x59\x6a\x95\xf1\x9a\x1c\x13\x9e\xd0\x48\x9b\xea\x6f\x70\x25\xe6\xcc\x83\xf9\x8d\x51\xc4\x8c\xef\x68\x3a\xbf\xfc\xd8\x5c\xb8\x04\xa7\x57\x1c\x24\x1a\x2c\x66\x0a\x42\xe5\xb0\x3a\x15\x27\xf5\x52\xf0\x19\x87\x22\xc8\x03\xc7\xba\x09\x5e\x9e\xdd\xbe\xb3\x8e\xb9\x4a\x2b\x57\xb7\x1e\xde\xdb\x7c\x06\x64\x7c\x09\xef\x78\x30\xbb\xd1\x35\x25\xaf\x4a\x41\x07\x63\x67\x0e\xbe\x6b\x6f\x9a\x1e\x6b\xf7\x51\x14\x7f\xf2\x4d\xbe\x5b\x20\x44\xbc\x8b\x5a\xf3\xe9\xd3\x87\x23\xc6\x80\x1e\x3b\xc6\x28\xf2\x9d\x97\x18\xda\xd4\x63\xa0\x7f\x7c\xfd\x9d\x2e\xcd\x19\x82\xc8\x99\x3f\x69\x39\xaf\xc7\xb3\x1d\xcb\xc4\x72\x07\x2b\xe5\x77\xd0\xef\xaf\x9b\xf4\x73\x64\xb1\x53\x35\x4b\x99\x97\x6d\xc1\x60\x54\xb3\xe4\x89\xb5\xc7\x61\xf1\xd7\xd1\x69\x35\x6f\xdd\x31\xa5\x39\x13\xa6\x86\x20\x69\x24\x26\x62\x8c\x54\xd4\x19\x9e\x32\x3d\x69\xd7\x8e\xb1\x03\x4e\xf3\x5e\x66\xa7\x54\x19\x4f\xff\x14\x26\x48\x66\x77\xd6\x79\xed\x3d\xa3\x76\xa4\x82\xa4\x34\xf7\x8d\x0c\x03\x7f\x77\xf1\xe0\x21\x65\xe0\xd3\x9f\x67\x32\xf8\x6d\x3d\x7c\xe8\x25\xb4\xc5\x07\xc6\x61\x0a\x74\x8c\x46\x07\x60\x3f\x47\xb4\xcb\x87\x26\xdb\xe0\xf1\xbe\x1c\xb4\xd4\x63\x6c\xb9\xcf\x28\x3d\x09\x2a\x4f\xa5\x66\xff\x25\x2a\x8c\x53\x70\xa2\x95\x33\xcc\xd6\x4b\x87\x1c\xad\x07\x8f\xb1\x77\xcc\x92\xb4\x84\xbb\x24\xad\x07\x78\x63\xe4\x8f\x71\xf1\x97\x6a\xc0\xab\x6c\x54\x32\x93\xba\x44\x55\xfd\xda\xa3\xb4\x40\x92\x28\x68\x10\x7c\xbd\xe0\xc7\x0f\x6d\x6e\xd2\x76\x6a\xe5\xb9\x75\xde\xa9\x39\xc3\x44\xe8\xbf\xbc\xff\xff\x01\x00\x00\xff\xff\x03\x4e\xd0\x50\x0a\xce\x02\x00") + +func cfI18nResourcesZhHansAllJsonBytes() ([]byte, error) { + return bindataRead( + _cfI18nResourcesZhHansAllJson, + "cf/i18n/resources/zh-hans.all.json", + ) +} + +func cfI18nResourcesZhHansAllJson() (*asset, error) { + bytes, err := cfI18nResourcesZhHansAllJsonBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "cf/i18n/resources/zh-hans.all.json", size: 183818, mode: os.FileMode(420), modTime: time.Unix(1456502789, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _cfI18nResourcesZhHantAllJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xbd\xfb\x53\x1c\x47\x96\x28\xfc\xfb\xf7\x57\xd4\xd5\xfd\x6e\x60\x4f\x00\xb2\x3d\xb3\x1b\x37\x14\x71\x63\x2f\x46\x58\xe6\x1b\x24\x58\x40\xda\x75\x98\x09\xa6\xa0\x0b\xa8\x51\xd3\xd5\xd3\xd5\x0d\x66\xbc\xbe\x01\xb2\x31\x60\xa1\x87\x1f\x7a\x63\xbd\x2c\xc9\x58\xb2\x1e\x96\x2d\x09\x23\x84\xff\x98\xa1\xba\x9b\x9f\xfc\x2f\x7c\xe7\x91\x55\x95\x55\x5d\x59\x55\xfd\x40\xf2\xec\xde\xd9\x58\x8b\xee\xae\x3a\xe7\xe4\xc9\xcc\x93\x27\xcf\xf3\xfd\xff\x47\xd3\x3e\x84\xff\xd7\xb4\x7d\x66\x66\xdf\x01\x6d\xdf\x48\x6e\x24\x37\xdc\x3b\x70\x60\x24\xb7\xaf\x9d\xbf\x2f\x16\xf4\x9c\x9d\xd5\x8b\xa6\x95\x73\x1f\x28\x9f\x39\x5b\xb9\xb5\x89\xcf\xc0\x23\x1f\xb5\x47\xc1\x78\xcf\x2a\x15\xb4\xff\x6f\xa8\xff\x88\x66\x17\x0b\x66\x6e\x52\xb3\xe7\x72\x45\xfd\x03\xcd\xb4\x35\x33\x37\xa3\x67\xcd\x4c\xa7\xa6\x0d\x14\xac\xbc\x51\x90\x7e\x2a\x4e\x99\xf6\x01\x4d\x1b\x9f\xd0\x6c\xa3\xd8\x51\x28\xe5\x72\xf0\x6a\x87\x91\x9b\x31\x0b\x56\x6e\xda\xc8\x15\x3b\x66\xf4\x82\xa9\x8f\x65\x8d\x8e\xc9\x82\x55\xca\x6b\x6d\x1f\x8e\xec\xcb\xe9\xd3\xc6\xc8\xbe\x03\x23\xfb\x00\x6c\x09\xfe\x6a\xaf\xfd\xea\xa3\xb6\xb8\xd1\x9c\x58\xaf\x5c\xfe\x84\x89\x75\xee\x5f\xd8\xd9\x78\x5c\xbd\x7b\xb5\xfc\xe3\xb9\xca\x27\x37\xca\xe7\x96\xff\x3e\x7f\x62\x77\xe1\xbb\xca\xb9\xa7\xf0\x8c\xf8\xfe\xc4\xe6\xaf\x5b\x97\xf7\x82\xc6\x3d\xe5\xa6\x5d\xd4\x27\x7f\xeb\xdc\x6c\x29\x8d\x0a\x6e\xfe\x4e\x1b\x9e\x32\x6c\x03\xf0\x15\x66\xcc\x71\x43\xcb\x67\x61\x0c\xda\x94\x3e\x63\x68\x7a\x4e\xd3\x6d\xdb\x1a\x37\xf5\xa2\x91\xd1\xc6\x2d\xbb\xd8\xa9\x75\x17\x0c\x18\x1f\xb0\x5c\xf7\xde\x30\x73\x40\x67\x0e\xfe\x98\x35\xb3\x59\xf8\x34\x0e\x93\x83\xbc\xe6\x37\x94\xbc\xf9\x9d\xb6\x3b\x7f\x69\x67\xf3\x4a\x79\xed\x94\x73\xf2\x52\xf9\xfc\xcf\xe5\x1b\xcb\xe5\xb5\x95\xdd\x0b\x6b\xd5\x85\x87\xc0\x8f\xf2\xf2\xd9\xf2\xda\xf7\xc0\x21\xe7\xf9\x66\xe5\xde\x49\x7e\xcc\x79\x78\x67\x67\x1b\xfe\xfe\xb8\xf2\xd5\xcd\xca\x57\xd7\xca\xf7\x6f\x79\x8f\xa9\x06\xd8\x95\xcf\xc3\x32\xd1\x0b\x30\x86\x98\x5d\xec\x3c\x7b\xec\x9c\xbb\xe6\x9c\x3c\x57\x5e\x5a\xa9\x7c\xb5\x5e\x59\x3f\xe9\x6c\x9d\x51\xef\x68\x04\xfa\xe1\x87\x9d\xf0\xcf\x11\xe0\xf4\x47\x1f\x69\xb3\xba\xed\x62\xd1\x4a\x36\x32\x48\xb0\x60\x7a\x5a\xcf\x65\xb4\x3f\xc3\xc3\xdd\xfc\xf7\x47\x1f\xfd\x39\x9e\x8e\x9d\x17\xbf\x00\x05\xc0\x1c\x67\xfe\x64\x79\x75\x69\xe7\xf9\x2d\x98\x65\xe9\xf5\x36\xad\x96\xd2\x00\x31\x6a\xb2\x8f\x58\x9a\x9e\x37\x35\x23\x97\xc9\x5b\x66\xae\x88\x8b\x4c\x3d\x41\xe5\xb5\xbb\xd5\xf5\xfb\xce\x83\xcb\x5a\xd7\x40\xaf\x56\xb9\xf7\x70\xf7\xf9\xd5\x18\x3e\x0f\x5a\xa5\xa2\xa1\x15\x2d\x6d\xcc\xd0\x4a\xb9\x69\x3d\x9f\x07\x56\x00\x0b\x72\x56\x51\x83\x25\x51\x80\xc5\x9b\x9d\xd3\xc4\xf7\xf0\x58\x71\x0a\x56\x58\x3e\x9f\x35\xc7\x09\xa7\x9a\x8e\xea\x9d\x05\xe7\xcc\xf9\xf2\xd3\x65\xe7\xd1\xa9\xf2\xc5\xeb\xb8\x55\x9e\x3d\x74\xb6\x3f\xaf\x5c\x79\xe0\xac\x9c\x02\x2a\xf9\xfb\xea\xd2\x8f\x32\x47\x62\x28\x45\x81\xae\x69\x47\x61\xd1\xb7\xc1\x46\x9b\xd6\x0b\xc7\x8d\x22\x2c\x7b\x58\xc1\x1d\xb6\x36\xd4\x33\x78\xac\xb7\xbb\xa7\x0d\x49\x9c\x31\x8d\x59\x2d\x63\xd8\xe3\x05\x33\x8f\xf4\xd8\x9a\x35\x01\x0b\x3c\x63\xce\x98\x99\x92\x9e\x15\x7b\x05\xbe\xd3\xb5\x49\x73\xc6\xc8\xb9\x5b\x22\x86\xa7\x74\x54\xc0\x0e\xe7\x49\x8e\x23\xe0\xd7\xad\xd5\x9d\xe7\xb7\xcb\x77\x6f\x56\xef\x9c\xaf\x3c\xb9\x03\xf3\xc0\x5b\x00\xc6\x0f\x0b\xc3\x59\xbe\xcd\x5b\xa6\x7a\xf7\x6e\xf9\xe2\xe9\xa4\xd1\x76\xd9\xb6\x39\x99\xd3\x0a\x56\xd6\xb0\x61\x9f\x16\xa7\x78\x49\xf1\xb4\x00\x27\x0a\xb0\x84\x51\xe2\x58\x85\xc9\x0e\x7c\xa8\x4d\xc3\x55\x1b\xfd\x8c\x9d\x07\x4a\xf9\xa9\xf4\xe3\x4c\xc0\xe6\x7c\xb1\x9a\x8c\x4d\xdb\xd9\xfe\x14\x36\x44\xf9\xa7\xed\xea\xb7\x5f\x54\x57\x1e\xc7\x8e\x98\xa6\x17\x21\xbe\x33\xac\x17\x26\x8d\xa2\xb4\x7d\x70\xf1\xd1\x77\x5a\x0e\xe6\x97\x10\xd4\x37\x90\x5a\x90\x30\x53\xce\xa3\x25\x58\x91\xe5\xf5\x4b\xb0\x69\x40\x8a\x97\xcf\x3f\x82\x99\xaa\x7c\xb7\xb9\x7b\xfe\xcb\x74\x84\xaa\x08\x04\x2e\xd5\x47\x5e\x0a\xb2\x9e\x7c\x52\xf9\xf9\xab\x58\xb2\x4a\x62\x7b\x64\x2d\x38\x82\xb4\x0e\x9d\x84\x40\x47\x87\x7d\xdc\xcc\x77\xd8\x76\xb6\x83\x8e\x59\xa2\xa4\x0d\x28\xa4\x47\x51\xb4\xc4\x3c\x05\xa3\xb2\x4b\xf9\x7c\xc1\xb0\xf9\x2c\xd6\x8c\x42\xc1\x2a\xd4\xb5\x55\xd2\x10\x53\x5e\x3e\x9f\x82\x1a\xb1\xbb\x3e\xfb\xdc\x59\x7e\x0a\xa7\xc8\xee\xea\xc3\xea\xdd\x5b\xd1\x0c\x81\xbf\xba\xdf\x19\x3d\xd2\x75\xb8\x47\xd3\x4b\xb0\x73\xf0\x6c\xfd\xdf\xc6\x07\xfa\x74\x3e\x6b\x74\x82\x80\xd7\x46\xf6\x8d\x8c\x8c\xec\xcb\xc3\x59\x39\x6b\x15\x32\xf8\xf7\xc8\x3e\xed\x35\x10\x1b\x7a\xde\xd0\xfe\x5a\xb2\x8a\xb0\xe7\xcc\x09\xe4\x28\x08\xc4\x9c\xe6\x3e\xf8\xba\x62\xe8\x0d\xe1\xfb\x75\x6b\xd9\xb9\x73\xa2\x7c\x75\xcd\x59\x5b\x77\x1e\x7e\x5a\xb9\xb9\xb5\xb3\x71\x9f\x39\xe7\x6c\x9d\xab\x5e\xba\x06\x03\xae\xde\x3b\x59\x7d\xf6\xa3\xb3\xb4\xe9\x7e\xb3\xd2\xf0\x80\xa7\xe7\xbc\x61\xe0\x58\x71\xb1\x88\x81\x4e\xc0\x62\x70\x7f\x12\xa2\x46\xe7\x3d\xf6\xba\xf2\xd8\xab\x17\xa1\x3f\x58\x1a\xa9\x73\xf6\x1e\x28\x0e\xb0\xd5\xca\xd7\xb7\x78\x98\xc1\x81\xaf\xa8\x0e\x44\x09\xef\xb8\x95\x9f\xeb\xb0\x41\xaf\x04\x21\x3c\xd4\x7f\x74\xb0\xbb\xa7\xa3\x6b\x60\x40\x1b\xee\x1a\x3c\xd4\x33\x4c\x7f\xbe\xdf\x61\xb9\x1f\xfb\x07\x0f\xfd\x09\x3e\xdb\xee\xe7\xa1\x81\xae\xee\x1e\xfc\xa6\x23\x67\x75\xc0\xfa\x46\x3d\xe0\x4f\xca\xd1\x26\xd2\xc2\xab\xfc\x35\x6b\xda\x2c\xe2\xa2\x29\x20\x3b\x48\x1e\xbb\x1c\xc0\xad\xc4\x0f\xc1\x21\x6e\x14\xf4\xf1\x22\x9c\x3e\x70\xb8\x76\x74\x78\x30\x48\x17\xcb\x17\xac\xe9\x7c\x91\xa6\x64\xcc\x2a\x4e\xa5\x9a\x00\x82\x0b\x0c\xae\xac\x2d\x54\xce\xdd\x66\x46\x56\xe7\x17\x9d\xb3\xa7\x2a\xeb\x3f\x80\x98\x66\x96\xf3\xf6\xd9\xd9\xfc\x02\xf5\x90\xf3\x3f\xc3\x79\x5b\xb9\xf4\xdc\x59\xbc\x2d\x93\x00\x92\x87\xf7\x70\x75\x6b\x03\x7e\x72\x16\xbf\x03\x38\xe9\x66\x43\xec\x73\xd8\xb4\x96\xf6\x5a\x78\x48\x70\xf8\x02\x3b\xb4\x52\x21\x8b\x7c\xb0\xc6\x8a\x3a\x3c\xab\x6b\x56\xce\xe8\x28\x9a\xc0\xa9\x1a\x2e\xa5\xd8\x68\x12\x42\x18\x7b\x70\x04\x3b\xdb\x57\xb4\xa3\x83\x7d\x38\xe4\xed\x4f\x41\x13\x71\xb6\x41\x8d\x9f\x2f\x7f\x7f\xa3\x3c\xff\xad\xd8\x6a\xcf\x6f\xef\xce\x3f\xae\xde\x58\x65\x26\xa4\xd9\x58\x02\x61\xa9\x76\xad\x77\xe4\x1b\x16\x28\xa9\xe7\xb7\x1e\xc4\x8d\x49\x96\xf4\x93\xac\xa2\x64\xcf\x44\x4c\x3d\x78\xf7\x40\xd2\xc4\xa2\xcf\xeb\xff\xf4\x4f\xb3\xd6\xe0\x41\xed\x35\x3b\x6f\x8c\x9b\x13\x73\x0a\x01\x00\xb7\x0d\x50\x10\x4a\x78\x23\xb4\x9b\x1f\xb4\x8b\x15\x46\x0b\xfa\x15\x68\x9a\xaa\x6d\xbf\xf3\x62\x0d\x74\x08\x18\x6d\xf9\xdc\x46\xba\xd1\xe6\x4b\xf6\x14\x1c\xc3\x03\xfc\xe9\xfd\x8e\x31\xed\xed\xa3\xbd\x7d\x07\x41\x60\xfe\x91\xbe\x42\xa9\x39\xae\x75\xf7\x1f\x3e\xdc\x75\xe4\x20\x7e\xc8\x68\x07\xfb\x0f\x77\xf5\x1e\xc1\xbf\x27\x34\xf8\xb6\xf7\x9d\x9e\xa1\xe1\xd1\x81\xae\xe1\x77\x49\xc2\x66\xac\xf1\xe3\x46\xa1\xc3\x9c\xd6\x27\x0d\x78\xb4\xfb\x8f\x3d\x83\xa3\xbd\x87\xbb\x0e\xf5\x34\x21\x70\x89\xc8\x5a\x74\xf5\x03\xec\xa7\x6b\x82\x9e\x05\x59\xec\x0b\xaa\xac\x69\x17\xf1\x92\x40\x77\xc1\x8e\x8c\x91\x35\x41\xb0\xe3\x1d\x48\x9f\x44\x45\x48\x2f\xb2\x64\x83\x6b\xd3\x6c\xc1\x2c\x16\xe1\x1a\x21\x6e\x47\xc7\xba\xbb\x06\x46\xc5\x75\x60\x48\x93\x8c\x00\x9a\x6b\x04\xa0\xad\xa0\xe7\xe6\x40\xbc\x97\x60\x79\x48\xd7\x29\x5b\x75\x07\x81\xaf\x76\x17\x36\xca\x5f\x2e\xa1\xf4\x5a\x7b\xc4\xf2\x6d\x77\xfe\x02\x5c\xee\x60\xe2\x2b\xe7\x56\x41\x55\xac\xfc\x70\xab\xbc\xb1\xe8\x9c\x7f\xc0\x62\x7e\x77\xe9\x6b\xb8\x62\xed\x3c\x7f\xbe\xf3\xe2\xdc\xee\xfc\x37\x95\x27\x67\xf1\x7a\x2e\xdd\xb5\x9c\x87\xf7\x50\xf6\x07\xe9\xad\x7c\xf1\xc8\xb9\xf9\x71\xf5\xc1\x67\xb0\x56\x94\xd7\x93\x68\x9e\x89\x6b\x54\x07\xef\x01\x73\x1c\x58\x97\x9b\x30\x27\x4b\x05\x1a\x05\x2c\xd7\x02\x2c\x62\x38\xf8\xd0\xdc\x03\x0c\x26\xb5\x8e\x4d\x2c\xd6\xd8\x5f\x8c\xf1\x22\x7c\xdd\x91\x35\x73\x46\xe7\x48\x4e\x9a\xe5\x52\x1e\x74\x3f\x00\x2a\xcc\x16\xb0\xec\x52\x1b\x4f\xd0\x92\xa3\x9a\xde\x09\x13\xe6\x01\x08\xc4\x63\x88\x6c\x51\x4d\x12\xdf\xa9\x11\xae\xe1\x29\x3c\xc9\x40\xb4\x89\xc5\x20\xbd\xc7\x18\xf5\x1c\x2e\x19\xb4\xd1\x8c\xd9\x56\x16\xef\xde\xb0\x16\x0a\x06\xce\xf4\x8c\xff\x2a\xd3\x97\xc4\x08\x5c\xee\xa3\xc3\xfd\xa3\xef\xf4\xf6\xf5\x88\xb1\xf6\xb0\x88\xc0\x85\x5b\x43\xe2\x01\x7a\xe2\x43\xfa\x2f\xfc\x6f\x64\xdf\x78\xb6\x64\x03\x69\xa3\x39\x0b\x6e\xcb\xc0\x3a\xff\x37\xfe\x19\x56\x67\x11\xbf\xfe\xa7\xf6\xc0\xf7\xd3\xc6\xb4\x55\x98\x1b\x9d\x1e\xc3\xdf\xde\x7c\xe3\xad\x3f\xb8\xbf\x7e\x44\x7f\x7c\x94\x6e\x09\xc3\xb9\x04\x42\xb9\x7c\x6e\x19\x2d\x03\x37\x56\x9d\xc5\x6f\x99\xd6\xca\xca\x77\x3b\xcf\x9f\xc2\x61\xc5\x6b\x5c\xdc\x9e\x57\x7e\x86\x65\xbe\xbb\x78\xaa\xf2\xe2\x81\x73\xe6\x63\x5e\x9b\x2d\x5e\x26\x2a\xe2\x22\xc9\x72\x56\x17\xe9\x54\x89\x26\x0e\x37\xda\xdd\xaf\xe0\x9a\xef\x52\xc9\x5f\xf3\x77\x9e\x25\xc4\x39\xf3\x10\x2f\x33\x17\x1f\x96\xaf\x9d\x45\xa3\x91\xfb\x6b\xe5\xc9\x39\xb4\x8d\x2c\x9f\xaf\x5c\xd9\x80\x3f\xf8\xe1\xe4\xf1\x46\xac\x86\xc8\x31\x54\x1e\x7e\xb2\xb3\x7d\x12\x6e\x68\x2f\x6b\x39\xbc\x02\x11\x72\x40\x30\xc0\xe5\xd6\x98\x99\xcb\x78\xbc\xf2\xce\x35\x21\xf4\x46\x7b\x8f\x0c\x0d\x77\x1d\xe9\xee\xf9\x2f\x2c\x5c\xd2\x33\xa8\x59\xa1\x93\x37\x0a\xd3\xa6\x6d\xe3\x61\x87\x0b\x66\x64\x5f\xc1\xd0\x33\x1d\x56\x2e\x3b\x07\x6a\xeb\xcb\x93\x1f\xb4\xfe\x5f\xd2\x1a\xf9\xc7\x92\x2c\x4d\x2d\x85\xfa\x24\x4e\x8a\xb5\xf0\x1b\x10\x1e\xe3\xe8\x3c\xf1\x45\xad\xe0\x84\x36\xd0\xd7\x75\xe4\x1f\x48\x84\xb4\x5e\x82\x34\xcb\xa7\xff\xca\xea\x4b\xad\xf8\xd9\xeb\x55\xf6\xdb\x16\x42\xcd\xf3\xe3\x1f\x4e\xfd\x19\xc0\xcd\x64\x4f\x59\xa5\x6c\x86\xf6\x9c\xf6\x37\x33\x4f\xfb\xaa\xdd\x37\x93\xc9\x5f\xe2\x9d\x51\xcb\x5a\xe3\x7a\x56\xcb\x98\x05\xd8\x10\x80\xb6\x53\x1b\xb0\x6c\x93\x24\x80\x69\xc3\xcf\x79\xfa\x34\x63\x90\x85\x71\xd2\x28\xb4\xa3\x33\xc6\x06\xb1\x62\x5a\x70\x49\x9d\x6b\x27\x73\x04\x3c\x69\x5b\xe4\xf2\x9c\x28\x58\xd3\x00\x72\xd6\x80\xab\x2e\x60\x9b\x32\x27\xa7\x0c\xb5\xf3\xd7\xa5\x19\xee\x90\xd5\xef\x1e\xc3\xc4\x12\x71\xee\x4a\x58\xf0\x3f\x20\xc7\xd9\xf4\x06\xb3\x5c\x5e\xfb\xbe\x72\xef\x61\xe5\xca\x83\xdd\xd5\x4f\x60\xbd\x78\xf4\xe2\xc2\xb8\xff\x4d\xf9\xdc\x4f\xa4\xcc\x2f\xb0\xcf\xd2\xf9\xe4\xae\xb3\xb8\xbc\x7b\xfd\x53\x67\xf3\x0c\xde\x62\x37\xee\xec\x6c\x7c\xe5\x6c\x5f\x2d\xaf\xcd\xef\xbc\x38\xed\x2c\x3f\x82\x3f\x76\xef\x5d\x64\xb3\x5d\xf9\xf4\x17\xf0\x58\xdc\x25\x75\x00\x2d\x04\xd3\xa5\x6c\xd1\x44\xa1\x02\xf7\x6c\xcf\xee\x34\xad\xe7\xcc\x09\x18\xab\x3a\x44\x04\xbe\x12\xf6\x94\x1f\x97\xaa\xeb\x9f\xf1\xcd\xba\x7c\x7a\x7d\x77\x7e\xc1\xb9\x75\x19\x17\xb4\x74\x95\xa6\xe5\xa4\x24\x83\xa4\x2e\x4b\xf6\x0c\xcb\xd0\x06\x34\xb5\xde\xa2\xbb\x58\xd8\xcb\xaf\xa1\xbb\x1a\x47\x55\x28\xe8\x73\x3c\x2c\x49\x58\xe2\x31\x60\xe3\x49\xc2\x7e\xd0\x31\x76\x6d\x1b\x5a\xa1\x94\x35\xe2\x8c\x0c\xbc\xfd\x9b\x53\x24\x9c\x07\x1f\x8b\x25\xb2\xb6\x02\x3c\xdb\xd9\x98\xdf\xbd\xf4\x8d\xb3\x7c\x01\x4d\x6f\xf3\x20\x29\x9f\x82\xb0\x04\xe9\x12\xda\x97\xec\x11\xad\xde\x39\xe3\xac\x2c\xc5\xcd\x69\xb3\xcc\x64\x08\x74\xda\x49\xfc\x24\xc2\x9b\xe2\x29\xc3\xa5\xc7\xdf\xd6\x6d\x43\xeb\x17\x3a\x85\xcd\xba\x3b\xba\x05\x70\xcb\xe1\x06\x44\x05\x87\xde\xb4\xff\x5a\xd2\x0b\x86\x36\x56\xd0\xc7\x8f\xe3\x3e\xc5\x1f\xe5\xd8\x8d\x29\x13\xc8\x13\xca\x09\x3e\x58\x30\xfe\x5a\x82\xad\x4f\xe6\xe3\xa2\x18\x05\x20\x16\xe2\xee\x18\x9d\x98\x7f\xb1\x61\x73\xd1\xf0\x84\xb9\x90\xcf\xcd\xf7\x85\x58\xf2\x85\x1a\xa8\x5f\x05\xab\x68\x8d\x5b\x59\xd6\xbd\x8a\xe3\x79\x3c\x41\xfc\x9f\x61\x98\x45\x33\x47\xab\x83\x9f\x78\xf3\x8d\xce\xb7\xfe\xf0\x87\xce\x37\x3b\xdf\xfc\x9f\xc1\x27\xf3\x20\x4e\x84\x06\xf7\xfb\xdf\xbf\xf1\xcf\x42\x79\x73\x45\xe0\x9f\xf6\x6c\xb9\x61\x20\x09\x3d\xe3\xad\x37\x5e\x80\x8d\x2e\x3a\x06\x86\xa7\xe0\xda\xc7\xec\x49\xf9\xfb\xfc\x2a\x07\x01\x5d\xdb\x44\x41\x46\x2f\xfd\x7d\xfe\x14\x40\x15\x07\xdf\xdd\xdd\xb5\xf9\xea\x9d\x05\xf4\xea\x9f\xfc\xde\xd9\xfa\xd6\xf9\x62\xd5\x8b\x85\x71\xee\x9f\x75\xdf\x38\x11\x7d\x24\x89\x11\x06\x8e\xa4\x57\x3a\x53\xaa\x5d\x77\x0c\x63\x2a\x40\x45\xb5\x66\xc9\x80\x89\x26\x7d\xdd\x0d\x49\x70\x4f\x6c\xfe\x52\x15\x5d\xe0\xc9\xd3\x9a\x17\x34\x8e\x96\x70\x1e\xfc\x5c\x5d\xff\x01\x58\x03\xaa\xc6\xee\x8d\x53\x4a\x52\xde\xef\x30\xb5\x23\x47\x0f\x7b\x87\xff\x10\x1a\x98\x8f\x6b\x07\x7b\x87\xfe\x88\x7f\x4d\x6b\x87\x7b\x0e\xf7\x0f\xbe\x47\x66\xe7\x29\xcb\x2e\x92\x19\xfe\xdd\xfe\xa1\x61\xfc\x26\xaf\xb9\x26\x69\x5b\x83\xd7\xbb\xe9\x95\xa2\x36\xdc\x7b\xb8\xa7\xff\x28\x3d\x51\xd2\xde\xed\xe9\xea\x03\x5d\xa2\xfb\xdd\x9e\xee\x3f\x8e\x0e\xbf\x37\xc0\x3e\xc2\x02\x06\xca\x74\x90\x30\x19\x84\x47\x7b\x12\x8c\xcd\xaf\x88\x50\xe5\x29\xa4\x67\x50\x5e\xc2\x9c\x29\xe7\xa7\x7c\xfe\x91\x73\xf3\x6a\xe5\xc4\xa6\xa6\x88\x3a\xd3\x32\x96\xc1\x81\x41\xc6\x07\x68\x1c\x47\x6f\x06\x88\xa4\xbc\xa5\x82\xb8\xb3\x71\x0a\xf6\x32\x46\x33\x7c\xf2\xd8\xb9\x7f\xd1\xd9\xbc\xe7\xbc\xb8\x89\x86\x67\xf8\x7b\x6d\x5d\x81\x04\x6d\xe3\x2a\x80\x18\x75\xf7\xd5\x7a\xf9\xfc\x96\xa6\x78\x19\x95\xa0\x2c\x5e\x22\xe7\xdc\xb0\x2e\x15\x28\x2f\x72\x2c\x0d\x24\x0b\xa3\x9f\xe2\x20\x2d\xac\x95\xef\xdf\x54\x43\x32\xa6\xf3\xc5\x39\x25\xdf\x2f\x3e\xac\x7c\xb7\x09\xeb\x5e\xfd\x3e\xf2\xdc\xbd\xd3\x81\x66\xd8\xae\x81\x58\xc7\x33\x26\xe0\x56\x6d\xd7\x8c\xce\xc9\x4e\x6d\xaa\x58\xcc\x1f\xd8\xbf\x7f\xce\x2a\x15\x46\x71\x72\xd0\x5b\x14\x3f\x41\xbe\x4c\x62\xa5\xad\x7a\xef\x24\xcb\x65\x10\xa2\x20\x85\x3d\x2f\xea\x49\xe7\xce\x89\x68\xf0\xf1\x84\xcf\xe8\x66\x96\xa4\x06\x9c\x5a\xf8\x8a\x7a\x09\xc2\xaa\xd8\xd9\x38\x09\x52\xdb\x5b\x30\x24\x8b\xef\x32\x39\x20\x20\x55\x2b\x53\xa0\x2a\x18\x76\xde\xca\x65\xe0\x60\x06\xc5\x98\x59\x34\xad\x1f\x87\x73\xb6\x04\x87\xa7\x59\x64\x1d\x99\xd9\x98\xcf\x96\x26\x05\x3d\x4a\x75\x08\x83\xd4\xae\x5c\x85\xb3\x05\xe4\x37\x30\xa5\x72\x73\x13\x55\x54\xd0\x6e\x24\x9e\x39\xb7\xce\x97\x4f\x5f\x11\x0e\x15\x97\x6a\xb5\xfe\x82\x54\x4e\xa0\xd7\x47\x89\x73\x65\x1b\x66\x05\x34\x5d\x05\x80\x02\x5c\x37\x66\x3c\xd5\x5d\xf8\xa8\x70\x14\xa0\x56\x83\x8e\x6f\xd8\x71\xcb\x74\xfb\xaa\x47\x22\xeb\xb3\xc0\xde\xca\xb7\xcf\x77\x2f\x29\x62\x68\x46\xf6\x0d\x10\x9b\xe0\xc4\x70\xd5\x10\x6f\x00\xae\x0e\x22\x78\x0e\x24\x65\xf4\xa2\xae\xe2\x25\x7a\xa1\x89\x95\x78\xd6\xff\xb8\x54\x3e\x7f\x09\x67\xd6\x1d\xab\x26\x23\xf2\x8e\xcc\x68\x9a\xda\xfc\x0d\x51\x30\x26\x4d\xbc\xb2\x51\x98\x2b\x45\x4f\x75\x6a\x43\x06\x07\x40\x4d\x19\xd9\xbc\x6a\x9d\xb5\x89\x85\x0f\x2c\xa9\x5c\x7a\x0e\xf7\x12\xbc\xd0\x52\xc8\x26\x4f\x34\x5c\x67\x77\xcf\xff\x20\x81\x89\x24\xe4\x75\x4f\x40\x90\x38\x54\x6a\xd5\xbf\x6e\xad\x20\xef\x49\xe6\x29\x47\xf5\xbb\xdf\x75\xa1\x0f\x11\xdf\x39\xa0\x09\x5e\x90\xca\x07\x5a\xa6\x8e\xd3\xea\x79\x19\xc7\xe6\xe0\x96\x47\x8f\x92\xc5\x08\x2e\xa5\x05\xbc\xb7\x66\x28\x06\xc7\x2a\x80\x22\xda\x8b\x91\xbd\xd9\x2c\x69\x93\xe8\x7f\xcf\xbb\xe0\x8a\x1a\x6e\x5b\xcd\x9a\x85\x75\x6f\xda\xc7\x3b\x7f\xf7\x3b\xd4\x4a\x0e\x5a\xf8\xb5\x36\xab\xe7\xe8\x12\x68\x8a\xb7\xc9\x3c\xc4\x9b\xe4\xc3\x0f\x3b\x99\xa4\x8f\x3e\xfa\x17\xed\xb5\x39\xd4\xae\x95\xd1\x19\xbf\xfb\x5d\xf9\xc7\xf5\xf2\x27\x78\x23\x92\xb7\x06\x0a\xb9\xaf\x7e\x28\xbf\xb8\x42\xa6\x87\xbb\xe5\xd3\xcb\x3b\xbf\xdc\xd8\x79\xb1\x56\x9d\x5f\x2c\xaf\xcc\x57\x9e\xad\x3b\x0f\x51\x37\xdb\xd9\x5c\x85\xbb\xdd\xce\x8b\x53\xa0\x18\xa1\x3e\x76\x62\xdd\xf9\x65\x71\xf7\xfa\x72\x75\xe9\x2e\x5e\xf8\x56\x7e\x29\x7f\xf9\x95\xf3\x60\xa5\xfa\xcd\xd7\xa0\x67\x09\x27\xbe\x84\x05\x95\x87\x9b\xeb\xbb\x97\xef\xc2\xbb\x3c\x38\x80\x80\x81\xa8\xfc\x8a\xf4\xa4\x3c\x26\xcd\xb9\x70\xfa\xd7\xad\x6b\xbf\x6e\x2d\xcf\x51\x18\x5a\x4e\x19\x09\xd2\xe5\x45\x06\xa3\x9d\x10\xb8\x65\x65\x99\x65\x1c\xce\xc3\xfa\x50\x77\xd6\x2a\x65\xb4\x77\x70\x8f\x14\x54\x42\x1f\x68\xaa\x2e\x2f\x05\x1f\xd5\x38\x2e\xc7\x5b\x8b\x68\x55\x7a\x76\xdb\x59\x7c\xa6\xa0\xe5\xe0\xc1\xfd\x83\xa0\x40\x1c\x43\x9b\xc8\xd1\x43\xbd\x47\x14\xa8\xf8\x58\xdf\xcf\xdb\x5c\x66\x41\x4a\xb0\xda\x60\xcf\x40\xff\x50\xef\x30\x68\x2a\xf5\x62\xf0\x84\x8d\x0a\xd5\x31\x54\x8b\x0e\x2a\xc0\xc2\x42\xd8\xbd\x7c\x5a\xf1\x6a\x5f\x6f\xd7\x90\x4a\xd4\x2c\xdf\x76\xce\x2a\xd4\x47\x8c\x2c\x74\xc3\xa8\x15\xaf\xfb\x51\xd3\xc9\x20\xb4\xd7\xbc\x23\xd7\x86\x43\x51\xcf\x9b\x9d\x52\x8c\x86\x6a\x8b\xf8\x18\x60\xc9\x49\xc7\x6a\x04\x08\xf5\x4a\x94\xa8\x38\x90\x02\xcf\xe5\x14\x60\x38\x1a\xdd\xec\x11\x9f\x3f\x52\x59\x42\x03\x70\x6b\xde\x69\x00\x8f\xf6\x1a\xfe\x3e\x63\x14\x6c\x12\x7f\xfc\xf3\x31\xfe\xf8\xd1\x47\x69\xd8\x58\x43\x06\x70\x96\x7e\x5f\x59\x86\x6b\x9b\xf7\xbb\x07\x33\x1d\x5f\x91\x92\xba\xb9\x91\xcc\x8a\x01\xd5\xca\x95\x2d\x4a\x8a\x97\xc7\xc7\x31\x0e\x97\x42\xa9\xfc\x28\xf6\x3c\x68\xba\xe6\x78\x29\xab\x17\xb4\xb1\x82\x75\xdc\x50\x45\xe7\xb2\x25\xd7\x59\xfe\x14\x8d\xb9\x0f\x6e\x54\xce\x7e\x5a\xf9\xf1\x79\xe5\xc9\x0f\x3b\x3f\x9f\xe4\xa8\x74\xba\xb3\x5e\xc4\xb0\xfd\xef\x3f\x4b\x24\xc0\xb5\xcc\xd2\xb5\x25\x4c\x87\xfb\xa3\x35\x31\x61\x60\xae\x4f\x2c\x45\x6c\x67\x46\x6b\xf9\xd2\xca\xee\xf5\xc5\xca\x95\x07\x48\x11\x67\x8e\x50\x24\x53\x1a\xba\xd0\x32\x82\x16\x19\x91\xcb\x04\x14\x8c\x97\xd0\xe6\xa9\x51\xc6\x8d\x4d\x57\x1f\x98\x1e\x37\x30\xeb\x23\x65\xfe\x4f\xf9\xfe\x37\xa8\x87\x3e\xbf\x1d\x7e\x5e\xab\xc2\x05\x66\xf9\xd3\xca\x29\x50\xa4\x2e\x38\xd7\x9e\xa1\x80\x7e\xb0\xe2\x2c\xae\x57\xb6\x6f\x55\x9e\x7c\xa2\xb8\x93\xf8\x94\x89\xbc\xa0\x10\x65\x48\x58\x00\x4f\x22\x59\x81\xa7\x03\x44\xc1\x39\x5a\xbd\xff\xb0\xbc\xf2\x25\xda\xef\x25\xd2\x14\x94\x65\x40\x69\xa0\x58\x75\x49\x19\x26\x35\x52\x75\x6c\xb1\xa4\xaf\x47\xc4\x13\x0a\x34\x66\x17\xdc\x3c\x13\x34\xd3\xe5\xf3\xb1\x08\xe4\x7d\x20\xae\x25\x1a\xdb\x7c\x94\x58\x68\xe6\x09\x05\x70\x07\x9e\x07\xc6\x20\xae\x70\xbe\x0f\x0c\xd2\x2a\x4c\xe2\x77\xfd\x85\x49\xf1\xdd\x7e\x0e\x42\xc4\x2f\x87\xf0\x0f\xf1\x35\x4f\xcb\x51\x8f\xd1\x9d\x9d\x2a\x05\x2f\x30\x33\x47\xc3\x33\x23\xae\xd5\x14\xba\x1f\x40\xbc\x9f\xb3\x0c\xc2\x78\x51\x2f\x56\xa5\x08\x69\x9e\xa5\xcc\x1b\x26\x92\x15\xcd\x94\xac\x09\x43\x08\x66\x30\xb9\x3a\xbb\x98\xef\x31\x03\xd9\x26\x14\x3e\x4e\xfb\x81\xf5\xc0\x56\xd3\xee\x77\x5c\x5d\x67\xbf\x8e\x90\x3a\x35\x6d\xd0\xa0\xad\x8e\x00\x42\x60\x5d\xad\x28\x01\x3c\x32\x3f\x63\x14\x70\x66\x00\x14\xdd\x08\xd9\xa8\x8a\x0f\xb0\x1f\x53\xe8\xac\x4a\x56\xaf\xcc\xb3\x2e\x17\xba\x79\xe1\x3d\x06\xbe\xa1\x93\x3f\x9c\x4d\x81\x8a\xfe\xe9\x6b\x95\xaf\xae\xe1\x98\x58\xb5\xda\xcf\x4f\x62\x1e\xdf\xd2\x29\x9c\xa0\xcf\x5f\xc0\xc7\x78\xe0\x35\x60\x09\x12\xfa\x38\x56\x4e\x55\x3f\x7e\xe1\x9c\xbb\x86\xca\xe8\xe2\xd3\x90\x7a\xaa\xd4\xf8\xa3\xe7\x07\x67\x20\xc0\x77\x8a\x14\x66\x7e\xb6\x79\x3a\x2b\xaf\x86\x36\x98\x93\xf7\x40\x73\x1f\x27\x2b\x76\xb1\x80\x97\x01\xc1\x4c\x64\xbc\xea\x2d\xe2\x31\x4c\x53\x4e\x52\xf5\x01\xaf\x78\x5c\x9e\x24\x33\x37\x03\xa7\x49\xcc\x84\x03\x01\xef\x5a\xb3\xc6\x0c\x3a\x9a\xf0\x0e\x21\x0c\xea\x13\x66\x01\xee\xa5\x13\x25\xbe\x9f\x00\x30\xcc\x34\x24\x9c\x9a\x39\x9d\x47\x45\x19\x8e\x8b\x00\xad\xf8\x13\xdd\xa2\xf0\x43\x2d\xc5\x4c\x9b\xf2\x6e\xa9\x9c\x76\x59\xe1\xaf\x85\xca\xf3\x1a\x5e\x11\x78\xe7\x20\x33\xb4\x73\xf1\x42\xf5\xbb\x3b\xd5\x6f\xbf\x41\xad\xb6\xf6\x02\x51\x03\x0f\x96\x42\xe5\x93\xa7\xce\xf6\x2a\x3f\x5c\xbe\x1f\xd0\x85\xfd\x85\xf2\xf9\x96\x73\xe6\x5e\xf4\x6a\x02\xf4\x70\x33\xdd\x5d\x38\x8d\x4f\x9f\x58\x67\xab\xb6\xb3\xb8\xec\x2c\x2e\xa2\x8c\xbf\x7a\x1f\xa8\x91\x09\xaa\x9c\xd9\x2e\xaf\xad\x44\x0c\x2d\x74\x29\x72\x5e\xfc\xb0\x7b\xed\x97\x98\xa5\x28\x25\xc5\x91\x5f\x42\x9c\xde\x78\x01\x75\x2f\xb9\x3a\x9d\xfc\xa6\x17\xbe\x0a\xef\x80\x28\x55\x99\x1b\xf0\xc6\x7b\xe6\x21\x87\xa0\xc2\xbe\xc2\xf0\x6b\x92\x80\xe2\x18\x77\x53\xe2\xf8\x27\x56\x3e\x5a\x47\x1b\xad\x67\x75\xfe\x95\x4c\x1b\xe7\x6b\xee\x25\x6d\x70\x7f\xaf\x97\x73\x98\x65\xfc\xe3\xb9\x97\xc5\xbc\x1a\x02\x93\xd9\x27\x13\xd8\x2c\x07\xad\x59\x6d\x68\xe8\x5d\x31\x85\x02\xbf\x11\x9b\xde\x27\x1c\x05\x74\x7a\xa2\x60\xc6\xd7\x93\xd4\xc3\xac\x6d\x69\x19\x23\x6b\x14\x0d\x0a\xbc\x16\xf9\xac\xa4\x31\xa8\x26\x62\xe7\xe7\x6b\xe5\xb5\x8f\x77\x36\xe6\x77\x5e\x3c\x71\x96\xef\xc2\xa6\xe3\x58\xea\x50\x3e\xab\x02\x21\x2b\x1a\xd3\x25\x10\x84\x63\x86\xc8\x0b\x34\xd0\xd1\x0f\x23\x74\x3f\x8b\x84\xec\xb8\xa1\x92\xf5\x03\x25\x40\x30\x1f\x90\xd9\x0d\x52\xc2\xf9\xf4\x54\xf8\xa7\x98\xdc\x45\xcc\x7f\x4e\x71\xf7\x50\x69\xb2\xf0\x36\x69\x00\x26\x1b\xfe\x85\x2f\x72\xc2\x34\xb2\x2a\x73\x66\x20\xdc\x9c\x54\x79\x14\xcb\xbf\x2c\xa2\xc7\xec\xfb\x4f\x76\x5e\xa8\xae\xe9\x61\xbd\x2d\xe8\x79\x50\x6a\x07\x4a\xbd\x09\xcd\x8c\xf1\x06\xb8\x1a\x94\x34\xc8\x59\xab\x70\x9c\xa2\x28\x8e\x9b\xf9\xbc\xaf\x63\x52\x6c\x0a\x22\xad\x97\x0e\x74\x87\x90\x51\xdd\x79\x76\x1b\xb3\x32\xdc\xa3\xa1\xfa\xec\x47\x90\xfa\x9c\x32\x1f\xbb\xac\xa2\xa8\x14\xfb\x98\x93\x09\xe0\xd8\x46\x85\x92\xf7\x39\x3f\x54\x3f\xbb\x60\x8b\x73\xc6\x40\x75\xe9\xc7\x1a\x70\x71\x2c\x84\xab\x33\x65\x6f\xe2\xe2\xc0\xa0\x92\x8c\xa9\x4f\xe6\x2c\x38\xd6\xc7\x6d\x76\xc1\x67\xad\x49\x72\x4e\xab\xd6\xfb\xa3\x25\x7a\x1f\xd7\xc7\x0f\x27\xaa\xeb\x9b\xe5\xf3\xcf\x76\x2f\x7d\xe2\x7c\x46\x79\xe2\x17\x6e\x57\xef\xae\x96\xef\x2a\x32\x60\xbb\xfc\x34\x0a\x6d\xca\xd0\xb3\x18\x19\x30\x65\x8c\x1f\xd7\x8a\x73\x79\x43\x58\x6a\xda\xd0\xff\xc9\x99\xaf\x39\x2b\x67\xb4\xa9\x6c\x0b\x32\x6b\xca\xf3\xdf\xc2\xb1\x5d\xbe\x7b\xb3\x7c\xed\xf6\xee\x8d\xab\xce\xd5\x93\xbe\xd9\x46\xc0\xa3\xe4\x55\x02\xa8\x36\x2c\x48\xd4\x79\xa5\x17\x4c\x50\x8e\x3e\x48\xb3\x75\xa8\x7e\x42\xe5\xa7\x9b\xce\x96\xc2\x5f\x05\xe0\x6d\x95\x1d\x28\x14\xa8\xa2\x00\xc0\xa9\xe6\x3a\x3b\x65\xc5\x45\x2d\xe6\x10\x78\xb4\xc4\x6e\x5a\xce\xec\xae\x3c\xb9\x13\x97\x9c\xec\x01\xe7\x9b\x16\xa3\xc8\x18\x13\x66\x8e\x63\x81\x68\x69\xc4\xca\x41\x90\x71\x24\xd7\x18\x29\xa6\xbc\x6c\x7f\xe7\xa3\x8e\x13\x79\x41\xd4\x98\x91\xce\xe8\xf0\x0a\x9d\x84\x8d\x13\xd6\x3d\x3c\x5e\x7e\x55\x3c\x2a\x16\xfd\xa9\x31\x11\xdf\x1a\xc1\x04\xb2\xf7\x18\x06\xf9\xa9\xa6\x9d\x81\x61\xdd\x81\xad\x38\x30\x2c\xd6\xb2\x74\x01\x1e\x84\x7f\xf9\xea\x8c\x44\x6b\x35\xa9\xfd\xfe\xfd\x99\x73\xe9\xe1\x32\x0b\xdf\x26\x5d\x8d\x61\x94\x3c\x3e\x09\x45\x68\xdd\x84\x41\xb2\x6e\xee\xb1\xa1\x86\x12\xf5\xb5\x37\xc5\x98\x18\x51\xec\x90\x24\xa3\x00\x7f\x4d\x57\x74\xcf\x2c\x50\x43\x4b\x0a\xcb\x40\x90\x93\x6c\x1c\xa8\x9f\x33\x92\xd5\x20\x48\x58\x04\xc7\xe4\x71\xee\x35\xc3\x5e\x35\x5f\x5a\x30\xfe\x90\x5d\x0e\x00\xb8\xdf\x8c\xd2\x37\xcc\x13\x6f\x5d\xd8\x82\xf1\x3e\x3f\xe0\x1f\x3d\x67\xfe\x8d\x86\xe9\xb1\xa4\x54\xaf\x05\xa9\xc6\xb6\x07\xcc\x08\xd8\x19\xa3\x08\x8b\x60\x4e\x88\x1a\xe6\x8f\xbf\x7a\x04\xf9\x69\xf8\x22\x09\x6d\x78\xf1\x5f\xf1\x0f\xa1\x28\xc8\xfc\xd8\x0b\xe3\x59\x48\xee\x87\xd1\x87\x4e\x80\x10\x15\xea\xa1\x15\x8b\x18\x91\x41\x86\x07\xb8\x16\x58\xb3\xb9\xac\xa5\x67\xd8\xd5\x3a\xc7\xb1\x73\xe4\x5e\x27\xbf\x5e\xce\x28\x62\xf0\x0c\xd6\xbf\x48\x94\x73\x64\x31\x70\xb6\xaf\x56\x9e\x3e\xde\xbd\x7c\x05\xfe\x0b\xba\x1c\x28\xb9\xce\xd7\xf3\x3b\x1b\x27\xab\x5b\x2b\xb2\x7b\x33\x25\x75\xd3\xe6\x64\x41\x67\xb3\xa6\xd0\xc2\x7a\x85\xf6\x70\xd0\xaf\x70\x93\xcc\x60\x26\xad\xf2\xed\xf3\xea\x8b\x95\x34\xb0\x94\x94\x09\x17\x35\x45\x61\xc2\xcd\x92\x0c\x43\x03\xf0\x07\xb3\xfc\xcf\x78\xd1\x74\x2f\x99\x7f\x0e\x6b\x8e\x7f\x76\x5d\xf7\x13\x05\xc3\x0d\xc4\xf4\x74\xa1\x3f\xd7\x52\xe5\xbe\x25\x55\xa8\xd2\x45\x41\x2b\xad\x1b\x53\x23\xc6\x85\x47\x5b\xcf\x4c\x83\x2a\x61\xc3\xc8\x8b\xa0\xda\x99\x13\x64\x8c\x82\x6b\x6c\xee\x38\x5f\x66\xa9\xc2\x18\x17\x2e\x51\xb2\xc9\xf5\x5a\xf3\xed\x95\x6c\x2a\x01\xe2\xdb\xd0\xf8\xca\x77\x59\x61\x70\xd1\x25\x4b\x12\x85\x13\x2c\x9e\xaa\x3e\x7e\x0e\x4f\x61\xf5\x2b\xd2\xd8\x64\x28\xc1\x41\x81\xce\xb8\xf6\xb1\xf3\xe8\x74\x75\xe9\x27\xbf\x62\x16\xa5\xac\xa3\xc7\xfa\xee\x29\xb8\xc8\xc1\xc5\x1a\x80\x72\x89\x13\x91\xac\xbf\xf0\xb0\xf2\xe4\x06\xd7\x26\x63\xff\x0d\x08\x3a\xb5\x3a\x5e\x42\x23\x5f\x11\x95\x4e\x83\x25\x39\x68\xa8\x1d\x81\xd2\x13\xaa\x9b\xef\xf3\xdb\xbb\x5f\x5f\x95\xcb\x44\xec\x7e\xfe\xb9\xb3\x7c\x3b\x49\x2b\xf1\x11\x62\x04\x4e\xc2\x8a\x64\x90\xea\xb5\x26\x01\x43\x85\x1e\x24\x8a\xf1\x41\x1e\x2f\x9c\x58\x24\x8e\x63\x7b\xf0\x32\x31\xa6\x83\x86\x6f\x92\x0a\x59\x30\x3a\x74\x69\xcc\x9d\x6e\x15\x40\xaa\xd5\xf3\x67\xb9\x0e\xcd\x48\xe9\x8d\x37\x7e\x3f\xee\xfa\xf9\xe8\x93\x81\x59\xf6\xfc\x3d\xf2\xca\xfd\xce\x12\xdf\x81\x30\x75\xbf\xb2\xc5\x57\x24\xf8\xf8\xcb\x3f\x8b\xa2\x15\x1e\x35\x68\xee\x0c\x93\xa3\x72\x73\x13\x1f\xf0\xc6\xb5\x70\xba\xbc\x76\x8d\x23\x50\xd8\x2c\xcd\x75\x29\x28\x95\x1b\x3f\xf2\x93\x22\x96\x34\xb6\xce\x4e\xab\xc7\xd7\xa6\xc9\x04\x71\x60\x7e\x88\x26\xf5\x2c\x5a\x05\x71\x08\x91\x60\x80\x65\x98\x31\x33\x22\x5a\x8b\xf3\x18\x38\x6c\xc2\xc2\x80\x0a\x2c\x04\x32\x6e\x65\x54\x2a\x2d\x8f\xd5\x2b\xe3\xb1\xf3\xfc\x1b\x2e\x6a\xe2\xda\xa3\xc8\x96\xff\xe8\xb4\x73\xf6\xf3\xf2\xe9\xe5\xf2\xf7\x9f\xed\x6c\x6d\xe2\x76\xbe\xa4\x88\x35\x7c\xbb\xb7\xaf\xaf\xf7\xc8\x21\xac\x1f\xd0\x75\xa8\x67\x50\x15\xab\xb1\xbe\x8c\xdb\x9a\xf6\x9b\xf3\xe5\x0d\x05\x28\xb7\x3c\x82\x32\x2a\x01\xee\xf6\x2f\x1e\x38\xb7\x2f\xec\x3c\x7f\xaa\x00\x61\x62\xf4\x77\x58\x0b\x49\x73\x35\x92\xb5\x03\xef\xde\x1e\x77\x29\x52\xa2\x42\xd3\x9b\x1b\x54\x16\x76\xa0\x8a\x1a\x71\x58\xbd\x04\xad\x74\xae\x9f\x55\xae\x5e\x50\x27\x89\x70\xcb\xe7\x70\x4e\x76\xa6\x86\xdc\x7e\xf2\x2b\x1c\xad\xb6\x77\x83\x71\x5d\xb3\xad\x18\x8c\xec\x84\x6d\x76\x48\xa1\x52\x8d\xb4\x18\xc8\x04\x55\x57\x89\x8b\x38\x70\x71\xde\x58\x2c\xa4\x23\xd5\x6f\xf4\x86\x9a\x1c\xa7\x40\x18\xc7\x11\x09\x7a\xfe\xea\x26\x16\xa7\x62\xcc\x28\xce\x1a\x06\x05\x9f\x05\x8f\x4e\x12\xae\x41\xeb\xa0\x10\x28\x64\x1c\x54\x20\xab\x05\x83\x01\x58\x41\x23\xe1\xcf\x27\xd9\xa2\xcc\x03\xf5\x6c\x86\xf1\x74\x4e\xeb\x73\x30\x52\x8c\xb3\x13\x46\x2f\x36\x62\xd7\x3a\xa3\x31\x45\x25\xcb\xd1\x8a\x63\x73\xb5\x93\xa1\xd2\x14\x3a\xb5\x50\x80\x5e\xbe\x60\x8d\x1b\x46\xe6\x5f\x14\x03\x7d\xe5\x74\x69\xaf\xcd\xed\xcf\xbd\x1e\xcf\xb4\x5a\x2a\x52\xe3\xad\xdf\x87\x9f\xf2\x52\x1a\x4f\x71\xba\xcb\x61\xc6\x98\xd0\x4b\x59\x97\xd5\xae\x84\xac\x27\xc0\x23\xcd\x65\xcf\xdb\x88\xca\x1b\x23\xc9\x53\x5c\xc9\xd7\xcf\x62\x62\x9d\xca\x00\x54\xdf\xe0\x3c\x21\xd9\x8a\x80\x95\xba\xc6\x29\x8b\xd4\xa4\x91\xf0\x32\x52\xae\x9e\x96\x44\x85\xb4\xd0\xcc\x21\xae\x1b\x4a\x7a\x7d\x1e\xd4\x13\x41\x12\xaa\xf4\x13\x18\xae\x52\xe5\x56\xf3\xb0\x95\xbc\x6b\x89\x51\xa0\x86\x6b\xaf\x8e\x5b\xb2\x10\x0b\xbf\x98\xb0\xd1\xfd\x77\x03\xde\x96\x14\xb8\x4b\x66\x36\x93\xc7\xbb\x06\x3c\xee\x7d\x70\xd9\x1c\x88\x4a\x4f\xa1\x8e\x46\x01\xf1\x22\xd6\x1b\x20\x20\x9d\xb3\x2e\x89\x82\x64\x97\xdd\xdb\x73\x45\x34\x4b\xc1\xf1\x83\xa2\xcb\x75\xb5\xea\x39\x37\xf9\xd9\xcd\xf5\x2d\xe5\x4c\xd2\x01\xa7\xe1\xd2\x58\x2a\x18\x54\x8a\x2b\x6b\x1e\x37\xb4\xc3\xed\xda\xe1\xb7\xdb\xb5\x43\x94\x5b\x7d\xe8\x6d\xe5\xa5\xe3\x94\xb3\xf8\x31\x6a\x6c\xe7\x36\x76\x97\xce\xb0\x4b\x96\xae\xfb\xcf\x30\xc1\x75\xf3\x0e\x7e\x79\xfe\x01\x3c\xc6\x65\xe7\xb4\xc3\x7f\x9f\x5f\x38\xfc\x36\xfc\xe7\x10\x39\x86\x0e\xbd\xfd\xeb\x16\xa6\x3d\x70\xaa\x73\xf4\x50\xbc\x3a\x9a\x99\x4c\x07\x07\xbb\x74\x50\xa6\x0c\xc6\x5e\xf3\x2f\xb0\x4e\xf0\xda\xd7\xf3\xef\x5d\x87\x07\xfa\x7a\x38\xa7\x13\xcb\xa5\x86\x5e\x18\x28\x98\x33\x70\xd9\x1c\xc4\xbf\x45\xaa\xce\xf4\x5c\x9e\xbf\x74\xd3\x75\xf6\xe3\x1f\xfb\xeb\x3a\x05\x3d\xfa\xd0\x5f\x2f\x8a\xfb\xda\xf6\x94\x46\x25\x34\xe9\xa7\xc6\xc0\xe5\x4d\xed\x7d\x18\x99\x2a\x43\x34\xe9\xed\xbc\x57\x9f\xa4\x31\x00\x58\xb5\xf4\xe8\x50\xcf\x20\x7d\x1a\xe8\x1a\x1a\xfa\xb7\xfe\xc1\x83\xc8\xe6\x86\xc0\x51\xe1\x14\x4e\x13\x74\x45\x28\x17\xc5\xab\xad\x57\xf0\x7e\xc7\x44\x6d\xda\x9f\x5f\x58\x6f\xa0\x6b\x10\xfe\x1e\xee\x19\x1c\x1a\xed\x1a\x1a\xc5\x4c\xd1\x3f\x49\x93\x3f\x74\xa0\xb6\x5e\x4b\x10\xad\x5c\x28\x70\x7a\x0e\xed\x87\x5c\xbd\xae\xa0\x49\x28\xa7\xe7\x80\x81\x4d\x40\x1a\xe7\xf4\x63\xcc\x37\x6e\x0a\x0a\x16\xb2\xa0\x9c\x2c\x2a\x5b\x41\xe0\xfc\xaa\x15\xbd\x39\xed\xdf\x00\x9e\x35\x6b\x6b\x03\xd6\xac\x51\x18\x9a\x82\x1b\x05\x65\xb5\x64\xac\x12\xd6\xd3\xa7\xe2\x92\x99\x76\x8d\xcb\x6c\x72\xc1\x10\xcc\x6e\xfd\x10\xcb\x60\x32\xd8\x11\x04\x3c\x22\x40\xc3\xbf\x1f\x89\xac\x57\x09\xb6\x88\xc4\xd2\xfa\x30\xad\x03\xa1\x73\x22\xb8\x02\x7a\x5b\x1c\x70\x55\x58\x71\x9a\xb5\x23\xda\x30\xb8\x8a\x90\x68\x16\x30\xd4\xd3\x7d\x74\xb0\x77\xf8\xbd\xd1\x43\x83\xfd\x47\x07\x1a\x07\x1f\x0b\x56\xeb\x1f\x3c\xc4\xdb\xb9\x19\x04\x49\x45\x83\x14\x8b\xbb\x09\x94\xa2\xd7\xc2\x1e\xb0\xcc\x3d\x8f\x54\x47\x68\xfc\xeb\x14\x7a\xc0\xdb\x80\x36\xb7\x2b\x0a\x60\xd3\x53\x0e\xb1\xc8\x1e\x56\x6d\x6a\xf9\xf5\xe9\x39\xdc\xb3\x81\x4d\x24\xfd\xef\xbf\xcb\x3f\xd4\x03\x43\x10\x32\x61\x59\x00\x83\x7f\x97\x53\x4f\xf6\xc3\x0f\x8a\x91\x27\x8c\x31\x81\x31\x54\xb7\x08\xf9\xa0\xdb\x73\xb9\x71\x2a\xfe\x0b\x10\xdc\xcc\x66\x58\x2b\xa3\x87\x7b\x8f\x1c\x1d\xe6\x74\xe9\x0e\x40\x0d\x2b\xea\xb5\x62\xa1\x64\x68\xff\xa1\x4d\xe8\x59\x1b\xff\x45\xca\xf7\x17\xad\xfd\x28\x81\x5e\xa7\xe7\xc6\xad\x2c\x1c\xe2\x81\xe7\xf8\x07\xaa\x98\x02\x10\xfa\xfa\xbb\xbb\xfa\x7a\xe0\xb7\xee\xbe\x9e\xae\xc1\xd7\x1b\x5b\x73\xa2\x28\x0d\x08\xce\x0e\xb7\x82\x88\x5c\x26\x35\xaf\xed\x77\x29\x63\x1b\x2a\x3e\x48\x15\x79\xc8\x8c\xea\xbd\xd3\x39\x37\x9d\x55\x96\x45\x48\x45\x81\xb7\x3a\xfd\xc2\xac\xb4\xa4\x34\xca\xd5\xea\xed\xa7\x85\xc6\x41\xd6\xff\xd1\xd1\x91\x31\x6d\xfc\xab\x29\x8c\x19\x6b\x1a\x2b\x36\xa3\x98\x10\xd3\xdc\x04\x30\xbc\x32\x00\xa4\x66\x40\xb0\x3f\xf2\x5f\x8f\xf6\x0f\x77\x51\x32\xfd\x30\xfc\xd1\x37\xea\xa7\xd4\x9b\x9a\x2b\x75\xa4\x2f\x0b\x9c\xbb\x3f\x24\xf2\xea\x43\xe2\x89\x57\x1c\xeb\x38\x79\xdd\xf4\x04\x5a\x07\xc5\x50\x36\xc5\x3d\xde\x24\x24\x5f\x25\x49\x10\x79\xfc\xa7\x93\x0f\x32\xd8\xe9\x39\x56\xc9\x54\x22\xa2\xe6\x7f\x31\x32\x23\x11\x6e\x58\x83\x08\xc2\xa5\xaf\x3a\x5b\x08\x3d\x24\xa5\x42\xd0\xd3\x08\xa9\xdf\xd2\x04\x34\xc5\xf8\xdc\x9e\x30\x3c\x97\x9e\xd1\x69\x16\x7a\xbc\x92\xe1\x16\xe9\xc2\x53\x7f\x74\xf0\x28\x70\x95\xea\x75\x35\xb3\xb3\xd2\x15\x08\x53\x28\x1e\x5c\x53\xa3\xeb\xd0\x50\x53\x9b\xdb\x15\x13\x78\x9f\xe8\x28\x5a\xc7\x8d\x9c\xd6\xd7\xf5\x76\x4f\x9f\x36\x30\xd8\x7f\xac\xf7\x60\xcf\x20\x08\xa7\x3f\xf6\x34\x25\x30\x5d\x14\x9c\xdf\xe7\x8d\xef\xed\x41\x00\x3c\x58\x7b\x87\xa1\x94\x29\x58\xc9\xe2\xa6\x36\x6e\x81\xf2\xda\x92\x21\x1e\x37\xe6\x6a\x99\xeb\x7e\xf1\xc7\x9e\xf7\xe2\xae\x2f\xda\x4b\xac\x1a\x5d\x2f\xd9\xbf\xd9\xb2\x8d\x7b\x59\xf4\xb5\x01\x26\x35\x55\xb3\x31\x4d\xc1\xcf\x1a\x23\x47\x0c\xb1\xd3\x73\x99\x31\xf8\x0f\xfe\x29\xe6\x2f\x08\x3f\x00\x1e\xe7\xad\x1e\x70\xff\x67\x3f\x06\x7f\xd3\x06\xda\x5f\x9c\xce\xef\x77\x1d\x13\xa3\x3c\x83\x74\xef\x6d\x6a\x47\x4d\xe9\x05\x23\xe3\xaa\x55\xcd\xab\x54\x2c\xda\xf9\x80\xc3\xa6\x27\xa2\xdb\xc9\x5f\xf9\xab\x0e\x52\x94\x9a\x13\x01\x24\x4b\x82\x6a\x57\xa4\x92\x25\x17\x36\x7a\x65\x0a\x17\x05\xbc\xd4\xc8\xc5\x66\x21\x76\xb8\x95\xe7\xc2\xc7\x8e\x7c\xd2\xe4\xb5\xee\xc1\x9e\x83\x3d\x47\x86\x7b\xbb\xfa\x68\x84\x59\x6d\xe8\xbd\xa1\xbe\xfe\x43\xa3\x07\x07\x61\x92\x47\xd1\xe0\xe5\xb3\xc6\x2d\xbd\x4f\x5f\x8b\x2d\x35\xa0\xdb\xa2\x09\x1d\x08\x10\xdc\xf0\x54\x0d\x0e\x96\x0b\x97\xfd\xf0\x65\x00\xe5\x63\xd8\x72\x42\xa5\x1f\xde\xa3\x4d\x5b\x19\x23\x72\x0f\xa5\x1c\x09\xf5\xd5\x20\x2a\xda\x7d\x32\xda\x7d\xe4\xed\x8c\x7d\x64\x5f\x80\xea\x08\x2a\x29\xf9\x9a\xa4\x02\x10\xca\x34\x48\xee\xe8\x9a\xa8\xa4\x26\x69\x46\x39\x00\x7b\xf8\x4d\x5f\x68\xbf\x49\x82\x1c\xbe\x7b\xcb\xff\xee\x2d\x49\x92\x0f\x89\xa6\x1d\x7a\x48\x5a\xca\x82\x9c\x2c\x3f\xcd\x11\x16\x96\x9d\x71\x62\x2e\x1a\x2a\x68\x70\x99\xb1\x8e\x69\x34\x52\xd1\xe4\xb8\x5e\xb5\x76\xa9\xf7\x49\xa3\xd0\xbc\x9b\xab\x3f\x83\x76\xad\x71\x2f\x11\x60\x01\xf8\xe5\x57\xa5\xcf\x6a\xf6\x9c\x9d\xb5\x26\x0f\xec\xdf\x9f\xa0\xa2\x2a\x21\x06\x2d\x89\xb0\x6b\xdc\x52\x19\x01\x80\x04\xb2\xcf\xcc\x95\x3e\xd8\x7f\x58\x1f\x6f\x98\xa5\xb8\x76\x5c\xa6\xd2\x5a\xa1\xc8\x42\x5a\x3e\x3e\x87\x0f\xe0\x07\x6e\xbd\x22\x2d\xa2\x28\x53\x62\xe3\x33\x4b\x16\x46\x8f\x12\xd7\xc8\xc8\xd4\x8c\x20\x3d\xa1\x86\x3f\x07\xf8\x0b\x41\x95\x6b\xe4\x0c\x10\xe6\xdb\x4f\x9b\xe0\x4e\xb3\x54\x35\x66\x1d\x1d\xc7\x0a\x02\x64\xde\x80\x23\x67\x06\x85\xe7\xbf\xc3\x19\x33\xfc\x6e\x3f\xf5\x9e\x79\x17\x0b\xe1\x81\x96\x2d\xfa\xd0\x74\xc1\x39\x87\xc7\x0a\xac\x9b\x7c\xa9\xa8\xe1\x6e\x73\xe5\xea\xdb\x73\xae\x87\xde\x2f\x42\x88\xb0\xdb\x44\x97\x2a\xa3\x30\x61\x15\xa6\x61\xf7\x1f\xea\x19\x76\xf5\x2d\xa1\xb9\x81\x00\x46\x02\x3a\xb5\xde\x09\x2a\x74\x45\xf0\x30\x6d\xda\x2d\x45\x3a\x63\xea\x5a\x47\x06\x6b\xf7\x0e\xa0\x29\xcc\x6d\x0e\x23\x60\x52\xfa\xbb\x5d\x04\x75\xa4\xdd\xcd\xbf\xa6\x10\x56\xec\x0d\x3b\x3c\x97\xe7\x95\xe2\xbe\x63\x1b\x45\xe1\x6b\x75\x83\x91\xf6\xe3\x46\xec\xa4\x6c\x6f\x8c\xeb\xb0\x66\x8c\x42\x01\x15\xce\x29\x00\x88\xf2\x95\x3c\x5d\xc0\x08\x01\x9a\xa0\xb9\x39\x58\x20\x82\xa7\xac\x8c\x78\xe4\xdf\x3b\x05\x2b\xde\x01\x25\x11\x33\xad\x32\xd6\x38\xf5\x23\x22\x34\x5e\x61\xb9\x19\xd3\x36\x8b\xae\x03\x49\xcf\x9b\xf0\x94\xdd\x39\x8e\xd5\x8a\x26\xb8\x58\x11\x46\x97\x77\xd6\xde\x8e\xc7\x27\x78\xae\x46\xf6\xed\x9f\x79\x6b\x3f\x16\xdc\x1d\xd9\x07\x48\x89\x9f\x30\xff\xb9\xc8\x4b\x31\x12\x3e\xb2\x4f\xe6\xc6\x81\xc0\xd8\x3f\xe8\x98\x9d\x9d\xed\x40\x2e\x76\x00\x6c\x23\x87\x01\x82\xd8\x5c\x2a\x06\x60\x46\x6b\xfb\xeb\xff\xc2\x45\x7a\x80\x6e\xb2\xee\x1e\x8d\x26\x2f\xa3\xfd\xef\xfd\xb2\x41\xb1\xa1\x25\x2a\x92\x4b\x25\x63\xe0\x04\x08\xab\xc6\x54\x18\x86\x15\x69\xe3\x43\xc7\x51\x33\x30\x03\xea\x66\xd3\xd0\x84\x19\xaf\x05\x70\xf2\x53\x7a\xce\x10\x6e\x23\xbb\x69\x78\x41\x25\xb5\x39\x58\x6c\x3b\x49\x6f\x32\x22\x84\x6a\xbb\x51\x00\x6a\x5a\x7b\x5d\x8c\xdd\x48\x09\x2f\x60\x49\x23\xe3\x7f\x00\x5e\xad\xc1\xbf\x51\xb0\xcd\xfb\x11\xea\xe1\xf4\x84\xa2\x46\x6d\x08\x56\xbc\x19\xaa\xd9\x35\x11\xa3\xfc\xb7\x04\x70\x8c\x25\xa9\x55\x18\xa2\x0d\x49\xad\x82\x9e\xc2\x4c\x14\xd8\x24\x91\x7b\x24\xfa\x6e\x9e\x6e\x2d\xd5\x4d\x08\xd7\x60\xae\x87\x8e\x54\xfc\x88\xb8\xe4\x37\xcf\xe4\xc0\x4d\xbf\x05\xb0\x84\xbc\x94\x0c\x05\x1d\xee\x19\xd6\x14\xf0\xe0\x1d\xbc\x71\x68\xec\xbd\xea\x98\x00\x45\xb5\x54\x80\x7f\xb3\xfa\xa4\xf6\x4e\x4f\xd7\xf0\xd1\xc1\x26\x62\x4f\x5c\xa8\xb6\xd4\xe9\xb0\x61\x40\xad\x0d\x8b\xe1\xbb\x7c\x8b\xc7\x2b\x80\x36\x3d\x5c\x23\x37\xd3\x24\x80\x19\x6c\x7f\xd9\x1c\x8c\xd6\xb2\x46\x86\xd6\x98\xb7\x1f\xd5\x46\x5b\x52\xfe\x5c\x4d\xc0\xb7\x8f\xa1\x90\x29\xd2\xff\x51\x4e\x12\xca\x99\x61\x8b\xd3\x13\xb8\x72\x16\xde\x33\x8a\x02\x10\x56\xd3\xa3\xc0\x7c\x2f\x86\xd8\xe2\xca\x5a\x07\x4d\x63\xd2\xa2\x2c\x23\x23\x07\x37\x09\xea\xf6\xed\xd2\x00\x33\xab\xba\x5d\xfd\x16\xc8\x04\xdd\x9b\x28\x8c\xe5\xe3\xa4\x51\xec\xe0\xda\x0d\x1d\x5c\xbb\xa1\xa9\x55\x82\xc5\x7b\xb5\xf7\xdd\x2e\xa5\x0d\x81\x10\x35\xaa\x44\x8c\x9d\x88\x22\xe8\x40\xbe\xed\x1f\xee\xdf\x2f\x2a\xa4\xfe\x07\xb9\x5b\xfe\x03\x8d\x13\x7e\xc0\x1e\xff\x46\x7f\xbf\xee\x9d\x32\x80\x60\x80\xba\x3b\x73\x84\x38\x99\x92\x0b\xd3\xec\x0b\x28\xe5\xb2\x58\x01\xa7\xad\x63\xa2\x4d\xbe\x58\x46\xdf\xb2\x42\x74\xfd\x9f\xfd\x07\x45\x16\xab\xbd\x5f\x84\x03\x82\xda\x35\xa6\x17\x14\xcf\x47\xd8\x50\x82\xef\x8d\x66\xd1\x96\x32\xaa\x4f\x67\xfe\xf9\x0f\x0a\x18\x30\xda\xc3\x73\x1d\x14\x69\x28\x5e\x35\xc6\xa7\x54\xaa\x5e\x3c\x97\x71\x7d\xc9\x61\x8c\x8d\x6d\x42\x4e\x7f\x7b\x9f\xfb\xcc\xbb\x56\xd6\x92\x77\x00\xb9\x55\xf5\xd9\x12\xfc\x27\xd9\x48\x6e\xb3\xc4\xfe\x53\xc3\xa1\x7f\x80\x1a\x94\xd7\x46\x5f\x6d\x52\x18\x4e\xeb\x79\xa1\x3b\x7b\x3b\xbb\x15\x1e\x6e\x1f\xec\xf4\x1c\x46\xbc\xb4\xe2\xb6\x12\x0b\xb3\xb9\x1b\x4b\x9d\xa0\x9b\xbf\xb5\xd4\xc9\xf6\x84\x39\xe4\x34\x6f\x4f\xd7\x74\xbd\x4d\xb6\x36\xf3\xa6\xeb\x21\xc0\x3f\xbd\x7b\x00\xfe\x8d\x9e\xee\x99\xb7\xfc\x9f\xdf\xa2\xaf\x1a\x5e\xc4\x96\x7f\xeb\x68\xec\xfd\x26\x82\x7a\xe0\x5d\x52\x17\xed\x86\x21\x90\xdd\xb1\xbe\x54\x33\xef\x55\x2e\x90\xde\xd8\xbb\xa5\xc2\x64\xed\xb4\xd5\xdc\x39\x5a\x00\xdb\x2d\xa5\xeb\x45\x3a\x90\x38\x13\xeb\xa1\xb1\xd3\x4d\xb2\x93\x34\xfe\x7e\x63\x7c\xe3\x3e\x06\xd1\xc1\xee\x51\x81\xee\x11\xcf\x4b\xb1\xee\x0d\xae\xf8\x02\x57\x34\xf5\xf6\xef\x91\x9e\x7f\x1b\x6d\x4a\x14\x33\xc0\x28\xcb\x9d\x8f\x20\xf8\x55\x33\x68\x5c\xf3\x1b\x42\x6d\x74\xdb\x08\x50\x4a\x8b\x06\xc2\x6e\xc9\x62\x0e\x22\x52\xd8\x1f\x64\x6c\xfc\x55\x53\xb8\xa4\x8b\x32\x41\x6e\x38\xbc\x19\xd7\x5b\x87\xdb\x47\xe1\x7d\x59\xcf\xab\xb5\x62\x8c\x4f\x04\x1f\x87\xa7\xa5\x95\xda\x20\x7a\x8c\x73\x36\x9a\x53\x13\x08\x48\xa1\xd8\x12\x20\x14\x01\xeb\x09\x3b\x6f\xff\xf4\x1e\x39\xd8\xf3\xef\x8d\xc1\x15\xa1\xef\x52\xbb\xfc\x0e\xb7\x5d\x3e\xdb\xf0\x1a\x02\x6b\x53\xec\xaf\x64\x94\xf7\x6f\x3a\x31\xdd\x98\x1a\xb4\x53\xb4\x3e\x06\x5d\xb5\x2b\x9b\x01\x26\xd9\x16\x1b\x93\xdc\x69\x4d\x6b\x4a\xf3\x5e\x43\x76\xbd\x7a\xb0\x46\xd9\xf2\x1a\x31\xe2\x49\xef\xd4\xc6\xae\xa4\x19\x9e\x4d\xa8\xd2\x8f\x2c\x1a\x4b\xc2\x70\x04\x92\x84\x91\x14\x3b\x64\xc3\x8d\xd6\x73\xe4\xd8\xe8\xb1\xae\xc1\xe0\x87\x63\x5d\x7d\x47\x1b\x5d\x5b\x8a\x7b\xbb\xa8\x90\xf8\x1f\x5c\x1d\xb1\x61\xd8\xa8\x1e\x52\x79\x32\xcf\x9a\x88\xe7\xde\x60\x3f\x07\x52\x34\x0c\x96\xf5\x1f\x04\x45\x3a\x50\x53\xb0\x92\x25\x58\xfa\x08\xc3\x86\x89\xa8\x35\xe7\xd2\x4f\x61\xcb\x6e\x93\xf0\x6b\x67\x82\xcf\xd8\xa6\xe7\xc3\xcd\xe6\x79\x75\x3c\x44\x7b\x7d\x87\xc8\x97\x6c\x51\xca\x83\xa4\x85\x34\xfe\xbe\x3c\xa7\xa3\x34\x91\x8d\x9f\xe1\x12\xc0\x06\x4f\x00\xd7\xd0\xcd\xa1\x7b\x46\xa6\x59\x83\x37\x03\xf4\xee\x7f\xcd\x32\xab\xc1\x51\x49\x96\x71\xd2\x14\x64\x1d\xa7\x83\x4a\xb5\x72\x76\xa6\x28\x7e\x8f\x1f\xfa\xb4\xf7\x31\x0d\x6d\x54\x14\x88\x3b\xf0\x27\x94\x76\x07\xf0\xf2\x4f\xff\xc1\x4f\x64\x6f\xc1\xfa\xc1\x64\x13\xe8\xa0\x10\x59\xa2\xc8\xff\x01\xef\x36\xb0\xdc\x8c\x0f\x40\x81\xf0\x7e\x11\xe1\x1b\x1d\x79\xdb\x28\x65\xac\x8e\x62\x71\x8e\xbe\x9e\xb0\x0a\x18\x1f\x19\xfc\xd2\xf5\x65\x48\x5f\x37\xca\x82\x8e\x98\xf2\x4b\xc9\x2f\xb3\x93\x21\xd3\x9c\x8e\x09\x1c\x87\x13\x84\x9a\x5e\x36\x09\xa4\xc1\x85\x90\x28\x85\x1a\x05\xdb\xac\xf6\x8d\x9d\x28\x9b\x83\xc0\x85\xc7\xa3\x6c\x9f\x0d\x81\x2b\xe5\xea\x4a\x7a\x56\xb9\xf4\x95\xba\x54\x24\xfc\xf4\xd9\xcd\x4d\x8d\x69\xcf\x92\x71\x05\x82\xbd\x4c\xc7\xf5\x50\x24\x24\xe4\x36\x05\x7c\xcf\x52\x6f\xbd\xd6\x20\xae\xab\x81\x7d\x29\x8d\xab\x2e\xa5\xdc\x1e\xd9\xc8\x65\xc0\xad\xb3\x92\x27\x40\x6d\xce\x4e\x5e\x37\xf0\xe6\x2d\xe5\x75\xb3\x3f\x69\x36\x63\xaf\x33\x0d\xae\x90\x3d\xba\x66\x30\xe0\x1a\x1d\xae\xc9\x0b\x87\x0c\x75\x4f\xb4\x71\x40\xb0\x07\xaa\x70\x29\x9f\x51\x25\x2f\xcb\x1d\xaf\x4d\x2f\x8b\xf9\x4f\x91\x69\xcc\x22\xad\xfb\x38\x7c\x55\xca\xe1\x1f\x0d\x1e\x5e\x4c\x4d\xfd\x89\xc4\xef\x77\xe4\xc8\x9e\xe8\x8a\x8a\x66\x92\x5c\xd0\x6d\xdc\xe1\x85\x90\xb4\x2a\x09\x46\x0c\xed\xe5\x25\x63\x7a\x08\x63\xb2\x62\x90\x65\xe8\xa0\x52\xd6\x38\x69\x32\x1b\x33\x48\xc3\x9e\x64\x63\x86\x50\xd4\x91\x8d\xd9\x14\xba\xf8\x20\x2d\x53\x3b\xdc\xf5\xef\x1d\x2e\xab\x3b\xa2\x13\xb1\x52\xac\xd8\x57\xb8\x50\xff\x13\xe4\x56\xd5\x37\x92\xdf\x46\x6e\x55\xdd\x34\xbf\xac\xdc\xaa\xba\x09\x4b\x95\x5b\x15\x0b\xb5\x15\x89\x40\x8d\xe1\x4a\x97\x79\x95\x08\xb0\xee\xcc\xab\x24\x88\x69\x32\xaf\xea\xdd\xf4\xc3\x83\xa8\x9a\xf4\x0c\x0e\xf6\x0f\xe2\x4e\xee\x1a\xc6\xfa\xcb\xb0\x7d\x29\x4d\x87\x9a\x72\x03\x2f\x3e\xfa\x08\xe6\x0d\xfe\xee\x29\x14\x94\xd5\x25\x15\x18\xf4\x1c\x55\x9e\xa3\xe1\x60\x1a\xb0\xe6\x07\x52\x58\x13\x1a\x4a\x2d\x6f\x6f\x90\xd4\x52\x40\xe7\x82\xd2\x3b\x2f\x96\x9d\xe7\x9b\x3b\xcf\x2f\x56\x1f\x3f\xe7\x8a\x83\x7e\x9b\x5c\xaa\x88\xab\x26\xa2\x59\x02\xb8\x05\xe1\xcb\x20\x40\x7b\xed\x20\xa7\x44\x1d\xf0\x22\x59\x8d\x8c\xaa\x2f\x52\x4a\xb2\x7e\xdd\x5a\xf6\x2a\x8f\xfe\xba\x75\xb9\x72\x67\xa1\x7c\xff\xa6\xb2\x35\x12\x90\x8b\x73\x26\x32\x68\xc2\x85\x60\xdb\xbd\x6f\xc8\xd7\x81\x51\x88\x63\x5c\x7a\xd1\xe6\x9a\x7f\xdc\x6d\x72\xcc\x10\x00\x54\x21\x20\x3c\xa5\xdc\xc8\x4d\xae\x6a\x8c\x4d\xd4\xbc\x2e\x6b\xd2\xaf\xbb\x4b\x9f\xef\x7e\xfe\xc8\xf9\x62\x95\x6b\x33\xc6\x92\x4e\xf1\x91\xd3\x7a\xe1\xb8\x51\x04\x9e\x8e\x7b\x83\xe0\xc4\x2c\xac\x6e\xa4\xfb\x2d\xe0\xe2\x8a\x79\xbb\x44\x5e\x70\x96\x36\xcb\x6b\x77\x91\x83\x0f\x2e\x73\x77\x37\xaf\xdf\x9d\xb3\x71\xc2\xb9\xfe\x13\x13\x99\x4c\x15\x35\x69\x30\x73\x98\x3d\xc5\x61\x86\x18\x77\x58\x53\x37\xb3\xd5\x64\xee\xfc\x7c\xb2\x16\x89\xd7\x3f\xa1\xfa\xe3\x52\x75\x5d\xd1\xa9\x4f\xd0\xfe\xaa\x37\x30\xd2\x60\x8b\xa3\x6b\xcc\x82\x83\x0b\xaf\x19\xdc\x9d\x96\x6e\x1c\x9a\x45\xd5\x1f\x6c\x55\x75\xcb\x9d\x0d\xea\xf5\x79\x76\xb5\x7c\xe9\x44\x79\x75\x09\xd8\xb3\x7b\xfa\x3c\xfc\xb7\xba\xbc\xc4\x0d\x3c\xf9\xe3\xee\xc2\xc6\xee\x75\x75\x0b\x87\x28\x42\x50\x2e\xb2\x95\xd5\x2f\x85\x7d\x90\x2f\x46\x19\x75\xaf\xb7\x5a\x7a\x82\x80\x44\x31\x6c\x1f\x50\x6a\x9a\xbc\xbb\xdc\x18\x36\xf3\x45\x82\x90\x3f\xfb\x99\x4d\xf1\xe4\x30\x21\x72\x21\x50\xae\xb5\x09\xc4\x30\x7b\xf6\xcb\xbc\x52\x53\x34\xa5\xe7\x26\xa9\xea\xc5\x8c\x69\xcc\x72\x9b\x59\x37\x34\x61\xdc\x2a\xe5\x8a\xed\x28\xd9\x8e\x0b\x47\x0c\xd9\x0a\x39\x09\x73\xda\x98\xb6\x0a\x73\xfc\x0d\xb7\xe6\x8c\xab\x86\x5e\x7d\xf0\x59\xf9\xca\x4f\xe5\xe5\xf3\xe5\xbb\x37\xab\x77\xce\x87\x4b\xbb\xd3\x7a\xaa\xae\x2f\x97\xcf\x6d\xfc\x7d\x7e\xa1\xf2\xcd\x42\xe5\xe6\x35\xd1\xbb\xe6\xd2\x59\x67\xf9\x29\x48\x92\xea\xfa\xc5\xf2\xa7\x4f\x77\xef\x7d\xc5\xdf\xc4\x8e\x46\x5e\xe4\x4c\x5b\x8d\x64\x8c\xa7\x53\x12\x71\xb8\xf1\xa4\xd5\x1f\x8b\x97\x72\x36\x5c\x15\x27\x16\x83\xd7\x0d\xc4\x79\xf8\x69\xe5\xa6\xa2\xc2\x34\x41\xa5\x6e\xc4\x02\x64\x52\x59\x5c\x86\xcd\x20\x95\xf5\x6f\xbb\xd1\xc7\x8c\x50\xbd\x8a\xe6\x49\x60\xb9\x7d\x1f\xb7\x56\x54\x83\xc5\x04\x57\xed\x1d\xce\x70\xa5\xec\xd8\x19\x50\xb0\x51\x08\x51\x55\x5e\xf3\x18\x95\x6e\x16\x8d\x2f\x6d\xad\xbb\x2f\xf0\x40\x77\xd6\x3c\x6c\x62\xfb\x1c\xee\xca\x8c\x2d\x56\xc7\xb9\xe6\x73\x76\x0e\x03\xe3\x83\x8f\x12\xac\x4e\x0c\xae\x2f\xe5\x27\x0b\x7a\xc6\xe0\x4e\x36\x00\x33\x98\x84\x7b\xc0\xd3\xba\x26\x41\x46\x97\xc6\xc8\xe4\x26\x67\xe2\xc2\x07\xf3\xbf\xbb\x3d\x8c\x54\xe2\xb0\x76\x64\xf2\x88\x2a\x2b\xcb\xbb\x6b\xf3\xd5\x3b\x0b\x34\x24\x69\x28\xf8\x0b\xb7\x44\x06\xe1\xee\xac\x9c\xc2\xbe\x33\x2b\xcb\xe5\xb5\xef\x2b\x27\x36\xe5\x71\x60\xd3\x92\x93\xb7\x01\x80\x73\x6a\xa9\xf2\xd3\x65\xee\x50\x83\xc0\xb8\x6f\xcd\xee\xfc\xf5\xea\xfa\x5d\x50\x04\xea\x1b\x4a\xf4\x1c\x89\xf4\xfa\x77\x8d\xac\xb2\x89\x3c\xf5\x52\xae\xde\xbd\x5b\xbe\x78\x3a\x1e\x08\x1e\x4c\xb1\x40\xb8\x67\x69\x3c\x90\xff\x52\x2d\xd6\x99\x2d\xff\x20\x2d\xd6\x55\x33\xf4\x7f\x9b\xac\xd7\xdf\x64\x5d\x3d\xf1\xff\xb7\xc9\x7a\xaa\x26\xeb\xee\x62\xc4\x46\x55\xa5\x1c\xd6\xf5\x82\xf5\x40\xf9\x6b\xa2\x82\x17\xf5\x43\x85\x3d\x3c\x4d\x0d\xa2\xa7\xb0\x8d\x28\x1c\xf2\xaa\xf9\x40\x61\xeb\x76\x79\xf0\xc6\x05\xec\x28\x5f\xb8\x00\x5a\xb8\x60\x2e\xb5\x49\x75\x6e\x5d\x2e\x7f\x7f\x23\x8e\xae\x7c\x89\xda\x62\x67\x70\x69\xb1\xfe\x64\x4f\xe9\x6f\x6a\x64\xcb\x71\x3b\x87\xbb\x02\xc7\xef\x91\xa7\x22\x6c\x7d\xb9\xf2\xe0\x02\xde\x9b\x6e\x3c\xac\xdc\xda\x0c\xec\x72\xa9\xfd\x1d\x6e\x77\xc2\xa2\x6c\x4e\xc1\x84\x51\x11\x35\x7c\x0e\x8f\x7a\x5f\xd0\x89\xe0\xda\x76\xde\x56\x58\x13\xa3\xa8\x1f\x47\xcb\xd7\xec\x14\x1a\x97\x12\xb5\x0c\x22\xd2\x93\x46\xa1\x99\x24\x84\xb0\x3a\xb0\xb5\xf9\x99\x87\xb0\x9c\xf8\x74\xc4\x56\xe0\x9b\x57\x40\x81\x06\x9d\x0e\x10\x28\xba\x64\x77\x5b\xb9\x9c\x31\x4e\xd6\xbc\x4c\x69\x9a\x9b\x46\x1b\xe3\x54\x73\x1e\x33\x7d\x48\x95\x6b\x6d\x13\x05\xa5\x8b\x87\xdb\x38\x97\x4f\x63\xc7\xae\x84\x96\x0a\x27\xb6\xe1\x2a\x57\x57\xd3\x04\x75\xf7\x68\x52\x37\xe7\xab\xbf\x7c\xce\x0d\x9b\x99\xc2\x24\x5e\x15\x75\x93\x84\xd4\x6f\x98\x49\xd5\x5f\x5e\x54\x7f\xbe\xd5\x42\x26\x25\xb3\x27\x3f\x47\xeb\x1f\x34\xc3\x71\xd1\x93\x52\xb0\x65\x88\xbe\x02\x70\xdc\x78\x42\x84\x75\x88\x1f\xb9\xef\x29\xff\xf8\x6a\xfa\x73\xec\x6c\x7f\x5a\xde\x3c\xeb\x6c\x5f\x0d\x33\x40\xa6\xbb\x7a\x6b\xa9\xfa\xcd\x0b\x67\xf9\x51\xbd\xcd\x3a\xd8\xd2\x10\x06\x2d\x8d\x5a\xad\xe1\xd3\xd1\x89\xf7\x57\xb4\x21\xc9\x7d\x87\xc2\xd6\x8a\x91\x5c\x0f\xb6\x8b\x3c\xa0\x25\xd8\x21\x45\xeb\x39\xaf\x35\x56\x74\x63\x92\x91\x9c\xdb\xc7\xf1\xb2\x07\x2f\x81\xc0\x71\x98\xfc\xa0\xd4\x3d\xa0\xb9\x56\x51\x2b\x89\x1e\xc1\x5a\x85\xec\x05\x2a\x02\x90\x12\x28\xc9\xa0\x9f\x81\x8c\xd5\x78\x10\x88\x3b\x0d\xb5\xc6\xc7\xc5\xc9\x3d\xfc\xe0\x1e\xfd\xdf\x12\x8c\x45\xb7\xf0\x38\x3a\xb3\x0d\x47\x96\x68\x7e\x7f\xe5\xc1\xee\xea\x27\xbf\x6e\x2d\x24\xe1\x9f\xe0\xf6\x65\x6e\xe5\x26\x76\x45\x2b\xb5\xd7\x6d\x6c\x1c\xb2\xfc\x88\xed\x8f\x95\xa7\x8f\x9d\x6b\xd7\xd2\x21\x80\xbd\x83\xcb\x38\x43\x27\xbd\xb7\x51\xdb\x70\x07\xb9\x75\xbb\x55\x22\x04\x0e\x14\x32\x69\x71\x4f\x37\xdc\xf7\x2e\x19\x7c\x81\xc0\xeb\x52\x08\x6a\xa8\xe7\x4c\x2a\x12\x45\x29\x73\x84\x74\x34\x67\x97\xf2\x18\x5e\x68\x64\xfa\xe8\x5b\xd2\x54\xb1\x56\xe8\xf1\x1c\x5c\xa0\xc4\xa3\x36\xde\x42\x0f\xd4\x1b\x02\x10\x44\x4a\x06\x08\x2a\x1e\x45\x57\x13\x7f\x65\xfb\x0d\x50\x93\xe6\xc2\x67\x42\xd4\xdb\xbe\x5d\x30\x15\x3d\xaa\x0d\x4b\xad\xcc\xc4\xa6\x96\x59\x9d\x44\x1c\x1c\xec\xd1\xdd\x77\x34\xcf\x6c\x52\x83\x2b\x1d\xa1\x01\x19\xeb\x89\x62\xaf\x27\xb3\x90\x77\x4a\x0a\x61\x55\x05\x04\xa3\x38\x51\x5c\xba\x43\x02\x32\x99\x28\x60\x9c\x09\xb7\x9d\xbf\x19\xb2\x39\x38\x7e\xcf\x6e\x9e\x41\x1b\xef\xea\xf9\x58\x83\x6d\x04\x02\xf6\x2c\x29\x8d\xa3\x21\xe8\x68\xad\x3a\x0f\x1b\x76\x11\x24\x42\x8c\x9a\xea\xa2\x11\x67\x1d\x17\x20\x63\x33\x46\xb2\x80\xf6\x1b\xed\x83\x50\x38\xb1\xc9\x27\x08\xb5\x52\x95\x21\xa8\x31\xe7\xda\x8a\xae\x77\x15\xbb\x33\x8b\x26\xd1\xa0\xa6\x94\xf2\x68\xac\x88\xc7\xfd\x7c\xb3\x72\xef\x64\xf9\xf2\x3d\xe7\xfe\x45\x90\xbe\xb0\xd0\xd1\x87\xb2\x7d\x65\x67\xe3\x33\xe7\xc4\x8f\x09\x48\xad\x3c\xdc\x21\x7d\x23\x6b\x8c\xe2\x2d\x4e\xa2\xf3\x27\xe1\x9e\x2c\xdb\x54\x19\x65\x02\x9a\xd9\x82\x09\x43\xfb\x9b\x99\x4f\xc6\xe0\x3c\xbc\xe7\x2c\xde\xa6\x67\x63\x41\xbb\xbe\x68\x8f\x78\xd5\x3a\x27\xf6\x24\xf7\x47\xf5\x00\x8a\x58\x24\x6a\xb3\x4b\xca\x0d\xce\x43\x16\x1b\x1c\xa1\x5d\x23\x69\x37\xc1\x1e\x62\x8c\x7c\x36\xf0\x54\x54\xd6\x4f\xc1\x9d\x92\xcd\x09\xe9\xb0\xc3\x05\xad\xe8\xde\xdc\xa8\x8d\xe8\xd8\x1c\x76\x47\x42\x7a\x6c\xed\x35\xf2\x16\x53\xe1\x61\xa5\x27\x8d\x47\x0d\xf7\xb4\xed\x2b\x70\x0f\x81\x1b\xa6\x20\x8f\x68\x40\x25\x87\xc8\xc3\x96\x52\x1f\x2f\xee\x5e\x3a\xcb\xfd\x67\xd5\x3e\x34\x97\xbc\x9c\x31\x4b\x36\xdc\x58\xb4\xb0\xdd\x12\x7a\x39\x7b\xf0\xe0\x75\x18\xb1\x68\xd8\x88\x8c\xa6\x0b\x57\x4c\xcf\x50\x46\x00\x17\xd1\xa0\x7d\x7c\xf7\xf2\x7a\xf9\xbb\x6b\x6c\x80\x4d\x40\x19\xec\x46\x18\xcf\x3f\xa9\x85\x60\x22\x54\x3e\x37\xa8\xe9\x53\x5c\x92\xbb\x18\x01\x3b\x01\xa9\xbd\x71\x75\xfd\x62\xf5\x92\x4a\x8b\x08\xc3\xe7\x98\xa0\x14\xb0\x41\x53\xde\x5d\x3c\xc5\xf3\x5a\xf9\xf1\x79\xe5\x89\xca\xce\x18\xc6\x90\x60\xff\x0f\xe0\x88\xf3\x72\x79\x70\xe3\xba\x0b\xf3\x56\x89\xe9\x25\xec\x81\xc1\xc2\x8a\xbc\x4c\xa8\x94\x39\x1f\x7f\x69\xb7\x26\x7b\x0d\xdd\xad\x49\xf5\x54\x78\xad\xd4\xbb\x3f\xb9\x1e\x8d\xd7\x9c\xc5\xf7\xea\xf0\x8e\xc5\x3e\xe2\x63\xd8\x56\x36\x5f\xb2\xa7\xd0\xcb\x59\x1a\x1f\x37\x6c\x9b\xcc\x68\xf1\x2b\x0d\xae\x89\xd7\x3f\x75\x96\xbf\x2b\x9f\x5e\xdf\x9d\x5f\xd8\xf9\xf9\x64\x68\x81\xcb\x1f\x65\x6d\x30\x89\x5c\x10\x18\xf1\xbc\x27\xb1\x90\x00\x25\x83\x23\xc6\x0c\x61\xac\x69\xc9\xa6\x1c\xe1\x81\x6e\x17\x9f\x0c\xbe\x59\x73\x63\x72\x54\x1c\x6d\xf5\x8d\x98\xf0\x56\x97\x97\x78\x6d\xca\x03\x73\xbe\x58\xe5\x85\x85\x3d\xc0\x9f\xdf\x76\xce\x7c\x56\xbe\x76\xbb\xb2\x76\x92\xaf\xb2\xf0\xab\x73\xfd\x07\xe7\xf3\xcf\x94\x17\xda\x1a\x7a\xf1\x46\x31\x66\xb2\x7d\x52\x1f\x27\x6f\x1d\xfd\x9c\xd7\xe7\xa8\x4f\x1f\xaa\x2a\x69\x09\xe5\x46\xdd\xce\xc6\x8f\x65\xf2\xb6\xed\x3c\xbf\x58\xfe\x7e\x9b\xa7\x22\x81\x20\x4c\x0a\xad\xcb\xc7\x56\xbb\xc7\x50\xc4\x51\xc4\x40\x0c\x22\x1a\x64\x78\x81\xe2\xa5\xde\xbd\x53\xd9\x46\xb1\x48\x81\x0d\x58\x59\x09\x9e\x8a\x77\x69\x5d\xff\xb9\xfc\xa5\xb8\x51\x85\xd6\x22\x3b\xe4\x05\x91\xf5\xaf\x4b\xd1\x09\xfb\x95\x37\xfa\xc4\x66\xda\xf5\x98\x06\x6a\x07\x9c\xae\x9d\xa6\x37\xe8\xb1\x98\xb6\x96\x89\xfd\x3c\x6b\xd4\x18\x05\x90\x78\x12\x84\x7a\x81\xbe\x78\xfa\x4b\x8c\x0e\x57\x67\x0d\xfb\x5b\x66\xb0\x91\x04\x4d\x10\x83\xa7\x87\x84\x09\x4a\x1e\xc8\xcb\xa7\x36\x99\x26\x0e\xa1\x85\x77\xfe\x15\xff\xd8\x13\xba\xe0\x48\xdf\xbd\x71\x2a\x84\x23\x99\x32\xaf\x21\xf6\xbb\x22\x19\x22\xed\x82\xe3\x53\xb2\xf6\xcd\x94\xe8\xb8\xfd\x6c\xe4\xea\x6a\x7a\x73\x27\xd0\x90\xa2\xe9\x74\x6b\x3a\x4d\xd7\x68\x8a\x51\xb8\x12\x89\x0d\x6b\x8f\xad\x6e\x05\xad\xd0\x3a\x93\xe7\x32\xa8\x78\x22\xfc\x3d\x59\xd8\x2a\xa5\xd5\x47\xd8\x04\xa9\x81\xc3\x25\x62\xed\xb5\x76\xdd\x29\x3b\xcd\x37\x7a\xd4\xb5\x6a\x11\x34\x78\xe0\x49\x6a\x48\xcd\x60\xd2\x4f\x0a\x2a\x41\xfe\xdb\x7f\x34\xe6\xa4\xa3\x27\x86\x67\xa1\x7e\xe5\x7b\xb7\x2b\x6a\x06\x18\xc2\xec\x99\xeb\x58\x0f\x8b\x1a\x4b\x0a\x66\x50\xc1\x5e\xd5\x29\xdc\xda\x1d\xe5\x2c\xfe\x80\x8a\x4a\x83\xe7\x2b\x2f\xc7\xc8\x13\xed\x15\x2a\x0b\x1c\xf0\xd6\xd8\x19\x18\xb9\xc1\xa2\xf6\xe2\xcb\xd8\x74\xfe\xf6\x8a\xdc\x7d\xc9\xa3\xe1\x40\x3a\xb7\x3b\x84\xd2\x6a\xfd\x0f\x26\x6b\x3c\xb3\x51\xf9\xcc\x59\xbc\x97\x2b\x4d\xe4\x29\x19\xe4\xf9\xed\xd2\x8d\x27\x44\x44\xd4\xeb\x2a\xa4\x6e\x66\x85\x36\x6b\x14\x0c\xb8\x03\xff\x45\x38\x9e\x45\xb0\x1d\x46\xf6\xe8\x93\xba\x3a\x00\xc6\x79\xf6\xb8\x7c\xf2\x8b\xca\x93\x73\xd5\xbb\xa7\xaa\xf7\x57\x44\x64\xdb\xd2\xa9\xea\x77\x77\xd4\x46\x6b\x1f\x6d\xbb\xbf\x16\xcc\x1c\xf6\xab\xd3\x28\x9e\x41\x64\xc3\xb4\x93\xf7\x02\xc3\x73\xf2\x96\x6d\x78\x51\x5e\xc7\xba\xbb\x06\xdc\x1c\xa6\x21\x4d\xaa\x47\xa0\xb9\xf5\x08\x68\xaf\x8f\x61\xf8\x9c\xdc\x32\xa3\xce\xba\x07\xe2\xf6\x39\x10\x1f\xf5\x29\x7c\x77\x71\xc1\x9e\x02\x90\x1b\xeb\xa9\x65\x4c\x36\xd9\x4f\xeb\xc5\xf1\xa9\x14\x60\x77\x36\x4e\x55\xbe\xbf\xa3\x02\x6e\x17\xe1\xaa\x2c\xc5\x1b\xcf\xb1\x47\xea\x35\xa3\x73\xb2\x13\xf3\x55\xbc\x9f\x5e\xa7\x7e\xfe\x66\x91\xcc\x48\xfc\x73\x5b\x52\xe8\xe1\x5f\xf4\x19\xdd\x87\xd0\x09\x8f\xb5\x05\xc0\x90\x07\x4c\x07\xcd\x05\x4e\x9c\x29\xfc\xa1\xa8\x4f\x36\x0e\xfb\xbf\xcf\xfc\xbe\xf3\xf7\x9d\x6f\xb4\xd1\xf4\xb5\xb9\x1f\x00\xe4\xeb\x1c\x12\x0a\x0b\x12\x9f\x2f\x76\x98\x92\xf1\xdf\xd6\xd0\xa0\xdc\xee\x85\x5e\xb7\x09\x8f\x68\x1b\x92\xd3\x96\x2b\x65\xb3\x75\x16\xbd\x61\x8e\xba\x3d\x64\x28\x16\x6d\x3c\x5b\xca\x18\xee\xf2\x13\x25\x48\xda\x03\x61\x4a\x7e\x3f\x9c\x69\xc0\x6d\x62\xe7\x3f\x6c\xe1\xac\x5a\x72\x18\x37\xf3\xe2\x89\xb3\x88\xd1\xa1\xe5\x1f\x4e\xb0\x03\xbf\xba\x74\xb7\xba\x7e\xa2\xbc\x7e\x69\xf7\xfa\x7d\x0c\xbb\x90\x62\x96\x44\x4c\x38\xc5\x2c\x45\x93\xcd\xf9\xc7\x43\xaa\xe5\x14\xe3\xf1\x3d\xa8\xdb\x53\x63\x96\x5e\xc8\x1c\xf0\xae\x3e\xaa\xcd\xfe\xc9\x7c\xf5\xc6\x7a\xf9\xeb\x5f\xd8\x61\xcf\x8f\x46\xc3\xa4\xa8\x2d\x61\x78\x2f\x18\x22\x54\x83\x8e\x65\x15\x6c\x8a\xca\x2a\x9f\x7f\x54\xfd\x71\xa9\xbc\x79\x96\x0f\xcb\x14\xc0\xf9\x4c\xa8\x0f\x05\x4b\xf3\x34\x88\x28\xf7\x26\x85\xb3\x86\x32\x64\x92\x9d\x35\x1e\xc0\x58\x6f\x3d\x43\x8b\x9d\x32\x17\x4e\xec\x70\x09\x4c\xaa\xf1\xd1\xc5\x37\x16\x4c\x9c\x8b\xc2\x03\x93\xde\x99\x20\x67\x14\x25\x3a\x13\x6a\xe0\xc7\x3b\x13\xe4\x5c\xa6\x94\xce\x84\x1a\x0c\x49\x86\xce\x9a\x7c\xa9\x94\x70\xd5\x15\xfd\x6a\x93\xac\x92\x40\xca\x3a\x79\xfc\xba\x94\x34\xea\x24\xa0\x71\x4e\x0f\x5e\x96\x31\x4e\x8f\x20\x18\xa1\x85\x53\x00\xa7\xe9\xc7\x58\xe7\xe0\x18\x34\x27\x73\xa2\x8b\x98\xff\x1c\xc7\x71\x65\xb3\xf1\xc5\xaa\x64\x22\x78\x69\xf3\xae\x46\xcb\xfb\xc6\x1d\xe7\xcc\xf9\xf2\xd3\x65\x10\x96\xe5\x9f\xb6\x85\xfb\xd0\xcd\x0f\x93\x5f\x49\xa0\x3e\xce\x51\x48\xe8\x13\xbc\x84\x2e\x20\xf2\x7b\x72\x0b\x27\x4d\xb4\x70\x7a\xcd\xec\x34\x3a\x61\xe8\x96\x6d\xb0\xe7\x05\xf3\x21\x58\x17\xc8\xe7\x0d\x8a\xd2\x60\x53\xb8\xd2\x41\xca\xcb\x84\xc6\xb6\xbb\xb0\x59\x39\x77\x09\x0f\x0e\xda\x9c\xbf\x6e\x2d\xc3\x42\x74\xee\x9c\x00\xe9\x5c\x5e\xbb\xeb\x3c\x3a\x55\xbe\x78\x1d\x83\xaf\x42\x56\x70\xf1\xb0\xc2\x65\xea\x12\x1f\x97\xf3\x23\x88\x48\x0c\xd4\xf1\x61\xc5\xb8\x73\x78\x42\x63\xdc\x39\x02\xca\x38\xee\x47\x8c\x72\x55\x6b\xa2\x3c\xfd\x0c\x31\x0e\x96\x9d\xda\x9d\xca\xfb\x27\xd1\x9d\x4a\x60\x7f\x2b\xfe\x01\x99\xa3\xe9\xa3\x07\xeb\xf7\x0f\x78\x83\x6e\xca\x3f\x50\x73\x72\xd6\xe3\x1f\xf0\x48\xd8\x6b\xcb\x84\x74\x22\xa7\xb6\x49\x78\xc4\xfd\x26\x4d\x48\x35\x27\x58\xac\x09\xa9\x01\xe3\x91\x37\xfc\xbd\xb3\xb9\xa8\x16\x7a\x32\x4d\x7b\xeb\xf2\x90\x14\xaf\xb4\xe6\x1e\x8f\x32\xcf\x07\x31\x88\x7f\xa4\xdd\x40\xbe\xbf\x43\x7a\x2d\x25\x22\x52\xe3\xeb\x45\xe3\xbd\x14\x8f\xe4\xa5\x79\x33\x6a\x04\x75\x7a\x6f\x86\x44\x6c\x1a\x6f\x46\x2b\x76\x5c\x4a\x9d\xf7\xe5\xf8\x31\x62\xf5\xe5\x14\x7e\x8c\x1a\x52\xff\x81\xad\x79\x12\x2f\xd2\xdb\xee\x7c\x06\xa8\x8d\xcf\x2d\x96\x79\x0d\x18\x94\x43\x54\x7a\x36\xc2\x60\x1c\xae\xff\x3d\xbb\x9c\xf6\xe2\xd4\xf1\xa7\x44\xc6\x24\x92\x18\xbc\xa9\x09\x50\x97\x3c\xaa\x28\xbb\xe9\x9e\x50\x5f\xbf\x99\xf5\xa0\x61\x8f\x17\x4c\xaa\x8c\x70\x40\x5a\x55\xd2\xd7\x4a\xa9\xc2\xe9\xba\x6c\x6e\x89\x7c\x2d\x1a\x21\xd7\x2b\xc0\xd0\x21\xec\x9d\x25\x62\x78\x3c\x0b\x95\x1c\x6e\xad\x52\x7c\x17\xd6\x60\x90\x78\xcd\x20\xc3\x13\xcf\x18\x66\xf3\xdd\xbf\x88\x4a\xf6\xf7\x8a\xa8\xe7\x10\x62\x2a\x6b\xe4\x4a\x05\x49\xd9\xf1\xb2\xf7\x2d\x36\xf8\xba\x11\xa2\xb1\xc4\xec\x6c\xcc\x3b\xf3\x27\xb1\xd0\x80\x1c\x17\xfa\xb3\x70\x83\xe1\xf7\xa1\x52\x16\x0d\x90\xea\xb1\x48\xa6\x34\x1d\x8b\x1a\xc3\xee\x97\x26\x46\x26\x58\xe3\xc9\x73\x22\xbf\x82\xb2\xfa\x85\x22\x64\xc9\xc5\x80\xf5\x9b\x39\x40\xd5\x90\x6d\xe1\xf1\x83\x0a\xde\x18\x11\x46\x3c\x12\x8a\x57\xf3\xa3\xb1\xf1\x26\xcf\x39\xd8\x14\x03\x4c\x7a\x2e\x97\x45\x55\xa3\x2d\xdf\xbf\xc9\x3b\x4b\xbe\x0b\xec\xce\x3f\xc6\x5c\xce\x67\xeb\xd5\xfb\x0f\xcb\x2b\x5f\x3a\xab\xaa\x1b\xb7\x44\x07\x5a\x89\x31\x50\xcc\xed\x5f\xa8\xd9\x16\x5f\xb5\xb9\x90\xf6\x94\x3e\x13\x98\xf4\x5c\x86\x4c\xb8\x25\x9b\xdf\x16\x2f\xa9\xcc\xa8\x54\xb2\x47\x04\x23\xaf\xfc\x5c\x9e\xff\x16\x1d\x1e\x0f\xbe\xf4\x8b\x3e\x70\x86\x29\x4d\xbe\x97\x89\xcd\x4f\xc6\x51\x2e\xe2\xfc\x90\x26\x2c\xe7\x82\xdb\xe3\x43\xcc\xab\xd5\x73\x11\x57\x85\x9a\xe3\xb5\x65\x67\x0b\x4f\x7e\xf4\xe9\xe7\xe7\xa3\x84\x48\x93\x17\xbb\x5a\x04\x86\x87\x89\xac\xc7\xde\xf2\x54\x6b\x09\xc6\xac\x1c\xdc\x84\x24\x1f\xa4\x91\xa6\xbb\x5d\x4a\x23\x3d\x12\x31\x52\x59\x90\x6c\xdc\x57\x0d\x1c\x65\x0c\x3d\x59\xbb\xb9\xf7\x68\xbc\xb8\x10\xf7\xee\xd6\x44\x63\x57\xf8\x76\xf7\x9a\x07\x11\x4b\x3b\x89\x19\xbf\x3d\x46\xb4\x60\x17\xa0\x54\x16\xa9\x6a\xec\xec\xfa\x1f\x76\x5b\xe2\x15\x8c\xe5\x3f\x3e\xaa\x09\xa9\xac\x95\xbf\x7a\x58\x3e\xf3\x53\x03\x08\x59\x09\x4c\x8f\x56\xe8\x65\xf5\x22\xc7\xba\x69\xda\xd0\xd0\xbb\xb2\x2a\xe2\x19\x7e\x63\x85\xac\x67\xb8\xa5\xd7\x93\x8f\xd3\xe3\xa2\x60\x11\x3b\x1f\xdf\xfa\xa7\x7f\x3e\xdc\xae\xbd\xf9\xc6\x5b\x7f\xc0\x7f\x0e\xa9\xac\xa9\x5c\x8f\x88\xeb\x0e\x79\xe6\x53\x7a\xf9\xef\xf3\x0b\xf4\x36\xfe\x7b\x48\x6d\x2c\x35\x6d\x58\xd1\x73\x1a\x37\x79\xe1\x98\xf2\x22\x1c\x20\x5e\xae\xb6\x02\x2f\x17\x01\x08\x87\xca\xcf\x7f\x8b\x35\x1a\xbe\x58\xad\x9c\x9c\x2f\x2f\xaa\x3c\x0a\x96\x48\x83\xcd\x5a\x05\xcc\x29\x83\x4b\x7c\x5e\xd9\x62\x13\x53\xe2\x1e\x2d\x55\xb7\x36\x9c\xa5\xcd\xea\xe7\x17\xaa\x2b\x8f\x63\x81\x72\xa7\x05\xf2\x07\x51\xeb\x05\xb7\xd4\x46\x0c\x74\xaa\xb5\xb0\xbb\x70\xbd\x72\xef\x21\x97\x5b\x88\x45\x30\xad\xe7\x5d\x67\x13\xa5\x67\x8b\x9c\x19\x11\x7e\x8f\x9d\xec\x5c\x3b\x39\xa9\x10\xf9\x82\x31\x63\x5a\xc0\x4c\xca\x4a\xb0\xb9\xe6\x42\x6c\x9a\x0d\x16\xd0\xba\xb3\x80\x63\x26\x43\x85\x6f\x02\x0f\x26\xde\x08\x67\xc1\xf6\xd5\xda\x84\x1c\xac\x78\xb1\x72\x4a\x64\x33\xc0\x8d\xe4\xdb\xe7\x49\xce\x2f\x1e\x1a\xb7\x31\x10\x61\xec\xfa\x04\xa6\x76\x20\xd5\x31\x2a\xcf\xda\xba\x97\x33\xe1\x6c\xaf\x12\x49\x44\xfc\xb9\x6b\xce\xc9\x73\x29\x6c\xeb\xd6\xf8\x71\xa3\xd0\x61\x4e\x53\xbe\x80\xe5\x25\x5c\xf1\xfa\x47\x5d\x67\x7f\x46\x7a\xa4\x03\x45\x9f\x6a\x1b\x90\x37\x5a\x24\x58\x69\xf2\x5b\xfe\x9e\x88\x06\xa8\xde\x18\xd6\x78\x09\x23\x32\x08\x05\xe6\xc0\x24\xfa\x96\xcb\xe7\x97\xd0\xf8\x0b\x8f\x24\x3b\x97\xd9\xd8\xcb\x23\x95\xaa\x6e\x2a\x77\xb9\x9b\x33\x26\xc6\x22\xbd\x12\x33\x00\xc4\x61\x1f\x48\x00\x79\x59\xf5\x36\x57\x6b\xd2\xf4\x22\xe6\x45\x82\xc8\xd5\xcd\xac\x91\x71\xd3\xe6\x31\xbd\x1c\xcb\xb1\x1e\xe5\x5a\x44\x14\x62\x40\x25\x3c\xda\xbd\x52\x38\x36\xad\x2a\x7d\x06\xde\xe3\x80\x16\xdc\x10\x28\x39\x27\xcd\x19\x83\x38\xaa\x2e\x22\x77\xb2\xba\xb5\xc2\x15\x64\x9c\x5b\x3f\x94\xcf\x5d\xf0\xd2\xeb\x5d\xbc\x22\x63\x91\x8a\x7c\x50\xe9\x18\xfa\xb8\x7d\xb5\xf2\xe4\x0e\x5e\xf6\x60\x11\x60\x6c\x07\xaa\xb0\xdb\x17\xe4\x6c\x79\x65\x44\x8f\x3b\x5e\xaf\x04\x89\xc8\xcd\x6f\xb3\x35\x6a\x7c\x65\x97\xa6\x61\x5d\x19\xb6\x1f\xf6\x42\xe9\x36\xda\xb4\x51\xd4\x33\xba\xd2\x83\x0d\x2a\x87\x18\x8d\xba\x5c\x4a\x65\x03\x45\x26\x17\x32\xe3\x40\x19\xe7\xec\xb2\xf3\xc9\x63\x3c\x31\x36\xef\x11\x06\x0d\x3d\xfd\xe7\x15\x55\x21\x0f\x96\xa6\xf3\x81\x52\x24\x38\x15\x06\x4c\x1d\x4a\x1b\xae\xbe\xa1\xda\xc1\x54\x1d\x44\xae\xe9\x81\x97\x81\xf9\xd5\xdd\xaf\xaf\x3a\x8f\xb6\x51\x22\xd2\x97\xd1\x68\x7b\x8e\x1c\xeb\x1d\xec\x3f\x72\xb8\xe7\xc8\xb0\x76\xac\x6b\xb0\xb7\xeb\xed\xbe\x1e\x8d\x0a\x90\x2b\x43\x38\xbe\x78\xe4\xdc\xfc\x18\x0b\xc1\x9d\xdb\x88\xf3\x45\x45\x41\x1e\x52\xae\x63\x09\xe8\x01\x05\x3c\xaf\x66\xb0\x0a\x86\xdb\x88\x2d\xe9\x7d\xad\xa6\xc8\xae\xed\x95\xd5\xcd\x8c\x61\xcd\xdf\x49\x2b\x9b\x49\x7e\x6e\x9c\xea\x10\x17\xf4\xe9\xd1\xc9\xb1\x91\x7d\x07\xfe\x10\x5d\x63\x38\xfc\xce\xff\xd9\x8f\xb5\x19\x48\xf1\xd8\x5f\x9c\xce\xef\x77\x3d\x2e\xa3\xd4\x6e\x7c\x52\x59\x5a\x38\x08\xa7\xa8\x8d\xec\xc3\x0a\xa2\xed\xd6\x04\x56\x67\x99\xb4\x47\xf6\x25\xb1\xe5\x3f\xeb\xb0\x93\x67\xbb\x0f\xbb\xa5\xef\x3f\xac\x8f\xf3\x47\x09\x49\xa0\x0f\x0b\x35\xa5\x09\x0c\x32\x8f\x95\x35\x6c\xac\x0b\x68\x53\x3d\xe9\x02\x6c\x48\xca\x1b\x96\x4a\x68\xff\x1b\x80\xb0\x66\x6d\xcd\xad\x20\x05\xc8\x8c\x7a\xf0\x8c\xec\xfb\x70\x64\x24\x88\x6a\x04\x91\x8d\xc8\xe8\xe0\xc3\x47\x5e\xb5\x71\x17\xe3\x80\x35\x6b\x14\x86\xa6\x8c\x6c\xb6\xce\x71\xa5\x42\x87\xe3\x2b\x06\x66\x24\x06\x68\x9a\xd9\x4d\xb1\x3e\xbd\x89\xa2\x1a\x28\x7b\x36\x55\xa2\x04\xe1\x8d\xd5\xfa\xd0\xb4\x62\xa6\xea\x1e\xd8\x2b\x9a\xab\x66\x36\x15\x57\x62\xf0\xb0\x67\xc6\xbc\x3f\x6d\x33\x3b\x03\x1a\xa9\x5a\x8e\xa4\xdf\x51\xa9\x91\x88\x59\x13\x78\x46\x08\x53\x3d\x5b\xa9\x9e\xd1\x84\xf1\xb8\x23\xaa\x1b\x56\x3a\x69\xd9\x08\x6c\x4f\x82\x6a\x75\x9d\x1c\x71\x3b\xb3\x55\xf3\x1d\xb7\x2d\xf7\x6a\xba\x9b\x1c\xce\x3f\xea\x84\x47\x6f\x6f\xbe\x06\x78\x7d\x00\xf8\x4e\xef\x59\x3e\x45\xbc\xb1\x9b\xa5\x6e\xe7\x41\x1e\xa9\xe3\xe3\xa8\x1a\x28\xdb\xea\x38\xb6\x18\xd3\xcf\xaf\x50\xc5\x31\x2c\x3e\xeb\xe2\x60\xa3\x40\x2c\x3d\xef\x0e\x0f\x0f\x60\x78\xfe\x07\x73\x6e\x4d\x61\xac\x90\xeb\x52\x13\x8b\x9f\x9e\x64\xf4\x88\x95\x20\x0d\x20\x24\xad\x7a\xe9\x5c\xe5\xec\xa7\xb1\x78\x9b\xf0\x5a\x79\x83\xaf\xcb\x6b\x15\xc4\xdb\x2a\xa7\x15\xd1\xd2\x62\xa7\x55\x14\xa5\x75\xf9\xac\x82\x0c\x6a\x08\x39\x0c\x5d\x74\x9c\x62\x2b\x54\x3c\xaa\xe5\xf3\x6c\x3f\xdc\xbd\x71\x46\x69\x7e\x12\x80\xeb\xf4\x54\x31\xfc\xb4\x9e\x2a\x81\x23\xe8\xa8\x92\xcc\x26\x29\x7c\x54\x84\x10\x16\x35\xa2\x3d\xbf\x25\x3b\xa5\x90\x77\x89\xb1\xdf\x12\x05\x7b\xe9\xa2\x72\x16\x17\xaa\xeb\x3f\xb4\xd2\x45\x45\x84\xff\x46\x3c\x54\x3c\xe9\x7b\xe1\xa1\x0a\x8f\xb2\x59\x07\x55\x4b\x06\xba\x77\x0e\xaa\xa6\x86\xbb\xb7\xfe\x29\x1a\xfa\x4b\xf0\x4f\x45\xb0\xe0\x37\xe5\x9e\x6a\x94\x0f\xcd\x6f\x81\x86\xbc\x53\x7c\xf0\xd7\xe3\x20\x52\xe2\xab\xc3\x39\xc5\x4c\xaa\xdf\x39\xd5\x93\x9b\xf1\xb3\x05\x81\x57\xc7\x74\xd7\x43\x3c\xab\xdb\xa2\x6e\x5f\x51\x89\xdb\x6b\xee\x22\x99\xcf\x02\x50\x94\x96\x52\xb2\xc2\x8a\x15\x17\x19\x1c\x8b\xe3\x3f\x74\xb4\xf7\x60\xdb\x01\x55\x9d\x1b\x9e\x48\x7a\x88\x92\x8b\x23\x56\x48\xf9\xd2\x89\xca\xa5\xad\xca\x57\xd7\xbc\xfa\xaa\x71\xd4\xd0\x81\xc8\x15\x99\x49\xb7\x8b\xa9\xee\xf3\xe2\x01\x6b\x75\x21\x04\x71\xd0\xc7\xdd\xcc\x56\xbf\xb8\x8f\x99\x35\xd4\xa3\xe3\xfa\x1d\x52\x49\x1e\x2c\xa7\x57\xd7\x78\x3c\x8c\x62\x3c\xc9\x6d\xb3\x04\xd2\xa8\xa1\x49\x55\x61\x55\xfe\x88\x10\xd6\xa2\x28\x84\x98\x58\x24\x37\x5c\x01\xb1\x06\x71\x5d\x68\x63\x4b\x2e\x8a\x0c\x61\x2a\xad\xd8\xc8\xdc\x45\x66\x25\xa7\xa8\xbb\x9b\x90\x99\x1c\x5e\xa8\x6e\xe9\xc9\xd8\x12\xbc\x4c\x5a\x26\x32\xfb\x80\xd7\x7f\x1a\xc2\x22\xf3\x0e\xa2\xb7\x4f\xdd\x24\x45\x67\x23\xa4\x29\xcb\x19\x97\x68\x10\x49\x56\x7c\x91\x4e\x41\x97\x32\x0a\x20\x21\xe0\xee\x24\x4c\x59\x50\x9e\xd6\xb7\x11\xd5\x88\x59\xc2\xc7\xa2\xf7\x03\x00\x94\xe8\x63\x71\x7b\x55\xe6\x49\x06\xf8\x7b\x58\x5d\x37\x8d\xfc\x39\x91\x42\x20\xf0\x76\x2a\xa4\x7c\x4b\x4f\x8d\x95\x6f\xe8\x0d\x62\x35\x54\xe7\x68\xc2\xd5\xb4\xd9\xe9\x55\xe2\x8d\x9f\x5d\xe9\xc8\x6e\x78\x76\x27\xb8\xd7\x9d\xe4\x20\x45\xf5\x3b\xd5\x0e\x7b\x04\x9a\xe2\x36\x5c\x82\x3c\xe5\xaa\xd1\x6d\x55\x4b\x03\x67\x2e\x26\x9f\x36\x32\x09\xc4\x07\xe5\xc4\xa7\xc1\xdf\x84\xb4\x21\x42\x5a\x2c\x6d\x5c\xb2\x92\xaa\x83\x13\xee\xc0\x39\x5f\xff\xf4\x87\xb5\x27\x5f\x52\xa7\x09\xae\x16\xc3\x4f\xd6\x9f\x54\x60\x9b\xa0\xb0\x75\x44\xa5\xa3\x23\x2a\xd9\x22\x2d\x2d\x91\xd9\x12\x8d\x51\x63\x15\x66\xf5\x02\x11\x84\xc2\x42\xa9\x04\x56\x5f\xac\xec\x2e\x5c\x75\xae\x5d\xaf\x4f\x20\x4d\x72\xa1\x48\x8a\x18\x1b\xc7\x56\xc4\x2a\xf8\x69\x81\x60\x9d\x4d\x95\xeb\x9c\xc3\x23\xe8\x31\xb1\x8a\x1b\xa2\x55\xb2\x74\x81\x0c\x9d\x9e\xa6\x8e\x06\xb1\x28\x65\x9b\x57\xf9\xf3\x8b\x78\x60\x35\x84\xd9\xed\x9d\x45\x0d\x31\x39\xe0\x8a\x63\x37\x60\x26\xdf\x01\xfd\x95\x7b\xce\xaa\x48\xd9\xbe\x1a\x68\x49\x14\x78\x47\x84\x8e\xb0\x5f\xa1\xee\xcd\xed\xd2\x47\xc5\xc4\x71\x06\xe2\xb9\x41\xc5\xb6\x23\x67\x20\x0d\x12\x84\xcf\x83\x9f\x79\x6b\x3f\x4d\xb7\x92\xf9\xdb\x57\xdd\x67\xc4\xf8\x9a\x99\x76\x34\x22\x63\x81\x10\x4e\x36\x8b\x5d\xac\x8c\x6c\x67\x63\xbe\xfc\xfd\x8d\xf2\xfc\xb7\x9c\x3b\x56\xb9\xb9\xd5\x18\x62\x31\xc7\x6e\xe4\x0d\x8f\x1d\x83\x71\xe2\x06\xee\xc5\xd3\xd4\xc6\x04\xc9\x11\x36\x8d\x51\xc4\x35\x55\xb8\x61\x86\xc1\xed\x1c\xbc\x54\x99\x78\x25\x3e\x0e\x3a\xd5\x1c\xc0\xba\xfb\x88\x62\x70\xa0\xdb\xb5\xe2\xa8\x65\xce\x93\x67\xce\xb7\x27\xf9\x5e\x4f\x2f\x08\xeb\x78\x5d\x63\x82\xed\x6b\x4f\xe9\x59\xb7\x7d\xb7\x2a\xfc\x93\xf2\x36\xb8\x3f\x79\x1d\x6b\x16\x8b\xde\xfb\xe2\x8d\x7a\x04\x11\x9f\x54\x58\xa8\xe6\x3d\x3d\x8d\xad\x1c\x9e\x5d\xae\x6f\x28\x2e\xb6\x54\x55\xf6\x55\xf5\xf5\xeb\x18\x5d\x1e\x58\x97\xc0\x37\x67\xe5\x7c\xf9\xea\xd9\xba\xf9\xe6\x42\x16\x25\x7d\x62\x81\x73\xf5\x9d\x7a\x80\x1b\x05\x6c\x1b\x91\xc2\x7c\x42\xb1\xb2\x75\x9b\x4f\xf2\x05\xcb\xb5\x15\x61\x30\x01\xce\x01\x35\xe6\xa3\xc6\x6b\x24\x6d\xdb\x9a\xdc\x29\x51\x18\x5a\x07\xd2\x17\x32\xb8\x01\x8d\x82\x7a\xff\x91\x67\x70\x67\xfb\xd3\xea\xd2\xdd\x9d\xad\x4d\xdc\x7d\x97\x30\x20\xb5\x11\xd1\x82\x51\x1a\xb5\x26\xa7\x44\x7d\xa7\xfa\x60\x1e\x04\x5c\xa2\xed\x29\x9d\xae\xe3\xd2\xe0\xde\x05\x63\x71\x46\xde\xff\xea\x81\x4e\x2c\x8e\x45\xe1\xdd\xf7\x22\x71\xa5\x64\x68\x00\x5d\xe2\x8c\x32\x5e\x69\x2e\x1b\x43\x3d\x01\x58\xa7\xe8\xd0\xf4\x33\xb3\xd5\x52\x8f\xfa\x6a\x96\xcf\xfd\x04\x8b\x49\xeb\xef\xc2\x17\x38\xcf\xba\x5e\xac\x39\x7d\xba\x71\xf3\x92\xdc\xdd\xb3\xb5\x46\x26\x21\x64\x48\x41\x52\x4f\x39\x9c\xd9\x3c\xdf\x2a\x9b\x66\x4a\x14\x9e\x9a\x82\x1a\x4a\x70\xd2\x9b\x12\x10\x58\xaf\x2b\x3b\xe3\x95\x21\x48\xb1\x35\xbf\xfd\x06\xa4\x33\x07\xe2\x37\xbe\x23\x8b\x05\xd3\x20\xac\x76\x11\x66\xb4\xa1\xeb\x41\x18\x48\xb3\xa2\xd2\xd6\x67\x64\x49\xd5\x24\x34\x0a\xde\x6c\x7c\xd9\x72\xcf\xa1\xd6\x2e\x58\x8f\x24\x4e\x92\x19\xa5\x80\xf0\xd1\xe2\x5c\xde\x88\xb3\x51\x31\x25\xbe\x8d\xaa\xf6\xe5\xfa\xd6\x34\x5b\xc7\x43\x17\xae\x54\x9d\x92\x84\xd1\x5c\xbe\x74\x45\x1b\xad\xd3\x18\x47\x7c\x32\x1a\x9b\x20\x26\xa6\xb5\x13\x84\x4d\x8e\x48\x0f\xb7\xea\x70\x5d\x50\xb7\xa3\x26\x5d\x17\x7f\x33\xf3\xf9\xd0\x8c\xa8\xd0\x7d\xf3\x65\x65\xe3\x41\xcc\x1c\xc4\xa1\x89\xb4\xdd\x60\x86\x05\xa7\x28\x63\x59\x4e\xae\x2d\xaa\xdb\x1c\x7b\x52\x98\xa4\xdc\x15\x76\x7d\x0e\x58\x36\x15\x2f\x6b\x83\x19\x2b\xca\x1f\xbd\x86\xe7\x3a\x36\x5d\x2a\x1a\x93\x46\xa1\x53\xd3\xde\xc1\x4b\x00\xb6\xaa\xb5\xe7\x72\x45\xfd\x03\x58\xb7\xd9\x7c\x3b\x35\x1a\xf9\xf3\xf8\x84\x1b\x3a\xe6\xcf\x7d\xc7\xd4\x9f\x13\x1c\x9c\x30\xdb\x8b\xb7\x79\x90\x8a\x91\x60\xd3\x40\xec\xa4\xe7\x93\x86\x27\xed\xd6\xb9\xf2\xb9\x0d\xcc\x2a\x7a\xf1\x69\xf9\xe2\x43\xf9\x57\x6e\xdb\x0a\x27\x24\xf5\xe4\x3f\xe1\xdc\x39\x01\xdf\x38\x8b\x4f\x77\x9e\x9f\xaf\xde\xbd\x8a\x6d\x12\x45\xd1\x01\x2c\xe5\xea\x9c\xf9\x78\xf7\xfc\x0f\x5a\x5b\x34\xf1\x6d\xf1\x7e\x4e\xf5\x21\x9d\x62\xcb\x1e\xd0\x8e\x58\x5c\xca\x94\x0a\x86\x26\x65\xd4\xb9\x10\xbd\x4e\x70\xe1\xc4\xae\x98\x9e\xe5\x02\x1f\x1e\x74\x19\x8c\xbe\xd3\x66\x75\xde\x12\x84\x13\x66\x72\x5c\xfb\x8b\x35\x46\x2a\x37\x3c\x4a\x99\x49\x6d\xb8\x5d\xb0\xb0\x9d\xad\xaa\xe0\xea\x51\x54\xb9\xbf\xe2\x6c\x2f\x62\x56\xc8\xd9\xd5\xf2\xfd\xdb\xdc\xe6\x31\x04\xcc\x79\xb0\x5a\x5e\x3e\x8b\x4d\x74\xe7\xb7\xe1\xbf\xb1\x64\x26\x6c\xcd\xb4\x5b\x90\x93\xfd\x6c\xca\xf6\xa3\xf3\x9e\x53\xf2\x0c\xd1\x49\x0e\x38\x81\x41\x7c\x46\x2e\x93\xb7\x60\x79\xd7\x77\x16\x7d\x90\xe7\xbb\xbc\x6c\xdc\xe2\x60\x2b\x9d\xcd\x4d\xd6\x04\x56\xc5\xda\xcf\xbd\x94\xf3\xba\x59\xb0\x45\x67\x51\xcd\x1a\xa7\xb6\x2f\x19\xb9\xc1\xa4\x96\x33\xf4\x02\xe8\x08\xc8\xb3\xf7\xa6\xb3\x43\x39\x10\x1c\x46\x11\xf8\xa6\x62\xc1\xf5\xb3\xe5\xb5\x6b\x81\x05\x70\x62\x73\xf7\xd4\x13\x67\x1e\xcb\xc1\xb0\x66\x3f\x92\xa3\x0c\xbc\xdb\xd5\x5f\x3e\x87\x53\xc6\x59\xbe\xb0\xf3\x02\x2f\xe5\x7c\xe1\x90\x9b\x56\xd6\xa8\x1a\xb5\x54\xa4\x66\x82\x1d\xe0\x42\x3d\xd4\xc7\x75\xa7\xf1\x30\xf9\x47\x81\x8b\xc6\x36\x5c\x5e\x6b\xff\x6b\xa4\xf4\xc6\x1b\xbf\x37\xb8\x7f\x75\x3b\x49\x33\xb3\x48\xd1\x0e\x54\xac\x66\x18\xce\xd4\x8f\x3e\x52\x09\x23\xa6\x49\x42\x00\x24\xed\x6c\xcc\xa3\x99\xfa\xa7\x9b\x20\x6b\x80\xb9\x1e\x02\xe0\x32\xcb\x1d\xe7\xd4\x73\x14\x3d\x1e\x70\xb5\xb0\x90\x06\x30\x50\xb0\xe0\x4a\x5d\x9c\x0b\x0d\x64\xcc\xb2\xb2\x86\xae\x2c\x43\xed\xd3\x17\x7a\x1f\xe8\x74\x36\x3e\x2e\x5f\xbd\xd0\x0c\x72\x77\xc9\xda\xa0\xfa\xe5\x26\x95\x0d\x1c\x63\x89\xb8\x7f\x61\x67\xe3\x31\xcf\x62\x33\xa4\xe4\x4a\xd3\x63\xd8\xf2\x3e\x3c\x7d\xee\xe3\x69\xa7\xb1\x96\x42\x38\x0d\x80\xc8\xf0\xcc\x05\xe1\x2a\x29\x7f\xa7\xab\xb7\xaf\xe7\xa0\xea\xf4\xa6\x2c\x44\xc5\x8b\x3d\x5d\xc3\x47\x07\x7b\xb4\x77\xfa\xba\x0e\x29\x33\xdf\x28\x38\x91\xcb\x21\x2b\xa0\x50\x7a\xa5\xc6\x95\x45\x5d\xb7\x4b\xc1\xe2\xdc\x4a\x8c\x5d\x50\x1b\x37\xbd\x0e\x98\xdf\x7e\x51\x5d\x79\xcc\xa5\x43\x2b\x4f\xee\xf8\x15\xdd\x2f\x9d\xf0\xb2\x28\x63\x91\x4f\x18\xc5\xf1\xa9\x80\x66\x67\xa7\x89\x90\x28\x9f\x39\x8b\xf7\x7f\xd9\x72\xe6\x62\x4c\x15\x0d\x11\xc6\xce\xde\xc0\x3a\x50\xb3\xfb\xaf\x39\xa4\xc6\x0c\xe8\x4b\x76\x2a\x75\x9a\x91\xee\x6c\x9e\x8c\x1a\x69\xbc\x0a\x1d\xc6\x0a\x93\xdc\xc1\x11\xb3\x78\x4e\xd3\x74\xb3\xc3\x6c\x10\xfe\x1c\xb6\x44\x72\xbe\xa8\x14\x92\x9a\x1f\xbc\x10\xd4\x90\x28\xc2\xcc\x47\xdd\x1c\xe3\xd0\x6b\x5d\x07\xdb\x3c\x87\x75\x33\x6c\xa3\x1b\x77\x81\x2b\xf2\xf9\xeb\x24\x89\x2b\xcf\x1e\x56\xbe\xfa\x01\xad\x38\x94\x7a\x1a\x35\xea\xba\xf0\xd7\x83\x98\xaf\xfc\x0d\xe3\x23\xd7\x67\xc4\x42\x21\x6f\x66\x8b\x96\x8a\x0a\x16\x87\x23\x4a\x04\x34\xb7\x5c\x38\xc0\xa0\xb3\x3e\x37\xb7\x58\x3a\x6e\xa0\x41\x04\xfa\x14\x5e\x6d\x41\x09\x88\x53\xd1\xef\x17\x13\x63\x98\x9d\xa2\xf4\xfa\xa8\x9b\xd7\x1d\x67\x04\x97\x5b\xff\x86\xdf\xf4\xf3\x45\xd4\x99\x70\x35\x64\xb8\x2a\x62\x3b\x16\x96\x16\xc9\xf4\x68\xef\x37\x22\xfb\x42\x28\x8f\x01\x99\x2e\x59\xff\xf3\xb3\xe3\xc9\x3b\x20\xc7\x7b\x26\x9d\x07\x40\x88\xf0\x06\xc5\xb9\x34\x44\x7b\x62\xdf\x21\x94\x04\x93\x0b\x4d\xb0\x25\x34\x15\xaf\xa9\x9e\x84\x6b\x09\x25\x16\x2b\x50\x88\x5c\x04\xf4\xe4\xf2\x9f\xef\x64\x75\x2c\xcc\x27\x8a\x6b\x65\x62\x5a\x80\x88\x88\x2d\x3a\xa7\x6b\x00\xa8\x95\x06\x15\x46\x4e\x95\x88\x45\xc8\x41\x44\x8d\x21\x54\x79\x80\xe2\x92\x20\xd0\xb9\xcd\x4d\xcc\xe9\x32\x4a\x8d\xe4\xb1\xeb\xc4\xb4\x7e\x1c\xee\xfa\x38\x0a\x4a\xcd\xc0\xa7\x8c\x0f\x4c\xca\xd6\x2a\x8a\x5a\x0d\x79\x1d\x38\x0f\x34\xe2\x8f\xf9\x58\x9f\x3a\x5c\x48\xd6\xbe\xc7\xc2\x01\xde\x1d\x96\x9c\x68\x7c\x13\xaf\xdc\xdc\xc4\x94\x1d\xfa\x06\x9d\xb1\x6b\x94\x85\xe2\x56\x6c\xf0\x2b\xb3\x4a\x68\xa2\x47\x62\x61\x9f\x84\x31\x11\x17\x82\x0d\x3c\xf0\xc6\x4b\xe9\x6e\xf1\xdd\xcf\xe3\xc0\x65\xb8\x46\xf7\x6b\x19\xae\x86\x92\x2f\x58\x54\xf5\x02\x43\x48\x25\xc0\xca\xa2\xe6\x5b\xcf\x9c\xe5\xa7\x1c\xfb\x88\x65\x3a\x36\x4e\x81\xcc\xaa\xdc\xda\x14\xe5\xdf\x6e\x6e\x56\xef\x9e\x52\x56\xea\x90\x08\xc0\x6b\x66\x1d\x03\x0a\xa2\xc5\xd2\x0d\x80\x59\xc6\x19\x87\x50\x54\xec\xe0\x6c\x18\x72\xa9\xb7\x88\x95\xd3\xe6\x64\x41\x6f\x6c\x28\x95\x6f\x9f\x57\x5f\xac\xd4\x3d\x94\xba\x8a\x10\x12\xa2\xb4\x45\x08\x19\x3e\xec\x38\x16\x5a\xdc\xbe\xd5\x1d\x16\x2f\x92\x58\x3c\xc2\x8d\x52\x53\x12\xc7\x1b\x22\xaf\x93\x38\xe4\xa5\x5c\xcb\x96\xfa\xa1\x9e\xe1\xe1\xde\x23\x87\xb4\xa1\xe1\xae\xc1\x61\xe5\x6d\x07\x5d\xe1\xdf\x9e\x8c\x6b\xca\x7c\xa8\xaf\xff\xed\xae\x3e\xad\x7f\x60\xb8\xb7\xff\x88\xb2\x34\x87\xf3\xfc\x1b\xd0\xcb\x77\x17\x36\x76\xaf\x2f\x2a\x4a\x73\x1c\x82\xdb\xbd\xee\xfb\x68\xbc\x06\x43\x14\x83\x69\x4f\x69\xe3\x59\x13\xf5\xf2\xf8\x00\x26\x7c\x90\x32\xf5\x9e\x82\xe4\x01\x49\xe2\x05\x9a\xc4\xf5\x34\x42\xcc\x28\xf0\x6a\xcd\xf2\x6c\xd2\xc1\xa9\x8e\xed\x20\x50\x13\xc9\x14\x6d\xe4\x77\xe6\xd5\x04\x70\xf8\x14\x36\x8c\x10\x4d\x9d\xd9\x3f\x05\x87\xee\x71\xa3\x08\x2a\xd8\xb8\x91\x98\x3d\xb2\x7d\xd5\xd9\x38\xe1\x5c\xff\x49\x90\xc3\x19\x44\x14\xf6\xa1\x4c\x1c\x39\xe4\xc7\x6d\xd9\xaf\xa4\xba\x3f\x91\xda\x4c\x75\xff\xc4\xa1\x49\x17\xd8\xce\x4e\x65\xe0\xb2\x60\x21\x07\x04\x49\xd7\x57\x7e\x27\x16\x81\xb8\xa3\xc6\x74\xb1\xdb\x43\x3e\xb9\x85\x86\xe9\xda\x9b\xc8\x0b\x43\xca\x13\xf2\xaa\xba\x69\x1f\xbe\xea\x16\x0f\xf5\x2f\x02\x65\x7f\x07\xca\x21\x92\xf4\xda\x64\x96\xd0\x65\x7f\x2f\x78\x91\xb0\xd6\x5e\x16\x37\xd8\x38\x91\x62\x1d\x73\x30\xce\x7f\xd6\x45\xc1\xaa\x66\xe2\x72\x50\x1d\x01\x71\xce\x5d\x49\x74\xc4\xb9\x78\xc9\x92\xac\xb8\x65\x1d\x0a\x04\x70\xee\x69\x22\xa6\x52\x92\x78\xce\x82\x44\x26\x79\x54\xbe\xb4\x86\x08\x2c\x97\x13\x1a\x22\xf8\x23\x48\x4b\x7e\x52\xed\xf8\xbd\x6a\x47\x1a\x2f\xce\xa3\x8b\xc6\xd7\x31\x3f\xbf\xc9\x16\x2d\xac\x94\xec\x61\x8b\x16\x69\xf4\xf6\x3f\xde\x50\x13\x87\xa5\xca\xc8\x6f\xc1\x31\x93\xe2\x70\xe0\x5b\xa1\xed\xf7\x35\xc3\x20\x6b\xdb\x2c\x5a\x05\x13\x0e\x0d\x00\x90\x20\x1d\xb7\xaf\xb2\x3e\x1a\x13\x7b\x4d\x40\xd2\x13\xe1\x11\x30\xa7\xa9\x3c\xa7\x1e\x6e\xf6\x89\xc6\xe0\x06\xc1\xac\x70\x7c\xba\xb8\x23\xfb\x60\x90\x24\x69\xad\x64\x8e\x6c\x83\xa1\xa5\xdc\xf8\x44\x64\x0b\xeb\x36\x48\x14\x25\xe2\x0e\x18\xe2\x6b\x48\xd0\x9a\x5d\xa9\x21\x93\x7d\x8a\x25\x2b\x8a\xef\xee\x05\x25\xce\xf6\xe7\xe9\x09\x88\x3c\xce\x53\x6a\x4f\xb1\xc4\x36\x8e\xbd\x2e\x34\x69\x00\xaa\x20\xc6\x53\x58\x72\x15\x4e\x2a\xa2\x1d\xd4\x25\x34\xd1\x5c\x84\xbf\x3c\x84\xdf\x1d\x49\xb5\x98\xa3\x75\x85\x08\x40\x74\xa0\xde\x39\xe3\xac\x2c\x25\xae\xed\x20\x6d\xf6\x5e\x29\x35\x49\x44\x88\x86\x4e\x5c\xe0\xa3\xb5\x9b\x5c\x9c\x56\x89\x55\x35\x14\xc4\x50\x87\x6a\xaf\xa7\xd3\xdb\xf4\x17\xae\xb3\x5c\xb0\xd2\x95\x58\x34\xde\xe7\x96\xeb\xb5\xd1\x2d\x9f\x3c\x7a\xb0\x1c\xb9\xac\x74\xc9\x84\x78\x6d\xce\xf7\x82\x09\xb5\x45\x57\x7e\x7b\xdc\xf9\xfb\xfc\x42\x4d\x21\x96\xdf\x1e\xcf\x5e\xf2\x72\x89\xe2\xc8\xde\x8d\xfa\x65\x0e\xae\x35\xa3\x78\xa9\xeb\x77\x8f\xd7\xe1\x6f\x63\x93\xbe\x9a\x3d\xf8\x12\x36\x5b\xab\xb7\x92\x97\x3d\x63\xef\xe1\xfd\x4d\xee\x6d\x98\x9a\x34\xde\xda\xad\xbf\xad\xa9\xda\x1a\xa6\xd0\xb5\x02\x75\x1f\xf1\xda\x22\x5c\x46\x69\x2a\xdd\xed\x05\x5f\x6b\x71\x79\x4b\x81\x4b\x7e\xa5\xbc\xf1\x34\x34\xae\x74\x2a\xe4\x9e\x10\x5a\xeb\xd6\x79\x75\xfd\x24\x43\x0e\xa3\xba\xbd\x30\xe9\x5c\x4b\xde\xc0\x5f\xdd\x38\xf7\x74\x78\x11\x5d\x32\xf7\xc6\x32\x10\xd9\x26\x33\xbd\x6d\x40\x22\xb4\xd5\x97\x07\x99\xb2\x74\x74\xd8\x51\x0d\x3a\x63\x27\x3f\x9d\xe0\x4c\x33\xfd\x61\x7c\x72\xab\xce\x34\x92\x14\xf3\xe4\x28\xe1\x61\x08\xff\xc2\x7c\x87\xc0\xca\xf6\xce\xe6\x57\xe6\x27\x09\x51\x10\xbb\xca\x9d\xeb\x9f\x56\xce\x7f\x16\x18\x4e\xf2\x0c\x52\xa6\xe0\x3f\xfe\xa8\x13\x07\xca\x41\x8e\xd1\xad\x64\xf7\xab\xbc\x07\xad\x6c\xb2\xac\x5a\xb9\x81\xe1\x05\xd1\xf3\x00\xbd\x80\xef\xc6\x07\xb8\xb7\x32\xb8\xb6\x57\xae\x47\xb2\x72\x5a\xa8\xf0\x36\x65\xe0\x53\x8f\xa1\xf1\x6c\x29\x43\xa7\x27\x97\xdc\xe0\xac\x9f\x31\x2b\x33\xd7\x8e\x55\x9d\xdb\xfe\x77\x1b\xe8\x00\xd8\xb1\xcd\xc8\x68\x63\x73\x58\x9e\x98\x82\xde\x60\x19\xe0\xeb\x98\x02\x4e\x2f\x7a\x19\xfd\x75\x19\xd9\x88\x94\x69\xa3\x38\x65\x65\xb4\xd7\x0e\xf5\x0c\xb7\x0f\xf4\x0f\xc1\x7f\x8e\x0e\xb7\x1f\xec\xe9\xeb\x19\xee\x69\x37\x8a\xe3\xaa\xf8\x30\x7a\x17\x75\x87\x1f\xcf\xfd\xba\xb5\x0c\x2f\xc3\xc5\x1b\x5f\xc7\x7f\x8e\xe2\x7f\x19\x84\x56\xb9\xbf\xa2\x0c\x13\x7b\xd7\xb2\x8b\x34\x14\x6e\x1b\x35\x3d\xd7\x61\x97\xc6\x38\x10\x41\x85\x76\x67\xe3\x79\xf9\xbb\x6b\x9c\x38\xe6\x77\x8f\x92\xdf\x4c\xc6\xe6\xda\xea\xb8\xe9\xd9\x6b\x22\x69\x50\x84\xe8\x4c\xe9\xf8\xa7\x88\x86\x50\x0e\x3e\x12\x54\x02\xda\x92\x48\x69\x1c\xb7\xa6\xb1\x13\x93\x17\x4e\xa6\x1d\xec\x3f\xdc\xd5\x7b\x84\x02\x49\xa9\x70\xf8\x9c\x44\x1d\xe6\x98\x98\xca\x76\x6f\x7b\x84\x91\xe3\xb3\x9a\xc0\x89\x2b\x3b\x03\x9b\x27\x00\xb9\x05\xbc\xec\x3d\x32\x34\xdc\xd5\xd7\xd7\x73\x50\x1b\xe8\x3b\x7a\x08\x46\xd0\xdd\x7f\xf8\x70\xd7\x91\x83\xaa\x2c\x15\x8c\x4a\xa5\x8e\x5a\x28\x2d\x25\x47\x49\x5c\x5f\xbc\xde\xc9\x1c\xe6\x8a\x06\xca\x54\xa8\xc0\xff\xf2\xa2\x72\xee\x76\xa8\x36\x85\x02\xaa\xd8\xe8\x5e\xb1\x06\x51\xf8\xc4\xdd\xf9\xb1\x3d\x03\x41\x28\x71\x6f\x00\x6c\x87\xbe\xba\x58\x3e\xf9\xbd\x28\xda\x40\x85\x51\x94\x08\xad\x02\x96\xef\xd1\x8e\xda\xfa\xa4\x81\xfd\x12\x54\x21\xb6\x5f\xad\xc3\x26\xc6\xc0\xbd\xfb\xdf\x54\x6e\x6e\xd2\x93\x69\x40\x76\xa6\x87\x49\x91\xed\x69\xc1\x6a\x5d\x39\x3f\xdf\xd7\xb4\x35\xea\xf7\x42\xae\x43\xd1\x66\x91\x1e\xce\xce\x69\x06\xf0\xd4\x82\xe5\x56\x1f\x21\x9c\x85\xbb\xbb\xb0\x59\xa6\x98\x45\xaa\xf7\x7f\x97\x7f\x75\xd6\x1e\x01\x6f\x77\x5e\x9c\xa9\x8f\xde\x6e\xaf\x68\x57\x0e\x56\x71\x56\x9f\xb4\x41\xa0\x7d\x30\x6e\xe4\x8b\x5a\xc7\xc4\xeb\x58\x27\x1e\xe9\x1e\x13\x15\xf4\x61\x7b\xcc\x4e\x61\x08\x32\xb7\x22\xd4\xa6\x4b\xd9\xa2\x99\xcf\x1a\x1c\xbd\xc6\x9e\xc9\xe0\xea\x53\x1d\x57\x11\x63\xdb\xbe\x1a\xae\x94\x42\xfd\x0c\x9d\x5b\x97\xb1\xe5\x41\x30\x57\xdb\x8f\xa3\xbf\x7d\x01\x41\xb9\x1d\x47\x38\xa9\x0b\x84\x6b\xc7\x84\x86\xf5\x58\x6f\x9d\x07\x91\xaa\x8c\xdf\xae\xe1\xc6\xbb\x3d\x5d\x7d\xc3\xef\x8e\x76\xbf\xdb\xd3\xfd\xc7\xd1\xe1\xf7\x06\x7a\x60\x84\x36\x0d\x7f\x64\x1f\x16\x98\x1b\xd9\x87\x33\x39\xb2\x2f\x67\xe5\x8c\x91\x7d\x23\xc0\xe7\x3a\x26\xaf\x16\xb8\xf3\xcb\xe2\xee\xf5\x65\xcc\x8c\xf3\xc0\xc3\x94\x86\xe1\xa7\x23\xfd\x88\xe5\x2f\x3c\xf7\x54\xa8\x6b\x6d\x61\x80\x2f\x65\x72\xef\x3c\x7f\xbe\xf3\xe2\x1c\x2f\xb5\x3a\x56\x92\x8a\x00\x52\x1e\xe1\x89\x3a\xeb\x4f\xd4\xc0\x1f\x74\xf3\xe3\xdb\x60\xb1\x51\xb7\x48\x0c\xa6\xf3\xff\xa0\x28\xa1\x36\x54\x9a\x5c\x32\xec\xba\xc6\xcf\x83\x4f\x80\xce\xb9\xf1\x75\xf3\x26\x86\xf6\xbd\xa0\xb8\x05\x74\xba\xbe\x32\x2f\x08\xb8\x05\x74\x46\xc0\x6c\x96\xce\xae\x81\x01\x6d\xa8\x67\xf0\x58\x6f\x77\xcf\x28\x1d\xb0\x47\xba\x7b\x9a\x26\x34\x12\x68\x0b\x28\xe5\x76\x3f\x28\x6d\x85\x0e\x93\x92\xd0\xa6\x50\xd5\x4a\x9d\x16\xb0\x87\xc1\x3b\x5f\xac\x46\x80\x6f\x29\xa3\xf6\x62\x6e\x7d\xe2\xf7\x70\x92\x7d\x32\x1b\xa6\x50\x26\xa6\x15\x84\x34\xc5\xae\x66\x39\xf3\xf6\xd1\xde\xbe\x83\x03\x5d\xb0\x48\x10\x5c\xbb\x76\xa4\xe7\xdf\x46\x83\xdf\x35\x3d\xb5\x41\x70\x70\x8b\x8b\xc0\xd1\xec\x30\xdc\x8d\xdb\xc4\xd2\x6c\x14\x25\x15\x86\x49\x31\x97\xf5\xc2\xef\xeb\x7a\xbb\xa7\xaf\x5d\x1b\x18\xec\x3f\xd6\x7b\xb0\x67\x90\xc6\x36\xdc\xff\xc7\x9e\xd4\xe2\x49\x39\x21\x04\x19\xef\xd4\x2e\x68\xdc\x73\x0c\xba\xd9\x79\xa8\x21\xba\xd5\xa4\x36\x4b\x60\xff\xe0\xa1\x80\xa4\x6f\x86\x38\x84\x85\xac\x13\xb0\x5a\x4d\x5a\x93\xac\x6b\x3d\x75\x42\x44\xfc\xeb\xd1\xfe\xe1\xae\x56\x90\xe7\xca\x03\x06\xd8\x2c\x81\x83\x3d\x03\xfd\xfe\x01\x85\x8d\xad\xf7\x68\xe3\x0f\xf5\x74\x1f\x1d\xec\x1d\x7e\x6f\x94\xda\x38\x13\xb6\x81\x2e\x38\x6b\x87\xfb\x47\x31\xb1\x77\x74\xf0\x68\x5f\xcf\xd0\xe8\x3b\xbd\x7d\xcd\x8b\xce\x10\x2a\x9c\x4e\x15\xaa\x66\xd9\x17\x44\xd5\xee\xad\xc6\xa1\x81\xae\x16\x1c\xef\x41\xe8\x30\xe7\xee\xea\x64\xf0\xcd\x13\xcf\x32\xff\xed\x41\x90\x62\x83\x7c\x8a\x05\xbf\x6b\xc1\x08\x64\x70\xe2\x14\x0b\xe1\x68\xf5\x30\x8e\xc2\x17\xbc\xe7\x06\xba\x86\x86\xfe\xad\x7f\xf0\x60\x7b\x3d\x0b\x3b\xfd\x58\x5c\x44\x28\x69\x05\x26\xfc\x16\x50\xb5\x6a\x48\xde\x69\xec\x7e\xf1\xc7\x9e\xf7\x5a\x36\x8e\x48\xe0\x2d\xa7\x1c\x77\x83\x3c\xe9\x2d\xd3\x7d\x6b\x00\xe2\xc6\x88\xc4\xb4\x27\x63\xda\xd3\x19\x91\xd5\xf9\x96\xcc\x4a\xff\xd1\xc1\xee\x9e\x0e\xbc\x0a\x0e\x77\x0d\x1e\xea\x19\xa6\x3f\x9b\x26\x3b\x12\x6a\xd3\xb4\xb2\xe8\x6c\xdd\x91\xce\x00\x5b\x78\xa8\xfb\x14\xb6\xe6\x50\xf7\x09\x6c\xcd\x99\x4e\xf0\x3a\xfc\x5b\x27\x7d\x24\xd0\x1d\x2d\xb9\x9a\x48\xf0\xbd\xc3\x48\x86\xdf\x12\xfa\x59\x29\xa1\xfd\xec\x7f\x6c\x09\xe5\x91\x90\x5b\x48\x73\x93\x97\xd4\x16\x12\xe5\x9f\x84\xa0\x38\xb4\x6b\x83\xfd\x2d\x50\xae\xa4\x43\x0f\x80\xc2\x7f\x09\x6a\x8b\x29\x25\x1e\xec\x15\xc1\x04\xbc\x55\x84\xa7\xbb\xc5\xaa\x88\x6b\x02\x6f\x3e\xcf\xbe\xe7\xe6\x56\x9b\xec\x88\x60\x57\x6e\xd3\x0c\xc9\xe7\x47\x91\xb0\x76\xe1\xb9\x1d\x0d\x53\xd9\xd0\x24\xba\x50\x61\xda\x64\xb0\x4d\x13\xdb\x04\x4d\x8d\x63\xf5\x2a\x08\x08\x46\x51\x09\x1c\x94\xd4\x79\x51\x85\xb6\x69\x76\x05\x31\x00\xd3\x08\x05\x0a\x6b\x0f\x45\xb3\xac\x9b\xb2\xec\x22\x11\x2d\x1a\x6c\x35\x4b\x32\xc1\x43\x0a\x05\xbc\x66\xe9\xb3\xb2\x19\x69\x93\x00\x9d\x39\x63\x36\x72\xd7\x34\x42\x6d\x75\xf9\xb3\xda\x9d\x83\xd1\xfd\xe7\x1f\xb5\x7e\x47\xe1\x48\x30\x9e\x86\x17\x0b\x0e\xc3\xfd\xd4\x82\x61\x70\x04\x0d\x13\x8a\x09\x1b\xe7\x1f\xc9\xdf\x34\x4d\x7a\x61\x72\x0f\x84\x81\x0b\xb5\xc5\xc2\x40\x04\x96\xb6\x07\x62\x80\xdb\x6b\xb3\x7e\x9b\x24\x9f\xe3\x40\xbd\xe4\x18\x0e\xfa\xf5\x3e\x72\x7e\x6f\xd3\x43\xa1\x98\xc2\x16\x9c\x0f\x1c\xd8\xd6\x9a\xc5\x30\xf3\xa6\x7b\x35\xc3\x3f\x3d\xdb\x24\xfe\xdd\xd7\x75\x44\x9b\x79\xcb\xff\xf9\x2d\xfe\xaa\xd9\x85\x52\x3f\xc6\x86\xc6\xa8\xaa\x51\xe4\x51\xc4\x04\x2a\x8b\x35\xf8\xe0\xdc\xb2\x81\xd3\x7a\xf1\x80\x5f\x6a\x1e\x8d\x56\x58\x61\x0d\x6b\xe0\x8f\x14\xe1\xff\x72\xc7\xf4\xac\x99\x11\x4f\x73\x51\x35\x7d\x3a\x4f\x3d\x5c\xde\x1f\xc9\x01\x74\xfc\x8f\x86\x6e\xf8\x82\x55\xb4\xc6\xad\xec\x08\xa0\x19\xd9\x57\x1c\xcf\x8f\xec\x6b\x77\x7f\xcb\x50\x13\x0b\x22\x96\x7f\x7e\xf3\x8d\xce\xb7\xfe\xf0\x87\xce\x37\x3b\xdf\xfc\x9f\xd2\x63\xe8\xc9\xb7\xf9\x81\xdf\xff\xfe\x8d\x7f\x1e\xd9\x87\x3f\x00\x21\x7f\x52\x0c\x9a\x88\x2a\x5f\xdf\x02\xf1\xe7\x8d\x1f\x0b\x8f\x8b\x5a\x6d\x97\x23\xc7\x83\x85\x85\xce\x61\x5f\x72\xd1\xbd\x88\x1e\xae\x3c\xfc\x04\xb6\x02\x15\x95\x7e\x89\xa3\x52\xcc\x10\x97\x33\xeb\xee\xeb\x15\x49\xe3\x75\x5a\x45\xe9\x75\xa9\xc1\xd8\x87\xd8\x7f\x1c\xff\xe2\x26\x45\x89\x09\x04\x14\x3a\x15\x6e\x29\x17\x86\xa0\xc6\x0d\x62\x4b\x15\xd0\x44\xf2\x26\xfe\x55\xed\xb0\x31\x6d\x15\xe6\x62\x21\x54\xd7\x2f\x96\x3f\x7d\xba\x7b\x4f\x19\x74\x25\x40\xb9\x11\x28\xba\x96\xb3\x72\x1d\x39\x63\x12\xe0\xcc\x18\x6e\x8b\x80\x58\x14\x5e\x7c\xc9\xee\xd7\x57\xab\x8f\xaf\xc3\x0e\xe5\x2a\xfd\x2a\x8c\x33\xb4\x49\x68\x41\x45\x35\xe6\x51\x6d\xda\x9a\x16\x4b\x0c\x82\xe3\xbc\x30\x4c\xe7\xdc\x72\x3c\xc6\x41\x51\x41\x15\xff\x8d\xe9\xd8\xe2\x16\x47\xe5\xc7\xb4\x34\x90\x87\x86\xfa\xb4\x6e\x43\xb4\x91\xc5\x48\x14\x2c\x8f\x4f\x31\x29\xc3\x66\xfe\xb0\x61\xc7\x06\xa6\xb8\xcf\x53\xd1\x55\x84\x54\xfe\xf4\xf3\xea\x7d\x31\xa2\x5a\x20\xb1\x84\x70\xd5\xff\xa6\xb8\xea\x57\xfc\x4f\xcd\xd8\x14\xfd\x8d\x18\x0c\x82\x97\xf2\xac\x62\x04\x2f\x03\xa6\x9a\x77\x93\x25\x51\x58\x10\xc4\xcb\x8c\x99\x11\x51\xa8\x1d\xe3\x14\x47\xd6\xa9\x0d\x64\x0d\x1d\x86\x2a\x7e\x84\xf5\x2b\x2d\x2f\x6b\xec\x2f\x28\xbd\xa9\x99\x1a\x91\xe8\x46\x07\x03\xe0\x22\xe8\x27\x54\x11\xad\xf6\x05\xe5\x9e\x3f\x73\x76\x67\xfb\x4a\xe5\xc9\x1d\xc4\xce\x31\x60\x38\x22\xaa\x24\xc8\x03\x84\x23\xae\x7a\xef\x24\x3f\x17\x92\x9d\x95\x95\xef\x76\x9e\x3f\xe5\x70\x3a\x67\x75\xd1\x39\x7b\x8f\x1f\x90\x7f\xdd\xf9\xf9\xa4\x10\xb1\x6e\x69\xcc\x98\xa0\x32\x26\xdb\x6f\x54\x86\xa1\xfd\x58\x2b\x83\x03\xe0\xdb\xb4\x0e\x57\xa6\xd1\x23\x19\x0b\x4e\x7a\x0c\xb2\xa3\x3a\x9f\xb1\xab\xa1\x06\x92\xd7\xce\x8c\x07\x09\x90\x65\x89\xc7\x3f\x61\xe5\x4f\x2a\xef\x99\x40\xae\x69\x1f\xe7\xdc\x14\x3a\x41\x0f\xc2\x47\x91\xde\x52\x5f\x75\x60\x6f\x3d\x55\xbe\x59\xa8\xdc\xbc\xb6\x7b\xe9\xec\xee\x8d\x53\x7c\x8a\xa5\x80\xd9\x24\x89\x2d\xa2\x2a\x89\x10\xae\x2c\xd5\x41\x95\xa5\x3a\xa8\xb2\x54\x5e\x2f\xe8\xd3\x44\x15\xff\xd6\x8d\x3f\x71\x8d\xfb\x24\x8a\x22\xa0\x39\x67\x3e\xe6\x82\xc0\x91\xf0\x62\x49\xf3\x74\xee\x71\xab\x94\xe3\xee\x4f\xee\x49\x62\x77\xe3\x57\x38\xca\xde\xc0\x43\xd2\x09\xc3\x77\xdd\xc4\xd3\xc5\xa3\xdd\x3d\xc9\x96\x3d\x72\x6b\x91\xc9\xcf\x78\x07\x12\x1c\xd2\x69\x8e\x22\x6f\x34\xd3\x74\x9e\x6a\x59\x73\xda\xe4\x41\xf1\x01\xdb\x87\x9f\xeb\x99\xfe\xd0\xd1\x0b\xeb\xc0\x59\x7e\xca\x94\xab\x20\xa6\x22\x30\xc0\xe8\x00\x8b\x9b\x65\x6e\x90\xad\x3e\x43\x1b\x65\x65\x32\xa5\x59\xcc\x48\x2e\x4e\xe9\x39\xf9\x49\x31\x9d\xad\xa0\xd9\x79\x74\xa6\x7c\x7e\x2b\x0a\x78\xec\x00\x48\x4d\x4e\xca\x15\x11\xa7\xa6\x57\x03\x8e\x44\xb8\x2c\x22\x13\x4f\x36\x37\x7a\xb9\x53\xf3\x1b\xae\xc0\x97\xaa\xc2\xa3\x72\xc8\xb2\x77\xd2\x88\x8e\x2b\x6b\x1f\x63\xb9\xa5\x47\xa7\xca\x17\xaf\x27\xe0\x8c\x58\xdd\x75\x2f\x6d\xd5\xa2\xae\x73\x45\xb7\x6a\xa7\xb5\x6e\x8f\x29\x28\x6a\xf8\x60\x8a\xa1\xac\xc1\x83\x49\x2e\xbc\xa4\x4d\x96\xcc\x0c\x91\x79\x08\xfe\xa8\x3b\xe8\x99\x01\x62\xf9\x5d\x2a\x69\xec\x1d\x2b\xc3\xfc\x4d\x3d\x33\xc0\xad\x9f\xe4\xb3\x24\x0a\x48\x2c\x1d\x7e\xe5\x45\x6a\x0f\x1b\xe8\xf1\xc2\x6d\x62\x87\xa8\x85\x0d\xdc\xae\x53\xb5\x9b\xf3\x0f\xbd\x08\x78\xa2\x3c\x63\x0c\x50\x15\xad\x66\x91\x0d\x96\xb0\x77\x41\x15\xe7\x9c\xba\x76\xfa\xc6\xe0\x22\xfe\x13\xa2\x50\x3b\xd7\xd6\x14\x75\xd4\x29\x7b\x50\x69\x22\xd9\x3d\x31\x8f\xed\xca\xbe\x58\xe5\x34\x7f\x2f\x37\x0e\x1b\xda\x3c\xbf\xed\x9c\xf9\x4c\x94\x8c\xe7\x82\xe9\x94\x0a\x88\xea\x05\x95\x7c\x57\x5b\x41\x14\xa4\xda\x46\x16\xd5\x61\xfc\x61\x1c\x04\xef\x24\x5b\xd2\xc4\x18\xb0\xe7\x92\x9d\x37\xb8\xe8\x34\xed\x02\xbb\x6e\xaa\xff\x3e\xbf\xb0\xbb\xb0\x81\x29\x80\x5f\xac\x62\x59\x56\xec\x86\xf8\x33\x97\x82\xe7\xd1\x70\x9f\xea\xf2\xd3\xe5\xea\xe3\xe7\xbc\x2f\x54\x83\xe8\xd3\xe1\x98\xe8\x87\x89\x63\xa4\x8a\xfb\xe7\xca\xa9\xf2\xf7\x37\x76\x5e\xac\x95\x6f\x2b\x72\x7c\xfa\xb0\x07\x12\x5a\x08\xdc\xc2\xc7\x7e\xab\x30\x9e\x19\x15\xe4\xe5\x0b\xce\xd2\x66\xe5\xca\x03\xd4\xf1\x89\xed\x22\x59\x9c\x8b\x2d\x4b\xb6\xe4\x24\xbc\x33\xba\x99\xa5\xd5\x21\xb4\x71\xd1\xbf\x5e\x59\xde\x9a\x10\x8b\x1a\x7a\x67\x1e\x22\x9a\xf4\x89\x59\x4a\xac\x34\x74\x4e\x64\xc3\xec\x1a\xa9\xa4\x1e\xf5\x1c\xe7\x77\x32\x19\xf9\x27\x53\xd9\x70\x20\x01\xb7\x5f\x87\x39\xcd\x10\xa5\x12\xcc\x09\x70\xb1\x2e\x62\x0a\x88\x6c\x26\x4f\x80\x25\x4a\x9c\x89\xf5\x30\xce\x79\xac\x22\xd1\x57\xe4\xd8\xb9\x5f\xca\x35\x61\xe2\x17\xcb\x99\x6d\xac\x5b\xcf\x0d\x4b\x96\xcf\x8b\x8f\x44\x8d\xbc\x76\xf8\x5e\x97\x40\x5f\xa8\x0e\x59\x1a\x46\x26\x96\x17\x93\x80\x07\x0d\xe7\x2d\xdc\x17\x92\xa9\x3c\x89\x08\xaf\x3a\x80\x4e\x59\xc9\xf1\xf8\x6a\xb8\xc8\xb8\x93\x70\x70\xfe\xfa\x6b\xba\xb0\xbb\x9b\xd8\x75\x2c\x5f\xe0\x66\x90\x9c\x38\xa6\xd9\x73\x76\xd1\x98\x6e\x17\x69\xc6\x64\x10\xc8\x61\x13\x79\x94\x3b\x98\x02\x2f\x7e\x06\x45\xb5\x88\x69\x6a\x5a\xa1\x44\x05\xe2\x95\x79\xaf\x81\x39\x21\x23\xfd\xaf\x5b\xcb\xfc\x07\x68\xd1\xb0\xa3\xb9\xa1\x7a\xa8\x86\x3c\xa8\x72\xce\xe2\x32\x6f\x06\x61\x01\xa0\x82\x2f\xf8\x2e\x65\x33\xb2\x8c\x73\xbf\x54\xe7\x0b\x7b\x63\xa7\x96\xa0\xb4\xa3\x85\xdc\x49\xb1\xb1\x03\xb4\x3f\x7b\x8c\x3d\x0c\x6e\x5e\x0d\x89\x1f\xaf\xb6\x66\x0a\xfc\x52\x21\x41\x69\xca\xad\x89\x86\xf7\x16\x2f\x83\x9f\x4f\xca\x6b\xa0\xbe\x8d\xe5\x25\xc2\x53\x46\x69\xdd\xcb\x2e\x21\xdd\x9e\xd1\x78\xb2\xd7\x9a\x98\x30\xa8\xf5\x9e\x8b\x50\xaa\x06\x13\x8b\x98\xab\xb5\x88\x12\x06\x74\x08\xa0\x3d\x69\x69\x65\xf7\xfa\x22\x6c\xbd\x54\xb8\x59\x96\xb9\xbd\x8a\x44\x39\x90\x78\xa4\xee\x69\xc3\x7c\xc5\xeb\xcc\xe6\x59\xae\xf5\x91\x0a\x63\x09\x0d\x94\x75\x21\x62\x6e\x26\xa2\x90\xea\xee\x4b\x52\x2a\x71\xf2\x58\x46\x49\x53\xc8\xb5\xf3\x63\x10\x79\x05\x85\xf5\x1a\x19\x19\xbf\x63\x24\xb1\xe7\xd5\xf9\x8d\xc1\x13\xa8\xa0\x1a\x0b\x39\x54\x0c\x35\x06\x66\xb8\x72\xa5\x60\x96\xe8\xa4\x19\xfe\x95\x3a\x60\x95\x72\xb9\x50\x1f\xe3\x84\x79\x93\x8e\x98\xdd\x2b\x9f\x22\x53\xbf\xc2\x6e\x3e\x91\x12\x2d\xe5\x79\xa4\x22\xbb\xa8\x4f\x72\x4d\xa1\xa2\x5b\xa8\x3e\x1d\x8d\x95\x67\xeb\xd5\xfb\x0f\xcb\x2b\x5f\x82\xd8\x94\x69\x6c\x94\xba\x40\xfd\x34\x9b\xab\x69\x24\x88\x4f\xa9\xcc\x19\xab\xbb\x69\x10\xf8\x35\xce\x52\x00\x97\x6d\xe8\x29\x80\x8b\x2a\x65\x69\xa8\xae\xa9\x38\xa6\x06\x8f\xd3\x23\xfc\x67\x70\xc8\xb0\xcb\xcb\x4e\xf4\x97\xf1\x42\x52\xd4\x1c\x50\xfa\xca\xfa\xb0\x6f\x95\x86\xbe\x41\x5c\x0d\xb3\x7a\x21\xe3\x2a\xb3\xa2\x23\xba\x36\x3c\x05\x87\x3b\x3a\x04\xe8\x90\x1e\xc3\xce\x4a\x13\x66\x0e\x08\xa3\xae\xd6\x64\x66\xb2\x60\x1b\x2b\xa9\xa3\x06\x56\xce\xb5\xeb\xd5\x17\x2b\xbb\x0b\x57\xab\x77\xce\x94\xaf\x6f\xfd\x7d\xfe\x44\xf9\xfe\x2d\xb6\xf3\x83\xcc\xc2\x1b\x0c\xdc\xc1\xb6\xbf\x73\x6e\x5d\x86\x5b\x87\xd2\x32\x0f\xc4\x1e\xa7\x45\xec\xb7\x9c\xc6\xee\x6e\x05\x6a\x40\xc1\x7d\xe5\x95\x27\xf0\xee\xe9\xf3\x80\x43\x56\x8a\xf9\xea\xb4\x7b\xf1\x71\xf9\xfe\x4d\xee\x2e\xaf\xc2\xca\x55\x5e\x34\xa5\x0b\xd4\x79\xb4\xe4\x1d\x5f\x95\x4b\xcf\x9d\xc5\xdb\x09\x90\x2c\x75\xb5\x85\x10\xa8\x25\x45\x2f\x23\x00\x35\x09\x73\x60\xe0\xc5\xda\x56\x79\xe3\x71\x1d\x6f\xad\xa0\xdc\x8c\x6f\xaf\x8d\xc0\xa8\xc8\x41\xa9\x98\xb4\xcc\x98\xa6\x98\xe5\x34\x39\x59\x40\x0f\x27\x48\x16\xb7\x53\xb4\x57\x43\x81\x7c\x29\xec\x78\x8a\x2b\x6c\xc1\x5e\x1f\xd0\xd5\x40\xc4\x70\xa5\x04\x4d\x06\x0b\xab\x69\xf7\xf9\x55\x15\x7a\xeb\x38\x15\xe5\xc9\x93\x7d\x02\x91\xb0\xaf\xb8\xad\xb6\xe0\x79\xd0\x13\x13\xbf\xb7\xb6\xaf\x7a\xca\x59\x8d\x0b\x07\xcb\x62\x3c\x02\xbd\x69\x3b\x8c\x32\x9a\xc4\xc3\xd8\x1f\x4e\x07\x36\xe4\xe7\xdc\xfe\x57\x42\x91\x18\xb7\x32\xc2\xaf\x88\x0d\x9c\x42\x9d\xb2\xf5\x9c\x05\x0b\x1f\x1b\xca\x1f\xcd\x91\x7d\xd7\x9a\x81\xb9\x37\x41\x0d\xcd\xb5\xf3\xa5\x0a\x00\x76\x78\x90\xb8\x26\xc4\xac\x49\x55\xe6\xb9\xd9\x16\xa9\xad\x3e\x50\x65\x2f\xbd\x47\x4b\x81\x78\xae\xd3\xd7\x9c\x6f\x4f\x56\x6e\x6e\x61\xf9\xf9\x6b\x67\x43\x85\x1c\xaa\xb7\x96\xaa\xdf\xbc\x70\x96\x1f\x39\x67\xee\xec\x6c\xcc\x87\x7e\x45\x43\xea\xa5\x5b\xbb\x5f\x5f\xdd\xd9\x5c\x86\x9d\x86\x93\x7a\xe6\x0a\xec\x3a\xe7\xec\x1d\x67\x65\x29\x40\x31\x5f\xbd\x01\xb7\xaa\xc1\x97\x52\x26\x08\x7e\xe2\xb6\xea\xf0\xdc\x98\xb5\x01\x4c\x9e\x2e\x05\xbc\xec\x7e\x87\xee\x19\xaa\x4d\xf3\xe0\x4b\xbf\xd7\x2f\xbb\x25\xbd\x0a\x9b\x6c\x04\x07\x81\xb5\x7d\x05\xa1\xc8\x04\xc6\xf5\xf7\x22\x1a\x49\x6e\xd1\x79\xd1\x66\x07\xe2\xad\x60\x2e\x73\xd9\x39\x6d\xc6\xb4\x4d\x24\x10\x6b\xe4\x04\xf4\x31\x1c\x4f\xcc\xbd\x51\x85\x52\xaa\xe1\x21\x7a\x63\x02\x9c\x12\x1d\xb7\x13\xa5\x2c\x20\x84\x6b\x97\xba\x72\xcd\xee\xf5\x4f\x9d\xe5\xef\xb0\x20\x95\xd4\x0b\xbd\xb6\x1d\x26\xec\x52\xa5\x54\x09\x92\x60\xda\x52\xb7\xc4\x90\x75\x20\x63\x62\x28\x10\xec\xca\x76\x60\x48\xc0\xe7\x6c\x98\xb8\xea\x45\xeb\x30\x8e\xee\x02\x11\xe0\x9a\xf8\xd5\x15\x6b\xc4\xad\xe6\xca\x83\xdd\xd5\x4f\xb0\xad\x8d\xdb\x3f\xb1\x86\xf6\x55\xdf\xa9\x5c\x13\xc5\x58\x5e\x3e\x2f\x3f\xaf\x1a\x65\x5e\xdc\xc8\x2c\x57\x9f\xe6\xbe\xf9\xa6\x1d\xd7\xee\x0c\x76\xd9\xf5\x9f\x59\x6d\x66\x07\x43\x75\xe9\x47\x3c\x12\x13\xcd\x5f\x87\xf5\x0f\xb4\x59\xdd\x2c\x72\x87\x37\xb7\xd5\x90\xb7\xd0\x69\xaf\x97\xf2\xed\xd4\x2d\xdf\xcc\x95\xd4\x07\x62\x60\xbc\xbc\xb0\x69\xd7\xd1\x6a\x9f\xdf\x3d\xf7\xac\x72\x7f\xc5\xd9\xc6\x76\xd7\x70\x65\xc1\xdb\x32\x68\x30\x67\x2f\x2a\xaf\xc7\xb5\x74\xf9\x87\xb4\xd0\x39\x53\x10\x25\x9f\xcf\xb2\xc2\xd9\x38\x51\xe6\x74\x69\x5a\xd3\xa7\xc9\x4f\x0a\xf2\x56\xf8\x22\x78\x41\x79\x02\xd6\x77\xba\xc2\x0f\x53\xfa\x8c\x5b\x14\xec\xcd\x37\xde\xfa\xc3\xe1\x76\xed\xcd\x43\xf0\xff\x6f\x1c\x52\x19\x26\x22\x38\xc9\x3a\xcd\xe2\x33\xbc\x4b\x4b\x0e\x0b\xac\xfd\xb3\x74\x66\x67\xe3\xb3\xdd\x4b\x67\xfd\x02\x62\x84\xe5\xef\xf3\x0b\x6f\x62\xa8\x3e\xe0\x79\x59\xc3\xe9\xd4\x3a\xde\xc4\x23\x11\x4e\x08\x6a\xe0\x05\x0f\x97\x72\x64\x9f\x46\x9f\x19\xe1\x50\x2a\x03\xad\x1f\x32\x48\x78\x20\x67\xe7\xf9\x37\xd5\x1b\xeb\x95\x4f\x6e\xb0\x0d\x9b\xdf\x8e\x11\xfe\x2f\x9d\x21\xda\x6b\x07\x8d\x09\xbd\x94\x2d\x1e\xf0\x7f\x7b\x89\x0b\x23\x9e\x4b\xf0\xea\xee\xf5\xb3\x78\x37\x22\x4f\x8c\xf7\x40\xe2\x8a\xa2\x4d\xfb\x1a\x5a\xb2\x0d\x50\xd0\x32\xf6\xeb\xb4\x83\x31\xf6\x0f\x64\x19\x6d\xeb\xd0\x5d\x91\x05\x4d\xbb\x46\x5a\x89\x08\x84\xd2\x6c\x14\xd9\xc2\xf5\x65\x83\x94\x9e\xa3\x37\x54\x51\x74\x08\x5d\x6c\x67\x99\x4f\x9e\x10\xa2\x3d\xee\xb3\x04\x14\x88\x6f\xbf\xc0\x48\xd5\xf3\x0f\xe0\x34\x22\x4b\xdd\x2a\xb0\xb3\xfa\xf1\x8b\xf2\xda\xc7\x5c\x45\xca\x59\x7c\xba\xf3\xfc\xbc\x1f\x72\x05\x9a\x22\xb9\xd0\x14\x63\x97\xdc\x92\x62\x3d\xbc\xf5\x4f\xff\x8c\xcb\xc1\x5d\x15\xaa\x79\xad\x71\x40\xba\x13\x86\xef\xd3\x54\xb9\xf3\xa6\x66\x3c\x47\x9d\x09\x77\x68\x7c\x18\x1b\x9e\x40\x0b\x0f\x5d\x37\x67\x6c\xb4\xda\x61\xea\x15\x6b\x44\x18\xa2\x3d\xc5\x32\x50\xee\xd9\xd7\x2c\x63\x0e\x2a\x59\xf7\xf1\xb4\x40\x29\x92\x9b\xbb\xcc\xc2\x01\xe6\x6b\x81\xd2\xaf\xd1\x84\x62\x7a\x92\x0a\x25\x1d\xbe\xea\xd7\x94\xfd\x51\xe9\x3d\x45\x67\x54\xd4\xd6\x1b\xc1\x47\x1a\x07\xa8\xe9\x20\x16\x26\xe1\x6a\x6e\x14\x02\x3e\x9e\xba\x54\xb2\x04\x58\x58\x98\x4d\x74\x8d\xf6\xdd\x49\xc2\xc2\x0c\xba\x04\xb5\xe1\x35\xea\xab\x8b\x78\xc4\x98\xd5\x06\x44\xa9\x26\x95\x88\x02\x65\x3b\xa6\xad\x2b\x42\xc8\xa9\x59\x87\x6f\xc7\x71\xcf\xd2\xfe\x87\xcd\x2a\x9f\x0a\x80\xab\x98\xc1\x83\x4a\x18\x5d\x03\xbd\xfe\x65\xd2\x36\x40\x06\x1f\x05\x15\x11\x6f\x5b\x70\x2f\x34\x73\xc3\x66\x1e\xef\x61\xc2\xc7\x0d\x0f\x8b\x2f\x50\x0b\x63\x83\x26\x2c\x74\xf7\x7d\xb5\x99\xe2\x2e\x9b\x94\x08\x1b\xdf\x31\xb1\xa6\x1a\x69\xf5\x35\xb8\xb0\xc8\x5b\x00\x19\xca\xa2\x47\x4b\x6c\x18\x05\x38\x20\xa6\x3c\x10\xca\x61\xe9\xe3\x7c\xb9\x83\xcb\x41\x0e\xee\x75\xef\x59\x25\x8e\xe0\xc9\x70\x7b\x75\xd7\x34\x86\x5b\x14\xae\x71\xe2\xa6\x30\x51\x5b\x4c\xdd\xdd\xd0\xae\x33\x80\xbb\x9c\xe5\xa8\x36\x6b\x4e\x03\x79\x00\x5c\x93\xda\x14\x78\x8f\x88\x2a\x81\xb8\xe0\x02\x05\xc5\xe1\xc7\x18\x2e\x95\x4f\xdf\x70\xce\x9c\x17\x25\xe6\x4e\x9e\xdb\x79\xb1\x86\xc6\x9c\x13\xeb\x22\x34\x88\xfa\xbe\xcb\xee\x42\xd0\xbe\x6b\x49\x66\xf9\xe0\xb9\x1b\x84\x18\xb9\xfc\x89\xd7\xc2\x80\xca\x03\x3e\x75\xb6\x57\xcb\xa7\x97\xab\xcb\x4b\x32\xc0\xe0\x63\xcb\x01\xd2\xf9\x89\xe4\xba\x81\x75\x71\x5f\x30\x68\x00\x26\x40\xa0\x21\xd1\xf9\x9f\x6d\x2a\x42\x63\x7c\x25\x73\x92\x37\x15\x1b\xdd\x35\xb6\x60\xd1\xd8\xe0\x86\x6e\x78\x3f\x7b\xf6\x9b\xe7\xb7\xf9\xc9\x38\xc3\x12\x11\x97\xf7\xfa\xbb\x8a\x3b\x2c\xc5\xc0\x08\x63\x4f\x5d\x72\xd9\x12\xf5\x36\xd3\x48\x46\x9e\xdf\xe4\x8b\x21\x00\xf5\xe3\x03\xea\x01\x9d\x1c\x28\x00\xa0\x39\xaa\xc5\xd6\x66\x0d\x2a\x4f\x9b\x51\x9e\x08\x6b\x77\xb9\xcb\x3c\xc3\xe6\x50\x15\x25\x54\xd7\xff\x54\x07\xb5\x71\xae\x26\x80\x18\xd3\x8b\x58\x05\xff\xf1\x17\xa1\xb8\x93\xc0\x5b\x7e\xff\x5f\x25\x4e\xae\xba\xea\x1d\xda\x54\x49\xb3\x86\x5f\x71\xfb\x78\x75\x09\x96\x9f\x98\x67\xb2\x89\xe3\x3e\x8e\x62\x64\xdc\xe6\xc1\x0c\x49\x8a\x36\x22\xf7\xa4\x6b\x3a\x6a\x47\xcb\x18\x2d\x54\x51\x28\xb6\xe6\x64\x0c\xbc\xa7\x26\x32\x7c\xbc\x71\xca\xe4\x17\x22\x2a\x03\x6d\xe9\xfe\xd6\x92\x50\xe1\x6d\x27\xf6\xcd\xd8\xf1\x78\x0d\x66\x23\x86\xf3\x0e\xd7\x3f\xf7\x71\xd5\x49\x3b\x06\x92\x44\xd1\x5e\x0b\x37\x8e\xc2\x3d\x20\xac\xd5\xf4\xa8\xe7\x3d\x66\x4d\xa6\xa1\x2c\x79\x96\x13\xd6\x6b\x7d\x1b\x3f\x26\xfa\x08\xc0\x05\x7b\x67\xd6\x01\x37\x95\x23\xd8\x45\x50\x2f\x64\x65\xd8\x04\x02\x14\x5e\xe2\x60\x47\x79\xb2\x4e\x8c\x19\x18\xde\x68\xa8\x9d\x44\x97\xbd\xf3\x4d\xc8\x70\x72\x14\xcb\x5d\xdb\x13\xd1\x86\xfd\xc3\x6a\x74\x91\xb8\x92\xfd\xbc\x80\xcb\xc6\xc1\x50\x82\xd0\x94\x6e\x27\x8d\x4a\x0d\x25\x55\xc8\x16\xcb\xf1\x74\x64\x85\x9a\x4c\xd5\x73\x0e\xd7\xe5\xcd\x95\x70\x61\x43\xe9\xba\x3a\x2a\xc7\x1f\x57\x69\x3b\x23\x0b\xb7\x76\x4c\xdc\x44\x88\xc6\x0f\x23\x9b\x5e\xa3\xc2\xd3\x12\xea\x5d\x6e\x36\x34\x80\x28\xe2\x12\x07\xe5\x87\x0a\xd5\x3d\xcd\xc9\xa1\x41\x3e\x9e\x06\xc0\xab\x41\xee\xc1\x99\xd7\xdc\x51\x57\x9f\x52\x51\xaf\x2e\x51\xb7\x0a\x11\xaf\x39\x88\x68\x38\xdd\xb6\xcd\xc9\x9c\xd2\x64\xc2\x8a\x57\xf9\xa7\x6d\x71\xbc\xa4\x82\x59\xcf\x79\x95\x00\x50\xc4\xe1\xb4\x42\xfa\x07\x3c\x25\x69\xce\x00\x3f\x08\x28\xd0\x30\x38\xc5\x11\x20\xa3\x4a\x27\x6b\x29\xcc\xd3\x77\xcd\xb6\x64\xbc\x24\x72\x3d\xe7\x6c\xaa\x21\x93\x83\xd8\x0d\x5d\x69\x05\x11\x9e\x93\x98\x43\x57\x52\xd2\x51\xd4\xb2\x1c\xb9\x61\xe6\xfc\xdb\x6d\xf7\x3b\x64\x5c\x0a\x6e\x26\x78\x0e\x1f\x52\x4f\x08\x47\x9a\x04\x2f\xb5\xb5\x90\xd0\x6e\xee\x3e\xa8\x24\xca\x38\xc0\x0e\x4b\x34\xd9\xa3\x45\x44\xb3\xad\x69\xb6\xe4\xab\x62\x34\x2e\x7d\x52\x5d\x7f\xfe\xeb\xd6\xe5\xdd\xf9\x4b\x6c\x84\x17\xad\x07\x36\xe6\x77\x36\xaf\xb0\xe9\x5e\x81\xad\x34\x3d\x86\x11\x30\x13\xbe\x6d\x3a\x36\x05\x5e\xc9\xcb\xfe\x3f\xaa\x72\x54\x6e\x6e\x2a\x43\xc3\xfa\x07\x86\x7b\xfb\x8f\xa8\x3a\xb6\xec\x2e\x6c\x80\xb0\x57\xbc\x39\x78\x48\xeb\x3a\x78\xb8\xf7\x88\x0a\x2b\x1b\x42\x48\x25\x50\x46\xb1\x12\x90\xa3\x07\x7b\x87\xfb\x07\x63\xc1\x38\x0f\xbf\x2b\x5f\xdf\x70\xbe\xbc\xa1\x06\x73\xb8\xeb\x48\xd7\xa1\x9e\x78\x30\x4c\x4d\x1c\x18\x15\x27\xe2\x94\xed\x7e\x65\x78\x68\xc2\x5b\x22\xd4\x9b\x13\xc4\x6d\x39\xe2\x54\x72\x2c\xa9\x16\x03\xe5\x75\xf3\x21\x10\x8a\x38\x4c\xc2\x1a\xb0\x46\xe9\x59\x6c\x5b\x35\xc7\xb9\xda\xaa\x95\x17\xd1\xe7\x50\xc3\xc8\xba\x98\x2c\xec\x1a\x44\xc1\xac\x70\x4a\x06\xe1\xcf\x6c\xff\xc3\x50\x8f\x3a\xb0\x7b\x39\xe0\x78\x6b\xe5\xbe\x29\x64\x6f\x6b\x88\x18\x65\x4b\x97\x38\xc4\x4a\xf1\x01\xcf\xaa\x3c\x32\xee\xad\x51\xb5\x19\x93\x63\xd4\x63\xe7\x96\x23\xa0\x0c\xaf\x02\x41\x86\x1d\xb3\x6e\x88\x99\x17\x55\xa2\x82\x4d\xf1\x48\xec\x2f\x15\x95\x06\x28\x5e\xc4\xab\x10\x50\x27\x5a\x2f\x0b\xa9\x6e\xec\x72\xa4\x66\x23\x94\xb8\x21\x5e\x20\x54\x43\x51\x5e\x14\x69\xc3\x7b\x0c\xce\x3c\xb3\x60\xe5\xa8\xbd\x8b\x3e\x81\x77\xe5\x50\xc8\x58\x3e\x6b\xc4\x04\x66\xac\xad\x07\x9e\x77\x1e\xac\x96\x97\xcf\xee\xfc\x7c\xd2\xd9\x5e\x45\xc3\x30\x8d\x46\x04\x86\xd3\x31\x88\x51\x37\xa1\x4c\x0c\x29\xb4\x2b\x7a\x40\x03\xba\x99\x09\x86\x46\xa9\xb2\x84\x9f\x5f\xac\x3e\x7e\x9e\xec\x65\x44\xe7\x17\xe7\x60\xc2\xd0\xb8\x9b\x30\x25\x14\xc3\xac\x71\x48\x14\x3a\xe3\xfc\x6b\xb8\xc7\x1f\x57\x37\x60\xbd\x48\xc5\x92\x13\x3f\xee\x2e\x5c\xe5\xf4\x4c\x2e\xa2\x44\xc0\x45\x46\x1e\x85\x4a\xd5\x5e\xcb\xe3\xb4\xa5\x34\xd4\x4a\x6a\x63\xcb\xa9\x55\xa9\x91\x49\x34\xc7\xb8\x17\xe3\x7c\x8b\xee\xab\x1a\x2c\x63\x2f\xde\xd8\x17\x55\xd3\x7a\x71\x7c\x2a\x16\xec\xee\x77\x17\xaa\xf7\x57\x40\x42\x55\xbe\xbf\xa3\x42\x01\x5b\x34\xd8\xda\xad\x1e\xdb\xc3\x80\x5b\xda\x24\x9f\xf7\xf7\x33\x65\xb1\x61\xb9\x93\xbf\x99\xec\x10\x70\xb7\x1d\x1e\x6c\x64\x7c\xf6\xb7\x61\xa2\x14\x08\x6c\x91\xe0\x9e\x17\xed\xc1\x6a\x1e\x70\x16\xbf\x75\x1e\xfc\x8c\x0e\x1b\x24\x20\x54\xd4\x24\x7e\x1c\x81\x31\xb8\xe4\xab\xe4\x13\x21\x43\x47\x67\xdd\x68\x12\xc2\xf3\x02\x19\xf7\x29\x20\xd6\xdd\xd4\x4f\x01\xcb\x28\x60\x99\x31\xdc\x43\x26\xca\x3a\x8d\xea\x75\xb0\x00\x87\xed\x36\x8d\xfd\xd3\x66\xa7\x0c\x8e\x37\x14\xed\x08\x45\x80\x62\xd6\xd5\x17\x44\x1b\x38\xd5\xaa\xe4\xdd\xfe\xe8\x06\x0f\xac\x7c\xf7\x66\xf9\xda\x6d\xb1\xc1\x96\x6f\x95\xcf\x3f\xe3\xa1\x02\x67\x31\xbb\xf6\xe2\x43\x8c\x83\x8d\x51\x29\xd0\x19\x17\x56\x23\xdc\xb5\xac\xf2\x3c\x2a\x28\x53\x78\xfd\x90\x48\x92\x9e\x09\x25\x66\x88\x12\x1f\x86\xe4\x25\xf4\xdb\xcb\xa5\xba\x19\x33\xb6\x48\x50\xf5\x62\x46\x83\x62\xce\x8a\x08\x74\xc1\x05\xc8\x51\x30\xca\xa0\x05\x25\x11\x1a\x5b\xd7\xe0\x22\xc3\x31\x2d\xa1\xc8\x5f\x35\x8d\x07\xa2\xc7\x14\x47\x80\xc8\x94\x4f\xcf\x07\x5b\x52\x1d\xb9\x1d\x2b\x9c\x15\x45\x73\xbc\x94\xd5\x0b\x69\xf2\xfd\x2a\x2b\x3f\xe3\x55\x95\x2f\x18\x67\x1e\xb2\x02\xe9\x2d\x01\x15\x5e\x0a\xc7\x1d\x9f\xb2\x2c\xdb\x8f\xc6\xc5\x96\xb0\xb8\x15\xd0\x57\x8e\x7f\x77\x6a\x6f\x5b\x28\x68\xc9\x0f\xa6\x17\x0c\x5a\xb0\x79\xdc\x53\xc5\x22\xef\xdd\x31\xee\x19\x66\x78\xa1\xbf\x36\x06\xc3\x88\x38\x75\x95\x3e\x5a\xbd\x77\x12\x6e\x64\xe5\x2f\x97\x40\xde\x55\x29\x1c\xb7\x72\x67\xa1\x7c\xff\x26\xf7\xba\x73\x16\x17\xe0\x4b\x8c\xf5\xbd\xb2\x81\x65\xb5\x28\x82\x1c\x83\xf1\xe9\xa0\xc3\x7b\xe9\xe2\x77\x18\x8a\xe4\x3a\xd4\x62\x07\xc8\x97\x6d\x4d\x9f\xd4\x95\x49\x1e\x48\x0d\x69\x30\x71\x19\x1e\xa1\x92\x59\x1c\xcc\x83\xa6\x33\x29\xaa\x5b\x9e\x2a\xb9\x5c\x56\x5d\xf7\x21\x2f\x6c\x59\xcc\x27\x1c\x0a\x31\x37\xa4\x18\x53\x14\xa7\x17\x69\x71\xf1\x51\x72\x8e\x6a\x4c\xb4\x8f\x80\x64\x72\xe6\x92\x18\x1e\xee\x49\x4c\x63\x52\x47\x9a\x63\xd4\xc0\xd3\xe5\x00\x12\xca\x60\x8a\x45\x42\x91\xe0\x5e\x3d\xc0\xc8\x5b\x4e\xea\xd1\xd4\xc0\x49\x94\x86\x6a\x12\x30\xe8\x5b\xdc\x30\x29\xb2\xa4\x71\x22\x80\x33\xd5\x9b\xf7\x70\x87\xaa\xb2\x0a\x06\xfc\xec\x63\x22\x26\xa3\x8d\xec\x0b\xe4\xa6\x8c\xec\x0b\x5d\x77\xbd\xf0\x7a\x34\xdf\x8a\xb8\x3f\x7a\x55\x99\x0c\x42\xb4\xa1\xae\x58\x0b\x5a\x95\xbd\xec\x5d\x94\x39\xb8\x9e\x8d\x53\x5e\x64\xa0\x5b\x76\x57\xb9\x1d\xc5\x98\xa8\x15\x35\x0c\x49\x88\x79\xec\x20\x8c\x61\xbd\x5e\x1a\x07\x1e\x84\x73\x70\x15\xd1\xfa\x87\x0e\xa8\xd2\x18\xca\x2b\x54\x7c\xf6\x87\x13\xe1\x3a\x0f\xec\x29\xa2\x34\x8e\xf2\x89\x75\x00\xa1\x31\x95\xe4\xea\x5f\xdd\x9d\x7f\xbc\xf3\xe2\x54\x5c\x66\xc3\x40\xa8\xa2\xa5\x7b\x06\xcb\xd9\x15\xa5\x9c\xe9\xa6\xf0\x29\xb9\xeb\xa6\x59\x54\xbf\xfd\x06\xe3\x63\x62\x2a\x5e\x32\x86\x24\xb6\x85\x09\x9a\x81\x2f\x8e\xc1\x4d\xc2\xc4\x0a\x38\x41\xf2\xd2\x13\x97\x4c\x96\x16\x40\x53\x59\x59\x56\xd3\x59\xc0\xc8\x1e\x8c\xc8\x71\x9b\x8d\x67\x4c\x7d\x32\x67\xd9\x70\x8c\xd1\xc9\x6d\x17\x33\xb1\xb9\x71\xf4\x2e\x4f\x6a\x75\x7d\x13\x54\x2a\x4c\x7b\x3c\xf5\xa8\xba\xf4\xa3\xfb\x6a\x0c\x5e\x2c\xc8\xa3\x6b\x59\x32\xc7\x4c\x88\x58\x1e\x14\xfa\x21\xdd\x3e\xa4\xca\xeb\x5e\x42\xa4\xa7\xed\x8b\x74\x14\xf7\xe6\x68\xb1\x5c\x3f\xd8\xd3\xa5\x8d\xe9\xe3\xb0\xeb\x95\xd2\xee\xd4\x23\x4e\x9f\xe6\xac\x14\xd2\x11\x51\xaf\x16\xf9\x28\x70\xbe\xd1\x11\xed\x29\xdb\xac\xea\xc7\x0d\x09\xf1\xce\x30\xeb\x63\x92\x50\x4f\x3d\x82\x49\x29\xaf\x7d\x9f\x12\x12\x0e\xf1\x10\xc7\xbd\x61\x8c\xf6\xac\xce\xf5\xdb\x8b\x7c\x3c\xaa\x25\x2b\x63\xc2\x8c\xfa\x4f\x39\xa6\x88\x5e\xc7\x62\x41\x00\x2d\x9e\x02\x0b\xf6\x34\xa6\xe7\x4d\xc3\xb9\x09\x1c\xcd\x58\xb3\xb9\xac\xa5\xa3\xbf\x40\xec\x7c\x3c\x3b\x8d\x69\xe9\x42\xa5\xdc\xf5\xa0\xb9\xc1\x66\x2a\x5f\xbe\x07\x52\x48\x66\x35\x2c\x68\x2c\x2b\xb6\xb5\x22\x6f\xf1\xf2\xa5\x13\x95\x4b\x5b\x95\xaf\xae\x39\xe7\xce\xec\xde\x58\x55\xef\xf8\x82\xc5\xe1\x80\x74\x51\xa0\x5c\x2a\xd0\xc0\xd0\xbf\xa4\x67\x0f\x68\xff\xc3\xc6\x62\x63\x94\x25\x80\xe7\xbc\x8a\x3f\x57\xae\xef\xfc\x72\xa3\x7a\xe9\x1a\x06\xc5\x56\xe7\x57\x2b\x4f\x4e\x80\x32\x53\xbd\x74\x0e\x9d\xc8\xb0\xb1\x36\x31\x82\xbf\xf2\xe4\x6c\xf9\xeb\x6b\x98\x75\x77\xe5\x7a\x1c\x35\x54\x77\x29\xb2\x08\x93\x17\x9d\xe6\x17\x42\xe3\x14\x5e\x2e\xa1\xc4\x66\x48\x50\x78\x72\x93\x18\xb1\x5f\xca\x63\xee\x2f\x06\x2d\x09\xd5\x85\xe6\x00\x9e\xe2\x62\x46\x45\x14\xba\x38\xeb\x4a\x31\xb1\xb6\x2e\xdf\xe7\x38\xd7\x0a\x13\x02\x69\xe9\x46\x11\x28\xb4\xb7\x4f\x4f\x95\xbf\x7a\x58\x3e\xf3\x53\xf9\xfe\x2d\xae\xb9\xc4\x05\x3e\x61\x8f\x3b\x8b\x4f\x79\x0e\xbd\x80\x43\x78\xb8\xfa\x1d\x1e\x20\x71\xc9\xc1\x03\xac\x73\xa9\x02\xd9\x59\x5b\x52\x5a\xe6\x07\x4a\x05\xe1\x11\xe3\xfb\x84\x54\xdc\x8e\xe9\x4e\x4a\x8c\x85\xf1\xe3\xb2\xa3\xdb\x42\xf4\xdb\x69\xf1\x06\x6e\x6a\xf5\xa2\xad\x79\x59\x81\xd5\x9e\xc2\x7a\xc4\xa2\x3f\x00\x3a\xf6\xb1\xba\xad\x1b\xb4\x46\x59\x01\xac\x33\x88\x32\x06\x31\xd9\x01\xa0\x10\x83\x1c\x93\xbb\x7b\x53\xd7\x6f\xac\xc5\xfa\x68\x89\xc3\xd6\x44\xd5\xdb\xe5\x47\x95\x33\xdb\x9c\xf8\x92\x1c\xce\x28\x48\xc4\xc4\x61\x6e\x4f\xae\xbd\x86\x7b\x0b\x69\xc5\x7f\x59\x96\xbb\x4b\xfc\xf5\x03\xca\x82\x5a\xa2\x07\x39\x2e\xcd\x79\x19\x2b\x26\x6d\x6c\x9c\x42\xa5\xe4\xc1\x65\xe1\xca\x93\xd6\x31\xa5\x97\x5c\x56\x55\xd0\xa2\x6a\xa3\xda\x41\x74\x26\x72\x67\x09\x60\x3c\x7d\x57\x8f\x93\x81\x8b\x73\xb0\xf3\x30\x0c\x20\xc1\xd9\xc0\xf8\x71\x96\xc8\xc5\xed\x06\x29\xc3\x74\xc2\xc9\xee\xe6\x7a\x62\x34\x18\x76\x82\x17\xb5\x77\xc8\xbf\x67\x51\x35\x3c\xb4\x17\x97\xb2\x45\x3e\xfc\x08\x02\x99\x11\x41\xea\xbb\xa6\x6c\x2a\x35\xa2\xcc\x7e\x81\xe3\x97\x1c\xe7\x95\x27\x77\xd0\xa0\xcb\xb6\x43\x37\x0e\x98\x87\x05\xdc\x2d\x9f\xfe\x02\xb3\x7f\xe1\x1e\x36\x7f\x92\x1d\x6b\x98\xa7\xf3\xe8\x74\x75\xe9\x27\x7e\xdd\xb3\xbc\xd3\xf3\x8a\x3c\x99\x54\x43\xe5\x2b\xd6\x4b\x1c\xac\x5b\x1e\x67\x4f\x06\x1b\x5a\x0b\xa9\x6e\x35\x0c\x38\xfc\x6a\xc2\x45\x66\xb0\xe7\x5f\x8f\xf6\x0c\x0d\x2b\xab\x07\x90\x9a\xa5\x3c\x84\x06\x7b\x86\x06\xfa\x8f\x0c\xa9\xd3\x71\xa8\xc8\xb5\xfa\xf5\xfe\xbe\x9e\x21\xf5\xb6\xe5\x62\xe1\x31\x7b\x70\xb0\xff\xe8\x70\x8f\xca\x7d\x19\x67\x53\x1c\x84\xad\xd9\x41\x19\xd7\x7e\x88\x3f\xee\x15\x33\x37\x61\xd1\x99\x87\xb7\x9c\x42\x4c\x89\x3e\x5e\xea\x2c\x2d\x9c\x2f\x56\x9d\xeb\x3f\x38\x9f\x7f\x86\x0a\xc6\x57\x0f\xab\x0f\xe0\x88\xfa\x4c\x49\xb2\xa1\xa3\xea\x9d\x31\xd0\xd1\x02\x38\xf3\x20\x6e\x0d\x51\x7c\xd2\xfe\x17\x3e\x29\xa7\xf3\x31\x45\x5a\xd7\xae\xa1\xbd\xf4\xce\x82\xb3\x7c\x17\x57\xdb\xc2\x66\xe5\xdc\x25\xcf\x82\xea\x5c\x38\xfd\xeb\xd6\x35\x19\x4a\x0a\x22\x84\x2d\xf1\xb0\x05\x9f\xb9\x3a\xb1\xf7\xd1\x95\x65\x58\x84\x11\x14\xc3\x39\xb4\x5f\x4c\xe2\x16\xb2\xc6\x4d\xdd\x55\x75\x40\x4f\xf8\x97\x74\xd4\x26\xa0\x11\x45\x0c\x97\xe9\xf4\xbf\xb2\xb1\x7b\x61\xad\xba\xf0\xd0\x2b\x0e\xc5\x21\x58\x3c\xc2\x96\x0c\xab\x35\x44\xa7\x20\x48\x98\x22\x23\x42\xdc\x02\xe5\x49\x39\x3d\x2f\x2f\xac\x9d\xfd\xd9\x4c\xad\x69\x12\x96\x29\x66\x2d\x18\xb3\x35\x3f\xfd\xcb\x48\xe9\x8d\x37\x7e\xaf\x34\xe4\x7b\x43\x82\xeb\x53\x12\x19\x98\xdf\xe7\x99\x47\x23\xc9\xf0\x92\xfd\x54\xd4\x08\xae\x08\x9a\xe2\x78\x93\x07\xdd\xa7\x36\x55\xb1\x56\x79\x62\xe6\x74\x67\xad\x52\x46\x7b\x07\xb5\xdb\xc2\x5c\xf2\xfc\x6d\x5f\x0d\xbe\x81\x75\x3a\x64\x65\xc9\x0f\x3d\x0c\x21\x4b\x31\xa9\x41\xc2\xdd\x00\xc3\x5a\xa3\xfc\x5e\xd0\x2d\xc7\x24\xd6\x62\x8c\x27\x7e\xdc\x30\x67\xc8\x04\xeb\xf7\x56\x18\x07\xcd\x9c\x9d\x6f\xa2\xf6\x88\x4a\x8d\xfa\xea\x29\x46\xb6\x05\xab\x33\x8b\xa2\xf5\x7e\x67\x05\xb5\xb4\xc7\x40\x33\x1b\xb0\x03\xf7\xc4\x0d\xc3\xaf\x04\xc6\x55\x53\x4d\xec\xf9\x44\x4d\x02\xec\x08\xc6\x51\xe1\xe8\x31\xbc\xa0\xb8\xda\xdf\xb4\x4e\xa5\x5e\x84\x21\x81\x95\xd6\x50\x64\xaf\x32\xcc\xe7\x6a\xf5\x97\x9f\x9c\xb5\x47\xb5\xcc\xe6\x4a\xd3\xce\xe6\x3d\xbc\x33\xf2\x45\x92\x57\x0b\xc8\xf9\xfb\x67\xbd\x46\x03\x70\x7b\xc3\xb3\xf5\xd1\x29\x55\x38\x30\xdc\x36\xb0\xc6\x18\x9d\xa0\x0d\x70\xc4\xaf\x5b\xf2\x0f\xc0\x1a\x4e\x0c\xde\x03\x06\x09\xa6\x84\xab\x2c\x2a\x23\x2a\x88\xa8\x3a\x2a\x2a\x7a\x18\x44\x45\x3f\x6c\x62\x42\xec\xe5\x72\x32\x2a\xbd\x66\xfb\xaa\x17\xfa\xe7\xb1\x42\x14\xf6\x23\xa5\x25\x01\x59\xa9\x20\x8a\xa4\x0a\x5c\xb9\xb8\xfb\xd5\xf6\xd5\x40\x8d\x19\x17\x1d\x35\x77\x8e\x57\x72\x18\x1b\x95\xe7\x95\x92\xea\xd8\xbf\x00\x8b\x23\xde\x78\x42\x87\xae\x94\x39\xc7\x5e\x85\x78\x54\xb9\x40\x54\x65\x2c\xfc\xe4\x40\x49\x1f\x28\xaa\x66\x4d\xcd\x0c\x6b\x6b\x49\x33\x13\x0e\xc5\x25\x9b\xa6\x5e\x90\x05\x79\x38\x9f\x0c\x6f\x14\x56\x38\xd2\x6a\xbf\x58\x4c\x28\x99\xf1\x0f\x57\x8b\xb2\xf1\x9b\x6e\x76\x27\x1f\x85\x21\x24\xdf\xec\x41\x23\xaa\x79\x47\xab\x6e\xde\x83\xbd\x04\x03\x8d\x88\xd5\xda\xcf\x8b\x30\x8c\x5a\x18\x1a\xd5\xf9\x6d\x35\x53\x12\x18\xbb\xd2\x86\xe0\xb1\xad\x10\x68\xfe\xc3\xbc\xa2\x2a\x67\x58\xb0\x9c\xd6\x9b\x20\xde\xe7\x17\x7f\x0d\x94\x07\x39\xc6\x5f\x13\xf1\x7b\xcb\x33\x09\xbf\xc4\xb5\x20\x7a\xe6\x9b\xb7\xa0\x6a\x46\xc3\x7c\x0b\x37\x35\xda\x73\x76\xbd\x1c\xae\xec\xe1\xe8\x4b\xac\x0d\x73\x63\xa6\x16\x6d\x2c\x24\x2a\x97\xca\x5e\x26\x78\xe1\xbf\xb0\x77\x5b\x8a\xe5\xb3\x37\xd6\x7a\x79\x93\x58\x89\xaf\x4e\x24\xdc\x1a\xd1\xcf\x11\x56\x69\x00\x1c\xa5\xf7\xf9\x0b\xe7\xec\xa9\xe4\xcc\x60\x0f\x6c\x3a\xed\x42\x82\x5d\x5f\x22\x55\x0d\x9e\x84\xea\xb1\x11\x98\x62\x22\x38\x7c\xe8\x31\x79\x2b\x32\xc8\x38\x87\xba\x0b\x2c\xee\x5c\x0f\x90\x97\x68\x0a\xf5\x21\xaa\x2b\xf3\x06\xa8\x8b\x09\x9a\x25\x58\xc2\xa8\x1b\x5c\xb4\xde\xfd\xf2\x15\x6e\xc2\x47\x4b\xad\xdb\x84\x01\x8e\x9c\xd8\x0c\x0c\x2e\x7e\x9b\x20\x7b\xfc\xe2\x65\x7c\x11\x7e\xdb\xfd\x1c\xe6\x56\xe8\x87\xc4\x32\xad\x8f\x96\xe4\x5d\xa5\x80\x1e\x4d\x7b\x04\xaa\xf8\x41\xd4\xcc\x5f\x78\x8e\xf7\x76\xe2\x9a\x9c\x82\xa0\x48\x11\x9c\x4a\x39\x90\x46\x47\xa1\x92\x4a\x41\xec\x71\xe3\x4a\x39\xa8\x9a\x9b\x7b\xd8\xbc\xf3\xca\x75\xcc\x06\xf6\x62\xb4\x17\x4a\xc1\xae\x74\x9e\x2a\x9f\x71\xee\x90\xd1\x2a\x25\xa1\xf6\xf9\x26\x7d\x19\xc5\xb5\x97\xc1\x1e\xc1\x08\x9f\x49\x21\x62\x15\x9c\xf0\x9f\x88\xe1\x43\xde\x8a\x0d\xd2\xf2\xc2\x6f\x62\x22\xb4\x06\xd9\xb2\xed\x85\xb9\x0e\x0d\xbd\xcb\x11\x4b\x59\x6b\x96\x43\xf3\xe2\x8f\x40\xaf\x2d\x85\x08\x5e\xa5\xb0\x3c\x82\x82\xe6\x6f\xb2\x83\xd7\x85\x98\x9b\xfb\x64\x30\x80\x22\x54\xb0\x4f\x84\xc5\x51\xd1\xe5\xf8\x32\xf1\x6b\xeb\x81\xea\x71\xcc\x86\x4b\xeb\xa2\xa9\xf4\xc6\x67\x82\x54\xea\xf5\x93\x96\x54\x36\x33\x28\x23\x0c\x3c\x5e\xc7\x98\xbb\x38\xba\x25\x6f\x1b\xa5\x8c\xd5\x51\x2c\xce\x11\x93\xe3\x23\xfa\xc8\x16\x22\xbf\xc2\xa9\x20\x2a\x0c\x98\x09\x90\x4a\xcd\x90\xc3\xfa\xd3\x28\x1b\x6e\x8a\xc1\x6f\xe7\xbe\x5b\x3b\x8e\x96\xa9\x09\x31\x1b\x8e\x73\x6a\xd2\xe8\x71\x35\xd5\x8a\x63\x41\x22\x6f\xa3\x8c\xdd\x58\xef\x69\x22\xb0\x0b\x02\xdc\x6f\xc9\x11\xa7\x22\x38\x74\x7f\x71\xfb\x00\x06\xc9\x53\x8d\xaa\x58\x30\x0d\x36\xd6\x98\xb9\x8c\x39\x63\x66\x4a\x7a\xd6\x0b\x37\xa1\xca\xf1\xe4\x2a\x02\x30\xc5\x92\xb2\x7a\xc3\x97\xcf\xb0\xb9\x15\x17\xc6\x3c\x39\x5f\x5e\xc4\x76\x0f\x18\x2f\xb8\x7c\x9b\xc3\x43\x38\x8e\x37\x91\x04\x6a\x32\x9a\xcf\xea\x9c\x25\xd0\xdf\xe5\x55\xff\xf7\x42\xe7\xbd\x96\x44\x18\x4a\xad\xdc\x8d\x4c\xcf\xce\xc6\x9d\xdd\x1b\x0f\x2b\xb7\x44\x97\x94\xdd\xcb\xa7\xcb\x0f\x9e\x88\x86\x31\x97\x3f\x11\xe0\xe3\xba\x05\x28\x29\xe3\x0e\x66\x30\xd9\x6d\x36\x35\x9c\xeb\xd4\xb4\x2e\xac\x06\x46\xe2\x91\x5b\x86\x72\x55\x1e\x62\x1a\x86\xae\xe5\x4b\x7e\xf8\x3f\x95\xfc\xb5\x29\x7a\xa7\x60\x60\x58\xb5\x72\x6b\x85\x86\x41\xcd\xce\x42\xd1\xc1\xda\xa1\xa3\xbd\x07\xa9\xe2\xd0\xc7\xe5\xcf\x3e\xc7\x72\xa2\xc1\xdf\x45\xd7\x1a\xaa\xad\x09\x13\x51\xfd\xf8\x05\x16\xef\xa1\x39\xaa\x6e\x6d\x38\x4b\x9b\xca\x90\x9c\x84\xd1\x83\x30\x89\x1a\x7d\x68\xac\xe4\x9b\x6d\x78\xac\x5e\x5c\x42\xcd\x28\xbd\x5f\xe4\xf1\x35\x37\x20\xa1\xdc\xa5\x18\x94\x77\x8d\x6d\x7c\x12\xdd\x0c\x8e\xda\xe9\xf3\x72\x3b\x5a\x3d\xb0\x8e\xe3\xc6\xdc\x4b\x19\x9c\x8c\x50\x7b\x59\x63\xc4\x43\x23\xcd\xe8\xe8\xbc\x6b\x62\x45\xba\xc1\x23\xb5\x2b\x32\xd8\x75\xa9\x25\x83\xc2\xee\x5c\xde\xa0\xd4\x63\x72\x9b\x78\x35\x38\x26\xee\xc2\x15\x35\x26\xef\x97\x46\xc6\xe4\x85\xea\x4a\x67\x89\x2d\x1f\x26\xf8\xa3\xa1\x8f\x73\xea\x49\x87\xdc\x29\x32\xc5\x31\x53\x7e\x78\x46\xc4\xa4\x9f\x79\x88\x69\xab\x30\x18\x3a\x69\xbc\xe3\x47\x3e\x78\xe2\x4a\xc0\x7b\xf4\x46\x65\x01\x36\x9c\x5e\x2a\x48\x55\x64\x90\x26\x44\x07\xc7\x92\xd4\x70\x0e\x29\x93\x14\x9f\x26\x5a\x0f\x61\x85\x52\x56\x6a\x62\xc6\xa2\x23\x58\x94\x2a\x1c\x6e\xe2\x6d\xc0\x58\x0a\x45\xd7\xb2\xe5\x25\xb1\xa3\xa4\x78\x12\xb9\x66\x09\x79\xdc\xcf\x38\x2b\x4b\xb1\xa4\xd2\xe5\xd3\x5b\x6d\x48\x28\x2e\x36\x2c\xe1\xe1\x35\x25\x6d\x95\x19\x45\xa6\x1e\xbb\xc4\xc9\x8b\x12\x96\x23\xad\xcb\x18\x85\x35\x82\x5c\xc0\xf2\x0e\x53\xf9\x0e\x10\xdd\x42\x8b\x0f\x93\x5a\x0b\xbf\x2e\x3a\x1b\xdb\x2f\x2d\x1e\x43\xe2\x0e\x6b\x74\x24\xc9\xdb\xac\xc5\x23\x49\xb9\x31\xd5\xe3\x71\xfd\x0f\xef\x5a\x76\x51\x5c\x8f\xe0\xd3\x41\x2a\xd2\xe9\xa7\x7a\xf4\x60\x1c\xa2\xc1\x37\x82\x68\x62\x1b\x06\xbf\xff\x43\xb7\xa0\x6a\x4b\x10\xd1\x1f\x00\x6b\x56\xe7\x08\xca\x31\x0a\x8d\x2f\xd6\x66\x8d\x46\xc4\x45\x01\x71\x8d\x21\x65\xc7\x56\xaa\x10\xe0\x90\xf3\x26\x29\xec\x37\x84\x42\xca\x35\xab\x67\x60\x82\xf3\xf5\x0f\xce\xed\x8f\xed\x32\xb6\x70\x08\x3f\x02\x21\x5e\x5f\x97\xfa\x61\xc6\x73\x46\xfd\x22\xee\x2b\x0c\x4f\x38\x3a\xd8\xeb\xb6\x97\xf2\x32\x18\xe4\x5c\x4e\xb7\x60\x30\xee\x47\x7c\x56\x2f\x15\x61\xb9\x15\xe1\x82\x9d\xcd\xce\xa9\x78\xc0\x4d\xa7\x28\x89\x74\xc1\xc5\xc2\xd9\x09\x72\x02\x28\x27\x76\x57\x97\xee\xc2\x55\x5a\x94\x1a\xe6\xe7\x14\x54\xe3\x59\xa7\x34\xfd\xc4\x9c\x42\x42\x1e\xf6\x48\x52\xe4\x98\x2b\x45\x68\x06\x94\xed\xbf\x54\x92\x4d\x69\xb6\x1a\xea\xe9\x86\x21\x0c\xbf\xa7\x1d\x1a\xec\x3f\x3a\xa0\x82\x9a\x58\xf5\x6b\xa8\x67\xf0\x58\x6f\x77\x4f\x6c\xb9\x24\xa1\xc0\x93\x89\x3d\x16\x8a\x2a\xc4\x37\xae\x84\xde\xd0\x40\x57\x02\x7a\xa1\x18\xc4\xa1\x67\x18\xf1\xc5\x9a\x08\x4a\x42\xb1\x26\x06\x74\xb0\xe7\x58\x4f\x5f\xff\x80\xba\x60\x13\x81\xda\x3d\x7f\xb2\x72\x69\x6b\x67\x73\x33\x01\x5a\x42\xf1\x27\x69\x70\xf1\x80\x94\xe5\x9f\x62\xfc\x9b\x68\x43\xe5\x04\x91\x86\x0c\xb6\x31\xd6\x5a\xbc\x3f\x00\x74\x05\x5a\xd8\xb2\xbf\x2d\xab\x64\xf9\xcb\x9f\x9c\xc5\x97\x60\x89\x1c\x72\x75\xe2\x84\xdd\x2e\xed\x4b\xf5\x0e\x0f\x16\xfc\x03\xfc\xae\xc6\x3d\x3a\x29\xa4\x79\xba\x2c\x6a\x09\x59\x24\x94\x84\xd4\x83\x14\x74\xc0\x77\xd4\xdd\x70\x74\x3a\xa1\x3d\x4a\x22\x2d\x11\x90\x14\x44\x71\x13\x7f\x37\x9f\x04\xee\x25\x74\x19\x06\x0d\x0e\x4f\x3f\x3c\x4a\x8e\x9b\xf9\xd7\x55\x13\xc0\xfd\xf9\xdd\x62\x96\xcb\x58\xbc\x65\x75\x05\xe4\x36\xbe\xbb\x7b\xea\x09\x1e\x16\xcf\x7e\xdc\x5d\x38\xcd\xb9\x45\xf1\x24\xf0\x9a\x6e\x90\x02\x51\x75\xab\x51\x0a\xa8\x95\x0f\x31\xac\x9d\xff\xa1\xce\x84\x07\xb4\x37\xdf\x78\xe3\xad\x76\x6d\xda\x6d\x5c\x23\x4a\x7f\xd8\x6e\x5b\x73\x0e\x6c\x1a\x33\xc6\xf5\x12\x67\x98\x7b\x15\xcf\xf2\x52\x6d\x2a\x75\x04\x43\x1a\x72\xc4\xc5\x86\xe9\xf9\xc3\x1b\xbf\xaf\x21\x10\xbf\xf2\x28\xc4\x9e\x0e\x6e\x35\x0a\x6c\x03\x6b\x15\xcc\xbf\x71\x39\x8a\xbc\xa8\x05\x43\x17\x0e\x2f\xd7\x9c\x5b\x42\x28\xc8\xf3\xba\x0a\xb9\xbd\x34\x85\x09\xb4\x72\x13\x3b\x2d\x01\x2d\xf0\x0d\xff\xc4\xdf\x10\x31\x18\x09\xeb\x36\xef\x29\x9f\x58\xc7\xa2\x8d\xa7\x1e\x97\x4f\x2f\xbb\xdd\x14\xa8\x90\x1b\xf7\xf8\x95\x73\xd5\xa9\x97\x43\x23\xfc\x38\xa0\x75\x71\x4e\x0b\x70\x3e\x63\xe4\xa8\x18\x3d\xb1\x21\x63\x11\x17\xa8\xd2\x65\xbe\x60\xce\x98\x59\x43\x24\xfa\x19\x1f\xc0\x76\xa1\x94\x09\xd3\x4e\x2a\xc8\x91\x82\x07\x97\xcb\x27\xbf\xa8\x3c\x11\xd5\xe9\xb8\x1d\x85\x48\xb7\x7f\xb4\x8c\xed\x28\xbe\xff\xcc\x6f\xd4\x7e\xff\x16\x17\xed\x50\xea\x4c\x31\x83\xc5\xeb\x41\xa1\x30\x44\x5f\x75\xc3\x37\x1f\x7d\x14\x5c\x0b\xfc\x7b\x57\xde\xec\xc1\x2f\xdd\x27\xa6\xa5\xae\x4b\xf0\x43\x20\xf7\xa1\xa1\x31\xd7\x92\x11\x5a\x06\x51\x74\xc8\xab\x22\x8a\x10\x25\x2f\x50\xb3\x27\x97\xc3\x30\x79\x34\xe0\xdd\x3e\x7d\xcc\xc8\xb2\x88\x73\xf3\x5f\x53\x97\xfb\xab\xed\x78\xac\x86\x98\x5c\x06\xd0\xa5\xef\x6d\x2f\x5a\x23\x32\x7f\x2d\x9e\x98\xe8\xc0\x8b\x70\x36\x5b\x22\x0d\xee\x55\xc7\x15\x40\x24\x8c\xdc\x0a\xb4\x0a\x02\xfe\x3e\xbf\x2a\x07\x8a\xfd\x7d\xfe\x14\xe0\x2b\x5f\xc4\xda\xf0\x7e\x3b\xd0\x95\x79\x4e\x23\x8e\x47\x1f\x93\xc9\x92\x74\x55\x52\xd6\xc7\x0e\x55\xd7\x4e\x8d\x3f\xba\xae\x76\x5d\x73\x92\x50\xa3\x3b\xfd\xb4\xb8\x74\x1d\xa8\x09\x11\x49\x41\x40\xa0\x5c\x52\x1a\x2e\xa8\x8a\x99\x47\x54\xd4\x6a\xfa\xd6\x9c\x8e\x53\x72\xe9\x76\x75\x41\xf3\x44\x36\x7a\xf9\x46\xc1\x91\x8c\xe4\x86\x7b\x07\x0e\x68\xbd\x13\x58\x17\x85\xce\xbd\x62\x61\x8e\x6c\x53\x96\x48\x58\xd2\xb5\x99\x37\x6b\xb2\x96\xda\xe9\x71\x6a\x7d\xe4\x5e\x94\x3b\xf2\x64\xe2\x8c\x1f\xac\x9c\x87\xe4\x2d\x81\x91\x1c\xec\x8f\xca\xad\x4d\x98\x2c\xe7\xce\x89\xf2\xd5\x35\xec\x46\x74\xf1\x42\xf5\xbb\x3b\x9c\xc2\x54\xf9\xfe\x7b\xed\x4d\x2e\x05\x11\x86\x81\x1d\xb4\x56\x96\xb8\x75\x91\xb8\x4e\x03\x1d\x09\xd5\x9b\x6a\x58\x52\xe7\xfe\x4a\x2e\xf0\x3e\xa4\x8a\xd7\xaa\x67\x0b\xd5\xbe\x9d\x7a\xd3\xc8\x7b\x25\xcd\x71\xc5\x08\x03\x9b\x25\xfd\xe1\xa2\x74\xce\xc7\xdd\xb5\xc5\xab\x2a\x9d\xd4\x23\x48\xf5\x7a\x31\x9c\x3a\xc2\x0e\x81\xb8\xb0\x0b\x5e\x1f\xe1\x22\x57\x89\x49\x25\x88\xcb\x4d\xfa\xc6\x60\x9c\xac\xd1\x89\xdb\xa5\xaf\xbf\xbb\xab\xaf\x07\xcf\x8a\xb6\xee\xbe\x9e\xae\xc1\xb6\x76\x6a\x29\x6f\x5a\x25\x5b\x3c\xc6\xea\x14\x66\x96\xaa\x6b\x95\x11\x49\x9c\xe5\x5d\xbd\x7b\xb5\xba\x3e\xcf\xf4\xc0\xfc\xf2\x4e\x70\xd1\xc0\x91\xe2\xe2\xe1\x25\x8f\x89\xe2\x94\x6c\xea\x2c\x2e\x3b\x2b\xa7\xd0\x29\x11\x7c\x5f\x3d\x18\x8e\x13\x18\xa5\x42\x86\xa3\xc5\xb9\xbc\x88\xb6\x40\xad\x8e\x2b\xb5\xb5\x61\xd8\x15\xb7\xc6\xcb\x59\x39\x43\xd5\x2e\x00\x33\x43\x6b\x61\xf1\xde\x13\x65\xdf\x4f\x6c\xba\xc0\xa8\xf7\x1d\x43\x53\x12\x06\x08\x67\x4c\x63\xd6\x2f\x67\x66\x62\xda\x53\xfc\x6c\xc2\x65\xe5\xee\xcd\xea\x9d\xf3\x9c\x6b\x24\xec\x6e\x7d\x29\x70\xc8\x8d\xb2\xe5\xa6\x41\xe9\xd0\x61\x9d\x2d\x1e\x22\x17\xaf\x75\xeb\x49\x7b\xed\x81\x94\x14\x88\xda\x18\x72\x76\x15\xc5\x22\xf6\x88\x8f\xa9\x82\x81\xa5\x24\x2b\x9f\xd3\x35\x40\x62\x49\x08\xec\x1d\x2c\xb8\xe2\xe5\xee\x50\x1d\x79\xf1\xcd\x31\x3d\x5b\x32\xb8\x3e\x4c\x6d\x6b\xac\x57\x67\x44\x41\x75\x79\xe9\x6b\xe7\xd1\xa9\xd6\x05\x7e\x63\x68\xa6\x9c\xcd\x14\x62\x89\xb4\xa0\x83\x9c\x49\x64\xf4\x5f\xa3\xca\x33\x88\xea\x01\x11\xa1\xa6\x2d\x09\xab\x8e\x2e\xec\xe0\x8d\x21\x82\x6b\x89\xc3\x78\x09\xde\x41\x71\x80\x37\xe0\x1d\x74\x89\x7c\xc5\xae\x41\x1e\x40\xe3\xae\xc1\xb8\x61\xbc\x44\xbf\x60\x6d\xcf\x8e\x86\x06\x33\x85\xda\xa4\x4e\x86\x03\xcc\x13\x17\x5d\xee\xc9\x21\x1f\x9b\x94\x82\x1e\x78\x51\x9e\xf2\x07\x2c\x02\x48\x26\x80\xb8\x06\x7e\x88\x89\x35\x5b\xc2\x10\x76\x3e\x8a\x02\x40\x7b\xb4\xdb\x3c\x6a\x83\xe0\x99\x76\xa6\x3a\x4c\x51\x0c\xcb\xac\x59\xbf\x7a\x51\x30\xaa\x41\x65\xbc\xa3\x78\x1a\x2e\x54\x94\xc2\xc7\x42\x08\xb2\xd9\x50\x2b\x93\x44\xd5\x89\xb1\x44\x46\xf8\xa5\x50\xa0\x10\xe9\x94\x91\x8d\x07\x5e\xbd\x7b\xb7\x7c\xf1\x74\x0c\x04\xac\xb4\x52\x98\x66\xbf\x01\x11\x2c\xe2\x8f\x5e\xd3\xfd\x40\x24\x5c\x6d\x46\x07\x97\x9d\xa3\xb2\x7b\xdc\x47\xa6\x1d\x5e\x76\x8b\xfc\xe0\xd2\xcb\x1b\x05\x9d\x85\x9a\xf8\x99\x5b\x4c\xc0\x4f\x20\x2c\xa8\xc9\xa6\xaa\xb0\x8f\x60\x37\x85\x27\x71\x2d\x97\x5f\xb7\x96\xf9\x23\x86\x8c\x7b\x46\xaa\x50\x0d\xfb\xeb\x67\x51\x4d\xa3\x0c\x1e\x51\xa6\x8f\xcc\x14\xf8\xee\xea\x62\xf9\xe4\xf7\x22\x38\x54\x7c\xb9\xa2\x2c\xf5\x43\x8c\x70\xcb\xce\xc4\x92\x28\x97\x9b\x49\x80\x85\x76\x0e\x1b\x0b\xd3\xa1\x29\x56\x65\xcf\xda\xfe\x9a\xb3\x36\x65\xe8\x9e\x85\x23\x06\x01\x15\x27\xc9\x18\x45\xdd\xcc\x8a\x75\x26\xd7\x1f\x0e\x5f\x2b\xe3\x87\xc4\x65\x0e\x6b\xae\x60\x5e\x31\xe2\xea\x77\x3f\x56\x7e\x7a\xc4\x15\x07\x62\x48\xe2\x03\x39\x91\x83\x7c\x86\x26\x72\xb0\x60\x8c\x53\x6f\x04\xd0\x8d\xb8\x8b\x68\xfc\x16\x5a\x9b\xaf\xfe\xf2\x79\x48\x11\x89\x6b\x14\x4a\x38\x6a\x2c\x0d\x89\xc4\xcb\xa6\x85\xc4\x21\xd8\x92\xed\x23\x25\x64\x36\x44\x24\x43\xe6\xa8\xc7\xc4\xc5\xca\x75\x10\xd2\x41\x4b\x39\x7d\xc2\x35\x9a\x6e\x12\x19\x72\x23\x1b\x81\x73\x5b\x92\x37\x02\x4a\x1b\x2f\x86\x9c\x6e\x87\x1c\xb5\xff\x1b\x51\xa8\xe5\x6d\x9d\x52\x9b\x8e\x4d\x04\xe0\xc8\xf7\xea\xdd\x5f\xca\xe7\x7e\x8a\x3d\xee\x90\x2f\xb5\x81\xeb\xad\xb9\x6d\x34\x7f\xb8\xb7\x9a\x2d\xa1\x40\x78\x35\x67\x8e\x9b\x79\x51\x77\xce\xcd\xc8\x24\x3f\x59\xd1\x8a\xab\x64\xc1\x6e\x3a\x2f\xc7\x8c\xd7\xa9\x57\x87\x2e\x69\x91\x22\xca\x29\xcb\x2e\x92\x18\xa0\x52\x3f\xb1\x79\x47\x84\x6b\x67\xe3\x79\xf9\xbb\x6b\x2c\x0c\xb8\xaf\x46\x0c\xf0\x40\xc3\x0e\xa1\xd5\xca\x4d\xfa\xb1\x03\x72\x11\xe5\xa9\x35\x0d\xda\x6d\xc6\xc8\xfc\xb7\xfa\x7c\x7e\x89\x29\x68\x31\xef\x69\x2d\x29\xce\x28\xcb\x9c\x86\x4a\x34\x4a\xb4\x28\xbb\x23\x49\x38\xd4\xf6\x31\x6e\xbc\xb8\x37\x8d\xb3\x12\x79\x19\xde\x8c\xe9\x59\x17\x7e\x35\x0d\xbb\xe2\x19\x15\xc3\x22\x2c\xcf\xcc\xfd\x10\x44\xbb\x17\xd2\x18\xa9\x3a\x24\x80\x20\x23\x1f\xfd\x44\xfe\x6a\xb7\x4d\x77\xbb\x57\x3d\x94\x1f\x47\xf7\xa7\xa8\x27\x89\x5d\x9c\x84\x84\x9f\xb5\x0a\x54\x4b\xc9\xab\x3b\xac\x14\x3f\xd4\xc4\x1b\x5d\x9c\xe7\xb7\xb8\x4a\x64\xa8\x67\x8a\x67\x09\xf4\x3a\x7e\x7b\x7d\x5e\x84\x15\x70\x6d\x9d\x85\xad\xf3\xec\x36\x76\xe8\x71\x6b\x17\x33\x34\xb9\x3a\x29\x40\x56\xdb\x05\x49\x83\x66\xf1\xf2\x72\x35\x6a\x6c\xff\xe7\x96\x51\x67\x45\xfa\xe5\x6a\xd4\xe2\x5a\xdd\x40\xa0\x5c\xfc\x05\x59\xbd\xf0\x92\x13\x04\xd3\xa6\x06\x0a\x50\x70\x50\x62\xd3\x45\xab\x54\x1c\xc9\x09\x7f\x4e\x97\x14\x64\x45\x5e\x9a\x31\xce\x8b\x30\xe4\xd2\xe3\x05\x73\x72\xaa\xa8\xa1\x7d\xb6\x93\x9c\x9f\xb0\x4b\x51\x2e\xc3\x6d\x3a\x83\xfe\x70\xd7\x12\x81\x0f\x70\xef\x56\xfc\xf4\xff\x0e\xf4\x0f\x0e\x47\x5a\x21\x94\xc5\x9e\x6b\x46\xb3\x3b\xbf\x5d\xbe\x74\x02\x89\xf5\x1d\x3f\xe4\xc2\xc1\xbc\xdc\xfb\xdf\x54\x6e\x6e\xe2\x62\xb8\x76\xbd\x7c\xfa\x76\x75\xe1\x85\xfc\xa6\xdf\xb7\x92\xe9\x90\xf9\xce\x05\xc4\x76\xbf\xbe\x8a\xd5\x12\xae\x5d\x77\x1e\xde\xc3\xbd\xe1\x96\xc0\x8a\x5b\xfa\xc0\xc4\x52\xce\x2f\x74\xef\x71\x31\xa2\x5f\x2d\xca\x89\x69\xab\x60\xc8\xd7\xd1\xd8\x71\xa3\x3f\x78\xf9\xac\xf3\xd9\xb5\xe0\x70\xef\x9c\xd8\x5d\x9b\x17\x29\x06\xe2\x1e\xe9\xf7\x3d\x08\x21\x8d\xa1\xdb\xc8\xb0\xab\x87\xff\x56\x07\x3b\x81\x1c\x25\x6a\x84\x8b\xc7\x7b\x5c\x0d\xf9\xb7\x15\x35\xc7\xd4\xbf\x84\xa8\x39\x1c\x7a\x29\xef\x86\xb4\xb4\xb3\x77\xd3\xd2\x72\x25\x4c\x35\xb1\xb0\x2c\x30\x7f\xe1\x7a\x84\x38\xdd\x57\x3c\xae\x18\x9d\x0b\x94\xe3\x56\x28\x8e\xc3\x35\xc4\x7e\xb7\xe9\xcc\x6f\x71\x4c\xf0\xee\xd2\x29\xee\x53\xcc\xee\x20\x01\x99\xdf\x51\x12\xab\x6c\x57\xc4\x0a\xa6\xfa\xbd\x92\xed\x2e\x9c\xa2\xda\x93\xce\x40\xbc\x35\x53\x54\x7b\xcf\x8b\x56\x3e\x41\xa4\x2d\xac\x95\xef\xdf\x4c\x23\xd2\xac\x7c\xfe\x37\xb6\xf6\x88\xf4\x97\xb0\xf6\xb8\xe7\xb1\x88\x9f\xc9\x28\x8f\x9d\xaf\x7e\x90\x3b\x19\x2b\xcf\x19\x94\x60\xea\xfa\xe6\x24\x88\x0e\xa8\x6a\x0e\xf3\xbb\xf0\x99\x7a\x0d\x77\xbf\x33\x7a\xa4\xeb\x70\x8f\x50\x74\x3a\xa8\x27\xb2\x1b\x17\xd3\xe1\x66\xaf\x72\x0b\xb7\xe3\x7c\x8b\xf6\x1b\x37\xdb\x6e\x9f\x73\xbf\x09\x0b\x3c\xd8\xfd\x0e\xe9\x04\x49\xc4\xc1\x6f\xae\x40\x4c\x45\x03\x6e\xad\x07\xfe\x6d\xdc\x6b\xf5\x2c\xac\x21\xd4\xba\x05\x71\x07\x8c\x2f\xf4\xb4\x9a\x0d\x5a\xb7\x28\x6f\x3f\x6b\x82\x08\xa0\xa0\x40\x38\x5b\xe7\x38\x08\x4e\x94\xba\x77\x5d\x0c\x92\x5e\x6d\xc3\x89\x52\x34\x29\x3d\x6d\x8e\xc2\x2a\x44\xb7\xcd\x98\x14\x49\xf7\x6c\xc0\x22\xcd\x70\x88\x3d\x7b\x2c\xa7\xdd\x73\x0d\x7c\xd6\x85\x42\xb7\x4c\x54\x05\xcf\xde\x01\x6d\x10\x8f\x1a\xac\x1f\x0e\x77\x8f\x8f\x9d\xf9\xcf\x9d\xdb\x17\x90\x0f\x54\x4b\x5f\x79\xfa\x85\xa3\x3f\xc6\x8c\x29\x13\xee\xe1\x3a\x28\x7b\x05\x63\x96\x2a\x41\x52\x71\xeb\xbf\x96\xcc\x02\x25\xeb\xbf\x3b\x3c\x3c\x80\x51\x51\x1f\xcc\xb5\xf3\x8d\x8e\x13\x47\xa7\x8a\xc5\xbc\x3d\x4a\xdf\x47\xbb\x28\x28\x4e\xb0\x80\xea\x30\x30\x0f\x84\x68\xa7\xd6\x93\xb5\x8d\x76\xd1\x4f\x8f\x9a\xf2\xe4\x8c\x22\x2a\xce\x78\x65\xc9\x19\x14\x55\x59\x5f\xbe\x09\x8d\x25\xae\xed\xfc\x44\xb8\x73\x7d\xfa\xf6\xf3\xee\xe4\xa4\xec\x43\x5f\x8b\xa9\xbe\x7e\xf4\x34\x14\xb7\xd1\x77\x57\xde\x0c\x92\x8c\x77\x3a\x33\x57\x32\x3c\x67\x0a\xdc\xef\xd0\x59\x10\xbc\x4f\x27\x0d\x45\xa2\x37\x80\x01\x83\x15\x7f\xde\xaa\x6c\x8a\x01\x61\xd0\x09\x3b\x16\x2e\x7f\x22\xf9\x9d\x53\xd0\xdd\xfd\x8e\x07\x34\x20\x01\x69\x0c\x06\x28\x5c\x40\x30\x4d\x7c\xc0\x17\xed\xb5\x93\x40\x61\x62\x4c\x4c\xc0\x4a\xa8\x63\x24\x4a\x9c\x38\xaa\x9b\x9b\x3b\xbf\x7c\x5d\x3e\xb1\x1e\x8a\xfb\xe0\x2d\x52\xf9\xea\x5a\xf9\x9c\xa2\xa1\x5d\x68\x58\xa2\x8c\x4a\x48\x2d\xd4\x73\x6e\x4a\x15\xca\xb6\x56\x8f\x91\xfd\xdd\xdc\x44\x7e\x77\xfe\x9b\xca\x93\xb3\x61\x2b\xb2\xcc\x84\x1a\x0a\x5b\x38\xfc\xc0\x52\xdc\xab\x69\x6c\x21\xe1\xfe\xf6\x3f\x9a\xcf\xc0\xe1\xe1\x15\x44\x0b\x8e\xa4\x44\x3f\x72\x44\x73\x52\xb9\xc3\x48\x92\xd5\xe0\xb1\x29\xeb\x95\x9f\x40\x96\x73\xab\x87\xe4\x02\x89\xc3\xfa\x24\xeb\x67\xf8\x47\x9d\x79\x8c\xc3\x70\xce\x52\x34\x8b\xe4\x9d\xc8\x5a\x93\x29\xbc\x7c\x6c\xae\x2d\x2f\x9f\x8f\x76\xf7\x91\xeb\xa2\x7c\xe1\x76\xf5\xee\xaa\x0a\xb3\x14\x4f\x23\x2b\x4a\x4a\x35\x04\xef\x25\x21\xa1\x58\xab\x66\x29\x95\x14\x17\x5d\x94\x0e\x58\x0f\xca\x28\x2d\x4e\x89\xd4\x6d\xe5\x14\x88\x2d\x90\x73\x9a\xbc\x30\x62\xbd\x28\x95\x54\x80\x43\xd5\xf8\x80\xce\x52\x76\xe2\x14\x4d\xee\xcc\x8c\xcd\x74\x3c\xb7\x4e\x44\x27\x6e\x3f\x7f\x1d\xc8\x62\x28\x2a\xbd\x90\x1a\x43\x89\x6a\x11\x3f\xdd\x74\xb6\xce\x61\x93\x28\xbc\x47\x47\xe8\x0c\x6e\x74\x2c\x7c\x7f\x47\x94\xe2\x5e\x75\xeb\xe8\x50\x63\x4c\x86\xb0\xf3\xf3\xc9\xf0\x2a\x00\x85\x24\xa6\x26\xe6\x30\x50\x4a\x66\xa2\x0f\xdd\x66\x6f\x3d\x94\x29\x80\x22\x21\xd2\x1c\x08\x6a\x52\xc6\xe0\x72\x12\xa2\x62\xb7\x6f\x33\x53\xcf\xa1\x54\xad\xdb\x35\x78\x9d\xc4\xd4\xf7\xff\x9f\xb9\x6b\xeb\x8d\xea\xd8\xd2\xef\xf3\x2b\xb6\x46\x8a\xc8\x68\x6c\x07\xa2\xf3\x44\x1e\x46\x0e\x17\x8f\x47\xc1\x20\x6c\x72\x34\x27\x44\xa8\xed\x6e\xdb\x3d\x69\x77\xf7\xf4\xee\xb6\xe3\x89\x90\x6c\x38\xc6\x76\x88\x81\x8c\x80\x90\xc4\xe1\x7e\x0b\xc1\x01\xcc\x49\x30\x60\xc8\x8f\x09\xdd\xb6\x9f\xf2\x17\x66\x5d\xaa\x6a\xd7\xbe\xac\xda\xbb\xdb\xc0\x44\xa3\x39\x0a\xee\x5d\xf7\xaa\x55\xab\xd6\xe5\xfb\x96\x17\xd9\x18\x24\x37\x0f\x8a\x90\xb8\xb4\x94\x68\x92\xa7\x64\x34\x6f\x6a\xbc\x38\xc2\x13\x6f\x64\x01\x93\x94\x92\xbe\x02\x9b\x2e\xdf\xa8\x85\x11\x1f\x31\x49\xb4\x1b\x49\x81\x5d\xf9\x20\xf6\xd1\xe7\x24\xd0\xe6\xec\x2f\xad\xb5\xfb\xad\xe5\x2b\x0c\xe2\x61\x7f\xc0\x54\xc0\xc8\xa7\xf7\x4c\x78\x2d\x0d\x8d\x33\xe3\xb9\x9d\xd5\x6b\xd1\xbd\x6a\x8c\x04\x38\x8f\x22\x43\x3b\x52\x69\x3e\xe0\xcb\x45\x39\xf4\x39\xf6\x82\x52\x31\x5c\x24\xaf\x19\xda\x66\x42\x1d\x31\xd0\xc3\x6e\x9b\x25\xe3\x76\xda\x86\x53\xd9\xee\xc8\x39\x95\xe6\x75\x0d\x3e\xd6\x81\xf4\xe1\xdb\x1d\x68\x7f\x06\x6a\x62\x66\x37\x6c\x60\xb8\xf5\x7a\x94\x19\x8b\x5f\x30\xac\xa6\x57\xfc\x3a\x7a\xb8\x58\xae\x74\x83\x3a\x7f\x70\x70\x88\x1e\x56\xd0\x5f\xbc\x28\xbb\xbb\xa1\x93\xf9\xca\x44\x37\x57\x0e\xf7\xe2\x58\xa1\x5c\xa8\x05\xc2\x8a\xff\x4e\x2c\x6f\xe3\x20\xd7\xaa\x44\xb8\xe5\xe2\x7a\x4b\x4a\x57\x87\xf7\xb6\xd2\x2d\x57\xe8\x40\x46\xef\x53\xbb\x63\xc8\x1e\x41\x17\x3d\x3b\x9b\x18\xa9\x90\x69\xce\xf5\xd7\xe1\x3e\x43\x81\x8d\xf3\xd7\x51\x2d\x20\x92\x31\x63\x2f\x67\x56\x38\x7e\x54\x31\xbf\x97\xfc\x2a\xb2\xa3\x43\x6d\x9d\x1a\x54\xef\x46\x29\xef\x29\xf6\xea\x1a\xa2\xc8\xc8\x2f\x3a\xb1\x6e\x7c\x49\x51\x86\x99\xb9\x40\x02\x22\x6a\xba\x03\x70\x29\xab\x55\xf1\xa5\x48\x19\x01\xbc\x5f\x22\xe2\x99\x85\xbd\x4e\x46\x91\x47\xa7\x7a\x50\xaf\x10\xef\xfa\xb4\x62\xbd\xf2\x99\xee\x9d\xe0\x80\x0c\xeb\x2b\x45\xf5\x2a\x12\x62\xdc\x3a\xe2\x3a\xdf\x9e\x55\xee\xd2\xef\xfe\xce\x64\x56\xcd\x9b\xf7\x9a\x37\xbf\x63\xc3\xe6\xd6\xd2\x2f\xcd\xb9\x5b\x29\x3c\xae\xdc\x31\x1c\x7c\x59\xa5\x65\xa9\x94\x3b\x8b\x97\x02\x8d\xd7\xa8\x6e\x21\xe2\xe2\x91\x5a\x09\xb4\xab\xdd\x22\xe2\xe2\x32\x6b\x66\x35\xf3\xa9\xf7\x6a\xed\x4b\x9e\x22\x4e\x9b\x33\x44\x8e\x3a\x4d\x4b\xb2\xa5\x74\xd8\x31\xce\xd3\xaa\xd4\x50\x9f\x40\x6d\xae\x58\x15\x95\xb9\x76\x9a\xa8\x25\x36\xf1\x8e\x2f\x75\x1e\x03\xd1\x39\x36\x0e\xc1\x9a\x30\x2e\x0f\xd3\x16\x6b\x15\xdf\x37\x42\x12\x64\xc5\x5e\x8c\x55\xa7\xcd\x58\x67\x63\x47\xcd\xa2\x83\x08\x10\x75\x98\x78\xaa\x8b\x44\x00\x7d\x46\x56\x1f\xdc\x44\x68\xb2\x53\xfa\x4a\xd0\x62\xa3\x4c\xa7\x84\x1c\x04\x47\xcb\xbd\xfc\x56\xf0\xf4\xa3\xc1\x9b\xca\x95\x95\x3d\xd5\x50\x30\x25\x87\xf1\xfd\x9b\xc8\x31\xb3\x72\x93\xc3\xec\xd0\x5d\xb4\x7c\xd7\x96\xe3\xa0\xbe\x60\xa6\x3d\x85\xe2\x91\x9c\x51\x21\xf3\x3f\x9f\x6c\x2d\x9f\xb4\x49\x2b\x0c\xd0\x8f\x11\x16\xa0\x17\xbd\x5a\x3b\x4f\xbc\x92\x84\xfa\xa4\x1b\x41\x78\x7b\x7a\x83\xd9\x07\x4f\xe9\x91\x2c\xcc\x67\x6e\xb4\xce\xdc\x62\xa9\x06\x2f\x96\xeb\xcf\xd0\x65\xa7\x99\xa1\x92\xe3\x01\x9d\xfc\x3b\xb4\x7a\x3a\x42\x07\xd3\x47\xca\x3b\xea\x9a\x80\xd3\x38\x2b\x51\x6a\x7c\x56\x98\xf6\x65\x1b\xa7\xe6\x01\x5a\x53\x04\x9a\xec\x1e\x64\xcf\xbd\xe3\x3c\x62\xdb\xa4\x5d\xeb\x9b\x05\x99\x95\x73\x9a\x13\xcf\xe8\xde\x14\x93\xe3\x68\x5c\x41\x1e\xb0\x86\xc6\x01\x09\xda\x91\xcc\x9e\x6c\x77\x17\x68\x9b\x71\x86\xb0\xc6\x31\x64\x5b\x3c\x5a\xd4\x7a\x3c\x71\x53\x71\xa0\x8d\x6d\x06\x90\x98\x94\x40\x98\x1a\xea\x3d\x09\xed\x92\xf3\x52\xcd\x8a\xf2\x6b\x29\x12\x44\xee\x5a\x48\x76\xd1\xb1\x6a\x42\xc4\x99\x64\x4a\xd3\x74\x3b\x52\xc7\x7e\xb8\xcc\x3c\x98\xfc\xb5\xc9\xf6\x65\x17\x9a\xd4\x52\x55\xbd\x7a\x73\xf9\x7c\x37\xab\xd5\xdd\x28\x33\x76\xf0\xb4\x8d\xa1\x23\xb0\xa6\xd2\x98\xab\x52\x18\x55\xec\x8d\x1b\xad\x0c\xaf\xd4\x6f\x9f\x83\xf2\x9d\x42\x98\x33\x04\x7b\xa3\xe4\x1d\x00\x61\x22\x93\xf0\xac\xbd\xd8\xbc\x7b\xa9\x75\xea\xd7\xad\x9f\x04\x04\x7a\xae\x24\x37\x51\x69\x30\x0d\xe3\x04\x55\xe7\xbd\x5b\xe8\x19\xeb\xf1\x76\xed\x7c\xff\x2f\x07\xba\xbc\x5d\x7d\xf0\xff\x3b\xfb\x24\x4f\xb3\xdd\x48\xeb\xc2\xda\xd6\x3c\xb1\x79\xc2\xcb\xe7\xf6\x09\xae\xe1\xf7\x99\xd9\x5d\x7d\xf8\x3f\x3b\xfb\x44\x7f\xb1\xd0\x0f\x9d\xfd\x8f\x1e\x6f\x4a\x97\x6e\xab\x63\x7c\x3a\xce\x3e\x40\x1b\x21\xbf\xc1\xe0\x74\xbc\xbe\xde\x96\x1b\x13\xc3\x88\xde\x37\xaa\x64\xb7\x53\x51\x83\x76\xc5\x48\xde\x68\x75\xd1\xb8\x44\x77\x26\x98\x82\xeb\x70\xd5\x5f\xc3\x39\xcc\x72\x2c\x36\x7f\x7b\xb1\xf9\xf4\xa6\x7d\x26\x92\x6b\x3c\xd2\xdb\x1b\xe8\x6e\x0a\xf2\x87\xe9\x43\x46\x2a\xe5\xd1\xe2\x18\x3d\x56\xa5\xa3\x47\x40\xca\xf0\xa0\x04\x2d\x95\xc1\x7d\x3c\xac\xce\x65\xfe\x44\x82\x25\x38\x62\xfc\x78\x34\x46\x17\x63\x14\x0c\x9c\x03\x24\xd1\x86\x31\xaa\x1f\xc4\xea\x84\x98\x5e\x9c\xa1\x15\x43\xd7\x15\xb4\xc4\xab\x6c\xda\x80\x1f\xa6\x72\xf0\xae\xcd\xf7\x78\x83\xa0\xae\x4e\x58\x8f\x13\xac\x49\x87\x07\x90\x05\xbf\xbd\x7e\x0c\xf6\xf6\xed\x13\xbd\x54\x77\xe1\x32\x74\x94\x93\xdd\x5b\x58\x70\xb7\x54\x72\xdf\x61\x27\x42\x8f\xf1\xfd\xb8\x40\x7a\xb0\x16\x09\xc3\x26\x25\x4a\xee\x48\x59\xbb\xb0\x14\x0d\x68\x92\xed\xa9\x87\x94\x3d\xce\xde\x97\x7d\xab\x0c\xe3\x40\x0f\xbd\x44\x0b\x14\xa9\x10\x76\x3d\xa9\x1d\x62\x1f\x4d\xa5\x5c\xa0\x70\x10\x82\x34\x50\x54\x39\x0a\xc6\x82\x75\x05\xb8\x37\xab\xb0\x07\x45\xcf\x31\x77\xec\xe5\x65\x46\x9c\x60\x42\x56\xf4\x69\x2e\xad\x36\x5f\x7e\xc3\x74\xda\xad\x99\x3b\xaf\x9e\xdf\xd8\xb8\xbe\x9e\xda\xa9\x06\xbe\x12\xeb\xc4\x14\x28\xe9\x07\x4a\x6f\x22\x44\x01\x51\x0f\x08\xaa\x64\x4d\xb1\x4b\x3d\x44\x77\xe8\x77\xe5\x8e\x8c\xb9\xb5\x6a\x78\xa4\x8e\xe1\xd3\x84\x5f\xa7\x56\x35\xe9\x49\xb6\x76\x5f\x98\xda\xbd\xe0\xed\xd9\x43\xef\xc4\x8f\x99\x0b\x3f\x11\x55\xac\xbd\x67\x62\xd0\x48\x65\x18\x03\xf8\xb4\x79\x8c\x5e\xef\x78\x80\x0b\xc6\xb2\x45\x6f\x00\xf3\xaf\xb4\x1d\x77\xf6\x22\x2c\xa3\x0a\xaa\xba\x77\x3e\x5a\x96\x50\xbc\x6d\x32\x3c\x07\x31\x40\xd0\xc5\x6a\xae\xe6\x47\xe7\x80\x1d\x4b\x87\xfa\xd5\x3f\x31\x8e\xa5\xcd\xf1\x33\x77\x73\x4e\x45\x7c\x2b\x26\x37\x97\x97\x0e\x6d\x26\xbf\x2e\x28\x05\x33\xcc\xb6\xec\x6e\x24\xa0\x8a\x48\xcc\xd6\xa3\xa6\xdf\x2c\x87\x4d\xac\xe7\xd1\x96\x22\x0a\x73\xa4\x8b\x62\x50\xc1\x91\xf2\x30\xfb\x73\xc3\xd9\x44\xd9\x67\xd3\x4e\x2a\x0a\xb0\x51\x51\x01\x45\x1f\x54\x07\x8d\x32\x60\x6b\x9d\xf5\x87\x30\x6e\x2b\x6e\xeb\x24\x5f\x7a\x5b\x1d\xe4\x58\xca\x58\xd0\x20\xbc\x05\xed\x2f\xb7\xbe\x3f\xf5\x06\x07\x61\x91\x21\x6c\x63\x10\x12\x05\xc3\x76\x86\x12\x49\x24\x51\xdb\x80\x64\x69\x9b\xc7\xd3\x5d\xa5\x33\x16\x88\x37\xbb\x9d\xa2\xb2\x30\x1f\x0d\xf0\x4c\x1f\xce\x08\x36\x57\x2a\xb5\xab\x3c\x51\xe1\xc4\x08\x23\x3e\xe6\x12\x74\xc3\xff\x5f\xfc\x11\x4f\x97\x98\x57\x90\x9c\x81\xe8\xc8\x50\x10\xd0\x25\xcc\xac\xa7\x08\x13\x9c\xbb\x89\xdc\xb4\x07\x37\xdc\x64\x81\x7d\xdd\x13\xf0\xbf\x8c\x91\x15\xb1\x49\x4f\x36\x4a\x68\x3d\x86\x6b\xe2\x03\x8f\x5e\x44\xc5\xf8\xab\x41\x86\x3e\x51\x01\x3e\xbe\xad\x46\xd0\xed\xba\xb7\x12\x7a\xe7\xc3\x77\x23\x85\x42\x5e\x7a\xdc\xff\xd9\xbb\xed\xbd\x3b\xfd\x5e\xf9\x5f\xd2\xa6\x3c\x89\x03\x31\x7b\x9f\xde\xd4\xee\x4d\xeb\xb5\x9f\x0e\xd9\x47\x23\x51\xf1\x94\x91\x3b\x80\x7a\xd2\xc8\x46\x5e\x12\x17\xa4\x89\xad\xc1\x69\x51\x67\xad\x11\xbb\x84\xd9\x53\xfa\xf4\x34\x47\x60\x36\x67\xd6\x33\x09\xa2\x8e\x87\x69\x6e\x89\xb7\x3b\x4c\xfb\x5a\x79\xa3\x83\x85\x1f\x60\xcf\xe5\xca\xea\xe1\xc1\x40\xcd\x7e\x88\xa7\x35\xe3\xa0\xc5\x15\xcb\x3c\x19\xee\xce\xa4\x0e\xbd\xf0\x79\xb5\x30\x82\xd6\x6f\x36\xcd\xa3\x15\xb4\x32\x42\xd9\x1e\xf9\xdd\xf4\x4a\x53\x36\x78\x49\xf5\x66\x27\xc3\x0f\x97\x61\xb2\x5b\x44\xda\x6e\x1c\x0e\xa1\xd2\x42\xeb\x74\xbc\x15\xd6\xbd\xf6\x92\x63\xa6\x92\x4a\x3a\xe1\x38\x13\x2f\x57\x1b\x6b\x60\xcc\x9d\x64\x32\xb9\x73\x83\x6c\xdf\x8b\x9b\x37\x7e\xe0\xa8\xe2\xe6\xfa\x85\xd6\x85\x35\xbc\x11\x16\x67\x38\x5d\x29\xa2\xfc\xa7\xf4\x07\xf7\x82\xea\x8e\xf1\xb7\x0f\x64\x52\x83\xed\xbe\xd8\x0d\x26\xd5\x23\xf4\xa1\x54\xc1\x84\x15\xdb\x3f\xcf\xe1\x48\xf4\x24\xe1\x58\x1e\xd1\x78\x44\xad\x6f\x9d\xb9\x88\x60\x0d\x96\xbf\x9d\xe3\xb0\x99\xf4\x8b\xe3\x75\xa4\xc6\xfd\x04\x1c\x97\x54\xd8\x16\xda\xab\x0a\xe3\x22\x88\xa3\x73\x0c\xd1\xef\x18\x41\x81\xa7\xd7\x02\x4e\x30\x3a\x02\xe1\x36\x3c\x12\x23\x5e\xb9\x51\x07\x98\x02\x1d\xec\x37\x07\xa6\x40\x1d\x17\xbc\x24\x02\xd2\x82\x19\x91\x3c\x93\x1c\xd9\x95\xce\x62\xcb\x8b\x9e\x1e\x9e\x65\x2a\xcc\x04\xd1\xa0\x6a\x4d\x05\x67\xb0\x6a\xe5\x5b\x3d\x67\x68\xa8\x9c\x35\xc7\x11\x19\x33\xd6\xef\x64\xdd\xb5\xeb\xce\xca\xb7\x1b\x6b\x21\x0d\xd5\xd9\x6e\xc3\x11\x55\xa4\xeb\x2d\x5b\x21\xd7\x05\xbf\xd2\xa8\xe9\x07\xbb\xb3\x7e\x0e\x9d\x46\xe7\xde\xe3\xf9\xd6\xb3\x73\x4e\x7b\x40\xbc\x21\xcb\x2c\x90\xad\x15\xfb\x95\xee\x6c\x25\x31\x50\x3e\x6d\xca\x5c\x35\x72\x2e\x90\xfa\x6f\x57\x2e\x10\xf7\x98\xf3\x3a\x82\xcf\xe5\x9a\x71\x1e\xde\xf1\x13\xc0\xbe\x10\x28\xea\x1d\x5f\x32\xec\x04\x70\x55\x89\x85\xd5\xbc\x21\xa4\x12\xd6\xe1\x6e\x3e\xc7\xe1\x36\x2a\x10\xdd\x27\x01\x3a\x49\xde\x76\xfa\x43\x7e\xcf\x1e\xdb\xd4\x84\xd1\x2c\xe5\xc2\x54\xa1\xd6\x83\x38\xb6\x35\x93\x97\xa9\x62\xbd\x8b\x3e\x95\x55\x2a\x6e\xb8\xa8\x28\xb8\x78\xaf\x52\x48\x4e\xeb\x5b\xcc\xde\xda\xbc\xcd\x38\xff\x72\x2f\x10\xb2\x70\xe1\xa2\x1a\x27\xc2\x17\xde\x57\x3e\x44\x9d\x20\xaf\x12\x6c\x2f\x3d\xf0\xa4\xee\x60\x1d\xb2\x21\xd2\xcc\xce\x9f\x20\x57\x5e\x0d\xf3\x8d\xa7\xc9\x98\x41\x87\xc8\x96\xdb\x24\x54\x8e\x4b\x7a\xa1\x12\x77\x17\x12\xad\x85\xaf\x77\x42\xdb\x34\xf7\xe9\x9e\x65\xd0\xd1\x5f\x8b\x06\x1e\xbf\xdc\x92\xda\x4a\xed\x6c\xf4\xc2\x7b\xdd\xa0\xfb\xc2\x45\x99\x65\x1e\xa3\x74\xd2\x6f\x64\x95\xd3\x81\x8c\xb3\x77\x35\xc1\x18\x10\xeb\x73\xb6\x53\x62\xf5\x79\x40\xec\x73\x14\xbe\x36\x73\x77\x13\xec\xed\xaf\x5f\x1c\x25\x99\xcc\xb3\xf4\x2e\x04\xfe\xfc\x27\x34\x0a\x76\x26\x6d\x23\xa9\x71\x82\x25\xd0\x31\x3b\xa5\x4a\xce\xd8\x4e\xd1\x75\xee\xd3\x83\x80\xf4\x0e\x66\x60\x72\xab\x02\x2f\x2f\x07\x5f\x52\x2c\xde\x89\xc7\xf6\x05\xc0\xc1\xdb\x69\x6d\x6f\x47\xee\x73\x9b\x9d\xcb\x7d\xdd\x87\xe8\x4d\x95\xde\x66\xd6\xcb\xcd\x6a\xe1\x6f\xc5\xea\x7e\x98\xe3\x0f\xa7\xe1\x29\x8b\x38\xf4\xf0\x27\xfc\xf7\x1e\x8c\x3d\xc1\xa7\x58\x51\xe6\x06\x8a\xb6\x1c\xae\x0a\x1e\xba\x91\xba\x30\x92\xd4\x35\xf9\x22\x0c\xab\x08\xb6\x9a\x90\x2e\xd4\x4e\xee\xfc\xf6\xf3\xe3\x75\x07\xac\x9c\x33\x42\x7e\x25\xe4\xee\x3a\x67\x2c\x29\x7d\x10\x8f\x30\xa1\x0f\x39\xbc\x61\x56\xcb\x41\x46\x19\x1c\x50\xc6\x83\x05\x35\x4f\x21\xc4\xb2\x76\xc7\xa8\xb0\x1c\xcb\xfd\xbf\x5f\xb9\x32\xfd\xb0\x9b\x39\x74\xda\x77\x93\xd3\xbe\x9a\xf3\xfd\xa9\x4a\x8d\x8c\xd2\xa5\xca\x58\x51\x24\x96\x50\xf1\xd3\xca\x1b\xdf\x7c\x70\x6a\xe3\xfa\x3a\x46\x3e\x13\xcb\x94\xd8\x94\x25\xd3\xea\x39\x31\x34\x3e\x21\x83\x16\x46\xf3\x48\x48\x43\xa7\x6a\x31\xba\x95\x26\x53\x49\xa9\x6c\xce\x78\xd3\x50\xac\x7c\x06\x2f\x3c\x3e\x9f\xd2\x92\xa5\xe3\x23\x11\x63\x7c\xb1\xbe\xd4\x6a\x9c\xa5\xf1\xfe\x49\xab\xc0\xe9\x4f\xf7\xd9\x47\x61\xe3\xcb\x18\x71\x29\x26\xc3\xa8\xaa\xc3\x40\x2f\xa1\x72\x8e\xc6\x6a\x21\xd2\x3b\xf2\x2c\xb8\x9b\x31\xc1\xfc\x56\x01\x47\xfd\x8c\x23\xf3\x05\xc1\x07\x64\x96\xd1\xd4\x12\x43\xc0\x24\x14\x4d\x6c\xed\xe3\x7d\x87\x07\xfb\x0f\x0e\x88\x41\x45\xf4\xf8\x12\x82\x8a\x3e\x46\xac\x2b\xef\x3f\x06\x0f\x0e\x78\x95\xe1\xff\x42\x22\x1d\x85\x99\x64\x29\x55\xdd\x0a\x00\x68\x44\xc5\x8d\x35\x6a\x1c\x4b\x53\xcd\xd5\xa0\x63\x75\x78\xad\x75\x05\x27\x4b\xc1\x68\x17\xcb\xdd\x25\x0c\x0d\xa9\x50\x42\x51\x8e\xd6\xb3\xc7\xdb\x4f\x18\x88\x9a\xa3\x56\x05\xf2\x16\xf2\x8e\x7a\xfd\x02\x9a\xfe\x46\xc8\xb6\xcb\xbf\x6a\x02\x5e\x07\x92\xa2\x08\xc6\x42\xc0\x4e\x8a\x47\x8d\x00\x15\x39\xcc\xad\x79\xf6\x24\x42\xd7\x60\x9a\xdf\x62\xeb\xc2\x02\x4f\xc7\xc6\xe2\x8f\x64\x16\x5d\xd8\x9a\x39\xbb\x35\x7b\x06\x33\x0b\xe6\xee\x10\x06\x36\x5e\x15\x86\xd7\xe2\x8f\xf5\x45\x86\x29\x02\x91\x8d\x7f\xa4\x00\xe3\x68\xb5\xb4\x33\x59\x88\xc3\x1f\xb7\x2e\x3e\x6a\x5d\x9c\x87\xca\xd1\xe0\x4a\x11\x29\x12\xba\xa3\x78\xfe\x5f\xfb\xb2\x15\xcb\x7f\xbe\xe5\x12\x87\xde\xe0\x20\x20\x42\x6e\xdf\x01\xda\x58\xb7\xd6\xfa\xbb\x29\x47\x70\x87\x26\x5a\x1a\x2e\x78\xe5\xc2\x18\xd4\x37\x29\x1a\xe1\x08\xb0\x3d\xb9\x12\x62\xd3\x5f\x07\x59\xbc\x79\xf2\x45\xeb\xd2\x83\xcd\xd5\xab\x62\xec\xa6\x01\x4d\x1a\x90\xa5\x20\xa7\xed\xba\x44\xe0\xc7\x8c\x28\x70\x48\xdd\x82\x52\x64\x26\x41\xcd\xf1\x9d\x27\xd6\xe3\xa0\xe9\x67\x71\x20\x94\x44\x1d\x01\x43\x37\xbb\x28\x38\xba\x56\x57\xa9\x0e\xca\xe4\xef\x33\x78\x92\x8e\x8b\x97\x01\x36\x58\x2d\xd0\xa1\xef\xa0\x89\xe1\x21\xa0\xe4\xd9\xdf\x67\x66\x9b\x57\x1f\x35\xbf\xfe\x12\x34\x03\x56\x1a\x24\x19\xfd\xd7\xde\xc3\x03\xfd\x03\x7d\x8c\x84\xc1\x57\x1d\x6e\x6e\x52\x5d\x8c\xa2\x80\x01\xf9\xc6\x07\xc4\x3b\x98\x92\x79\xd0\xca\x35\x5e\x1c\x1b\x2f\x4d\x63\x4a\xcf\x08\x94\xc9\x8d\x15\xf2\x54\xd5\x7f\x86\x2a\x40\xa7\x38\x6c\x93\xc9\x22\x67\xae\x61\xc4\x19\xca\x2f\x9f\x86\xad\x7e\x44\x54\xbe\x1a\x1f\x12\x6e\xde\x1f\x2f\x94\x4a\x50\xbf\x8f\x99\x9a\x08\x6d\x24\x2d\xf9\xca\x6d\x18\x29\x8f\xa0\xb9\xfe\x64\xe3\x24\x82\x76\x6d\xae\x3c\xc4\x3d\x75\x7b\x56\x3d\x43\x48\x67\x52\x2a\xcc\x8b\xe5\x8d\x13\xcf\xd8\x3f\x05\xf2\x86\x13\x89\xb8\x34\x91\x80\x23\xcb\xe1\xd9\x07\xb8\x1d\x97\x4f\x6e\x2c\x9f\x46\x4e\x0e\xab\x34\x43\x40\x61\xe2\x86\xfe\x86\x32\x38\x7e\x85\xd7\x3e\xc6\xa9\x2f\xdf\xf5\x06\xa9\xdf\xad\x95\x27\xf0\xe2\x80\x37\x11\xf5\xdc\x39\xf7\x1e\x65\x20\x28\x80\xb3\x0a\x65\x3e\xc0\xd1\xf6\x19\xe0\xcc\xe6\xad\x57\x16\x02\x15\x5d\x19\x4e\x02\x8c\x03\xb8\xa2\x72\x04\xdb\xac\x3c\x06\x45\x02\x68\x94\x8a\x61\x3f\xe3\x6a\x68\xb9\xd9\xdf\xe3\xbd\xbf\x73\x27\xfe\xfe\x97\x5d\x3b\xbb\x74\xfa\x5d\xbc\x5e\x74\x4c\x0e\x17\x0a\x65\x4d\x3c\xd1\x45\xe1\x0e\x8c\x21\x59\x1d\x27\x03\x2a\x2e\xa4\x8f\xeb\xb8\xa7\x54\x69\xe4\x41\xc0\x35\xca\xf9\x1a\x12\xf4\xc3\xcb\x37\x37\x9c\xf3\x0b\xcc\xf8\xfe\x59\xb9\x32\x55\x2a\xe4\xc7\x4c\x56\x72\xac\x2d\x1d\x5f\xcc\x69\x42\x79\x76\x0d\x85\x2a\xb5\x51\xe2\xcc\x34\xb1\x13\xd9\x57\x87\xca\x20\xcf\x8a\xb9\x2b\xbc\x83\x10\x7a\x63\xe5\x26\xa3\xba\x35\x67\xe7\x91\x2f\x63\xf5\xea\xe6\xea\x7d\x93\xd9\x62\xc8\x20\x25\x53\x8a\x0a\x7f\x3c\xb5\xc4\xfa\x05\x5e\x63\xcb\xf7\x38\xba\x95\xe6\x16\x19\x2a\x60\x72\x83\xdc\x9f\x27\xab\x1c\x25\x1a\xe6\x13\xc2\x0d\x86\x08\xfb\xb3\xcf\x36\x2e\x20\xef\x03\x6f\x2d\xf8\x6f\xdc\x5d\xa1\xd1\x7b\x8c\x44\xdc\x7c\xf6\x13\xa7\x39\x42\x29\x93\x76\x14\xf9\x12\xf1\xfa\x1e\x2e\x45\x07\xc2\x99\x4c\x57\x6e\x6d\xae\x5c\x32\xb8\x76\xca\x86\x45\xce\x6a\x90\x1f\x36\x1a\x2f\x5f\xc3\x6f\x71\x37\x1b\xfe\x9c\xe4\xdd\xcc\xdb\x14\xfd\xd6\xb1\x3c\x01\xce\x91\x78\xc3\x1b\xb5\xb3\xfd\x19\xf4\xd1\xde\xa0\x7a\xd7\x22\x46\xa9\x97\xab\xd7\x0b\x13\xd5\xba\x69\x60\x22\x97\x2f\x68\x58\x96\xdc\x48\xd2\x3c\x7e\x60\x42\x5a\x6c\xc2\x3c\x3a\xd9\x98\x12\x94\x07\x75\xbf\x56\x99\xd6\x80\x7b\x91\x35\xb0\xb2\x9f\xd4\xdc\xc4\xfa\x0a\x33\x31\x8a\x29\x3d\x89\xad\x10\x53\x13\x88\x71\x1d\x76\x84\x88\x8c\x4a\x45\xe5\xc9\xd7\xf8\x49\xdd\x68\x7f\xed\x66\xfb\x6b\x25\xf6\xa3\xea\x0d\x8d\x73\xa2\x6a\xb2\xf5\x46\x60\xdd\xca\x0d\x31\x57\x35\xe3\xe9\x8d\xe2\x79\x67\x3b\xc3\x09\x67\x95\xce\xcc\x5b\x3e\xb1\xee\xb3\xaa\xe0\x15\xcc\x59\xa5\xa3\xcb\x67\x55\x01\x36\x11\xd5\x15\xe6\x1f\xfe\x72\x4d\x1a\xf8\x1f\xeb\xdf\x47\xe8\x0f\xe9\x9e\x5b\xda\xb8\xfa\x8f\xe6\x8d\xcb\x72\xa9\xaf\x78\x08\x2a\xb1\x4d\xcf\x40\x98\xb2\xee\x44\xa4\x66\x0c\x2f\x7d\xf9\x15\x66\x58\x9f\xb8\xcb\xf7\x28\xe6\x2f\xd2\x37\x8e\x0d\x83\xe2\x33\x79\xc7\xbc\x7a\x79\xaa\xf9\xf3\x57\xad\x85\x73\xcc\xe6\xd5\xb6\x8c\x2a\xa2\x10\xa8\xe3\xf3\x9a\x20\xf8\x42\xeb\xf0\x41\xe4\xb0\x58\x30\x5d\xc3\x05\x7d\x20\x31\xdb\x95\x40\xac\xd8\x65\xec\x27\xb2\xb7\x85\x4b\xe6\x4a\xd0\x20\x66\xcc\x50\xa2\x7f\xad\x38\x91\x83\x35\xc7\x13\x38\x82\x51\xfd\x41\x72\xbf\xdd\x49\xca\xad\xab\x96\x28\x5b\x32\x76\x86\x29\x57\xa7\x88\xe7\x66\x82\x58\x3d\xf0\xe8\x4c\xee\xf2\x06\xc3\xfc\x87\xe8\x4e\x54\xd7\xbd\xb3\xe0\xfb\xf4\x25\x22\x95\x17\x30\x86\x31\x59\x7e\x91\xbc\x83\x36\xd0\x71\x4a\xbd\x83\x62\xf4\xdf\x3d\x9e\xf7\xd7\x42\x00\xb4\x8c\x09\xbc\x5a\xf4\xa8\xcf\x4d\xc8\x09\xe1\xc8\x34\x38\xd8\x25\x5f\x99\x2a\xeb\x8f\x02\x61\x80\xa4\x57\x04\x80\x9f\xcf\x13\x70\x32\x2c\x52\xa4\x0b\xc3\x05\x02\x3f\x67\x94\xdc\x1e\xef\x20\xea\x0e\xae\x1b\x61\xa2\x38\x86\x78\x03\xf9\x2e\xdd\x58\x80\x21\x07\x9d\xe5\xd1\x60\x9e\x9d\x53\xb4\xa7\xca\x23\xcc\xf8\xbc\xf4\x20\x72\xaa\x99\xd5\x64\xeb\xe4\x5d\x16\x55\x70\xea\xf8\x88\xa6\x1d\x4e\xa5\x75\xaa\x8f\x09\xad\x20\x72\x99\x73\xec\x01\xba\x7f\xb5\x1c\x44\x73\xfc\xda\x73\x38\x5a\x20\xc8\xb6\x66\xce\x43\x67\xf8\x95\x4d\x27\xd6\x12\x1c\x2f\x2f\x07\xfc\x77\xe4\x7d\x56\xf9\xa9\x20\x7d\x2e\x5d\xdd\x9c\x7f\x8c\xbf\xbe\x1f\xfc\xaa\x82\x98\x40\xed\x85\xe2\xa0\x4c\xeb\xb2\x01\x53\x65\xdc\xc9\x04\x9b\xe9\xf7\x99\x25\x87\xdc\x45\x41\x72\xf6\x22\xa6\xfc\x9c\x78\x16\xd4\x4b\xad\x72\x28\x13\xcc\x5b\xac\x10\x4a\x16\xd2\xf5\x51\x8e\x3c\x9c\x8f\x8c\x82\x73\xa6\x39\x46\x89\xd1\x1c\xb6\xbe\x59\xde\xba\xb8\x68\x3e\x4b\xec\x05\xe2\x64\x5e\x5a\x6d\xad\x5c\xe7\xfc\x65\x7e\x13\x18\x41\x06\x92\x7a\xf3\x45\x48\xfa\x1b\x59\xd6\x5c\x7a\x8c\x58\xc2\x2f\x2f\xc7\xe5\x38\xcb\xf7\x08\xc9\x20\xca\x6b\xea\xa7\x2c\xae\x72\x35\xbc\x6b\x77\x23\xe0\x0f\x83\xaf\x61\x06\x5d\x18\x2d\x82\xe1\x60\x30\x30\xc3\xfa\xc4\x0f\x7d\xe3\x2b\x74\x40\x83\x7a\x9e\xf2\x94\x42\xf0\x58\x82\x8c\x81\xa7\x4f\x08\x9a\xcd\xb4\xce\x71\x65\xf8\x1d\xbf\xb4\xd8\x9c\x16\xfa\xce\xb7\x3e\x14\x1f\x40\x7a\x7c\x0a\xd5\x04\x13\x27\x99\x96\x49\x59\x1d\xe0\x45\x7c\x0c\x51\xe9\xfd\x63\xc3\xd3\xc7\xb4\x63\x58\x8a\x05\xb1\xf4\x00\xf2\x04\x71\xde\xdb\xe2\xd3\xd6\xcc\x1d\x6d\x80\x10\xea\x73\x77\x8e\xe3\x31\x91\x5e\x04\x3b\x88\xef\xf6\xb4\x0e\x70\xea\x28\x3f\xc5\x23\xf8\x0f\x42\x5b\xb5\x22\x48\x42\x58\x3e\x50\xf6\x2a\x79\x42\x7e\xdc\xdf\x8f\xd4\x7f\x01\x64\xb2\x5f\xcf\x83\x1e\x27\x99\xdc\x1e\xce\x73\x69\x38\xee\x5b\x3f\x9d\x47\x5c\xe2\xb9\x5b\x70\x70\xa9\x16\x03\x5a\xac\xeb\x70\x74\x41\x63\xce\x4e\xa2\xf9\x87\x24\xba\x22\x8a\x1a\x2d\x8a\x18\x33\xa0\xf7\xe8\xf8\x5e\xd3\x30\x9b\xe6\x92\x5b\xfa\x1b\x12\x0f\xd4\x46\xc6\x8b\x93\x85\xc0\x86\xaf\x0c\x6b\x19\x22\xe8\xfe\x07\x8a\xbf\xfa\xed\x07\x58\x5e\xb4\x11\xc2\xfb\x8a\xcc\x8d\xe9\x11\x75\x9f\x1c\x38\xf2\xd1\x50\xff\xa1\xde\xc3\x43\xef\xed\x3f\x78\xf8\x40\xf7\xde\xde\xa1\x5e\x6f\xcf\xc1\x81\xa1\x7d\x03\x43\xde\xbf\xf7\xef\xdd\xbb\x6f\xe0\xd3\xb6\x4c\x64\x9f\x1c\x3a\xdc\xff\x71\xef\xd0\x3e\x8f\x6a\xea\xa8\x86\x24\x18\x4b\xbf\xcd\x3a\xc6\x4a\x95\x61\xb8\x11\x15\xbc\xca\xa7\x46\x27\xff\x44\x07\xeb\xfa\x3d\x3d\x3d\x9f\x7a\x9f\xe8\xbf\xeb\x0f\xdb\x6a\x85\x0f\xa8\xb4\x03\x18\x4a\xe8\xbe\x40\x7f\x92\x43\xa8\x2d\xa9\x28\x31\x8a\x8b\xb9\xb0\xf0\xb2\x93\x0a\xce\xdd\x85\x3b\x54\x2c\x55\x99\x12\x73\x76\x9a\x3f\x3f\xdd\x94\x6c\x83\x99\x78\x04\x52\x18\x03\xe4\xa4\xa4\x74\x68\x62\xf4\x79\x8f\xd4\x72\xfe\xb8\xd8\xfb\x90\x2f\xfb\xc1\x4c\xeb\x9c\x10\x00\xe8\xc2\xbe\x4d\xef\x06\x06\xc9\x68\x40\x98\x51\x10\x7c\x62\x77\x54\xa4\x0b\xa5\xc7\x37\x6f\x3e\x6a\x5d\xf8\x26\xb9\xc6\x00\xb4\x52\x9e\xd4\x44\xc8\x49\xa1\x3a\xd2\x0d\x77\x07\xa1\x2b\x52\xad\x09\x17\xfc\x77\x41\xa1\xe4\xba\xb5\xfc\x91\x3c\x3d\xe1\x78\x6e\xc1\x59\x37\x8c\x6e\x70\xd2\x67\xd1\xdb\x2e\xce\xdf\xab\x17\x4b\xcd\xb9\x93\x84\xe5\xbf\x00\x53\xf0\x6a\xed\xf4\xa6\x83\x49\x60\xa4\xda\x68\xeb\xd4\xa6\x6c\xa5\x73\x4b\xb0\x83\x1c\x25\x65\xb6\x2c\x57\xd1\x7c\xc0\xea\x2b\xdd\x93\x0e\x1e\x36\xc5\xe3\x25\x95\x4c\xa5\xdf\xca\x17\x7d\xf7\xf1\xdf\x80\xbd\xba\x72\x5d\x2c\x2c\xdd\x3a\x1b\x37\x66\x37\xae\x0b\x51\xcf\x58\x4c\x74\x0b\x52\x39\x71\x9b\x64\xf4\x61\xa7\x7a\xaa\x39\x94\x5e\xea\x83\x83\xd8\x50\x88\xc1\x27\x5a\x0e\x05\xe3\xc4\x9f\x74\x31\x30\x75\xd9\x83\x2d\x6d\xfe\x28\x66\xc0\x27\x87\xd7\x23\x7c\x92\x45\x5a\x68\xb1\x29\x2c\x34\x1f\xdd\xe7\x3f\x12\x26\x81\x86\x6b\xdb\x7d\xb4\xac\x83\x22\x46\x46\xcd\xdb\x9f\xba\xd5\xcd\x3d\x20\xae\x62\xc5\x52\x1c\xd4\x9c\x32\x4f\x89\xc3\x0d\x8f\x4c\x0d\x37\x3c\x07\x1d\x0c\xd7\x1a\x59\x30\xdc\x70\x4f\x53\x86\x1b\x1b\x67\x78\xb2\x5c\xe3\x94\x79\x45\x54\x87\xc4\x5d\x39\x25\xed\x25\x7e\x41\x25\x17\xe3\xcc\x18\xf1\xde\x25\x82\x08\x31\x2d\x44\x21\xfb\x52\xf4\xcb\xa1\x1a\x5a\x3d\xea\xd3\x3a\xae\xc6\x1f\xb7\x21\xf1\x90\x28\x41\x1a\x57\x94\x5e\x37\x5a\x13\x3e\x9f\xe7\x17\x37\x7f\x5c\x85\xb5\x61\x66\x04\xa1\x37\x93\x72\x96\x93\x8b\x4b\x8f\x2f\x4b\x0f\x9e\x30\xcc\x82\x32\x3a\x8a\x9a\xad\x8f\xc4\x5a\x85\x91\xf1\x0a\x99\x75\x8c\x57\x0c\x9a\xa8\x4d\x5b\xb9\x5d\x59\x68\xd4\x79\xfe\xd9\x15\xb5\xb9\xbe\x06\xda\x36\x3f\xf2\x5b\x67\xee\x34\xcf\x3e\x64\x5f\x03\x3c\x39\xf8\x2e\x0e\xe5\x7e\x65\x60\x5b\x47\x7f\xb4\x23\xc2\x04\xf4\xed\xa6\xa4\x6f\x8c\xd6\x0a\x64\xca\xa9\xe6\x8a\xe2\x06\x98\x5b\xda\x5c\x7d\x8e\x98\x8a\xcf\x2f\xc1\x7f\x24\xd7\x13\x8f\xe1\x87\xb3\x29\x54\x98\x10\xef\x7f\xe9\x41\x1b\xd5\x6a\x6d\x0f\x5e\x85\xf2\x9e\x55\xd9\x54\xb1\x0a\xda\x68\x87\xd8\x9d\x98\xd3\x23\xfb\x48\x96\xef\x05\x7c\xd0\x42\x5b\x15\x5f\xdc\xa2\x84\x63\x99\x5c\xcc\x38\xd7\x14\xae\x54\xa9\x38\x51\x14\xc7\xcf\xa9\xf3\x1a\x24\x6a\xeb\xdb\x73\xcd\x05\x61\xe7\xeb\x6a\x49\x29\xd3\x99\xc1\xfd\xe8\xe3\xc7\xb8\x42\x98\x68\xbf\x52\x66\x28\xc1\xcf\x8b\xf5\xd0\x5e\xec\xc2\xcb\xaf\x7e\xcc\x0f\x28\x43\xf0\x13\x66\x10\x91\x35\x3b\x65\x79\xff\x2e\xde\x1a\x4a\xca\x33\x57\x9a\xdf\x5f\xe5\x5f\x63\xed\xc1\xef\x56\x83\xc1\x47\xa6\x45\xe7\xf8\x44\x05\xd6\x91\x5c\x64\xca\x8a\x2a\xa5\x1e\x8d\x54\x9e\xc8\xf2\xbc\x62\x79\xbc\x00\xcf\x74\xe6\x0c\x83\x6b\x4c\xc7\x71\x49\xda\x92\x15\xb0\xc5\xc1\xb9\x1b\x4f\xd7\x5b\x8b\xbf\x29\x14\xae\xbf\x5f\x13\x41\xcd\x75\x83\x93\x26\x0a\x44\x8b\xe7\x3d\xfb\x8f\x0d\x0e\xf5\xf6\xf5\x0f\xf4\x1d\x1b\xea\x3f\xb0\xef\xe0\x91\x21\x2d\x61\xe4\xcc\x54\x5b\x28\xc7\xcb\xab\x08\x10\xee\x8e\x55\x59\x47\x1d\x3b\x3c\x74\xe4\xd0\x76\x3a\x66\x97\x6f\xab\x63\xa5\xdc\x70\x41\xba\x95\x5c\x91\x8d\xa5\x1c\x86\xfd\x68\x1b\xbf\xb4\x3d\x16\x97\x5a\xf7\xaf\xb1\x4d\xd7\x51\x4d\xa3\xca\x6f\x0d\x71\x97\x71\x35\x14\xb1\x2b\xee\x35\x12\x07\xf2\x7b\xcf\x21\x01\x30\x5d\xd6\x75\xfb\x73\x36\x6c\x72\xd9\x09\x17\x74\x5f\x0a\x6e\x1f\x97\x95\x06\x6d\x0a\x8b\x23\x76\xdc\x78\xae\x38\xa2\x72\xa5\xec\x0d\xe7\xfc\xe2\x88\x71\x1e\x48\x73\x06\x1a\xdf\x95\x67\xad\x65\xe5\xac\x13\x6b\x73\xa0\x65\x49\x65\xea\xcc\xa2\x69\xc2\xbf\xd4\x9b\x1d\x34\x10\xe7\xe5\xb0\xb4\x35\xfb\x23\xe3\xbf\xb4\x16\x67\x0c\xde\xa3\xeb\xd2\x90\x13\x81\x39\x02\x59\x2c\x25\x92\x31\xba\x8a\xa1\x1e\x2e\x5a\x1b\x51\xfb\x4d\x2e\x87\xba\x87\x71\xfb\x90\x13\x47\x9a\x01\x52\x40\x78\x39\x5c\x08\xd8\x28\x67\xdb\x7a\x70\x63\xa3\x92\x10\x70\xb5\xe3\xe8\xab\xb3\x5c\xc5\x2f\x3a\xc4\xc6\xab\x17\xb2\x11\x56\x85\x24\x8a\xa9\xb9\x14\x35\x25\xda\xe5\xfe\xdb\x45\x1f\x9a\x42\x1c\x8a\x21\x6f\x0a\xe4\xb3\x3d\x2c\xc0\x60\x73\xfb\x0e\x56\x32\x7b\x47\xbb\x18\xca\x22\xb5\x49\x83\x89\x57\xe7\x18\x18\x67\x68\x62\xf0\x46\xad\x38\x4c\xd0\x71\x68\x1a\x38\x46\xb3\xb5\x43\x63\x43\xb6\x3d\xe6\x68\x9d\x46\x9b\x78\x7d\x55\xb2\x08\x7d\x7d\xf5\x51\x4c\x76\x87\xd5\xa5\xe3\x87\x0a\x05\x39\x30\x45\x92\x1b\x14\x5c\x90\x5c\x32\x53\x8a\x7d\x7a\x72\xbd\x92\x3c\xd2\x46\x72\x08\xff\xec\xd9\xf8\x19\xf3\xf0\xb3\x26\xc7\xa7\xa6\xc5\x77\x02\xbf\xea\xae\xe9\xb3\x82\x74\xcd\xdb\x81\x66\xee\x3a\x5c\x62\x36\x55\xa8\x87\x43\x47\xda\xda\x9b\x29\x17\xbd\x73\x89\xc9\x8e\x24\xbe\x8c\x65\xb8\x0c\x38\x40\xe2\xfa\x21\xbd\xc7\x4b\x01\x27\xd6\x95\x68\xe4\x4a\x16\xb2\x72\x26\x65\xf3\x51\x16\x82\x68\xaa\x28\xa5\x0a\xb9\xb0\x3f\x6e\x10\xc8\xad\x97\x3a\x5a\x77\x53\x4c\x4c\xb3\xcb\x68\x3f\xc3\xf2\x9c\x24\xd0\x51\xfd\xf8\xb8\xe2\x89\x70\xb4\xb4\x7c\x57\x07\x5e\xaf\xc4\x5a\x15\x9e\xec\x42\xb3\x19\x0d\x67\x9d\x8e\x4a\x55\xdf\xf6\xa0\xa2\x8d\x66\x1b\x94\x99\xc3\x51\xd9\xeb\xa7\xd7\x09\xfd\x1d\x33\x73\x18\x32\x10\xb4\x92\x75\x4f\xbc\xe5\xb5\xd2\x93\xe8\x1e\x15\x4d\xd9\x76\x46\xf5\x76\xd7\x0a\x5f\x10\xf6\x7a\x89\x04\x08\xcb\xf7\xb6\xbf\x60\xe4\xe6\x28\x67\x6a\xab\x83\x69\xac\xbb\x3c\x76\x8a\xf4\x5b\x2e\x4b\x64\xc4\x52\x69\x82\xe9\x17\x8b\x76\xc4\x8f\xcb\xb6\xa7\x8e\x0a\x56\x10\x50\xd0\x79\xb0\x44\xff\x96\x2a\xec\xe5\x28\x92\x77\x17\x3c\x17\x99\x09\x4b\xaa\x6d\xf9\x2e\x7c\xd4\xba\x7f\x4d\x87\x83\x9d\x69\x9e\xfb\x9a\xc3\x9d\x5c\xad\x60\x92\xa9\xb4\xb6\xdf\x9e\x10\x2f\x9e\x3a\x21\xbf\x67\x30\x4a\xda\xb0\xf5\x2e\x7b\x04\x59\x69\x85\x27\xca\xb5\xcb\xcd\xcb\xc2\x0c\x37\xca\x18\xee\x5d\xd6\x88\xd6\x75\x51\x5d\xb9\xff\x25\xb4\x8e\x0e\x05\xc9\x97\xd9\x28\xbb\x8d\x29\xf0\xb0\x77\xf5\xbf\xd1\x7e\x46\x34\x14\x91\x36\x95\xb3\x8c\x74\x70\xa0\x90\x78\x6a\x1a\x7e\x6e\x4c\x7c\x36\x31\xc4\xba\xa3\xac\xa8\x79\xa5\xa0\xa3\x87\x10\x8d\xd2\xaa\x30\x19\xb9\xc9\x75\x4d\x76\x9c\xc1\x35\x2d\xeb\x80\x92\x07\xe2\x0b\x86\x59\x57\x21\x79\xc7\x8f\x7b\xef\x12\xbe\x10\x77\x61\x37\xa7\xee\x17\x55\x4e\xd9\x60\x1d\x73\x1e\x8e\x1f\x97\xd8\x1c\xa2\x75\xfd\xb1\xbe\x40\xc1\x76\xd4\x63\x36\x68\xc7\x2b\x13\xa3\x0a\x30\xd1\x7d\xbf\x46\x90\xa8\x16\xdb\xd2\x88\xed\xb2\xae\x5c\xf2\xf4\xd2\x53\x39\xe6\xc4\xac\x73\x74\x72\x5f\x25\x34\x37\x7d\x15\x03\x57\x24\xcf\x89\xa9\x0b\x16\x41\xf9\x51\xa1\x9a\x70\x69\x0a\xfb\xa4\x00\x0e\x71\x5b\x50\xe2\x7f\xa3\x5c\x3f\x38\xaa\x42\xa7\x7d\x28\xa6\x23\x86\xc5\xa4\xd7\x27\xab\x1c\x1a\xea\x25\x15\x17\xfd\xb4\xf8\x31\x07\x69\x68\x98\x04\x77\xcc\x46\xfc\x7b\x57\x28\x06\x3a\xa4\x8b\xfe\x67\x47\xf0\xa4\x22\x62\xd5\xa8\xa7\xfe\xa2\x30\x4a\xe4\x46\xac\x62\xef\x45\xca\x88\x2d\x81\xd0\xd4\x9d\x72\x38\x90\xc5\xf2\x71\x27\xa5\xe2\x96\x0b\x48\x71\xf5\x84\x86\x59\x55\x09\x72\xc1\xca\x01\xf2\x99\x4a\x8c\x89\xf1\x02\xd0\x05\x69\xe5\x84\xa6\x93\x99\x7f\xe3\x3d\xc0\xc0\x62\x4a\xc4\x0c\x91\xeb\x69\x40\x06\x85\x40\x65\xa5\x8c\xb8\xb6\x02\xf9\x17\x8e\x96\x8f\xd6\xe9\xff\x78\xf4\x1f\x86\xb9\x21\x75\xb8\xaf\x37\x85\xd4\x78\x68\xf3\x3d\x8a\x25\x0f\x35\xfc\x71\xd3\xa7\xa3\xff\x4c\x9a\x24\x41\xee\xeb\xc8\x75\x3c\x54\x8a\x61\xcd\xb0\x5f\x72\x4a\x96\x8a\xbc\xf4\x0d\xef\x91\x42\xbd\x43\x6e\x87\x1e\x8c\x4d\xd0\xf3\x2f\x90\xda\x62\x32\x72\x52\xfa\x72\x40\x6a\x19\xaa\x25\x19\xac\x03\xc6\x55\xad\x8f\x2b\x2e\x03\x83\xdc\xe1\x5e\x32\x7b\xaa\xcc\x6a\xc1\x7b\x58\xe5\x9f\xdb\x54\xa4\x67\xae\x34\xef\x9c\xde\xb8\xbe\xce\xb8\x19\x98\xa7\x39\x77\x47\xa5\x9b\x24\x4e\x1f\xe8\x29\xe8\x45\xd4\x41\xd0\x76\xc4\x97\x0a\xd8\xb0\x76\x85\xc0\xc6\x7b\xe5\xd6\xc6\xf2\x69\x93\xab\x6e\x57\x61\x72\xd5\x55\x5d\x2a\xad\xfd\xc9\xa3\xe6\xdc\x2d\x0e\x1a\x4e\xc5\x23\xc9\xb2\x8b\xca\x61\x6a\xe2\x8e\x40\x52\xec\xea\x82\x39\xde\x3e\x72\x0a\x62\xc3\x70\xa4\x37\xca\xa5\x72\x69\xda\x43\x5a\x76\xdf\x6b\x54\x15\x77\xbf\x75\x39\xa2\xd0\x3a\x90\xfb\xbc\x38\xd1\x98\x08\x20\xf4\x38\xc1\x38\x00\xdb\x0b\x5d\x79\x32\xc4\x5e\x86\xde\x18\xfc\xbf\x78\x2f\x34\x06\x9f\x69\xe6\x5f\x3b\xed\x07\x63\xf3\x61\x13\x7b\x3e\xd2\x17\x37\x96\x35\x05\x71\x6b\x07\x1f\x05\xb7\x7b\xb4\x01\xfc\x6e\xf3\x34\x46\x60\xaa\xd9\x0f\x26\x5f\x83\x97\x52\x04\x3c\xe7\x5a\x31\xa4\x20\x46\x8b\xab\x4a\x9b\x4b\xf3\x1b\xff\xc0\x18\x83\xcd\xf9\xc7\xcd\x87\x5f\x27\x0e\x52\x9e\xb3\x12\x27\x06\x19\xb4\x20\x0e\x91\x97\xb7\x52\xb4\x80\x2b\x62\x14\x17\xbd\x30\x11\xbe\xba\xe0\x0f\xa9\x37\x57\x50\xe8\xbd\x70\x09\xb1\x15\x90\x73\xa5\x21\x78\x2b\x30\x9d\x3b\xfd\x33\x91\x47\xd8\xd1\xa6\x5c\x45\x4a\xb0\x30\xc2\x6a\x69\xe7\xaf\xaa\xc0\x19\x6f\x9b\xf0\x7d\xca\x24\x46\x3f\x47\x9a\x97\x5a\x65\xac\x26\x87\x73\x27\x14\xda\x9a\x59\x65\x82\xe7\xcc\xcd\xf8\x8d\x11\x04\x9e\x6f\x67\x20\xad\x85\x73\xcd\x2f\x05\x83\x76\x2c\x94\xcb\x70\x4a\xe5\x90\xe0\x8a\x93\x7a\x29\x32\x8c\x43\x03\xe4\x56\x23\xd5\x34\x7f\x9b\xdb\xba\xba\x80\x91\x7a\x2b\xdf\xbc\x5a\x5b\x6d\x2d\x5c\x74\x85\x85\x65\xe8\xc6\xb6\x9a\x6f\xa3\xe1\xcc\x31\x71\xf1\xa2\x59\x83\xe0\xbe\x08\x83\x4e\xbe\xcb\xe7\x09\x14\x87\x8f\xf0\x59\x7b\xfc\xf8\x81\xd0\x6b\xbd\xcb\x0e\xfc\x09\x7d\xe7\x25\x86\x1c\x75\x19\x88\x1f\x5f\x7f\xa7\x79\x3f\x03\xb4\x38\xf3\x93\xd6\xed\xba\x3c\xdb\xcb\x4b\xf2\x76\xa0\x52\xfe\x10\xfd\xf0\xba\x48\x2f\xc7\xff\x3a\x9f\x4f\xd6\xb8\xe0\xf1\x14\x1f\x58\xc4\xc0\xc0\x68\x66\xc9\x83\x4b\x8c\x91\xe2\x02\xe1\xd1\x81\x76\x68\xb8\x3f\x13\x46\x88\xf8\x68\xa4\x21\x52\x0e\x5a\xe0\xa0\x76\x0e\xd1\xf5\xa8\x3b\xcc\x0e\x31\x2d\x6c\x59\x84\x12\xbf\x9e\xfe\x53\x90\x1a\xe9\x76\x9e\xc5\x2a\x7b\x2f\x5a\x13\x74\x5e\xe5\x12\x6a\x2a\x78\xb1\x5b\x83\xca\xda\xa6\x8b\xa6\x58\xdf\x12\x4a\xb8\x0c\x72\x8e\x06\x68\x03\xef\xe5\xf8\x72\xe7\xe6\x48\x6e\x2f\x5a\xdc\xd1\x7c\x3d\x22\x68\x7b\xcc\x1b\x26\xe1\x05\x53\xa9\xd9\xbf\x84\x75\x6b\x0a\x08\xb4\x52\x80\xd9\x6c\xe8\x50\x8b\x75\xe3\x46\x60\x63\x0a\x78\xa0\x96\x25\x34\x8f\x49\xd5\x89\xed\xf3\xc3\x06\xd4\x58\x95\x4b\x4a\x46\x49\x97\xde\xa9\xef\x6a\xbc\xe8\x49\xad\x84\x57\x00\x1f\x15\xf8\xe3\xe7\xb6\x74\x88\xed\x3f\x79\x40\xed\x57\x6a\xb6\x22\x75\xf4\x9f\x3e\xfd\xbf\x00\x00\x00\xff\xff\x3d\x56\x92\xe5\x5d\xd2\x02\x00") + +func cfI18nResourcesZhHantAllJsonBytes() ([]byte, error) { + return bindataRead( + _cfI18nResourcesZhHantAllJson, + "cf/i18n/resources/zh-hant.all.json", + ) +} + +func cfI18nResourcesZhHantAllJson() (*asset, error) { + bytes, err := cfI18nResourcesZhHantAllJsonBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "cf/i18n/resources/zh-hant.all.json", size: 184925, mode: os.FileMode(420), modTime: time.Unix(1456502789, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +// Asset loads and returns the asset for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func Asset(name string) ([]byte, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err) + } + return a.bytes, nil + } + return nil, fmt.Errorf("Asset %s not found", name) +} + +// MustAsset is like Asset but panics when Asset would return an error. +// It simplifies safe initialization of global variables. +func MustAsset(name string) []byte { + a, err := Asset(name) + if err != nil { + panic("asset: Asset(" + name + "): " + err.Error()) + } + + return a +} + +// AssetInfo loads and returns the asset info for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func AssetInfo(name string) (os.FileInfo, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err) + } + return a.info, nil + } + return nil, fmt.Errorf("AssetInfo %s not found", name) +} + +// AssetNames returns the names of the assets. +func AssetNames() []string { + names := make([]string, 0, len(_bindata)) + for name := range _bindata { + names = append(names, name) + } + return names +} + +// _bindata is a table, holding each asset generator, mapped to its name. +var _bindata = map[string]func() (*asset, error){ + "cf/i18n/resources/de-de.all.json": cfI18nResourcesDeDeAllJson, + "cf/i18n/resources/en-us.all.json": cfI18nResourcesEnUsAllJson, + "cf/i18n/resources/es-es.all.json": cfI18nResourcesEsEsAllJson, + "cf/i18n/resources/fr-fr.all.json": cfI18nResourcesFrFrAllJson, + "cf/i18n/resources/it-it.all.json": cfI18nResourcesItItAllJson, + "cf/i18n/resources/ja-jp.all.json": cfI18nResourcesJaJpAllJson, + "cf/i18n/resources/ko-kr.all.json": cfI18nResourcesKoKrAllJson, + "cf/i18n/resources/pt-br.all.json": cfI18nResourcesPtBrAllJson, + "cf/i18n/resources/zh-hans.all.json": cfI18nResourcesZhHansAllJson, + "cf/i18n/resources/zh-hant.all.json": cfI18nResourcesZhHantAllJson, +} + +// AssetDir returns the file names below a certain +// directory embedded in the file by go-bindata. +// For example if you run go-bindata on data/... and data contains the +// following hierarchy: +// data/ +// foo.txt +// img/ +// a.png +// b.png +// then AssetDir("data") would return []string{"foo.txt", "img"} +// AssetDir("data/img") would return []string{"a.png", "b.png"} +// AssetDir("foo.txt") and AssetDir("notexist") would return an error +// AssetDir("") will return []string{"data"}. +func AssetDir(name string) ([]string, error) { + node := _bintree + if len(name) != 0 { + cannonicalName := strings.Replace(name, "\\", "/", -1) + pathList := strings.Split(cannonicalName, "/") + for _, p := range pathList { + node = node.Children[p] + if node == nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + } + } + if node.Func != nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + rv := make([]string, 0, len(node.Children)) + for childName := range node.Children { + rv = append(rv, childName) + } + return rv, nil +} + +type bintree struct { + Func func() (*asset, error) + Children map[string]*bintree +} +var _bintree = &bintree{nil, map[string]*bintree{ + "cf": &bintree{nil, map[string]*bintree{ + "i18n": &bintree{nil, map[string]*bintree{ + "resources": &bintree{nil, map[string]*bintree{ + "de-de.all.json": &bintree{cfI18nResourcesDeDeAllJson, map[string]*bintree{}}, + "en-us.all.json": &bintree{cfI18nResourcesEnUsAllJson, map[string]*bintree{}}, + "es-es.all.json": &bintree{cfI18nResourcesEsEsAllJson, map[string]*bintree{}}, + "fr-fr.all.json": &bintree{cfI18nResourcesFrFrAllJson, map[string]*bintree{}}, + "it-it.all.json": &bintree{cfI18nResourcesItItAllJson, map[string]*bintree{}}, + "ja-jp.all.json": &bintree{cfI18nResourcesJaJpAllJson, map[string]*bintree{}}, + "ko-kr.all.json": &bintree{cfI18nResourcesKoKrAllJson, map[string]*bintree{}}, + "pt-br.all.json": &bintree{cfI18nResourcesPtBrAllJson, map[string]*bintree{}}, + "zh-hans.all.json": &bintree{cfI18nResourcesZhHansAllJson, map[string]*bintree{}}, + "zh-hant.all.json": &bintree{cfI18nResourcesZhHantAllJson, map[string]*bintree{}}, + }}, + }}, + }}, +}} + +// RestoreAsset restores an asset under the given directory +func RestoreAsset(dir, name string) error { + data, err := Asset(name) + if err != nil { + return err + } + info, err := AssetInfo(name) + if err != nil { + return err + } + err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755)) + if err != nil { + return err + } + err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode()) + if err != nil { + return err + } + err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime()) + if err != nil { + return err + } + return nil +} + +// RestoreAssets restores an asset under the given directory recursively +func RestoreAssets(dir, name string) error { + children, err := AssetDir(name) + // File + if err != nil { + return RestoreAsset(dir, name) + } + // Dir + for _, child := range children { + err = RestoreAssets(dir, filepath.Join(name, child)) + if err != nil { + return err + } + } + return nil +} + +func _filePath(dir, name string) string { + cannonicalName := strings.Replace(name, "\\", "/", -1) + return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...) +} + diff --git a/vendor/github.com/cloudfoundry/cli/cf/terminal/color.go b/vendor/github.com/cloudfoundry/cli/cf/terminal/color.go new file mode 100644 index 0000000..7f12648 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/terminal/color.go @@ -0,0 +1,141 @@ +package terminal + +import ( + "fmt" + "os" + "regexp" + "runtime" + + "golang.org/x/crypto/ssh/terminal" +) + +type Color uint + +const ( + red Color = 31 + green = 32 + yellow = 33 + // blue = 34 + magenta = 35 + cyan = 36 + grey = 37 + white = 38 +) + +var ( + colorize func(message string, color Color, bold int) string + OsSupportsColors = runtime.GOOS != "windows" + TerminalSupportsColors = isTerminal() + UserAskedForColors = "" +) + +func init() { + InitColorSupport() +} + +func InitColorSupport() { + if colorsEnabled() { + colorize = func(message string, color Color, bold int) string { + return fmt.Sprintf("\033[%d;%dm%s\033[0m", bold, color, message) + } + } else { + colorize = func(message string, _ Color, _ int) string { + return message + } + } +} + +func colorsEnabled() bool { + return userDidNotDisableColor() && + (userEnabledColors() || (TerminalSupportsColors && OsSupportsColors)) +} + +func userEnabledColors() bool { + return UserAskedForColors == "true" || os.Getenv("CF_COLOR") == "true" +} + +func userDidNotDisableColor() bool { + return os.Getenv("CF_COLOR") != "false" && (UserAskedForColors != "false" || os.Getenv("CF_COLOR") == "true") +} + +func Colorize(message string, color Color) string { + return colorize(message, color, 0) +} + +func ColorizeBold(message string, color Color) string { + return colorize(message, color, 1) +} + +var decolorizerRegex = regexp.MustCompile(`\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]`) + +func Decolorize(message string) string { + return string(decolorizerRegex.ReplaceAll([]byte(message), []byte(""))) +} + +func HeaderColor(message string) string { + return ColorizeBold(message, white) +} + +func CommandColor(message string) string { + return ColorizeBold(message, yellow) +} + +func StoppedColor(message string) string { + return ColorizeBold(message, grey) +} + +func AdvisoryColor(message string) string { + return ColorizeBold(message, yellow) +} + +func CrashedColor(message string) string { + return ColorizeBold(message, red) +} + +func FailureColor(message string) string { + return ColorizeBold(message, red) +} + +func SuccessColor(message string) string { + return ColorizeBold(message, green) +} + +func EntityNameColor(message string) string { + return ColorizeBold(message, cyan) +} + +func PromptColor(message string) string { + return ColorizeBold(message, cyan) +} + +func TableContentHeaderColor(message string) string { + return ColorizeBold(message, cyan) +} + +func WarningColor(message string) string { + return ColorizeBold(message, magenta) +} + +func LogStdoutColor(message string) string { + return Colorize(message, white) +} + +func LogStderrColor(message string) string { + return Colorize(message, red) +} + +func LogHealthHeaderColor(message string) string { + return Colorize(message, grey) +} + +func LogAppHeaderColor(message string) string { + return ColorizeBold(message, yellow) +} + +func LogSysHeaderColor(message string) string { + return ColorizeBold(message, cyan) +} + +func isTerminal() bool { + return terminal.IsTerminal(1) +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/terminal/debug_printer.go b/vendor/github.com/cloudfoundry/cli/cf/terminal/debug_printer.go new file mode 100644 index 0000000..032703b --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/terminal/debug_printer.go @@ -0,0 +1,14 @@ +package terminal + +import ( + "time" + + . "github.com/cloudfoundry/cli/cf/i18n" + "github.com/cloudfoundry/cli/cf/trace" +) + +type DebugPrinter struct{} + +func (DebugPrinter) Print(title, dump string) { + trace.Logger.Printf("\n%s [%s]\n%s\n", HeaderColor(T(title)), time.Now().Format(time.RFC3339), trace.Sanitize(dump)) +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/terminal/table.go b/vendor/github.com/cloudfoundry/cli/cf/terminal/table.go new file mode 100644 index 0000000..63cd820 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/terminal/table.go @@ -0,0 +1,109 @@ +package terminal + +import ( + "fmt" + "strings" +) + +type Table interface { + Add(row ...string) + Print() +} + +type PrintableTable struct { + ui UI + headers []string + headerPrinted bool + maxValueLengths []int + rows [][]string +} + +func NewTable(ui UI, headers []string) Table { + return &PrintableTable{ + ui: ui, + headers: headers, + maxValueLengths: make([]int, len(headers)), + } +} + +func (t *PrintableTable) Add(row ...string) { + t.rows = append(t.rows, row) +} + +func (t *PrintableTable) Print() { + for _, row := range append(t.rows, t.headers) { + t.calculateMaxSize(row) + } + + if t.headerPrinted == false { + t.printHeader() + t.headerPrinted = true + } + + for _, line := range t.rows { + t.printRow(line) + } + + t.rows = [][]string{} +} + +func (t *PrintableTable) calculateMaxSize(row []string) { + for index, value := range row { + l := visibleSize(Decolorize(value)) + if t.maxValueLengths[index] < l { + t.maxValueLengths[index] = l + } + } +} + +func (t *PrintableTable) printHeader() { + output := "" + for col, value := range t.headers { + output = output + t.cellValue(col, HeaderColor(value)) + } + t.ui.Say(output) +} + +func (t *PrintableTable) printRow(row []string) { + output := "" + for columnIndex, value := range row { + if columnIndex == 0 { + value = TableContentHeaderColor(value) + } + + output = output + t.cellValue(columnIndex, value) + } + t.ui.Say("%s", output) +} + +func (t *PrintableTable) cellValue(col int, value string) string { + padding := "" + maxVisibleSize := t.maxValueLengths[col] + + if col < len(t.headers)-1 { + thisVisibleSize := visibleSize(Decolorize(value)) + padding = strings.Repeat(` `, maxVisibleSize-thisVisibleSize) + } + + return fmt.Sprintf("%s%s ", value, padding) +} + +func visibleSize(s string) int { + r := strings.NewReader(s) + + var size int + for range s { + _, runeSize, err := r.ReadRune() + if err != nil { + panic(fmt.Sprintf("error when calculating visible size of: %s", s)) + } + + if runeSize == 3 { + size += 2 // Kanji and Katakana characters appear as double-width + } else { + size += 1 + } + } + + return size +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/terminal/tee_printer.go b/vendor/github.com/cloudfoundry/cli/cf/terminal/tee_printer.go new file mode 100644 index 0000000..a9e3add --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/terminal/tee_printer.go @@ -0,0 +1,92 @@ +package terminal + +import ( + "fmt" +) + +type Printer interface { + Print(a ...interface{}) (n int, err error) + Printf(format string, a ...interface{}) (n int, err error) + Println(a ...interface{}) (n int, err error) + ForcePrint(a ...interface{}) (n int, err error) + ForcePrintf(format string, a ...interface{}) (n int, err error) + ForcePrintln(a ...interface{}) (n int, err error) +} + +type OutputCapture interface { + SetOutputBucket(*[]string) +} + +type TerminalOutputSwitch interface { + DisableTerminalOutput(bool) +} + +type TeePrinter struct { + disableTerminalOutput bool + outputBucket *[]string +} + +func NewTeePrinter() *TeePrinter { + return &TeePrinter{} +} + +func (t *TeePrinter) SetOutputBucket(bucket *[]string) { + t.outputBucket = bucket +} + +func (t *TeePrinter) Print(values ...interface{}) (n int, err error) { + str := fmt.Sprint(values...) + t.saveOutputToBucket(str) + if !t.disableTerminalOutput { + return fmt.Print(str) + } + return +} + +func (t *TeePrinter) Printf(format string, a ...interface{}) (n int, err error) { + str := fmt.Sprintf(format, a...) + t.saveOutputToBucket(str) + if !t.disableTerminalOutput { + return fmt.Print(str) + } + return +} + +func (t *TeePrinter) Println(values ...interface{}) (n int, err error) { + str := fmt.Sprint(values...) + t.saveOutputToBucket(str) + if !t.disableTerminalOutput { + return fmt.Println(str) + } + return +} + +func (t *TeePrinter) ForcePrint(values ...interface{}) (n int, err error) { + str := fmt.Sprint(values...) + t.saveOutputToBucket(str) + return fmt.Print(str) +} + +func (t *TeePrinter) ForcePrintf(format string, a ...interface{}) (n int, err error) { + str := fmt.Sprintf(format, a...) + t.saveOutputToBucket(str) + return fmt.Print(str) +} + +func (t *TeePrinter) ForcePrintln(values ...interface{}) (n int, err error) { + str := fmt.Sprint(values...) + t.saveOutputToBucket(str) + return fmt.Println(str) +} + +func (t *TeePrinter) DisableTerminalOutput(disable bool) { + t.disableTerminalOutput = disable +} + +func (t *TeePrinter) saveOutputToBucket(output string) { + if t.outputBucket == nil { + return + } + + *t.outputBucket = append(*t.outputBucket, Decolorize(output)) +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/terminal/ui.go b/vendor/github.com/cloudfoundry/cli/cf/terminal/ui.go new file mode 100644 index 0000000..e973513 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/terminal/ui.go @@ -0,0 +1,245 @@ +package terminal + +import ( + "bufio" + "fmt" + "io" + "strings" + + . "github.com/cloudfoundry/cli/cf/i18n" + + "github.com/cloudfoundry/cli/cf" + "github.com/cloudfoundry/cli/cf/configuration/core_config" + "github.com/cloudfoundry/cli/cf/trace" +) + +type ColoringFunction func(value string, row int, col int) string + +func NotLoggedInText() string { + return fmt.Sprintf(T("Not logged in. Use '{{.CFLoginCommand}}' to log in.", map[string]interface{}{"CFLoginCommand": CommandColor(cf.Name() + " " + "login")})) +} + +type UI interface { + PrintPaginator(rows []string, err error) + Say(message string, args ...interface{}) + PrintCapturingNoOutput(message string, args ...interface{}) + Warn(message string, args ...interface{}) + Ask(prompt string, args ...interface{}) (answer string) + AskForPassword(prompt string, args ...interface{}) (answer string) + Confirm(message string, args ...interface{}) bool + ConfirmDelete(modelType, modelName string) bool + ConfirmDeleteWithAssociations(modelType, modelName string) bool + Ok() + Failed(message string, args ...interface{}) + PanicQuietly() + ShowConfiguration(core_config.Reader) + LoadingIndication() + Table(headers []string) Table + NotifyUpdateIfNeeded(core_config.Reader) +} + +type terminalUI struct { + stdin io.Reader + printer Printer +} + +func NewUI(r io.Reader, printer Printer) UI { + return &terminalUI{ + stdin: r, + printer: printer, + } +} + +func (ui *terminalUI) PrintPaginator(rows []string, err error) { + if err != nil { + ui.Failed(err.Error()) + return + } + + for _, row := range rows { + ui.Say(row) + } +} + +func (ui *terminalUI) PrintCapturingNoOutput(message string, args ...interface{}) { + if len(args) == 0 { + fmt.Printf("%s", message) + } else { + fmt.Printf(message, args...) + } +} + +func (ui *terminalUI) Say(message string, args ...interface{}) { + if len(args) == 0 { + ui.printer.Printf("%s\n", message) + } else { + ui.printer.Printf(message+"\n", args...) + } +} + +func (ui *terminalUI) Warn(message string, args ...interface{}) { + message = fmt.Sprintf(message, args...) + ui.Say(WarningColor(message)) + return +} + +func (ui *terminalUI) ConfirmDeleteWithAssociations(modelType, modelName string) bool { + return ui.confirmDelete(T("Really delete the {{.ModelType}} {{.ModelName}} and everything associated with it?", + map[string]interface{}{ + "ModelType": modelType, + "ModelName": EntityNameColor(modelName), + })) +} + +func (ui *terminalUI) ConfirmDelete(modelType, modelName string) bool { + return ui.confirmDelete(T("Really delete the {{.ModelType}} {{.ModelName}}?", + map[string]interface{}{ + "ModelType": modelType, + "ModelName": EntityNameColor(modelName), + })) +} + +func (ui *terminalUI) confirmDelete(message string) bool { + result := ui.Confirm(message) + + if !result { + ui.Warn(T("Delete cancelled")) + } + + return result +} + +func (ui *terminalUI) Confirm(message string, args ...interface{}) bool { + response := ui.Ask(message, args...) + switch strings.ToLower(response) { + case "y", "yes", T("yes"): + return true + } + return false +} + +func (ui *terminalUI) Ask(prompt string, args ...interface{}) (answer string) { + ui.printer.Println("") + ui.printer.Printf(prompt+PromptColor(">")+" ", args...) + + rd := bufio.NewReader(ui.stdin) + line, err := rd.ReadString('\n') + if err == nil { + return strings.TrimSpace(line) + } + return "" +} + +func (ui *terminalUI) Ok() { + ui.Say(SuccessColor(T("OK"))) +} + +const QuietPanic = "This shouldn't print anything" + +func (ui *terminalUI) Failed(message string, args ...interface{}) { + message = fmt.Sprintf(message, args...) + + if T == nil { + ui.Say(FailureColor("FAILED")) + ui.Say(message) + + trace.Logger.Print("FAILED") + trace.Logger.Print(message) + // ui.PanicQuietly() + } else { + ui.Say(FailureColor(T("FAILED"))) + ui.Say(message) + + trace.Logger.Print(T("FAILED")) + trace.Logger.Print(message) + // ui.PanicQuietly() + } +} + +func (ui *terminalUI) PanicQuietly() { + panic(QuietPanic) +} + +func (ui *terminalUI) ShowConfiguration(config core_config.Reader) { + table := NewTable(ui, []string{"", ""}) + + if config.HasAPIEndpoint() { + table.Add( + T("API endpoint:"), + T("{{.ApiEndpoint}} (API version: {{.ApiVersionString}})", + map[string]interface{}{ + "ApiEndpoint": EntityNameColor(config.ApiEndpoint()), + "ApiVersionString": EntityNameColor(config.ApiVersion()), + }), + ) + } + + if !config.IsLoggedIn() { + table.Print() + ui.Say(NotLoggedInText()) + return + } + + table.Add(T("User:"), EntityNameColor(config.UserEmail())) + + if !config.HasOrganization() && !config.HasSpace() { + table.Print() + command := fmt.Sprintf("%s target -o ORG -s SPACE", cf.Name()) + ui.Say(T("No org or space targeted, use '{{.CFTargetCommand}}'", + map[string]interface{}{ + "CFTargetCommand": CommandColor(command), + })) + return + } + + if config.HasOrganization() { + table.Add( + T("Org:"), + EntityNameColor(config.OrganizationFields().Name), + ) + } else { + command := fmt.Sprintf("%s target -o Org", cf.Name()) + table.Add( + T("Org:"), + T("No org targeted, use '{{.CFTargetCommand}}'", + map[string]interface{}{ + "CFTargetCommand": CommandColor(command), + }), + ) + } + + if config.HasSpace() { + table.Add( + T("Space:"), + EntityNameColor(config.SpaceFields().Name), + ) + } else { + command := fmt.Sprintf("%s target -s SPACE", cf.Name()) + table.Add( + T("Space:"), + T("No space targeted, use '{{.CFTargetCommand}}'", map[string]interface{}{"CFTargetCommand": CommandColor(command)}), + ) + } + + table.Print() +} + +func (ui *terminalUI) LoadingIndication() { + ui.printer.Print(".") +} + +func (ui *terminalUI) Table(headers []string) Table { + return NewTable(ui, headers) +} + +func (ui *terminalUI) NotifyUpdateIfNeeded(config core_config.Reader) { + if !config.IsMinCliVersion(cf.Version) { + ui.Say("") + ui.Say(T("Cloud Foundry API version {{.ApiVer}} requires CLI version {{.CliMin}}. You are currently on version {{.CliVer}}. To upgrade your CLI, please visit: https://github.com/cloudfoundry/cli#downloads", + map[string]interface{}{ + "ApiVer": config.ApiVersion(), + "CliMin": config.MinCliVersion(), + "CliVer": cf.Version, + })) + } +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/terminal/ui_unix.go b/vendor/github.com/cloudfoundry/cli/cf/terminal/ui_unix.go new file mode 100644 index 0000000..2f3a463 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/terminal/ui_unix.go @@ -0,0 +1,103 @@ +// Copied from https://code.google.com/p/gopass/ + +// +build darwin freebsd linux netbsd openbsd + +package terminal + +import ( + "bufio" + "fmt" + "os" + "os/signal" + "strings" + "syscall" + + . "github.com/cloudfoundry/cli/cf/i18n" +) + +const ( + sttyArg0 = "/bin/stty" + exec_cwdir = "" +) + +// Tells the terminal to turn echo off. +var sttyArgvEOff []string = []string{"stty", "-echo"} + +// Tells the terminal to turn echo on. +var sttyArgvEOn []string = []string{"stty", "echo"} + +var ws syscall.WaitStatus + +func (ui terminalUI) AskForPassword(prompt string, args ...interface{}) (passwd string) { + sig := make(chan os.Signal, 10) + + // Display the prompt. + fmt.Println("") + fmt.Printf(prompt+PromptColor(">")+" ", args...) + + // File descriptors for stdin, stdout, and stderr. + fd := []uintptr{os.Stdin.Fd(), os.Stdout.Fd(), os.Stderr.Fd()} + + // Setup notifications of termination signals to channel sig, create a process to + // watch for these signals so we can turn back on echo if need be. + signal.Notify(sig, syscall.SIGHUP, syscall.SIGINT, syscall.SIGKILL, syscall.SIGQUIT, + syscall.SIGTERM) + defer signal.Stop(sig) + + go catchSignal(fd, sig) + + pid, err := echoOff(fd) + defer echoOn(fd) + if err != nil { + return + } + + passwd = readPassword(pid) + + // Carriage return after the user input. + fmt.Println("") + + return +} + +func readPassword(pid int) string { + rd := bufio.NewReader(os.Stdin) + syscall.Wait4(pid, &ws, 0, nil) + + line, err := rd.ReadString('\n') + if err == nil { + return strings.TrimSpace(line) + } + return "" +} + +func echoOff(fd []uintptr) (int, error) { + pid, err := syscall.ForkExec(sttyArg0, sttyArgvEOff, &syscall.ProcAttr{Dir: exec_cwdir, Files: fd}) + + if err != nil { + return 0, fmt.Errorf(T("failed turning off console echo for password entry:\n{{.ErrorDescription}}", map[string]interface{}{"ErrorDescription": err})) + } + + return pid, nil +} + +// echoOn turns back on the terminal echo. +func echoOn(fd []uintptr) { + // Turn on the terminal echo. + pid, e := syscall.ForkExec(sttyArg0, sttyArgvEOn, &syscall.ProcAttr{Dir: exec_cwdir, Files: fd}) + + if e == nil { + syscall.Wait4(pid, &ws, 0, nil) + } +} + +// catchSignal tries to catch SIGKILL, SIGQUIT and SIGINT so that we can turn terminal +// echo back on before the program ends. Otherwise the user is left with echo off on +// their terminal. +func catchSignal(fd []uintptr, sig chan os.Signal) { + select { + case <-sig: + echoOn(fd) + os.Exit(2) + } +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/terminal/ui_windows.go b/vendor/github.com/cloudfoundry/cli/cf/terminal/ui_windows.go new file mode 100644 index 0000000..d18ea67 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/terminal/ui_windows.go @@ -0,0 +1,45 @@ +// +build windows + +package terminal + +import ( + "os" + "syscall" +) + +// see SetConsoleMode documentation for bit flags +// http://msdn.microsoft.com/en-us/library/windows/desktop/ms686033(v=vs.85).aspx +const ENABLE_ECHO_INPUT = 0x0004 + +func (ui terminalUI) AskForPassword(prompt string, args ...interface{}) (passwd string) { + hStdin := syscall.Handle(os.Stdin.Fd()) + var originalMode uint32 + + err := syscall.GetConsoleMode(hStdin, &originalMode) + if err != nil { + return + } + + var newMode uint32 = (originalMode &^ ENABLE_ECHO_INPUT) + + err = setConsoleMode(hStdin, newMode) + defer setConsoleMode(hStdin, originalMode) + defer ui.Say("") + + if err != nil { + return + } + + return ui.Ask(prompt, args...) +} + +func setConsoleMode(console syscall.Handle, mode uint32) (err error) { + dll := syscall.MustLoadDLL("kernel32") + proc := dll.MustFindProc("SetConsoleMode") + r, _, err := proc.Call(uintptr(console), uintptr(mode)) + + if r == 0 { + return err + } + return nil +} diff --git a/vendor/github.com/cloudfoundry/cli/cf/trace/trace.go b/vendor/github.com/cloudfoundry/cli/cf/trace/trace.go new file mode 100644 index 0000000..6406980 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/cf/trace/trace.go @@ -0,0 +1,96 @@ +package trace + +import ( + "fmt" + "io" + "log" + "os" + "regexp" + + . "github.com/cloudfoundry/cli/cf/i18n" + "github.com/cloudfoundry/gofileutils/fileutils" +) + +type Printer interface { + Print(v ...interface{}) + Printf(format string, v ...interface{}) + Println(v ...interface{}) +} + +type nullLogger struct{} + +func (*nullLogger) Print(v ...interface{}) {} +func (*nullLogger) Printf(format string, v ...interface{}) {} +func (*nullLogger) Println(v ...interface{}) {} + +var stdOut io.Writer = os.Stdout +var Logger Printer + +func init() { + Logger = NewLogger("") +} + +func EnableTrace() { + Logger = newStdoutLogger() +} + +func DisableTrace() { + Logger = new(nullLogger) +} + +func SetStdout(s io.Writer) { + stdOut = s +} + +func NewLogger(cf_trace string) Printer { + switch cf_trace { + case "", "false": + Logger = new(nullLogger) + case "true": + Logger = newStdoutLogger() + default: + Logger = newFileLogger(cf_trace) + } + + return Logger +} + +func newStdoutLogger() Printer { + return log.New(stdOut, "", 0) +} + +func newFileLogger(path string) Printer { + file, err := fileutils.Open(path) + if err != nil { + logger := newStdoutLogger() + logger.Printf(T("CF_TRACE ERROR CREATING LOG FILE {{.Path}}:\n{{.Err}}", + map[string]interface{}{"Path": path, "Err": err})) + return logger + } + + return log.New(file, "", 0) +} + +func Sanitize(input string) (sanitized string) { + var sanitizeJson = func(propertyName string, json string) string { + regex := regexp.MustCompile(fmt.Sprintf(`"%s":\s*"[^\,]*"`, propertyName)) + return regex.ReplaceAllString(json, fmt.Sprintf(`"%s":"%s"`, propertyName, PRIVATE_DATA_PLACEHOLDER())) + } + + re := regexp.MustCompile(`(?m)^Authorization: .*`) + sanitized = re.ReplaceAllString(input, "Authorization: "+PRIVATE_DATA_PLACEHOLDER()) + re = regexp.MustCompile(`password=[^&]*&`) + sanitized = re.ReplaceAllString(sanitized, "password="+PRIVATE_DATA_PLACEHOLDER()+"&") + + sanitized = sanitizeJson("access_token", sanitized) + sanitized = sanitizeJson("refresh_token", sanitized) + sanitized = sanitizeJson("token", sanitized) + sanitized = sanitizeJson("password", sanitized) + sanitized = sanitizeJson("oldPassword", sanitized) + + return +} + +func PRIVATE_DATA_PLACEHOLDER() string { + return T("[PRIVATE DATA HIDDEN]") +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/cli_connection.go b/vendor/github.com/cloudfoundry/cli/plugin/cli_connection.go new file mode 100644 index 0000000..9adcf9b --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/cli_connection.go @@ -0,0 +1,383 @@ +package plugin + +import ( + "errors" + "fmt" + "net" + "net/rpc" + "os" + "time" + + "github.com/cloudfoundry/cli/plugin/models" +) + +type cliConnection struct { + cliServerPort string +} + +func NewCliConnection(cliServerPort string) *cliConnection { + return &cliConnection{ + cliServerPort: cliServerPort, + } +} + +func (c *cliConnection) withClientDo(f func(client *rpc.Client) error) error { + client, err := rpc.Dial("tcp", "127.0.0.1:"+c.cliServerPort) + if err != nil { + return err + } + defer client.Close() + + return f(client) +} + +func (c *cliConnection) sendPluginMetadataToCliServer(metadata PluginMetadata) { + var success bool + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.SetPluginMetadata", metadata, &success) + }) + + if err != nil { + fmt.Println(err) + os.Exit(1) + } + + if !success { + os.Exit(1) + } + + os.Exit(0) +} + +func (c *cliConnection) isMinCliVersion(version string) bool { + var result bool + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.IsMinCliVersion", version, &result) + }) + + if err != nil { + fmt.Println(err) + os.Exit(1) + } + + return result +} + +func (c *cliConnection) CliCommandWithoutTerminalOutput(args ...string) ([]string, error) { + return c.callCliCommand(true, args...) +} + +func (c *cliConnection) CliCommand(args ...string) ([]string, error) { + return c.callCliCommand(false, args...) +} + +func (c *cliConnection) callCliCommand(silently bool, args ...string) ([]string, error) { + var ( + success bool + cmdOutput []string + callCoreCommandErr error + getOutputAndResetErr error + disableTerminalOutputErr error + ) + + c.withClientDo(func(client *rpc.Client) error { + disableTerminalOutputErr = client.Call("CliRpcCmd.DisableTerminalOutput", silently, &success) + callCoreCommandErr = client.Call("CliRpcCmd.CallCoreCommand", args, &success) + getOutputAndResetErr = client.Call("CliRpcCmd.GetOutputAndReset", success, &cmdOutput) + + return nil + }) + + if disableTerminalOutputErr != nil { + return []string{}, disableTerminalOutputErr + } + + if callCoreCommandErr != nil { + return []string{}, callCoreCommandErr + } + + if !success { + return []string{}, errors.New("Error executing cli core command") + } + + if getOutputAndResetErr != nil { + return []string{}, errors.New("something completely unexpected happened") + } + + return cmdOutput, nil +} + +func (c *cliConnection) pingCLI() { + //call back to cf saying we have been setup + var connErr error + var conn net.Conn + for i := 0; i < 5; i++ { + conn, connErr = net.Dial("tcp", "127.0.0.1:"+c.cliServerPort) + if connErr != nil { + time.Sleep(200 * time.Millisecond) + } else { + conn.Close() + break + } + } + if connErr != nil { + fmt.Println(connErr) + os.Exit(1) + } +} + +func (c *cliConnection) GetCurrentOrg() (plugin_models.Organization, error) { + var result plugin_models.Organization + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetCurrentOrg", "", &result) + }) + + return result, err +} + +func (c *cliConnection) GetCurrentSpace() (plugin_models.Space, error) { + var result plugin_models.Space + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetCurrentSpace", "", &result) + }) + + return result, err +} + +func (c *cliConnection) Username() (string, error) { + var result string + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.Username", "", &result) + }) + + return result, err +} + +func (c *cliConnection) UserGuid() (string, error) { + var result string + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.UserGuid", "", &result) + }) + + return result, err +} + +func (c *cliConnection) UserEmail() (string, error) { + var result string + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.UserEmail", "", &result) + }) + + return result, err +} + +func (c *cliConnection) IsSSLDisabled() (bool, error) { + var result bool + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.IsSSLDisabled", "", &result) + }) + + return result, err +} + +func (c *cliConnection) IsLoggedIn() (bool, error) { + var result bool + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.IsLoggedIn", "", &result) + }) + + return result, err +} + +func (c *cliConnection) HasOrganization() (bool, error) { + var result bool + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.HasOrganization", "", &result) + }) + + return result, err +} + +func (c *cliConnection) HasSpace() (bool, error) { + var result bool + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.HasSpace", "", &result) + }) + + return result, err +} + +func (c *cliConnection) ApiEndpoint() (string, error) { + var result string + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.ApiEndpoint", "", &result) + }) + + return result, err +} + +func (c *cliConnection) HasAPIEndpoint() (bool, error) { + var result bool + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.HasAPIEndpoint", "", &result) + }) + + return result, err +} + +func (c *cliConnection) ApiVersion() (string, error) { + var result string + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.ApiVersion", "", &result) + }) + + return result, err +} + +func (c *cliConnection) LoggregatorEndpoint() (string, error) { + var result string + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.LoggregatorEndpoint", "", &result) + }) + + return result, err +} + +func (c *cliConnection) DopplerEndpoint() (string, error) { + var result string + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.DopplerEndpoint", "", &result) + }) + + return result, err +} + +func (c *cliConnection) AccessToken() (string, error) { + var result string + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.AccessToken", "", &result) + }) + + return result, err +} + +func (c *cliConnection) GetApp(appName string) (plugin_models.GetAppModel, error) { + var result plugin_models.GetAppModel + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetApp", appName, &result) + }) + + return result, err +} + +func (c *cliConnection) GetApps() ([]plugin_models.GetAppsModel, error) { + var result []plugin_models.GetAppsModel + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetApps", "", &result) + }) + + return result, err +} + +func (c *cliConnection) GetOrgs() ([]plugin_models.GetOrgs_Model, error) { + var result []plugin_models.GetOrgs_Model + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetOrgs", "", &result) + }) + + return result, err +} + +func (c *cliConnection) GetSpaces() ([]plugin_models.GetSpaces_Model, error) { + var result []plugin_models.GetSpaces_Model + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetSpaces", "", &result) + }) + + return result, err +} + +func (c *cliConnection) GetServices() ([]plugin_models.GetServices_Model, error) { + var result []plugin_models.GetServices_Model + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetServices", "", &result) + }) + + return result, err +} + +func (c *cliConnection) GetOrgUsers(orgName string, args ...string) ([]plugin_models.GetOrgUsers_Model, error) { + var result []plugin_models.GetOrgUsers_Model + + cmdArgs := append([]string{orgName}, args...) + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetOrgUsers", cmdArgs, &result) + }) + + return result, err +} + +func (c *cliConnection) GetSpaceUsers(orgName string, spaceName string) ([]plugin_models.GetSpaceUsers_Model, error) { + var result []plugin_models.GetSpaceUsers_Model + + cmdArgs := []string{orgName, spaceName} + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetSpaceUsers", cmdArgs, &result) + }) + + return result, err +} + +func (c *cliConnection) GetOrg(orgName string) (plugin_models.GetOrg_Model, error) { + var result plugin_models.GetOrg_Model + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetOrg", orgName, &result) + }) + + return result, err +} + +func (c *cliConnection) GetSpace(spaceName string) (plugin_models.GetSpace_Model, error) { + var result plugin_models.GetSpace_Model + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetSpace", spaceName, &result) + }) + + return result, err +} + +func (c *cliConnection) GetService(serviceInstance string) (plugin_models.GetService_Model, error) { + var result plugin_models.GetService_Model + + err := c.withClientDo(func(client *rpc.Client) error { + return client.Call("CliRpcCmd.GetService", serviceInstance, &result) + }) + + return result, err +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/fakes/fake_cli_connection.go b/vendor/github.com/cloudfoundry/cli/plugin/fakes/fake_cli_connection.go new file mode 100644 index 0000000..61446ce --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/fakes/fake_cli_connection.go @@ -0,0 +1,962 @@ +// This file was generated by counterfeiter +package fakes + +import ( + "sync" + + "github.com/cloudfoundry/cli/plugin" + "github.com/cloudfoundry/cli/plugin/models" +) + +type FakeCliConnection struct { + CliCommandWithoutTerminalOutputStub func(args ...string) ([]string, error) + cliCommandWithoutTerminalOutputMutex sync.RWMutex + cliCommandWithoutTerminalOutputArgsForCall []struct { + args []string + } + cliCommandWithoutTerminalOutputReturns struct { + result1 []string + result2 error + } + CliCommandStub func(args ...string) ([]string, error) + cliCommandMutex sync.RWMutex + cliCommandArgsForCall []struct { + args []string + } + cliCommandReturns struct { + result1 []string + result2 error + } + GetCurrentOrgStub func() (plugin_models.Organization, error) + getCurrentOrgMutex sync.RWMutex + getCurrentOrgArgsForCall []struct{} + getCurrentOrgReturns struct { + result1 plugin_models.Organization + result2 error + } + GetCurrentSpaceStub func() (plugin_models.Space, error) + getCurrentSpaceMutex sync.RWMutex + getCurrentSpaceArgsForCall []struct{} + getCurrentSpaceReturns struct { + result1 plugin_models.Space + result2 error + } + UsernameStub func() (string, error) + usernameMutex sync.RWMutex + usernameArgsForCall []struct{} + usernameReturns struct { + result1 string + result2 error + } + UserGuidStub func() (string, error) + userGuidMutex sync.RWMutex + userGuidArgsForCall []struct{} + userGuidReturns struct { + result1 string + result2 error + } + UserEmailStub func() (string, error) + userEmailMutex sync.RWMutex + userEmailArgsForCall []struct{} + userEmailReturns struct { + result1 string + result2 error + } + IsLoggedInStub func() (bool, error) + isLoggedInMutex sync.RWMutex + isLoggedInArgsForCall []struct{} + isLoggedInReturns struct { + result1 bool + result2 error + } + IsSSLDisabledStub func() (bool, error) + isSSLDisabledMutex sync.RWMutex + isSSLDisabledArgsForCall []struct{} + isSSLDisabledReturns struct { + result1 bool + result2 error + } + HasOrganizationStub func() (bool, error) + hasOrganizationMutex sync.RWMutex + hasOrganizationArgsForCall []struct{} + hasOrganizationReturns struct { + result1 bool + result2 error + } + HasSpaceStub func() (bool, error) + hasSpaceMutex sync.RWMutex + hasSpaceArgsForCall []struct{} + hasSpaceReturns struct { + result1 bool + result2 error + } + ApiEndpointStub func() (string, error) + apiEndpointMutex sync.RWMutex + apiEndpointArgsForCall []struct{} + apiEndpointReturns struct { + result1 string + result2 error + } + ApiVersionStub func() (string, error) + apiVersionMutex sync.RWMutex + apiVersionArgsForCall []struct{} + apiVersionReturns struct { + result1 string + result2 error + } + HasAPIEndpointStub func() (bool, error) + hasAPIEndpointMutex sync.RWMutex + hasAPIEndpointArgsForCall []struct{} + hasAPIEndpointReturns struct { + result1 bool + result2 error + } + LoggregatorEndpointStub func() (string, error) + loggregatorEndpointMutex sync.RWMutex + loggregatorEndpointArgsForCall []struct{} + loggregatorEndpointReturns struct { + result1 string + result2 error + } + DopplerEndpointStub func() (string, error) + dopplerEndpointMutex sync.RWMutex + dopplerEndpointArgsForCall []struct{} + dopplerEndpointReturns struct { + result1 string + result2 error + } + AccessTokenStub func() (string, error) + accessTokenMutex sync.RWMutex + accessTokenArgsForCall []struct{} + accessTokenReturns struct { + result1 string + result2 error + } + GetAppStub func(string) (plugin_models.GetAppModel, error) + getAppMutex sync.RWMutex + getAppArgsForCall []struct { + arg1 string + } + getAppReturns struct { + result1 plugin_models.GetAppModel + result2 error + } + GetAppsStub func() ([]plugin_models.GetAppsModel, error) + getAppsMutex sync.RWMutex + getAppsArgsForCall []struct{} + getAppsReturns struct { + result1 []plugin_models.GetAppsModel + result2 error + } + GetOrgsStub func() ([]plugin_models.GetOrgs_Model, error) + getOrgsMutex sync.RWMutex + getOrgsArgsForCall []struct{} + getOrgsReturns struct { + result1 []plugin_models.GetOrgs_Model + result2 error + } + GetSpacesStub func() ([]plugin_models.GetSpaces_Model, error) + getSpacesMutex sync.RWMutex + getSpacesArgsForCall []struct{} + getSpacesReturns struct { + result1 []plugin_models.GetSpaces_Model + result2 error + } + GetOrgUsersStub func(string, ...string) ([]plugin_models.GetOrgUsers_Model, error) + getOrgUsersMutex sync.RWMutex + getOrgUsersArgsForCall []struct { + arg1 string + arg2 []string + } + getOrgUsersReturns struct { + result1 []plugin_models.GetOrgUsers_Model + result2 error + } + GetSpaceUsersStub func(string, string) ([]plugin_models.GetSpaceUsers_Model, error) + getSpaceUsersMutex sync.RWMutex + getSpaceUsersArgsForCall []struct { + arg1 string + arg2 string + } + getSpaceUsersReturns struct { + result1 []plugin_models.GetSpaceUsers_Model + result2 error + } + GetServicesStub func() ([]plugin_models.GetServices_Model, error) + getServicesMutex sync.RWMutex + getServicesArgsForCall []struct{} + getServicesReturns struct { + result1 []plugin_models.GetServices_Model + result2 error + } + GetServiceStub func(string) (plugin_models.GetService_Model, error) + getServiceMutex sync.RWMutex + getServiceArgsForCall []struct { + arg1 string + } + getServiceReturns struct { + result1 plugin_models.GetService_Model + result2 error + } + GetOrgStub func(string) (plugin_models.GetOrg_Model, error) + getOrgMutex sync.RWMutex + getOrgArgsForCall []struct { + arg1 string + } + getOrgReturns struct { + result1 plugin_models.GetOrg_Model + result2 error + } + GetSpaceStub func(string) (plugin_models.GetSpace_Model, error) + getSpaceMutex sync.RWMutex + getSpaceArgsForCall []struct { + arg1 string + } + getSpaceReturns struct { + result1 plugin_models.GetSpace_Model + result2 error + } +} + +func (fake *FakeCliConnection) CliCommandWithoutTerminalOutput(args ...string) ([]string, error) { + fake.cliCommandWithoutTerminalOutputMutex.Lock() + fake.cliCommandWithoutTerminalOutputArgsForCall = append(fake.cliCommandWithoutTerminalOutputArgsForCall, struct { + args []string + }{args}) + fake.cliCommandWithoutTerminalOutputMutex.Unlock() + if fake.CliCommandWithoutTerminalOutputStub != nil { + return fake.CliCommandWithoutTerminalOutputStub(args...) + } else { + return fake.cliCommandWithoutTerminalOutputReturns.result1, fake.cliCommandWithoutTerminalOutputReturns.result2 + } +} + +func (fake *FakeCliConnection) CliCommandWithoutTerminalOutputCallCount() int { + fake.cliCommandWithoutTerminalOutputMutex.RLock() + defer fake.cliCommandWithoutTerminalOutputMutex.RUnlock() + return len(fake.cliCommandWithoutTerminalOutputArgsForCall) +} + +func (fake *FakeCliConnection) CliCommandWithoutTerminalOutputArgsForCall(i int) []string { + fake.cliCommandWithoutTerminalOutputMutex.RLock() + defer fake.cliCommandWithoutTerminalOutputMutex.RUnlock() + return fake.cliCommandWithoutTerminalOutputArgsForCall[i].args +} + +func (fake *FakeCliConnection) CliCommandWithoutTerminalOutputReturns(result1 []string, result2 error) { + fake.CliCommandWithoutTerminalOutputStub = nil + fake.cliCommandWithoutTerminalOutputReturns = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) CliCommand(args ...string) ([]string, error) { + fake.cliCommandMutex.Lock() + fake.cliCommandArgsForCall = append(fake.cliCommandArgsForCall, struct { + args []string + }{args}) + fake.cliCommandMutex.Unlock() + if fake.CliCommandStub != nil { + return fake.CliCommandStub(args...) + } else { + return fake.cliCommandReturns.result1, fake.cliCommandReturns.result2 + } +} + +func (fake *FakeCliConnection) CliCommandCallCount() int { + fake.cliCommandMutex.RLock() + defer fake.cliCommandMutex.RUnlock() + return len(fake.cliCommandArgsForCall) +} + +func (fake *FakeCliConnection) CliCommandArgsForCall(i int) []string { + fake.cliCommandMutex.RLock() + defer fake.cliCommandMutex.RUnlock() + return fake.cliCommandArgsForCall[i].args +} + +func (fake *FakeCliConnection) CliCommandReturns(result1 []string, result2 error) { + fake.CliCommandStub = nil + fake.cliCommandReturns = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetCurrentOrg() (plugin_models.Organization, error) { + fake.getCurrentOrgMutex.Lock() + fake.getCurrentOrgArgsForCall = append(fake.getCurrentOrgArgsForCall, struct{}{}) + fake.getCurrentOrgMutex.Unlock() + if fake.GetCurrentOrgStub != nil { + return fake.GetCurrentOrgStub() + } else { + return fake.getCurrentOrgReturns.result1, fake.getCurrentOrgReturns.result2 + } +} + +func (fake *FakeCliConnection) GetCurrentOrgCallCount() int { + fake.getCurrentOrgMutex.RLock() + defer fake.getCurrentOrgMutex.RUnlock() + return len(fake.getCurrentOrgArgsForCall) +} + +func (fake *FakeCliConnection) GetCurrentOrgReturns(result1 plugin_models.Organization, result2 error) { + fake.GetCurrentOrgStub = nil + fake.getCurrentOrgReturns = struct { + result1 plugin_models.Organization + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetCurrentSpace() (plugin_models.Space, error) { + fake.getCurrentSpaceMutex.Lock() + fake.getCurrentSpaceArgsForCall = append(fake.getCurrentSpaceArgsForCall, struct{}{}) + fake.getCurrentSpaceMutex.Unlock() + if fake.GetCurrentSpaceStub != nil { + return fake.GetCurrentSpaceStub() + } else { + return fake.getCurrentSpaceReturns.result1, fake.getCurrentSpaceReturns.result2 + } +} + +func (fake *FakeCliConnection) GetCurrentSpaceCallCount() int { + fake.getCurrentSpaceMutex.RLock() + defer fake.getCurrentSpaceMutex.RUnlock() + return len(fake.getCurrentSpaceArgsForCall) +} + +func (fake *FakeCliConnection) GetCurrentSpaceReturns(result1 plugin_models.Space, result2 error) { + fake.GetCurrentSpaceStub = nil + fake.getCurrentSpaceReturns = struct { + result1 plugin_models.Space + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) Username() (string, error) { + fake.usernameMutex.Lock() + fake.usernameArgsForCall = append(fake.usernameArgsForCall, struct{}{}) + fake.usernameMutex.Unlock() + if fake.UsernameStub != nil { + return fake.UsernameStub() + } else { + return fake.usernameReturns.result1, fake.usernameReturns.result2 + } +} + +func (fake *FakeCliConnection) UsernameCallCount() int { + fake.usernameMutex.RLock() + defer fake.usernameMutex.RUnlock() + return len(fake.usernameArgsForCall) +} + +func (fake *FakeCliConnection) UsernameReturns(result1 string, result2 error) { + fake.UsernameStub = nil + fake.usernameReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) UserGuid() (string, error) { + fake.userGuidMutex.Lock() + fake.userGuidArgsForCall = append(fake.userGuidArgsForCall, struct{}{}) + fake.userGuidMutex.Unlock() + if fake.UserGuidStub != nil { + return fake.UserGuidStub() + } else { + return fake.userGuidReturns.result1, fake.userGuidReturns.result2 + } +} + +func (fake *FakeCliConnection) UserGuidCallCount() int { + fake.userGuidMutex.RLock() + defer fake.userGuidMutex.RUnlock() + return len(fake.userGuidArgsForCall) +} + +func (fake *FakeCliConnection) UserGuidReturns(result1 string, result2 error) { + fake.UserGuidStub = nil + fake.userGuidReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) UserEmail() (string, error) { + fake.userEmailMutex.Lock() + fake.userEmailArgsForCall = append(fake.userEmailArgsForCall, struct{}{}) + fake.userEmailMutex.Unlock() + if fake.UserEmailStub != nil { + return fake.UserEmailStub() + } else { + return fake.userEmailReturns.result1, fake.userEmailReturns.result2 + } +} + +func (fake *FakeCliConnection) UserEmailCallCount() int { + fake.userEmailMutex.RLock() + defer fake.userEmailMutex.RUnlock() + return len(fake.userEmailArgsForCall) +} + +func (fake *FakeCliConnection) UserEmailReturns(result1 string, result2 error) { + fake.UserEmailStub = nil + fake.userEmailReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) IsLoggedIn() (bool, error) { + fake.isLoggedInMutex.Lock() + fake.isLoggedInArgsForCall = append(fake.isLoggedInArgsForCall, struct{}{}) + fake.isLoggedInMutex.Unlock() + if fake.IsLoggedInStub != nil { + return fake.IsLoggedInStub() + } else { + return fake.isLoggedInReturns.result1, fake.isLoggedInReturns.result2 + } +} + +func (fake *FakeCliConnection) IsLoggedInCallCount() int { + fake.isLoggedInMutex.RLock() + defer fake.isLoggedInMutex.RUnlock() + return len(fake.isLoggedInArgsForCall) +} + +func (fake *FakeCliConnection) IsLoggedInReturns(result1 bool, result2 error) { + fake.IsLoggedInStub = nil + fake.isLoggedInReturns = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) IsSSLDisabled() (bool, error) { + fake.isSSLDisabledMutex.Lock() + fake.isSSLDisabledArgsForCall = append(fake.isSSLDisabledArgsForCall, struct{}{}) + fake.isSSLDisabledMutex.Unlock() + if fake.IsSSLDisabledStub != nil { + return fake.IsSSLDisabledStub() + } else { + return fake.isSSLDisabledReturns.result1, fake.isSSLDisabledReturns.result2 + } +} + +func (fake *FakeCliConnection) IsSSLDisabledCallCount() int { + fake.isSSLDisabledMutex.RLock() + defer fake.isSSLDisabledMutex.RUnlock() + return len(fake.isSSLDisabledArgsForCall) +} + +func (fake *FakeCliConnection) IsSSLDisabledReturns(result1 bool, result2 error) { + fake.IsSSLDisabledStub = nil + fake.isSSLDisabledReturns = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) HasOrganization() (bool, error) { + fake.hasOrganizationMutex.Lock() + fake.hasOrganizationArgsForCall = append(fake.hasOrganizationArgsForCall, struct{}{}) + fake.hasOrganizationMutex.Unlock() + if fake.HasOrganizationStub != nil { + return fake.HasOrganizationStub() + } else { + return fake.hasOrganizationReturns.result1, fake.hasOrganizationReturns.result2 + } +} + +func (fake *FakeCliConnection) HasOrganizationCallCount() int { + fake.hasOrganizationMutex.RLock() + defer fake.hasOrganizationMutex.RUnlock() + return len(fake.hasOrganizationArgsForCall) +} + +func (fake *FakeCliConnection) HasOrganizationReturns(result1 bool, result2 error) { + fake.HasOrganizationStub = nil + fake.hasOrganizationReturns = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) HasSpace() (bool, error) { + fake.hasSpaceMutex.Lock() + fake.hasSpaceArgsForCall = append(fake.hasSpaceArgsForCall, struct{}{}) + fake.hasSpaceMutex.Unlock() + if fake.HasSpaceStub != nil { + return fake.HasSpaceStub() + } else { + return fake.hasSpaceReturns.result1, fake.hasSpaceReturns.result2 + } +} + +func (fake *FakeCliConnection) HasSpaceCallCount() int { + fake.hasSpaceMutex.RLock() + defer fake.hasSpaceMutex.RUnlock() + return len(fake.hasSpaceArgsForCall) +} + +func (fake *FakeCliConnection) HasSpaceReturns(result1 bool, result2 error) { + fake.HasSpaceStub = nil + fake.hasSpaceReturns = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) ApiEndpoint() (string, error) { + fake.apiEndpointMutex.Lock() + fake.apiEndpointArgsForCall = append(fake.apiEndpointArgsForCall, struct{}{}) + fake.apiEndpointMutex.Unlock() + if fake.ApiEndpointStub != nil { + return fake.ApiEndpointStub() + } else { + return fake.apiEndpointReturns.result1, fake.apiEndpointReturns.result2 + } +} + +func (fake *FakeCliConnection) ApiEndpointCallCount() int { + fake.apiEndpointMutex.RLock() + defer fake.apiEndpointMutex.RUnlock() + return len(fake.apiEndpointArgsForCall) +} + +func (fake *FakeCliConnection) ApiEndpointReturns(result1 string, result2 error) { + fake.ApiEndpointStub = nil + fake.apiEndpointReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) ApiVersion() (string, error) { + fake.apiVersionMutex.Lock() + fake.apiVersionArgsForCall = append(fake.apiVersionArgsForCall, struct{}{}) + fake.apiVersionMutex.Unlock() + if fake.ApiVersionStub != nil { + return fake.ApiVersionStub() + } else { + return fake.apiVersionReturns.result1, fake.apiVersionReturns.result2 + } +} + +func (fake *FakeCliConnection) ApiVersionCallCount() int { + fake.apiVersionMutex.RLock() + defer fake.apiVersionMutex.RUnlock() + return len(fake.apiVersionArgsForCall) +} + +func (fake *FakeCliConnection) ApiVersionReturns(result1 string, result2 error) { + fake.ApiVersionStub = nil + fake.apiVersionReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) HasAPIEndpoint() (bool, error) { + fake.hasAPIEndpointMutex.Lock() + fake.hasAPIEndpointArgsForCall = append(fake.hasAPIEndpointArgsForCall, struct{}{}) + fake.hasAPIEndpointMutex.Unlock() + if fake.HasAPIEndpointStub != nil { + return fake.HasAPIEndpointStub() + } else { + return fake.hasAPIEndpointReturns.result1, fake.hasAPIEndpointReturns.result2 + } +} + +func (fake *FakeCliConnection) HasAPIEndpointCallCount() int { + fake.hasAPIEndpointMutex.RLock() + defer fake.hasAPIEndpointMutex.RUnlock() + return len(fake.hasAPIEndpointArgsForCall) +} + +func (fake *FakeCliConnection) HasAPIEndpointReturns(result1 bool, result2 error) { + fake.HasAPIEndpointStub = nil + fake.hasAPIEndpointReturns = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) LoggregatorEndpoint() (string, error) { + fake.loggregatorEndpointMutex.Lock() + fake.loggregatorEndpointArgsForCall = append(fake.loggregatorEndpointArgsForCall, struct{}{}) + fake.loggregatorEndpointMutex.Unlock() + if fake.LoggregatorEndpointStub != nil { + return fake.LoggregatorEndpointStub() + } else { + return fake.loggregatorEndpointReturns.result1, fake.loggregatorEndpointReturns.result2 + } +} + +func (fake *FakeCliConnection) LoggregatorEndpointCallCount() int { + fake.loggregatorEndpointMutex.RLock() + defer fake.loggregatorEndpointMutex.RUnlock() + return len(fake.loggregatorEndpointArgsForCall) +} + +func (fake *FakeCliConnection) LoggregatorEndpointReturns(result1 string, result2 error) { + fake.LoggregatorEndpointStub = nil + fake.loggregatorEndpointReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) DopplerEndpoint() (string, error) { + fake.dopplerEndpointMutex.Lock() + fake.dopplerEndpointArgsForCall = append(fake.dopplerEndpointArgsForCall, struct{}{}) + fake.dopplerEndpointMutex.Unlock() + if fake.DopplerEndpointStub != nil { + return fake.DopplerEndpointStub() + } else { + return fake.dopplerEndpointReturns.result1, fake.dopplerEndpointReturns.result2 + } +} + +func (fake *FakeCliConnection) DopplerEndpointCallCount() int { + fake.dopplerEndpointMutex.RLock() + defer fake.dopplerEndpointMutex.RUnlock() + return len(fake.dopplerEndpointArgsForCall) +} + +func (fake *FakeCliConnection) DopplerEndpointReturns(result1 string, result2 error) { + fake.DopplerEndpointStub = nil + fake.dopplerEndpointReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) AccessToken() (string, error) { + fake.accessTokenMutex.Lock() + fake.accessTokenArgsForCall = append(fake.accessTokenArgsForCall, struct{}{}) + fake.accessTokenMutex.Unlock() + if fake.AccessTokenStub != nil { + return fake.AccessTokenStub() + } else { + return fake.accessTokenReturns.result1, fake.accessTokenReturns.result2 + } +} + +func (fake *FakeCliConnection) AccessTokenCallCount() int { + fake.accessTokenMutex.RLock() + defer fake.accessTokenMutex.RUnlock() + return len(fake.accessTokenArgsForCall) +} + +func (fake *FakeCliConnection) AccessTokenReturns(result1 string, result2 error) { + fake.AccessTokenStub = nil + fake.accessTokenReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetApp(arg1 string) (plugin_models.GetAppModel, error) { + fake.getAppMutex.Lock() + fake.getAppArgsForCall = append(fake.getAppArgsForCall, struct { + arg1 string + }{arg1}) + fake.getAppMutex.Unlock() + if fake.GetAppStub != nil { + return fake.GetAppStub(arg1) + } else { + return fake.getAppReturns.result1, fake.getAppReturns.result2 + } +} + +func (fake *FakeCliConnection) GetAppCallCount() int { + fake.getAppMutex.RLock() + defer fake.getAppMutex.RUnlock() + return len(fake.getAppArgsForCall) +} + +func (fake *FakeCliConnection) GetAppArgsForCall(i int) string { + fake.getAppMutex.RLock() + defer fake.getAppMutex.RUnlock() + return fake.getAppArgsForCall[i].arg1 +} + +func (fake *FakeCliConnection) GetAppReturns(result1 plugin_models.GetAppModel, result2 error) { + fake.GetAppStub = nil + fake.getAppReturns = struct { + result1 plugin_models.GetAppModel + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetApps() ([]plugin_models.GetAppsModel, error) { + fake.getAppsMutex.Lock() + fake.getAppsArgsForCall = append(fake.getAppsArgsForCall, struct{}{}) + fake.getAppsMutex.Unlock() + if fake.GetAppsStub != nil { + return fake.GetAppsStub() + } else { + return fake.getAppsReturns.result1, fake.getAppsReturns.result2 + } +} + +func (fake *FakeCliConnection) GetAppsCallCount() int { + fake.getAppsMutex.RLock() + defer fake.getAppsMutex.RUnlock() + return len(fake.getAppsArgsForCall) +} + +func (fake *FakeCliConnection) GetAppsReturns(result1 []plugin_models.GetAppsModel, result2 error) { + fake.GetAppsStub = nil + fake.getAppsReturns = struct { + result1 []plugin_models.GetAppsModel + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetOrgs() ([]plugin_models.GetOrgs_Model, error) { + fake.getOrgsMutex.Lock() + fake.getOrgsArgsForCall = append(fake.getOrgsArgsForCall, struct{}{}) + fake.getOrgsMutex.Unlock() + if fake.GetOrgsStub != nil { + return fake.GetOrgsStub() + } else { + return fake.getOrgsReturns.result1, fake.getOrgsReturns.result2 + } +} + +func (fake *FakeCliConnection) GetOrgsCallCount() int { + fake.getOrgsMutex.RLock() + defer fake.getOrgsMutex.RUnlock() + return len(fake.getOrgsArgsForCall) +} + +func (fake *FakeCliConnection) GetOrgsReturns(result1 []plugin_models.GetOrgs_Model, result2 error) { + fake.GetOrgsStub = nil + fake.getOrgsReturns = struct { + result1 []plugin_models.GetOrgs_Model + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetSpaces() ([]plugin_models.GetSpaces_Model, error) { + fake.getSpacesMutex.Lock() + fake.getSpacesArgsForCall = append(fake.getSpacesArgsForCall, struct{}{}) + fake.getSpacesMutex.Unlock() + if fake.GetSpacesStub != nil { + return fake.GetSpacesStub() + } else { + return fake.getSpacesReturns.result1, fake.getSpacesReturns.result2 + } +} + +func (fake *FakeCliConnection) GetSpacesCallCount() int { + fake.getSpacesMutex.RLock() + defer fake.getSpacesMutex.RUnlock() + return len(fake.getSpacesArgsForCall) +} + +func (fake *FakeCliConnection) GetSpacesReturns(result1 []plugin_models.GetSpaces_Model, result2 error) { + fake.GetSpacesStub = nil + fake.getSpacesReturns = struct { + result1 []plugin_models.GetSpaces_Model + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetOrgUsers(arg1 string, arg2 ...string) ([]plugin_models.GetOrgUsers_Model, error) { + fake.getOrgUsersMutex.Lock() + fake.getOrgUsersArgsForCall = append(fake.getOrgUsersArgsForCall, struct { + arg1 string + arg2 []string + }{arg1, arg2}) + fake.getOrgUsersMutex.Unlock() + if fake.GetOrgUsersStub != nil { + return fake.GetOrgUsersStub(arg1, arg2...) + } else { + return fake.getOrgUsersReturns.result1, fake.getOrgUsersReturns.result2 + } +} + +func (fake *FakeCliConnection) GetOrgUsersCallCount() int { + fake.getOrgUsersMutex.RLock() + defer fake.getOrgUsersMutex.RUnlock() + return len(fake.getOrgUsersArgsForCall) +} + +func (fake *FakeCliConnection) GetOrgUsersArgsForCall(i int) (string, []string) { + fake.getOrgUsersMutex.RLock() + defer fake.getOrgUsersMutex.RUnlock() + return fake.getOrgUsersArgsForCall[i].arg1, fake.getOrgUsersArgsForCall[i].arg2 +} + +func (fake *FakeCliConnection) GetOrgUsersReturns(result1 []plugin_models.GetOrgUsers_Model, result2 error) { + fake.GetOrgUsersStub = nil + fake.getOrgUsersReturns = struct { + result1 []plugin_models.GetOrgUsers_Model + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetSpaceUsers(arg1 string, arg2 string) ([]plugin_models.GetSpaceUsers_Model, error) { + fake.getSpaceUsersMutex.Lock() + fake.getSpaceUsersArgsForCall = append(fake.getSpaceUsersArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.getSpaceUsersMutex.Unlock() + if fake.GetSpaceUsersStub != nil { + return fake.GetSpaceUsersStub(arg1, arg2) + } else { + return fake.getSpaceUsersReturns.result1, fake.getSpaceUsersReturns.result2 + } +} + +func (fake *FakeCliConnection) GetSpaceUsersCallCount() int { + fake.getSpaceUsersMutex.RLock() + defer fake.getSpaceUsersMutex.RUnlock() + return len(fake.getSpaceUsersArgsForCall) +} + +func (fake *FakeCliConnection) GetSpaceUsersArgsForCall(i int) (string, string) { + fake.getSpaceUsersMutex.RLock() + defer fake.getSpaceUsersMutex.RUnlock() + return fake.getSpaceUsersArgsForCall[i].arg1, fake.getSpaceUsersArgsForCall[i].arg2 +} + +func (fake *FakeCliConnection) GetSpaceUsersReturns(result1 []plugin_models.GetSpaceUsers_Model, result2 error) { + fake.GetSpaceUsersStub = nil + fake.getSpaceUsersReturns = struct { + result1 []plugin_models.GetSpaceUsers_Model + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetServices() ([]plugin_models.GetServices_Model, error) { + fake.getServicesMutex.Lock() + fake.getServicesArgsForCall = append(fake.getServicesArgsForCall, struct{}{}) + fake.getServicesMutex.Unlock() + if fake.GetServicesStub != nil { + return fake.GetServicesStub() + } else { + return fake.getServicesReturns.result1, fake.getServicesReturns.result2 + } +} + +func (fake *FakeCliConnection) GetServicesCallCount() int { + fake.getServicesMutex.RLock() + defer fake.getServicesMutex.RUnlock() + return len(fake.getServicesArgsForCall) +} + +func (fake *FakeCliConnection) GetServicesReturns(result1 []plugin_models.GetServices_Model, result2 error) { + fake.GetServicesStub = nil + fake.getServicesReturns = struct { + result1 []plugin_models.GetServices_Model + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetService(arg1 string) (plugin_models.GetService_Model, error) { + fake.getServiceMutex.Lock() + fake.getServiceArgsForCall = append(fake.getServiceArgsForCall, struct { + arg1 string + }{arg1}) + fake.getServiceMutex.Unlock() + if fake.GetServiceStub != nil { + return fake.GetServiceStub(arg1) + } else { + return fake.getServiceReturns.result1, fake.getServiceReturns.result2 + } +} + +func (fake *FakeCliConnection) GetServiceCallCount() int { + fake.getServiceMutex.RLock() + defer fake.getServiceMutex.RUnlock() + return len(fake.getServiceArgsForCall) +} + +func (fake *FakeCliConnection) GetServiceArgsForCall(i int) string { + fake.getServiceMutex.RLock() + defer fake.getServiceMutex.RUnlock() + return fake.getServiceArgsForCall[i].arg1 +} + +func (fake *FakeCliConnection) GetServiceReturns(result1 plugin_models.GetService_Model, result2 error) { + fake.GetServiceStub = nil + fake.getServiceReturns = struct { + result1 plugin_models.GetService_Model + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetOrg(arg1 string) (plugin_models.GetOrg_Model, error) { + fake.getOrgMutex.Lock() + fake.getOrgArgsForCall = append(fake.getOrgArgsForCall, struct { + arg1 string + }{arg1}) + fake.getOrgMutex.Unlock() + if fake.GetOrgStub != nil { + return fake.GetOrgStub(arg1) + } else { + return fake.getOrgReturns.result1, fake.getOrgReturns.result2 + } +} + +func (fake *FakeCliConnection) GetOrgCallCount() int { + fake.getOrgMutex.RLock() + defer fake.getOrgMutex.RUnlock() + return len(fake.getOrgArgsForCall) +} + +func (fake *FakeCliConnection) GetOrgArgsForCall(i int) string { + fake.getOrgMutex.RLock() + defer fake.getOrgMutex.RUnlock() + return fake.getOrgArgsForCall[i].arg1 +} + +func (fake *FakeCliConnection) GetOrgReturns(result1 plugin_models.GetOrg_Model, result2 error) { + fake.GetOrgStub = nil + fake.getOrgReturns = struct { + result1 plugin_models.GetOrg_Model + result2 error + }{result1, result2} +} + +func (fake *FakeCliConnection) GetSpace(arg1 string) (plugin_models.GetSpace_Model, error) { + fake.getSpaceMutex.Lock() + fake.getSpaceArgsForCall = append(fake.getSpaceArgsForCall, struct { + arg1 string + }{arg1}) + fake.getSpaceMutex.Unlock() + if fake.GetSpaceStub != nil { + return fake.GetSpaceStub(arg1) + } else { + return fake.getSpaceReturns.result1, fake.getSpaceReturns.result2 + } +} + +func (fake *FakeCliConnection) GetSpaceCallCount() int { + fake.getSpaceMutex.RLock() + defer fake.getSpaceMutex.RUnlock() + return len(fake.getSpaceArgsForCall) +} + +func (fake *FakeCliConnection) GetSpaceArgsForCall(i int) string { + fake.getSpaceMutex.RLock() + defer fake.getSpaceMutex.RUnlock() + return fake.getSpaceArgsForCall[i].arg1 +} + +func (fake *FakeCliConnection) GetSpaceReturns(result1 plugin_models.GetSpace_Model, result2 error) { + fake.GetSpaceStub = nil + fake.getSpaceReturns = struct { + result1 plugin_models.GetSpace_Model + result2 error + }{result1, result2} +} + +var _ plugin.CliConnection = new(FakeCliConnection) diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_app.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_app.go new file mode 100644 index 0000000..05e9a02 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_app.go @@ -0,0 +1,60 @@ +package plugin_models + +import "time" + +type GetAppModel struct { + Guid string + Name string + BuildpackUrl string + Command string + Diego bool + DetectedStartCommand string + DiskQuota int64 // in Megabytes + EnvironmentVars map[string]interface{} + InstanceCount int + Memory int64 // in Megabytes + RunningInstances int + HealthCheckTimeout int + State string + SpaceGuid string + PackageUpdatedAt *time.Time + PackageState string + StagingFailedReason string + Stack *GetApp_Stack + Instances []GetApp_AppInstanceFields + Routes []GetApp_RouteSummary + Services []GetApp_ServiceSummary +} + +type GetApp_AppInstanceFields struct { + State string + Details string + Since time.Time + CpuUsage float64 // percentage + DiskQuota int64 // in bytes + DiskUsage int64 + MemQuota int64 + MemUsage int64 +} + +type GetApp_Stack struct { + Guid string + Name string + Description string +} + +type GetApp_RouteSummary struct { + Guid string + Host string + Domain GetApp_DomainFields +} + +type GetApp_DomainFields struct { + Guid string + Name string +} + +type GetApp_ServiceSummary struct { + Guid string + Name string +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_apps.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_apps.go new file mode 100644 index 0000000..9fe3179 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_apps.go @@ -0,0 +1,25 @@ +package plugin_models + +type GetAppsModel struct { + Name string + Guid string + State string + TotalInstances int + RunningInstances int + Memory int64 + DiskQuota int64 + Routes []GetAppsRouteSummary +} + +type GetAppsRouteSummary struct { + Guid string + Host string + Domain GetAppsDomainFields +} + +type GetAppsDomainFields struct { + Guid string + Name string + OwningOrganizationGuid string + Shared bool +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_current_org.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_current_org.go new file mode 100644 index 0000000..ea401f7 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_current_org.go @@ -0,0 +1,21 @@ +package plugin_models + +type Organization struct { + OrganizationFields +} + +type OrganizationFields struct { + Guid string + Name string + QuotaDefinition QuotaFields +} + +type QuotaFields struct { + Guid string + Name string + MemoryLimit int64 + InstanceMemoryLimit int64 + RoutesLimit int + ServicesLimit int + NonBasicServicesAllowed bool +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_current_space.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_current_space.go new file mode 100644 index 0000000..5575d32 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_current_space.go @@ -0,0 +1,10 @@ +package plugin_models + +type Space struct { + SpaceFields +} + +type SpaceFields struct { + Guid string + Name string +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_oauth_token.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_oauth_token.go new file mode 100644 index 0000000..64d1a54 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_oauth_token.go @@ -0,0 +1,5 @@ +package plugin_models + +type GetOauthToken_Model struct { + Token string +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_org.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_org.go new file mode 100644 index 0000000..366444e --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_org.go @@ -0,0 +1,32 @@ +package plugin_models + +type GetOrg_Model struct { + Guid string + Name string + QuotaDefinition QuotaFields + Spaces []GetOrg_Space + Domains []GetOrg_Domains + SpaceQuotas []GetOrg_SpaceQuota +} + +type GetOrg_Space struct { + Guid string + Name string +} + +type GetOrg_Domains struct { + Guid string + Name string + OwningOrganizationGuid string + Shared bool +} + +type GetOrg_SpaceQuota struct { + Guid string + Name string + MemoryLimit int64 + InstanceMemoryLimit int64 + RoutesLimit int + ServicesLimit int + NonBasicServicesAllowed bool +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_org_users.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_org_users.go new file mode 100644 index 0000000..d6a8428 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_org_users.go @@ -0,0 +1,8 @@ +package plugin_models + +type GetOrgUsers_Model struct { + Guid string + Username string + IsAdmin bool + Roles []string +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_orgs.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_orgs.go new file mode 100644 index 0000000..6ef3f59 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_orgs.go @@ -0,0 +1,6 @@ +package plugin_models + +type GetOrgs_Model struct { + Guid string + Name string +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_service.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_service.go new file mode 100644 index 0000000..45f8984 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_service.go @@ -0,0 +1,29 @@ +package plugin_models + +type GetService_Model struct { + Guid string + Name string + DashboardUrl string + IsUserProvided bool + ServiceOffering GetService_ServiceFields + ServicePlan GetService_ServicePlan + LastOperation GetService_LastOperation +} + +type GetService_LastOperation struct { + Type string + State string + Description string + CreatedAt string + UpdatedAt string +} + +type GetService_ServicePlan struct { + Name string + Guid string +} + +type GetService_ServiceFields struct { + Name string + DocumentationUrl string +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_services.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_services.go new file mode 100644 index 0000000..3c78c8a --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_services.go @@ -0,0 +1,25 @@ +package plugin_models + +type GetServices_Model struct { + Guid string + Name string + ServicePlan GetServices_ServicePlan + Service GetServices_ServiceFields + LastOperation GetServices_LastOperation + ApplicationNames []string + IsUserProvided bool +} + +type GetServices_LastOperation struct { + Type string + State string +} + +type GetServices_ServicePlan struct { + Guid string + Name string +} + +type GetServices_ServiceFields struct { + Name string +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_space.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_space.go new file mode 100644 index 0000000..ec85130 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_space.go @@ -0,0 +1,56 @@ +package plugin_models + +type GetSpace_Model struct { + GetSpaces_Model + Organization GetSpace_Orgs + Applications []GetSpace_Apps + ServiceInstances []GetSpace_ServiceInstance + Domains []GetSpace_Domains + SecurityGroups []GetSpace_SecurityGroup + SpaceQuota GetSpace_SpaceQuota +} + +type GetSpace_Orgs struct { + Guid string + Name string +} + +type GetSpace_Apps struct { + Name string + Guid string +} + +type GetSpace_AppsDomainFields struct { + Guid string + Name string + OwningOrganizationGuid string + Shared bool +} + +type GetSpace_ServiceInstance struct { + Guid string + Name string +} + +type GetSpace_Domains struct { + Guid string + Name string + OwningOrganizationGuid string + Shared bool +} + +type GetSpace_SecurityGroup struct { + Name string + Guid string + Rules []map[string]interface{} +} + +type GetSpace_SpaceQuota struct { + Guid string + Name string + MemoryLimit int64 + InstanceMemoryLimit int64 + RoutesLimit int + ServicesLimit int + NonBasicServicesAllowed bool +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_space_users.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_space_users.go new file mode 100644 index 0000000..abde8e4 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_space_users.go @@ -0,0 +1,8 @@ +package plugin_models + +type GetSpaceUsers_Model struct { + Guid string + Username string + IsAdmin bool + Roles []string +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/models/get_spaces.go b/vendor/github.com/cloudfoundry/cli/plugin/models/get_spaces.go new file mode 100644 index 0000000..b741717 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/models/get_spaces.go @@ -0,0 +1,6 @@ +package plugin_models + +type GetSpaces_Model struct { + Guid string + Name string +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/plugin.go b/vendor/github.com/cloudfoundry/cli/plugin/plugin.go new file mode 100644 index 0000000..29b0f4e --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/plugin.go @@ -0,0 +1,69 @@ +package plugin + +import "github.com/cloudfoundry/cli/plugin/models" + +/** + Command interface needs to be implemented for a runnable plugin of `cf` +**/ +type Plugin interface { + Run(cliConnection CliConnection, args []string) + GetMetadata() PluginMetadata +} + +/** + List of commands avaiable to CliConnection variable passed into run +**/ +type CliConnection interface { + CliCommandWithoutTerminalOutput(args ...string) ([]string, error) + CliCommand(args ...string) ([]string, error) + GetCurrentOrg() (plugin_models.Organization, error) + GetCurrentSpace() (plugin_models.Space, error) + Username() (string, error) + UserGuid() (string, error) + UserEmail() (string, error) + IsLoggedIn() (bool, error) + IsSSLDisabled() (bool, error) + HasOrganization() (bool, error) + HasSpace() (bool, error) + ApiEndpoint() (string, error) + ApiVersion() (string, error) + HasAPIEndpoint() (bool, error) + LoggregatorEndpoint() (string, error) + DopplerEndpoint() (string, error) + AccessToken() (string, error) + GetApp(string) (plugin_models.GetAppModel, error) + GetApps() ([]plugin_models.GetAppsModel, error) + GetOrgs() ([]plugin_models.GetOrgs_Model, error) + GetSpaces() ([]plugin_models.GetSpaces_Model, error) + GetOrgUsers(string, ...string) ([]plugin_models.GetOrgUsers_Model, error) + GetSpaceUsers(string, string) ([]plugin_models.GetSpaceUsers_Model, error) + GetServices() ([]plugin_models.GetServices_Model, error) + GetService(string) (plugin_models.GetService_Model, error) + GetOrg(string) (plugin_models.GetOrg_Model, error) + GetSpace(string) (plugin_models.GetSpace_Model, error) +} + +type VersionType struct { + Major int + Minor int + Build int +} + +type PluginMetadata struct { + Name string + Version VersionType + MinCliVersion VersionType + Commands []Command +} + +type Usage struct { + Usage string + Options map[string]string +} + +type Command struct { + Name string + Alias string + HelpText string + UsageDetails Usage //Detail usage to be displayed in `cf help ` +} diff --git a/vendor/github.com/cloudfoundry/cli/plugin/plugin_shim.go b/vendor/github.com/cloudfoundry/cli/plugin/plugin_shim.go new file mode 100644 index 0000000..42c6457 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/plugin/plugin_shim.go @@ -0,0 +1,44 @@ +package plugin + +import ( + "fmt" + "os" + "strconv" +) + +/** + * This function is called by the plugin to setup their server. This allows us to call Run on the plugin + * os.Args[1] port CF_CLI rpc server is running on + * os.Args[2] **OPTIONAL** + * SendMetadata - used to fetch the plugin metadata +**/ +func Start(cmd Plugin) { + cliConnection := NewCliConnection(os.Args[1]) + + cliConnection.pingCLI() + if isMetadataRequest(os.Args) { + cliConnection.sendPluginMetadataToCliServer(cmd.GetMetadata()) + } else { + if version := MinCliVersionStr(cmd.GetMetadata().MinCliVersion); version != "" { + ok := cliConnection.isMinCliVersion(version) + if !ok { + fmt.Printf("Minimum CLI version %s is required to run this plugin command\n\n", version) + os.Exit(0) + } + } + + cmd.Run(cliConnection, os.Args[2:]) + } +} + +func isMetadataRequest(args []string) bool { + return len(args) == 3 && args[2] == "SendMetadata" +} + +func MinCliVersionStr(version VersionType) string { + if version.Major == 0 && version.Minor == 0 && version.Build == 0 { + return "" + } + + return strconv.Itoa(version.Major) + "." + strconv.Itoa(version.Minor) + "." + strconv.Itoa(version.Build) +} diff --git a/vendor/github.com/cloudfoundry/cli/testhelpers/io/io.go b/vendor/github.com/cloudfoundry/cli/testhelpers/io/io.go new file mode 100644 index 0000000..614deb6 --- /dev/null +++ b/vendor/github.com/cloudfoundry/cli/testhelpers/io/io.go @@ -0,0 +1,71 @@ +package io + +import ( + "bytes" + "io" + "os" + "strings" +) + +func SimulateStdin(input string, block func(r io.Reader)) { + reader, writer := io.Pipe() + + go func() { + writer.Write([]byte(input)) + defer writer.Close() + }() + + block(reader) +} + +func CaptureOutput(block func()) []string { + oldSTDOUT := os.Stdout + r, w, err := os.Pipe() + if err != nil { + panic(err) + } + + os.Stdout = w + defer func() { + os.Stdout = oldSTDOUT + }() + + doneWriting := make(chan bool) + result := make(chan []string) + + go captureOutputAsyncronously(doneWriting, result, r) + + block() + w.Close() + doneWriting <- true + return <-result +} + +/* + The reason we're doing is that you can't write an infinite amount of bytes into a pipe. + On some platforms, the limit is fairly high; on other platforms, the limit is infuriatingly small + (looking at you, Windows). To counteract this, we need to read in a goroutine from one end of + the pipe and return the result across a channel. +*/ +func captureOutputAsyncronously(doneWriting <-chan bool, result chan<- []string, reader io.Reader) { + var readingString string + + for { + var buf bytes.Buffer + io.Copy(&buf, reader) + readingString += buf.String() + + _, ok := <-doneWriting + if ok { + // there is no guarantee that the writer did not + // write more in between the read above and reading from this channel + // so we absolute must read once more if we want all the bytes + var buf bytes.Buffer + io.Copy(&buf, reader) + readingString += buf.String() + break + } + } + + result <- strings.Split(readingString, "\n") +} diff --git a/vendor/github.com/cloudfoundry/gofileutils/LICENSE b/vendor/github.com/cloudfoundry/gofileutils/LICENSE new file mode 100644 index 0000000..1b5ec8b --- /dev/null +++ b/vendor/github.com/cloudfoundry/gofileutils/LICENSE @@ -0,0 +1,176 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS diff --git a/vendor/github.com/cloudfoundry/gofileutils/NOTICE b/vendor/github.com/cloudfoundry/gofileutils/NOTICE new file mode 100644 index 0000000..af7e5e6 --- /dev/null +++ b/vendor/github.com/cloudfoundry/gofileutils/NOTICE @@ -0,0 +1,11 @@ +Copyright (c) 2015-Present CloudFoundry.org Foundation, Inc. All Rights Reserved. + +This project contains software that is Copyright (c) 2014-2015 Pivotal Software, Inc. + +This project is licensed to you under the Apache License, Version 2.0 (the "License"). + +You may not use this project except in compliance with the License. + +This project may include a number of subcomponents with separate copyright notices +and license terms. Your use of these subcomponents is subject to the terms and +conditions of the subcomponent's license, as noted in the LICENSE file. diff --git a/vendor/github.com/cloudfoundry/gofileutils/fileutils/dir_utils.go b/vendor/github.com/cloudfoundry/gofileutils/fileutils/dir_utils.go new file mode 100644 index 0000000..a430217 --- /dev/null +++ b/vendor/github.com/cloudfoundry/gofileutils/fileutils/dir_utils.go @@ -0,0 +1,20 @@ +package fileutils + +import ( + "os" +) + +func IsDirEmpty(dir string) (isEmpty bool, err error) { + dirFile, err := os.Open(dir) + if err != nil { + return + } + + _, readErr := dirFile.Readdirnames(1) + if readErr != nil { + isEmpty = true + } else { + isEmpty = false + } + return +} diff --git a/vendor/github.com/cloudfoundry/gofileutils/fileutils/file_utils.go b/vendor/github.com/cloudfoundry/gofileutils/fileutils/file_utils.go new file mode 100644 index 0000000..ac9b6eb --- /dev/null +++ b/vendor/github.com/cloudfoundry/gofileutils/fileutils/file_utils.go @@ -0,0 +1,74 @@ +package fileutils + +import ( + "io" + "io/ioutil" + "os" + "path" + "path/filepath" +) + +func Open(path string) (file *os.File, err error) { + err = os.MkdirAll(filepath.Dir(path), os.ModeDir|os.ModePerm) + if err != nil { + return + } + + return os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666) +} + +func Create(path string) (file *os.File, err error) { + err = os.MkdirAll(filepath.Dir(path), os.ModeDir|os.ModePerm) + if err != nil { + return + } + + return os.Create(path) +} + +func CopyPathToPath(fromPath, toPath string) (err error) { + srcFileInfo, err := os.Stat(fromPath) + if err != nil { + return err + } + + if srcFileInfo.IsDir() { + err = os.MkdirAll(toPath, srcFileInfo.Mode()) + if err != nil { + return err + } + + files, err := ioutil.ReadDir(fromPath) + if err != nil { + return err + } + + for _, file := range files { + err = CopyPathToPath(path.Join(fromPath, file.Name()), path.Join(toPath, file.Name())) + if err != nil { + return err + } + } + } else { + var dst *os.File + dst, err = Create(toPath) + if err != nil { + return err + } + defer dst.Close() + + dst.Chmod(srcFileInfo.Mode()) + + src, err := os.Open(fromPath) + if err != nil { + return err + } + defer src.Close() + + _, err = io.Copy(dst, src) + if err != nil { + return err + } + } + return err +} diff --git a/vendor/github.com/cloudfoundry/gofileutils/fileutils/temp_utils.go b/vendor/github.com/cloudfoundry/gofileutils/fileutils/temp_utils.go new file mode 100644 index 0000000..4961a8d --- /dev/null +++ b/vendor/github.com/cloudfoundry/gofileutils/fileutils/temp_utils.go @@ -0,0 +1,27 @@ +package fileutils + +import ( + "io/ioutil" + "os" +) + +func TempDir(namePrefix string, cb func(tmpDir string, err error)) { + tmpDir, err := ioutil.TempDir("", namePrefix) + + defer func() { + os.RemoveAll(tmpDir) + }() + + cb(tmpDir, err) +} + +func TempFile(namePrefix string, cb func(tmpFile *os.File, err error)) { + tmpFile, err := ioutil.TempFile("", namePrefix) + + defer func() { + tmpFile.Close() + os.Remove(tmpFile.Name()) + }() + + cb(tmpFile, err) +} diff --git a/vendor/github.com/dgrijalva/jwt-go/.gitignore b/vendor/github.com/dgrijalva/jwt-go/.gitignore new file mode 100644 index 0000000..80bed65 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/.gitignore @@ -0,0 +1,4 @@ +.DS_Store +bin + + diff --git a/vendor/github.com/dgrijalva/jwt-go/.travis.yml b/vendor/github.com/dgrijalva/jwt-go/.travis.yml new file mode 100644 index 0000000..1027f56 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/.travis.yml @@ -0,0 +1,13 @@ +language: go + +script: + - go vet ./... + - go test -v ./... + +go: + - 1.3 + - 1.4 + - 1.5 + - 1.6 + - 1.7 + - tip diff --git a/vendor/github.com/dgrijalva/jwt-go/LICENSE b/vendor/github.com/dgrijalva/jwt-go/LICENSE new file mode 100644 index 0000000..df83a9c --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/LICENSE @@ -0,0 +1,8 @@ +Copyright (c) 2012 Dave Grijalva + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/vendor/github.com/dgrijalva/jwt-go/MIGRATION_GUIDE.md b/vendor/github.com/dgrijalva/jwt-go/MIGRATION_GUIDE.md new file mode 100644 index 0000000..7fc1f79 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/MIGRATION_GUIDE.md @@ -0,0 +1,97 @@ +## Migration Guide from v2 -> v3 + +Version 3 adds several new, frequently requested features. To do so, it introduces a few breaking changes. We've worked to keep these as minimal as possible. This guide explains the breaking changes and how you can quickly update your code. + +### `Token.Claims` is now an interface type + +The most requested feature from the 2.0 verison of this library was the ability to provide a custom type to the JSON parser for claims. This was implemented by introducing a new interface, `Claims`, to replace `map[string]interface{}`. We also included two concrete implementations of `Claims`: `MapClaims` and `StandardClaims`. + +`MapClaims` is an alias for `map[string]interface{}` with built in validation behavior. It is the default claims type when using `Parse`. The usage is unchanged except you must type cast the claims property. + +The old example for parsing a token looked like this.. + +```go + if token, err := jwt.Parse(tokenString, keyLookupFunc); err == nil { + fmt.Printf("Token for user %v expires %v", token.Claims["user"], token.Claims["exp"]) + } +``` + +is now directly mapped to... + +```go + if token, err := jwt.Parse(tokenString, keyLookupFunc); err == nil { + claims := token.Claims.(jwt.MapClaims) + fmt.Printf("Token for user %v expires %v", claims["user"], claims["exp"]) + } +``` + +`StandardClaims` is designed to be embedded in your custom type. You can supply a custom claims type with the new `ParseWithClaims` function. Here's an example of using a custom claims type. + +```go + type MyCustomClaims struct { + User string + *StandardClaims + } + + if token, err := jwt.ParseWithClaims(tokenString, &MyCustomClaims{}, keyLookupFunc); err == nil { + claims := token.Claims.(*MyCustomClaims) + fmt.Printf("Token for user %v expires %v", claims.User, claims.StandardClaims.ExpiresAt) + } +``` + +### `ParseFromRequest` has been moved + +To keep this library focused on the tokens without becoming overburdened with complex request processing logic, `ParseFromRequest` and its new companion `ParseFromRequestWithClaims` have been moved to a subpackage, `request`. The method signatues have also been augmented to receive a new argument: `Extractor`. + +`Extractors` do the work of picking the token string out of a request. The interface is simple and composable. + +This simple parsing example: + +```go + if token, err := jwt.ParseFromRequest(tokenString, req, keyLookupFunc); err == nil { + fmt.Printf("Token for user %v expires %v", token.Claims["user"], token.Claims["exp"]) + } +``` + +is directly mapped to: + +```go + if token, err := request.ParseFromRequest(req, request.OAuth2Extractor, keyLookupFunc); err == nil { + claims := token.Claims.(jwt.MapClaims) + fmt.Printf("Token for user %v expires %v", claims["user"], claims["exp"]) + } +``` + +There are several concrete `Extractor` types provided for your convenience: + +* `HeaderExtractor` will search a list of headers until one contains content. +* `ArgumentExtractor` will search a list of keys in request query and form arguments until one contains content. +* `MultiExtractor` will try a list of `Extractors` in order until one returns content. +* `AuthorizationHeaderExtractor` will look in the `Authorization` header for a `Bearer` token. +* `OAuth2Extractor` searches the places an OAuth2 token would be specified (per the spec): `Authorization` header and `access_token` argument +* `PostExtractionFilter` wraps an `Extractor`, allowing you to process the content before it's parsed. A simple example is stripping the `Bearer ` text from a header + + +### RSA signing methods no longer accept `[]byte` keys + +Due to a [critical vulnerability](https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/), we've decided the convenience of accepting `[]byte` instead of `rsa.PublicKey` or `rsa.PrivateKey` isn't worth the risk of misuse. + +To replace this behavior, we've added two helper methods: `ParseRSAPrivateKeyFromPEM(key []byte) (*rsa.PrivateKey, error)` and `ParseRSAPublicKeyFromPEM(key []byte) (*rsa.PublicKey, error)`. These are just simple helpers for unpacking PEM encoded PKCS1 and PKCS8 keys. If your keys are encoded any other way, all you need to do is convert them to the `crypto/rsa` package's types. + +```go + func keyLookupFunc(*Token) (interface{}, error) { + // Don't forget to validate the alg is what you expect: + if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok { + return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"]) + } + + // Look up key + key, err := lookupPublicKey(token.Header["kid"]) + if err != nil { + return nil, err + } + + // Unpack key from PEM encoded PKCS8 + return jwt.ParseRSAPublicKeyFromPEM(key) + } +``` diff --git a/vendor/github.com/dgrijalva/jwt-go/README.md b/vendor/github.com/dgrijalva/jwt-go/README.md new file mode 100644 index 0000000..f48365f --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/README.md @@ -0,0 +1,85 @@ +A [go](http://www.golang.org) (or 'golang' for search engine friendliness) implementation of [JSON Web Tokens](http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html) + +[![Build Status](https://travis-ci.org/dgrijalva/jwt-go.svg?branch=master)](https://travis-ci.org/dgrijalva/jwt-go) + +**BREAKING CHANGES:*** Version 3.0.0 is here. It includes _a lot_ of changes including a few that break the API. We've tried to break as few things as possible, so there should just be a few type signature changes. A full list of breaking changes is available in `VERSION_HISTORY.md`. See `MIGRATION_GUIDE.md` for more information on updating your code. + +**NOTICE:** A vulnerability in JWT was [recently published](https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/). As this library doesn't force users to validate the `alg` is what they expected, it's possible your usage is effected. There will be an update soon to remedy this, and it will likey require backwards-incompatible changes to the API. In the short term, please make sure your implementation verifies the `alg` is what you expect. + + +## What the heck is a JWT? + +JWT.io has [a great introduction](https://jwt.io/introduction) to JSON Web Tokens. + +In short, it's a signed JSON object that does something useful (for example, authentication). It's commonly used for `Bearer` tokens in Oauth 2. A token is made of three parts, separated by `.`'s. The first two parts are JSON objects, that have been [base64url](http://tools.ietf.org/html/rfc4648) encoded. The last part is the signature, encoded the same way. + +The first part is called the header. It contains the necessary information for verifying the last part, the signature. For example, which encryption method was used for signing and what key was used. + +The part in the middle is the interesting bit. It's called the Claims and contains the actual stuff you care about. Refer to [the RFC](http://self-issued.info/docs/draft-jones-json-web-token.html) for information about reserved keys and the proper way to add your own. + +## What's in the box? + +This library supports the parsing and verification as well as the generation and signing of JWTs. Current supported signing algorithms are HMAC SHA, RSA, RSA-PSS, and ECDSA, though hooks are present for adding your own. + +## Examples + +See [the project documentation](https://godoc.org/github.com/dgrijalva/jwt-go) for examples of usage: + +* [Simple example of parsing and validating a token](https://godoc.org/github.com/dgrijalva/jwt-go#example-Parse--Hmac) +* [Simple example of building and signing a token](https://godoc.org/github.com/dgrijalva/jwt-go#example-New--Hmac) +* [Directory of Examples](https://godoc.org/github.com/dgrijalva/jwt-go#pkg-examples) + +## Extensions + +This library publishes all the necessary components for adding your own signing methods. Simply implement the `SigningMethod` interface and register a factory method using `RegisterSigningMethod`. + +Here's an example of an extension that integrates with the Google App Engine signing tools: https://github.com/someone1/gcp-jwt-go + +## Compliance + +This library was last reviewed to comply with [RTF 7519](http://www.rfc-editor.org/info/rfc7519) dated May 2015 with a few notable differences: + +* In order to protect against accidental use of [Unsecured JWTs](http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html#UnsecuredJWT), tokens using `alg=none` will only be accepted if the constant `jwt.UnsafeAllowNoneSignatureType` is provided as the key. + +## Project Status & Versioning + +This library is considered production ready. Feedback and feature requests are appreciated. The API should be considered stable. There should be very few backwards-incompatible changes outside of major version updates (and only with good reason). + +This project uses [Semantic Versioning 2.0.0](http://semver.org). Accepted pull requests will land on `master`. Periodically, versions will be tagged from `master`. You can find all the releases on [the project releases page](https://github.com/dgrijalva/jwt-go/releases). + +While we try to make it obvious when we make breaking changes, there isn't a great mechanism for pushing announcements out to users. You may want to use this alternative package include: `gopkg.in/dgrijalva/jwt-go.v2`. It will do the right thing WRT semantic versioning. + +## Usage Tips + +### Signing vs Encryption + +A token is simply a JSON object that is signed by its author. this tells you exactly two things about the data: + +* The author of the token was in the possession of the signing secret +* The data has not been modified since it was signed + +It's important to know that JWT does not provide encryption, which means anyone who has access to the token can read its contents. If you need to protect (encrypt) the data, there is a companion spec, `JWE`, that provides this functionality. JWE is currently outside the scope of this library. + +### Choosing a Signing Method + +There are several signing methods available, and you should probably take the time to learn about the various options before choosing one. The principal design decision is most likely going to be symmetric vs asymmetric. + +Symmetric signing methods, such as HSA, use only a single secret. This is probably the simplest signing method to use since any `[]byte` can be used as a valid secret. They are also slightly computationally faster to use, though this rarely is enough to matter. Symmetric signing methods work the best when both producers and consumers of tokens are trusted, or even the same system. Since the same secret is used to both sign and validate tokens, you can't easily distribute the key for validation. + +Asymmetric signing methods, such as RSA, use different keys for signing and verifying tokens. This makes it possible to produce tokens with a private key, and allow any consumer to access the public key for verification. + +### JWT and OAuth + +It's worth mentioning that OAuth and JWT are not the same thing. A JWT token is simply a signed JSON object. It can be used anywhere such a thing is useful. There is some confusion, though, as JWT is the most common type of bearer token used in OAuth2 authentication. + +Without going too far down the rabbit hole, here's a description of the interaction of these technologies: + +* OAuth is a protocol for allowing an identity provider to be separate from the service a user is logging in to. For example, whenever you use Facebook to log into a different service (Yelp, Spotify, etc), you are using OAuth. +* OAuth defines several options for passing around authentication data. One popular method is called a "bearer token". A bearer token is simply a string that _should_ only be held by an authenticated user. Thus, simply presenting this token proves your identity. You can probably derive from here why a JWT might make a good bearer token. +* Because bearer tokens are used for authentication, it's important they're kept secret. This is why transactions that use bearer tokens typically happen over SSL. + +## More + +Documentation can be found [on godoc.org](http://godoc.org/github.com/dgrijalva/jwt-go). + +The command line utility included in this project (cmd/jwt) provides a straightforward example of token creation and parsing as well as a useful tool for debugging your own integration. You'll also find several implementation examples in to documentation. diff --git a/vendor/github.com/dgrijalva/jwt-go/VERSION_HISTORY.md b/vendor/github.com/dgrijalva/jwt-go/VERSION_HISTORY.md new file mode 100644 index 0000000..b605b45 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/VERSION_HISTORY.md @@ -0,0 +1,105 @@ +## `jwt-go` Version History + +#### 3.0.0 + +* **Compatibility Breaking Changes**: See MIGRATION_GUIDE.md for tips on updating your code + * Dropped support for `[]byte` keys when using RSA signing methods. This convenience feature could contribute to security vulnerabilities involving mismatched key types with signing methods. + * `ParseFromRequest` has been moved to `request` subpackage and usage has changed + * The `Claims` property on `Token` is now type `Claims` instead of `map[string]interface{}`. The default value is type `MapClaims`, which is an alias to `map[string]interface{}`. This makes it possible to use a custom type when decoding claims. +* Other Additions and Changes + * Added `Claims` interface type to allow users to decode the claims into a custom type + * Added `ParseWithClaims`, which takes a third argument of type `Claims`. Use this function instead of `Parse` if you have a custom type you'd like to decode into. + * Dramatically improved the functionality and flexibility of `ParseFromRequest`, which is now in the `request` subpackage + * Added `ParseFromRequestWithClaims` which is the `FromRequest` equivalent of `ParseWithClaims` + * Added new interface type `Extractor`, which is used for extracting JWT strings from http requests. Used with `ParseFromRequest` and `ParseFromRequestWithClaims`. + * Added several new, more specific, validation errors to error type bitmask + * Moved examples from README to executable example files + * Signing method registry is now thread safe + * Added new property to `ValidationError`, which contains the raw error returned by calls made by parse/verify (such as those returned by keyfunc or json parser) + +#### 2.7.0 + +This will likely be the last backwards compatible release before 3.0.0, excluding essential bug fixes. + +* Added new option `-show` to the `jwt` command that will just output the decoded token without verifying +* Error text for expired tokens includes how long it's been expired +* Fixed incorrect error returned from `ParseRSAPublicKeyFromPEM` +* Documentation updates + +#### 2.6.0 + +* Exposed inner error within ValidationError +* Fixed validation errors when using UseJSONNumber flag +* Added several unit tests + +#### 2.5.0 + +* Added support for signing method none. You shouldn't use this. The API tries to make this clear. +* Updated/fixed some documentation +* Added more helpful error message when trying to parse tokens that begin with `BEARER ` + +#### 2.4.0 + +* Added new type, Parser, to allow for configuration of various parsing parameters + * You can now specify a list of valid signing methods. Anything outside this set will be rejected. + * You can now opt to use the `json.Number` type instead of `float64` when parsing token JSON +* Added support for [Travis CI](https://travis-ci.org/dgrijalva/jwt-go) +* Fixed some bugs with ECDSA parsing + +#### 2.3.0 + +* Added support for ECDSA signing methods +* Added support for RSA PSS signing methods (requires go v1.4) + +#### 2.2.0 + +* Gracefully handle a `nil` `Keyfunc` being passed to `Parse`. Result will now be the parsed token and an error, instead of a panic. + +#### 2.1.0 + +Backwards compatible API change that was missed in 2.0.0. + +* The `SignedString` method on `Token` now takes `interface{}` instead of `[]byte` + +#### 2.0.0 + +There were two major reasons for breaking backwards compatibility with this update. The first was a refactor required to expand the width of the RSA and HMAC-SHA signing implementations. There will likely be no required code changes to support this change. + +The second update, while unfortunately requiring a small change in integration, is required to open up this library to other signing methods. Not all keys used for all signing methods have a single standard on-disk representation. Requiring `[]byte` as the type for all keys proved too limiting. Additionally, this implementation allows for pre-parsed tokens to be reused, which might matter in an application that parses a high volume of tokens with a small set of keys. Backwards compatibilty has been maintained for passing `[]byte` to the RSA signing methods, but they will also accept `*rsa.PublicKey` and `*rsa.PrivateKey`. + +It is likely the only integration change required here will be to change `func(t *jwt.Token) ([]byte, error)` to `func(t *jwt.Token) (interface{}, error)` when calling `Parse`. + +* **Compatibility Breaking Changes** + * `SigningMethodHS256` is now `*SigningMethodHMAC` instead of `type struct` + * `SigningMethodRS256` is now `*SigningMethodRSA` instead of `type struct` + * `KeyFunc` now returns `interface{}` instead of `[]byte` + * `SigningMethod.Sign` now takes `interface{}` instead of `[]byte` for the key + * `SigningMethod.Verify` now takes `interface{}` instead of `[]byte` for the key +* Renamed type `SigningMethodHS256` to `SigningMethodHMAC`. Specific sizes are now just instances of this type. + * Added public package global `SigningMethodHS256` + * Added public package global `SigningMethodHS384` + * Added public package global `SigningMethodHS512` +* Renamed type `SigningMethodRS256` to `SigningMethodRSA`. Specific sizes are now just instances of this type. + * Added public package global `SigningMethodRS256` + * Added public package global `SigningMethodRS384` + * Added public package global `SigningMethodRS512` +* Moved sample private key for HMAC tests from an inline value to a file on disk. Value is unchanged. +* Refactored the RSA implementation to be easier to read +* Exposed helper methods `ParseRSAPrivateKeyFromPEM` and `ParseRSAPublicKeyFromPEM` + +#### 1.0.2 + +* Fixed bug in parsing public keys from certificates +* Added more tests around the parsing of keys for RS256 +* Code refactoring in RS256 implementation. No functional changes + +#### 1.0.1 + +* Fixed panic if RS256 signing method was passed an invalid key + +#### 1.0.0 + +* First versioned release +* API stabilized +* Supports creating, signing, parsing, and validating JWT tokens +* Supports RS256 and HS256 signing methods \ No newline at end of file diff --git a/vendor/github.com/dgrijalva/jwt-go/claims.go b/vendor/github.com/dgrijalva/jwt-go/claims.go new file mode 100644 index 0000000..f0228f0 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/claims.go @@ -0,0 +1,134 @@ +package jwt + +import ( + "crypto/subtle" + "fmt" + "time" +) + +// For a type to be a Claims object, it must just have a Valid method that determines +// if the token is invalid for any supported reason +type Claims interface { + Valid() error +} + +// Structured version of Claims Section, as referenced at +// https://tools.ietf.org/html/rfc7519#section-4.1 +// See examples for how to use this with your own claim types +type StandardClaims struct { + Audience string `json:"aud,omitempty"` + ExpiresAt int64 `json:"exp,omitempty"` + Id string `json:"jti,omitempty"` + IssuedAt int64 `json:"iat,omitempty"` + Issuer string `json:"iss,omitempty"` + NotBefore int64 `json:"nbf,omitempty"` + Subject string `json:"sub,omitempty"` +} + +// Validates time based claims "exp, iat, nbf". +// There is no accounting for clock skew. +// As well, if any of the above claims are not in the token, it will still +// be considered a valid claim. +func (c StandardClaims) Valid() error { + vErr := new(ValidationError) + now := TimeFunc().Unix() + + // The claims below are optional, by default, so if they are set to the + // default value in Go, let's not fail the verification for them. + if c.VerifyExpiresAt(now, false) == false { + delta := time.Unix(now, 0).Sub(time.Unix(c.ExpiresAt, 0)) + vErr.Inner = fmt.Errorf("token is expired by %v", delta) + vErr.Errors |= ValidationErrorExpired + } + + if c.VerifyIssuedAt(now, false) == false { + vErr.Inner = fmt.Errorf("Token used before issued") + vErr.Errors |= ValidationErrorIssuedAt + } + + if c.VerifyNotBefore(now, false) == false { + vErr.Inner = fmt.Errorf("token is not valid yet") + vErr.Errors |= ValidationErrorNotValidYet + } + + if vErr.valid() { + return nil + } + + return vErr +} + +// Compares the aud claim against cmp. +// If required is false, this method will return true if the value matches or is unset +func (c *StandardClaims) VerifyAudience(cmp string, req bool) bool { + return verifyAud(c.Audience, cmp, req) +} + +// Compares the exp claim against cmp. +// If required is false, this method will return true if the value matches or is unset +func (c *StandardClaims) VerifyExpiresAt(cmp int64, req bool) bool { + return verifyExp(c.ExpiresAt, cmp, req) +} + +// Compares the iat claim against cmp. +// If required is false, this method will return true if the value matches or is unset +func (c *StandardClaims) VerifyIssuedAt(cmp int64, req bool) bool { + return verifyIat(c.IssuedAt, cmp, req) +} + +// Compares the iss claim against cmp. +// If required is false, this method will return true if the value matches or is unset +func (c *StandardClaims) VerifyIssuer(cmp string, req bool) bool { + return verifyIss(c.Issuer, cmp, req) +} + +// Compares the nbf claim against cmp. +// If required is false, this method will return true if the value matches or is unset +func (c *StandardClaims) VerifyNotBefore(cmp int64, req bool) bool { + return verifyNbf(c.NotBefore, cmp, req) +} + +// ----- helpers + +func verifyAud(aud string, cmp string, required bool) bool { + if aud == "" { + return !required + } + if subtle.ConstantTimeCompare([]byte(aud), []byte(cmp)) != 0 { + return true + } else { + return false + } +} + +func verifyExp(exp int64, now int64, required bool) bool { + if exp == 0 { + return !required + } + return now <= exp +} + +func verifyIat(iat int64, now int64, required bool) bool { + if iat == 0 { + return !required + } + return now >= iat +} + +func verifyIss(iss string, cmp string, required bool) bool { + if iss == "" { + return !required + } + if subtle.ConstantTimeCompare([]byte(iss), []byte(cmp)) != 0 { + return true + } else { + return false + } +} + +func verifyNbf(nbf int64, now int64, required bool) bool { + if nbf == 0 { + return !required + } + return now >= nbf +} diff --git a/vendor/github.com/dgrijalva/jwt-go/doc.go b/vendor/github.com/dgrijalva/jwt-go/doc.go new file mode 100644 index 0000000..a86dc1a --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/doc.go @@ -0,0 +1,4 @@ +// Package jwt is a Go implementation of JSON Web Tokens: http://self-issued.info/docs/draft-jones-json-web-token.html +// +// See README.md for more info. +package jwt diff --git a/vendor/github.com/dgrijalva/jwt-go/ecdsa.go b/vendor/github.com/dgrijalva/jwt-go/ecdsa.go new file mode 100644 index 0000000..2f59a22 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/ecdsa.go @@ -0,0 +1,147 @@ +package jwt + +import ( + "crypto" + "crypto/ecdsa" + "crypto/rand" + "errors" + "math/big" +) + +var ( + // Sadly this is missing from crypto/ecdsa compared to crypto/rsa + ErrECDSAVerification = errors.New("crypto/ecdsa: verification error") +) + +// Implements the ECDSA family of signing methods signing methods +type SigningMethodECDSA struct { + Name string + Hash crypto.Hash + KeySize int + CurveBits int +} + +// Specific instances for EC256 and company +var ( + SigningMethodES256 *SigningMethodECDSA + SigningMethodES384 *SigningMethodECDSA + SigningMethodES512 *SigningMethodECDSA +) + +func init() { + // ES256 + SigningMethodES256 = &SigningMethodECDSA{"ES256", crypto.SHA256, 32, 256} + RegisterSigningMethod(SigningMethodES256.Alg(), func() SigningMethod { + return SigningMethodES256 + }) + + // ES384 + SigningMethodES384 = &SigningMethodECDSA{"ES384", crypto.SHA384, 48, 384} + RegisterSigningMethod(SigningMethodES384.Alg(), func() SigningMethod { + return SigningMethodES384 + }) + + // ES512 + SigningMethodES512 = &SigningMethodECDSA{"ES512", crypto.SHA512, 66, 521} + RegisterSigningMethod(SigningMethodES512.Alg(), func() SigningMethod { + return SigningMethodES512 + }) +} + +func (m *SigningMethodECDSA) Alg() string { + return m.Name +} + +// Implements the Verify method from SigningMethod +// For this verify method, key must be an ecdsa.PublicKey struct +func (m *SigningMethodECDSA) Verify(signingString, signature string, key interface{}) error { + var err error + + // Decode the signature + var sig []byte + if sig, err = DecodeSegment(signature); err != nil { + return err + } + + // Get the key + var ecdsaKey *ecdsa.PublicKey + switch k := key.(type) { + case *ecdsa.PublicKey: + ecdsaKey = k + default: + return ErrInvalidKeyType + } + + if len(sig) != 2*m.KeySize { + return ErrECDSAVerification + } + + r := big.NewInt(0).SetBytes(sig[:m.KeySize]) + s := big.NewInt(0).SetBytes(sig[m.KeySize:]) + + // Create hasher + if !m.Hash.Available() { + return ErrHashUnavailable + } + hasher := m.Hash.New() + hasher.Write([]byte(signingString)) + + // Verify the signature + if verifystatus := ecdsa.Verify(ecdsaKey, hasher.Sum(nil), r, s); verifystatus == true { + return nil + } else { + return ErrECDSAVerification + } +} + +// Implements the Sign method from SigningMethod +// For this signing method, key must be an ecdsa.PrivateKey struct +func (m *SigningMethodECDSA) Sign(signingString string, key interface{}) (string, error) { + // Get the key + var ecdsaKey *ecdsa.PrivateKey + switch k := key.(type) { + case *ecdsa.PrivateKey: + ecdsaKey = k + default: + return "", ErrInvalidKeyType + } + + // Create the hasher + if !m.Hash.Available() { + return "", ErrHashUnavailable + } + + hasher := m.Hash.New() + hasher.Write([]byte(signingString)) + + // Sign the string and return r, s + if r, s, err := ecdsa.Sign(rand.Reader, ecdsaKey, hasher.Sum(nil)); err == nil { + curveBits := ecdsaKey.Curve.Params().BitSize + + if m.CurveBits != curveBits { + return "", ErrInvalidKey + } + + keyBytes := curveBits / 8 + if curveBits%8 > 0 { + keyBytes += 1 + } + + // We serialize the outpus (r and s) into big-endian byte arrays and pad + // them with zeros on the left to make sure the sizes work out. Both arrays + // must be keyBytes long, and the output must be 2*keyBytes long. + rBytes := r.Bytes() + rBytesPadded := make([]byte, keyBytes) + copy(rBytesPadded[keyBytes-len(rBytes):], rBytes) + + sBytes := s.Bytes() + sBytesPadded := make([]byte, keyBytes) + copy(sBytesPadded[keyBytes-len(sBytes):], sBytes) + + out := append(rBytesPadded, sBytesPadded...) + + return EncodeSegment(out), nil + } else { + return "", err + } +} diff --git a/vendor/github.com/dgrijalva/jwt-go/ecdsa_utils.go b/vendor/github.com/dgrijalva/jwt-go/ecdsa_utils.go new file mode 100644 index 0000000..d19624b --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/ecdsa_utils.go @@ -0,0 +1,67 @@ +package jwt + +import ( + "crypto/ecdsa" + "crypto/x509" + "encoding/pem" + "errors" +) + +var ( + ErrNotECPublicKey = errors.New("Key is not a valid ECDSA public key") + ErrNotECPrivateKey = errors.New("Key is not a valid ECDSA private key") +) + +// Parse PEM encoded Elliptic Curve Private Key Structure +func ParseECPrivateKeyFromPEM(key []byte) (*ecdsa.PrivateKey, error) { + var err error + + // Parse PEM block + var block *pem.Block + if block, _ = pem.Decode(key); block == nil { + return nil, ErrKeyMustBePEMEncoded + } + + // Parse the key + var parsedKey interface{} + if parsedKey, err = x509.ParseECPrivateKey(block.Bytes); err != nil { + return nil, err + } + + var pkey *ecdsa.PrivateKey + var ok bool + if pkey, ok = parsedKey.(*ecdsa.PrivateKey); !ok { + return nil, ErrNotECPrivateKey + } + + return pkey, nil +} + +// Parse PEM encoded PKCS1 or PKCS8 public key +func ParseECPublicKeyFromPEM(key []byte) (*ecdsa.PublicKey, error) { + var err error + + // Parse PEM block + var block *pem.Block + if block, _ = pem.Decode(key); block == nil { + return nil, ErrKeyMustBePEMEncoded + } + + // Parse the key + var parsedKey interface{} + if parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil { + if cert, err := x509.ParseCertificate(block.Bytes); err == nil { + parsedKey = cert.PublicKey + } else { + return nil, err + } + } + + var pkey *ecdsa.PublicKey + var ok bool + if pkey, ok = parsedKey.(*ecdsa.PublicKey); !ok { + return nil, ErrNotECPublicKey + } + + return pkey, nil +} diff --git a/vendor/github.com/dgrijalva/jwt-go/errors.go b/vendor/github.com/dgrijalva/jwt-go/errors.go new file mode 100644 index 0000000..1c93024 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/errors.go @@ -0,0 +1,59 @@ +package jwt + +import ( + "errors" +) + +// Error constants +var ( + ErrInvalidKey = errors.New("key is invalid") + ErrInvalidKeyType = errors.New("key is of invalid type") + ErrHashUnavailable = errors.New("the requested hash function is unavailable") +) + +// The errors that might occur when parsing and validating a token +const ( + ValidationErrorMalformed uint32 = 1 << iota // Token is malformed + ValidationErrorUnverifiable // Token could not be verified because of signing problems + ValidationErrorSignatureInvalid // Signature validation failed + + // Standard Claim validation errors + ValidationErrorAudience // AUD validation failed + ValidationErrorExpired // EXP validation failed + ValidationErrorIssuedAt // IAT validation failed + ValidationErrorIssuer // ISS validation failed + ValidationErrorNotValidYet // NBF validation failed + ValidationErrorId // JTI validation failed + ValidationErrorClaimsInvalid // Generic claims validation error +) + +// Helper for constructing a ValidationError with a string error message +func NewValidationError(errorText string, errorFlags uint32) *ValidationError { + return &ValidationError{ + text: errorText, + Errors: errorFlags, + } +} + +// The error from Parse if token is not valid +type ValidationError struct { + Inner error // stores the error returned by external dependencies, i.e.: KeyFunc + Errors uint32 // bitfield. see ValidationError... constants + text string // errors that do not have a valid error just have text +} + +// Validation error is an error type +func (e ValidationError) Error() string { + if e.Inner != nil { + return e.Inner.Error() + } else if e.text != "" { + return e.text + } else { + return "token is invalid" + } +} + +// No errors +func (e *ValidationError) valid() bool { + return e.Errors == 0 +} diff --git a/vendor/github.com/dgrijalva/jwt-go/hmac.go b/vendor/github.com/dgrijalva/jwt-go/hmac.go new file mode 100644 index 0000000..c229919 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/hmac.go @@ -0,0 +1,94 @@ +package jwt + +import ( + "crypto" + "crypto/hmac" + "errors" +) + +// Implements the HMAC-SHA family of signing methods signing methods +type SigningMethodHMAC struct { + Name string + Hash crypto.Hash +} + +// Specific instances for HS256 and company +var ( + SigningMethodHS256 *SigningMethodHMAC + SigningMethodHS384 *SigningMethodHMAC + SigningMethodHS512 *SigningMethodHMAC + ErrSignatureInvalid = errors.New("signature is invalid") +) + +func init() { + // HS256 + SigningMethodHS256 = &SigningMethodHMAC{"HS256", crypto.SHA256} + RegisterSigningMethod(SigningMethodHS256.Alg(), func() SigningMethod { + return SigningMethodHS256 + }) + + // HS384 + SigningMethodHS384 = &SigningMethodHMAC{"HS384", crypto.SHA384} + RegisterSigningMethod(SigningMethodHS384.Alg(), func() SigningMethod { + return SigningMethodHS384 + }) + + // HS512 + SigningMethodHS512 = &SigningMethodHMAC{"HS512", crypto.SHA512} + RegisterSigningMethod(SigningMethodHS512.Alg(), func() SigningMethod { + return SigningMethodHS512 + }) +} + +func (m *SigningMethodHMAC) Alg() string { + return m.Name +} + +// Verify the signature of HSXXX tokens. Returns nil if the signature is valid. +func (m *SigningMethodHMAC) Verify(signingString, signature string, key interface{}) error { + // Verify the key is the right type + keyBytes, ok := key.([]byte) + if !ok { + return ErrInvalidKeyType + } + + // Decode signature, for comparison + sig, err := DecodeSegment(signature) + if err != nil { + return err + } + + // Can we use the specified hashing method? + if !m.Hash.Available() { + return ErrHashUnavailable + } + + // This signing method is symmetric, so we validate the signature + // by reproducing the signature from the signing string and key, then + // comparing that against the provided signature. + hasher := hmac.New(m.Hash.New, keyBytes) + hasher.Write([]byte(signingString)) + if !hmac.Equal(sig, hasher.Sum(nil)) { + return ErrSignatureInvalid + } + + // No validation errors. Signature is good. + return nil +} + +// Implements the Sign method from SigningMethod for this signing method. +// Key must be []byte +func (m *SigningMethodHMAC) Sign(signingString string, key interface{}) (string, error) { + if keyBytes, ok := key.([]byte); ok { + if !m.Hash.Available() { + return "", ErrHashUnavailable + } + + hasher := hmac.New(m.Hash.New, keyBytes) + hasher.Write([]byte(signingString)) + + return EncodeSegment(hasher.Sum(nil)), nil + } + + return "", ErrInvalidKey +} diff --git a/vendor/github.com/dgrijalva/jwt-go/map_claims.go b/vendor/github.com/dgrijalva/jwt-go/map_claims.go new file mode 100644 index 0000000..291213c --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/map_claims.go @@ -0,0 +1,94 @@ +package jwt + +import ( + "encoding/json" + "errors" + // "fmt" +) + +// Claims type that uses the map[string]interface{} for JSON decoding +// This is the default claims type if you don't supply one +type MapClaims map[string]interface{} + +// Compares the aud claim against cmp. +// If required is false, this method will return true if the value matches or is unset +func (m MapClaims) VerifyAudience(cmp string, req bool) bool { + aud, _ := m["aud"].(string) + return verifyAud(aud, cmp, req) +} + +// Compares the exp claim against cmp. +// If required is false, this method will return true if the value matches or is unset +func (m MapClaims) VerifyExpiresAt(cmp int64, req bool) bool { + switch exp := m["exp"].(type) { + case float64: + return verifyExp(int64(exp), cmp, req) + case json.Number: + v, _ := exp.Int64() + return verifyExp(v, cmp, req) + } + return req == false +} + +// Compares the iat claim against cmp. +// If required is false, this method will return true if the value matches or is unset +func (m MapClaims) VerifyIssuedAt(cmp int64, req bool) bool { + switch iat := m["iat"].(type) { + case float64: + return verifyIat(int64(iat), cmp, req) + case json.Number: + v, _ := iat.Int64() + return verifyIat(v, cmp, req) + } + return req == false +} + +// Compares the iss claim against cmp. +// If required is false, this method will return true if the value matches or is unset +func (m MapClaims) VerifyIssuer(cmp string, req bool) bool { + iss, _ := m["iss"].(string) + return verifyIss(iss, cmp, req) +} + +// Compares the nbf claim against cmp. +// If required is false, this method will return true if the value matches or is unset +func (m MapClaims) VerifyNotBefore(cmp int64, req bool) bool { + switch nbf := m["nbf"].(type) { + case float64: + return verifyNbf(int64(nbf), cmp, req) + case json.Number: + v, _ := nbf.Int64() + return verifyNbf(v, cmp, req) + } + return req == false +} + +// Validates time based claims "exp, iat, nbf". +// There is no accounting for clock skew. +// As well, if any of the above claims are not in the token, it will still +// be considered a valid claim. +func (m MapClaims) Valid() error { + vErr := new(ValidationError) + now := TimeFunc().Unix() + + if m.VerifyExpiresAt(now, false) == false { + vErr.Inner = errors.New("Token is expired") + vErr.Errors |= ValidationErrorExpired + } + + if m.VerifyIssuedAt(now, false) == false { + vErr.Inner = errors.New("Token used before issued") + vErr.Errors |= ValidationErrorIssuedAt + } + + if m.VerifyNotBefore(now, false) == false { + vErr.Inner = errors.New("Token is not valid yet") + vErr.Errors |= ValidationErrorNotValidYet + } + + if vErr.valid() { + return nil + } + + return vErr +} diff --git a/vendor/github.com/dgrijalva/jwt-go/none.go b/vendor/github.com/dgrijalva/jwt-go/none.go new file mode 100644 index 0000000..f04d189 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/none.go @@ -0,0 +1,52 @@ +package jwt + +// Implements the none signing method. This is required by the spec +// but you probably should never use it. +var SigningMethodNone *signingMethodNone + +const UnsafeAllowNoneSignatureType unsafeNoneMagicConstant = "none signing method allowed" + +var NoneSignatureTypeDisallowedError error + +type signingMethodNone struct{} +type unsafeNoneMagicConstant string + +func init() { + SigningMethodNone = &signingMethodNone{} + NoneSignatureTypeDisallowedError = NewValidationError("'none' signature type is not allowed", ValidationErrorSignatureInvalid) + + RegisterSigningMethod(SigningMethodNone.Alg(), func() SigningMethod { + return SigningMethodNone + }) +} + +func (m *signingMethodNone) Alg() string { + return "none" +} + +// Only allow 'none' alg type if UnsafeAllowNoneSignatureType is specified as the key +func (m *signingMethodNone) Verify(signingString, signature string, key interface{}) (err error) { + // Key must be UnsafeAllowNoneSignatureType to prevent accidentally + // accepting 'none' signing method + if _, ok := key.(unsafeNoneMagicConstant); !ok { + return NoneSignatureTypeDisallowedError + } + // If signing method is none, signature must be an empty string + if signature != "" { + return NewValidationError( + "'none' signing method with non-empty signature", + ValidationErrorSignatureInvalid, + ) + } + + // Accept 'none' signing method. + return nil +} + +// Only allow 'none' signing if UnsafeAllowNoneSignatureType is specified as the key +func (m *signingMethodNone) Sign(signingString string, key interface{}) (string, error) { + if _, ok := key.(unsafeNoneMagicConstant); ok { + return "", nil + } + return "", NoneSignatureTypeDisallowedError +} diff --git a/vendor/github.com/dgrijalva/jwt-go/parser.go b/vendor/github.com/dgrijalva/jwt-go/parser.go new file mode 100644 index 0000000..7bf1c4e --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/parser.go @@ -0,0 +1,131 @@ +package jwt + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" +) + +type Parser struct { + ValidMethods []string // If populated, only these methods will be considered valid + UseJSONNumber bool // Use JSON Number format in JSON decoder + SkipClaimsValidation bool // Skip claims validation during token parsing +} + +// Parse, validate, and return a token. +// keyFunc will receive the parsed token and should return the key for validating. +// If everything is kosher, err will be nil +func (p *Parser) Parse(tokenString string, keyFunc Keyfunc) (*Token, error) { + return p.ParseWithClaims(tokenString, MapClaims{}, keyFunc) +} + +func (p *Parser) ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) { + parts := strings.Split(tokenString, ".") + if len(parts) != 3 { + return nil, NewValidationError("token contains an invalid number of segments", ValidationErrorMalformed) + } + + var err error + token := &Token{Raw: tokenString} + + // parse Header + var headerBytes []byte + if headerBytes, err = DecodeSegment(parts[0]); err != nil { + if strings.HasPrefix(strings.ToLower(tokenString), "bearer ") { + return token, NewValidationError("tokenstring should not contain 'bearer '", ValidationErrorMalformed) + } + return token, &ValidationError{Inner: err, Errors: ValidationErrorMalformed} + } + if err = json.Unmarshal(headerBytes, &token.Header); err != nil { + return token, &ValidationError{Inner: err, Errors: ValidationErrorMalformed} + } + + // parse Claims + var claimBytes []byte + token.Claims = claims + + if claimBytes, err = DecodeSegment(parts[1]); err != nil { + return token, &ValidationError{Inner: err, Errors: ValidationErrorMalformed} + } + dec := json.NewDecoder(bytes.NewBuffer(claimBytes)) + if p.UseJSONNumber { + dec.UseNumber() + } + // JSON Decode. Special case for map type to avoid weird pointer behavior + if c, ok := token.Claims.(MapClaims); ok { + err = dec.Decode(&c) + } else { + err = dec.Decode(&claims) + } + // Handle decode error + if err != nil { + return token, &ValidationError{Inner: err, Errors: ValidationErrorMalformed} + } + + // Lookup signature method + if method, ok := token.Header["alg"].(string); ok { + if token.Method = GetSigningMethod(method); token.Method == nil { + return token, NewValidationError("signing method (alg) is unavailable.", ValidationErrorUnverifiable) + } + } else { + return token, NewValidationError("signing method (alg) is unspecified.", ValidationErrorUnverifiable) + } + + // Verify signing method is in the required set + if p.ValidMethods != nil { + var signingMethodValid = false + var alg = token.Method.Alg() + for _, m := range p.ValidMethods { + if m == alg { + signingMethodValid = true + break + } + } + if !signingMethodValid { + // signing method is not in the listed set + return token, NewValidationError(fmt.Sprintf("signing method %v is invalid", alg), ValidationErrorSignatureInvalid) + } + } + + // Lookup key + var key interface{} + if keyFunc == nil { + // keyFunc was not provided. short circuiting validation + return token, NewValidationError("no Keyfunc was provided.", ValidationErrorUnverifiable) + } + if key, err = keyFunc(token); err != nil { + // keyFunc returned an error + return token, &ValidationError{Inner: err, Errors: ValidationErrorUnverifiable} + } + + vErr := &ValidationError{} + + // Validate Claims + if !p.SkipClaimsValidation { + if err := token.Claims.Valid(); err != nil { + + // If the Claims Valid returned an error, check if it is a validation error, + // If it was another error type, create a ValidationError with a generic ClaimsInvalid flag set + if e, ok := err.(*ValidationError); !ok { + vErr = &ValidationError{Inner: err, Errors: ValidationErrorClaimsInvalid} + } else { + vErr = e + } + } + } + + // Perform validation + token.Signature = parts[2] + if err = token.Method.Verify(strings.Join(parts[0:2], "."), token.Signature, key); err != nil { + vErr.Inner = err + vErr.Errors |= ValidationErrorSignatureInvalid + } + + if vErr.valid() { + token.Valid = true + return token, nil + } + + return token, vErr +} diff --git a/vendor/github.com/dgrijalva/jwt-go/rsa.go b/vendor/github.com/dgrijalva/jwt-go/rsa.go new file mode 100644 index 0000000..0ae0b19 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/rsa.go @@ -0,0 +1,100 @@ +package jwt + +import ( + "crypto" + "crypto/rand" + "crypto/rsa" +) + +// Implements the RSA family of signing methods signing methods +type SigningMethodRSA struct { + Name string + Hash crypto.Hash +} + +// Specific instances for RS256 and company +var ( + SigningMethodRS256 *SigningMethodRSA + SigningMethodRS384 *SigningMethodRSA + SigningMethodRS512 *SigningMethodRSA +) + +func init() { + // RS256 + SigningMethodRS256 = &SigningMethodRSA{"RS256", crypto.SHA256} + RegisterSigningMethod(SigningMethodRS256.Alg(), func() SigningMethod { + return SigningMethodRS256 + }) + + // RS384 + SigningMethodRS384 = &SigningMethodRSA{"RS384", crypto.SHA384} + RegisterSigningMethod(SigningMethodRS384.Alg(), func() SigningMethod { + return SigningMethodRS384 + }) + + // RS512 + SigningMethodRS512 = &SigningMethodRSA{"RS512", crypto.SHA512} + RegisterSigningMethod(SigningMethodRS512.Alg(), func() SigningMethod { + return SigningMethodRS512 + }) +} + +func (m *SigningMethodRSA) Alg() string { + return m.Name +} + +// Implements the Verify method from SigningMethod +// For this signing method, must be an rsa.PublicKey structure. +func (m *SigningMethodRSA) Verify(signingString, signature string, key interface{}) error { + var err error + + // Decode the signature + var sig []byte + if sig, err = DecodeSegment(signature); err != nil { + return err + } + + var rsaKey *rsa.PublicKey + var ok bool + + if rsaKey, ok = key.(*rsa.PublicKey); !ok { + return ErrInvalidKeyType + } + + // Create hasher + if !m.Hash.Available() { + return ErrHashUnavailable + } + hasher := m.Hash.New() + hasher.Write([]byte(signingString)) + + // Verify the signature + return rsa.VerifyPKCS1v15(rsaKey, m.Hash, hasher.Sum(nil), sig) +} + +// Implements the Sign method from SigningMethod +// For this signing method, must be an rsa.PrivateKey structure. +func (m *SigningMethodRSA) Sign(signingString string, key interface{}) (string, error) { + var rsaKey *rsa.PrivateKey + var ok bool + + // Validate type of key + if rsaKey, ok = key.(*rsa.PrivateKey); !ok { + return "", ErrInvalidKey + } + + // Create the hasher + if !m.Hash.Available() { + return "", ErrHashUnavailable + } + + hasher := m.Hash.New() + hasher.Write([]byte(signingString)) + + // Sign the string and return the encoded bytes + if sigBytes, err := rsa.SignPKCS1v15(rand.Reader, rsaKey, m.Hash, hasher.Sum(nil)); err == nil { + return EncodeSegment(sigBytes), nil + } else { + return "", err + } +} diff --git a/vendor/github.com/dgrijalva/jwt-go/rsa_pss.go b/vendor/github.com/dgrijalva/jwt-go/rsa_pss.go new file mode 100644 index 0000000..10ee9db --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/rsa_pss.go @@ -0,0 +1,126 @@ +// +build go1.4 + +package jwt + +import ( + "crypto" + "crypto/rand" + "crypto/rsa" +) + +// Implements the RSAPSS family of signing methods signing methods +type SigningMethodRSAPSS struct { + *SigningMethodRSA + Options *rsa.PSSOptions +} + +// Specific instances for RS/PS and company +var ( + SigningMethodPS256 *SigningMethodRSAPSS + SigningMethodPS384 *SigningMethodRSAPSS + SigningMethodPS512 *SigningMethodRSAPSS +) + +func init() { + // PS256 + SigningMethodPS256 = &SigningMethodRSAPSS{ + &SigningMethodRSA{ + Name: "PS256", + Hash: crypto.SHA256, + }, + &rsa.PSSOptions{ + SaltLength: rsa.PSSSaltLengthAuto, + Hash: crypto.SHA256, + }, + } + RegisterSigningMethod(SigningMethodPS256.Alg(), func() SigningMethod { + return SigningMethodPS256 + }) + + // PS384 + SigningMethodPS384 = &SigningMethodRSAPSS{ + &SigningMethodRSA{ + Name: "PS384", + Hash: crypto.SHA384, + }, + &rsa.PSSOptions{ + SaltLength: rsa.PSSSaltLengthAuto, + Hash: crypto.SHA384, + }, + } + RegisterSigningMethod(SigningMethodPS384.Alg(), func() SigningMethod { + return SigningMethodPS384 + }) + + // PS512 + SigningMethodPS512 = &SigningMethodRSAPSS{ + &SigningMethodRSA{ + Name: "PS512", + Hash: crypto.SHA512, + }, + &rsa.PSSOptions{ + SaltLength: rsa.PSSSaltLengthAuto, + Hash: crypto.SHA512, + }, + } + RegisterSigningMethod(SigningMethodPS512.Alg(), func() SigningMethod { + return SigningMethodPS512 + }) +} + +// Implements the Verify method from SigningMethod +// For this verify method, key must be an rsa.PublicKey struct +func (m *SigningMethodRSAPSS) Verify(signingString, signature string, key interface{}) error { + var err error + + // Decode the signature + var sig []byte + if sig, err = DecodeSegment(signature); err != nil { + return err + } + + var rsaKey *rsa.PublicKey + switch k := key.(type) { + case *rsa.PublicKey: + rsaKey = k + default: + return ErrInvalidKey + } + + // Create hasher + if !m.Hash.Available() { + return ErrHashUnavailable + } + hasher := m.Hash.New() + hasher.Write([]byte(signingString)) + + return rsa.VerifyPSS(rsaKey, m.Hash, hasher.Sum(nil), sig, m.Options) +} + +// Implements the Sign method from SigningMethod +// For this signing method, key must be an rsa.PrivateKey struct +func (m *SigningMethodRSAPSS) Sign(signingString string, key interface{}) (string, error) { + var rsaKey *rsa.PrivateKey + + switch k := key.(type) { + case *rsa.PrivateKey: + rsaKey = k + default: + return "", ErrInvalidKeyType + } + + // Create the hasher + if !m.Hash.Available() { + return "", ErrHashUnavailable + } + + hasher := m.Hash.New() + hasher.Write([]byte(signingString)) + + // Sign the string and return the encoded bytes + if sigBytes, err := rsa.SignPSS(rand.Reader, rsaKey, m.Hash, hasher.Sum(nil), m.Options); err == nil { + return EncodeSegment(sigBytes), nil + } else { + return "", err + } +} diff --git a/vendor/github.com/dgrijalva/jwt-go/rsa_utils.go b/vendor/github.com/dgrijalva/jwt-go/rsa_utils.go new file mode 100644 index 0000000..213a90d --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/rsa_utils.go @@ -0,0 +1,69 @@ +package jwt + +import ( + "crypto/rsa" + "crypto/x509" + "encoding/pem" + "errors" +) + +var ( + ErrKeyMustBePEMEncoded = errors.New("Invalid Key: Key must be PEM encoded PKCS1 or PKCS8 private key") + ErrNotRSAPrivateKey = errors.New("Key is not a valid RSA private key") + ErrNotRSAPublicKey = errors.New("Key is not a valid RSA public key") +) + +// Parse PEM encoded PKCS1 or PKCS8 private key +func ParseRSAPrivateKeyFromPEM(key []byte) (*rsa.PrivateKey, error) { + var err error + + // Parse PEM block + var block *pem.Block + if block, _ = pem.Decode(key); block == nil { + return nil, ErrKeyMustBePEMEncoded + } + + var parsedKey interface{} + if parsedKey, err = x509.ParsePKCS1PrivateKey(block.Bytes); err != nil { + if parsedKey, err = x509.ParsePKCS8PrivateKey(block.Bytes); err != nil { + return nil, err + } + } + + var pkey *rsa.PrivateKey + var ok bool + if pkey, ok = parsedKey.(*rsa.PrivateKey); !ok { + return nil, ErrNotRSAPrivateKey + } + + return pkey, nil +} + +// Parse PEM encoded PKCS1 or PKCS8 public key +func ParseRSAPublicKeyFromPEM(key []byte) (*rsa.PublicKey, error) { + var err error + + // Parse PEM block + var block *pem.Block + if block, _ = pem.Decode(key); block == nil { + return nil, ErrKeyMustBePEMEncoded + } + + // Parse the key + var parsedKey interface{} + if parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil { + if cert, err := x509.ParseCertificate(block.Bytes); err == nil { + parsedKey = cert.PublicKey + } else { + return nil, err + } + } + + var pkey *rsa.PublicKey + var ok bool + if pkey, ok = parsedKey.(*rsa.PublicKey); !ok { + return nil, ErrNotRSAPublicKey + } + + return pkey, nil +} diff --git a/vendor/github.com/dgrijalva/jwt-go/signing_method.go b/vendor/github.com/dgrijalva/jwt-go/signing_method.go new file mode 100644 index 0000000..ed1f212 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/signing_method.go @@ -0,0 +1,35 @@ +package jwt + +import ( + "sync" +) + +var signingMethods = map[string]func() SigningMethod{} +var signingMethodLock = new(sync.RWMutex) + +// Implement SigningMethod to add new methods for signing or verifying tokens. +type SigningMethod interface { + Verify(signingString, signature string, key interface{}) error // Returns nil if signature is valid + Sign(signingString string, key interface{}) (string, error) // Returns encoded signature or error + Alg() string // returns the alg identifier for this method (example: 'HS256') +} + +// Register the "alg" name and a factory function for signing method. +// This is typically done during init() in the method's implementation +func RegisterSigningMethod(alg string, f func() SigningMethod) { + signingMethodLock.Lock() + defer signingMethodLock.Unlock() + + signingMethods[alg] = f +} + +// Get a signing method from an "alg" string +func GetSigningMethod(alg string) (method SigningMethod) { + signingMethodLock.RLock() + defer signingMethodLock.RUnlock() + + if methodF, ok := signingMethods[alg]; ok { + method = methodF() + } + return +} diff --git a/vendor/github.com/dgrijalva/jwt-go/token.go b/vendor/github.com/dgrijalva/jwt-go/token.go new file mode 100644 index 0000000..d637e08 --- /dev/null +++ b/vendor/github.com/dgrijalva/jwt-go/token.go @@ -0,0 +1,108 @@ +package jwt + +import ( + "encoding/base64" + "encoding/json" + "strings" + "time" +) + +// TimeFunc provides the current time when parsing token to validate "exp" claim (expiration time). +// You can override it to use another time value. This is useful for testing or if your +// server uses a different time zone than your tokens. +var TimeFunc = time.Now + +// Parse methods use this callback function to supply +// the key for verification. The function receives the parsed, +// but unverified Token. This allows you to use properties in the +// Header of the token (such as `kid`) to identify which key to use. +type Keyfunc func(*Token) (interface{}, error) + +// A JWT Token. Different fields will be used depending on whether you're +// creating or parsing/verifying a token. +type Token struct { + Raw string // The raw token. Populated when you Parse a token + Method SigningMethod // The signing method used or to be used + Header map[string]interface{} // The first segment of the token + Claims Claims // The second segment of the token + Signature string // The third segment of the token. Populated when you Parse a token + Valid bool // Is the token valid? Populated when you Parse/Verify a token +} + +// Create a new Token. Takes a signing method +func New(method SigningMethod) *Token { + return NewWithClaims(method, MapClaims{}) +} + +func NewWithClaims(method SigningMethod, claims Claims) *Token { + return &Token{ + Header: map[string]interface{}{ + "typ": "JWT", + "alg": method.Alg(), + }, + Claims: claims, + Method: method, + } +} + +// Get the complete, signed token +func (t *Token) SignedString(key interface{}) (string, error) { + var sig, sstr string + var err error + if sstr, err = t.SigningString(); err != nil { + return "", err + } + if sig, err = t.Method.Sign(sstr, key); err != nil { + return "", err + } + return strings.Join([]string{sstr, sig}, "."), nil +} + +// Generate the signing string. This is the +// most expensive part of the whole deal. Unless you +// need this for something special, just go straight for +// the SignedString. +func (t *Token) SigningString() (string, error) { + var err error + parts := make([]string, 2) + for i, _ := range parts { + var jsonValue []byte + if i == 0 { + if jsonValue, err = json.Marshal(t.Header); err != nil { + return "", err + } + } else { + if jsonValue, err = json.Marshal(t.Claims); err != nil { + return "", err + } + } + + parts[i] = EncodeSegment(jsonValue) + } + return strings.Join(parts, "."), nil +} + +// Parse, validate, and return a token. +// keyFunc will receive the parsed token and should return the key for validating. +// If everything is kosher, err will be nil +func Parse(tokenString string, keyFunc Keyfunc) (*Token, error) { + return new(Parser).Parse(tokenString, keyFunc) +} + +func ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) { + return new(Parser).ParseWithClaims(tokenString, claims, keyFunc) +} + +// Encode JWT specific base64url encoding with padding stripped +func EncodeSegment(seg []byte) string { + return strings.TrimRight(base64.URLEncoding.EncodeToString(seg), "=") +} + +// Decode JWT specific base64url encoding with padding stripped +func DecodeSegment(seg string) ([]byte, error) { + if l := len(seg) % 4; l > 0 { + seg += strings.Repeat("=", 4-l) + } + + return base64.URLEncoding.DecodeString(seg) +} diff --git a/vendor/github.com/go-openapi/analysis/.gitignore b/vendor/github.com/go-openapi/analysis/.gitignore new file mode 100644 index 0000000..dd91ed6 --- /dev/null +++ b/vendor/github.com/go-openapi/analysis/.gitignore @@ -0,0 +1,2 @@ +secrets.yml +coverage.out diff --git a/vendor/github.com/go-openapi/analysis/.travis.yml b/vendor/github.com/go-openapi/analysis/.travis.yml new file mode 100644 index 0000000..5a1353d --- /dev/null +++ b/vendor/github.com/go-openapi/analysis/.travis.yml @@ -0,0 +1,17 @@ +language: go +go: +- 1.7.1 +install: +- go get -u github.com/stretchr/testify/assert +- go get -u gopkg.in/yaml.v2 +- go get -u github.com/go-openapi/swag +- go get -u github.com/go-openapi/jsonpointer +- go get -u github.com/go-openapi/spec +- go get -u github.com/go-openapi/loads/fmts +script: +- go test -v -race -cover -coverprofile=coverage.txt -covermode=atomic ./... +after_success: +- bash <(curl -s https://codecov.io/bash) +notifications: + slack: + secure: Sf7kZf7ZGbnwWUMpffHwMu5A0cHkLK2MYY32LNTPj4+/3qC3Ghl7+9v4TSLOqOlCwdRNjOGblAq7s+GDJed6/xgRQl1JtCi1klzZNrYX4q01pgTPvvGcwbBkIYgeMaPeIRcK9OZnud7sRXdttozgTOpytps2U6Js32ip7uj5mHSg2ub0FwoSJwlS6dbezZ8+eDhoha0F/guY99BEwx8Bd+zROrT2TFGsSGOFGN6wFc7moCqTHO/YkWib13a2QNXqOxCCVBy/lt76Wp+JkeFppjHlzs/2lP3EAk13RIUAaesdEUHvIHrzCyNJEd3/+KO2DzsWOYfpktd+KBCvgaYOsoo7ubdT3IROeAegZdCgo/6xgCEsmFc9ZcqCfN5yNx2A+BZ2Vwmpws+bQ1E1+B5HDzzaiLcYfG4X2O210QVGVDLWsv1jqD+uPYeHY2WRfh5ZsIUFvaqgUEnwHwrK44/8REAhQavt1QAj5uJpsRd7CkRVPWRNK+yIky+wgbVUFEchRNmS55E7QWf+W4+4QZkQi7vUTMc9nbTUu2Es9NfvfudOpM2wZbn98fjpb/qq/nRv6Bk+ca+7XD5/IgNLMbWp2ouDdzbiHLCOfDUiHiDJhLfFZx9Bwo7ZwfzeOlbrQX66bx7xRKYmOe4DLrXhNcpbsMa8qbfxlZRCmYbubB/Y8h4= diff --git a/vendor/github.com/go-openapi/analysis/CODE_OF_CONDUCT.md b/vendor/github.com/go-openapi/analysis/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..9322b06 --- /dev/null +++ b/vendor/github.com/go-openapi/analysis/CODE_OF_CONDUCT.md @@ -0,0 +1,74 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of experience, +nationality, personal appearance, race, religion, or sexual identity and +orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or +advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at ivan+abuse@flanders.co.nz. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at [http://contributor-covenant.org/version/1/4][version] + +[homepage]: http://contributor-covenant.org +[version]: http://contributor-covenant.org/version/1/4/ diff --git a/vendor/github.com/go-openapi/analysis/LICENSE b/vendor/github.com/go-openapi/analysis/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/vendor/github.com/go-openapi/analysis/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/go-openapi/analysis/README.md b/vendor/github.com/go-openapi/analysis/README.md new file mode 100644 index 0000000..b6e526c --- /dev/null +++ b/vendor/github.com/go-openapi/analysis/README.md @@ -0,0 +1,6 @@ +# OpenAPI initiative analysis [![Build Status](https://ci.vmware.run/api/badges/go-openapi/analysis/status.svg)](https://ci.vmware.run/go-openapi/analysis) [![Coverage](https://coverage.vmware.run/badges/go-openapi/analysis/coverage.svg)](https://coverage.vmware.run/go-openapi/analysis) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) + +[![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/analysis/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/analysis?status.svg)](http://godoc.org/github.com/go-openapi/analysis) + + +A foundational library to analyze an OAI specification document for easier reasoning about the content. \ No newline at end of file diff --git a/vendor/github.com/go-openapi/analysis/analyzer.go b/vendor/github.com/go-openapi/analysis/analyzer.go new file mode 100644 index 0000000..ee84f9a --- /dev/null +++ b/vendor/github.com/go-openapi/analysis/analyzer.go @@ -0,0 +1,628 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package analysis + +import ( + "fmt" + slashpath "path" + "strconv" + "strings" + + "github.com/go-openapi/jsonpointer" + "github.com/go-openapi/spec" + "github.com/go-openapi/swag" +) + +type referenceAnalysis struct { + schemas map[string]spec.Ref + responses map[string]spec.Ref + parameters map[string]spec.Ref + items map[string]spec.Ref + allRefs map[string]spec.Ref + referenced struct { + schemas map[string]SchemaRef + responses map[string]*spec.Response + parameters map[string]*spec.Parameter + } +} + +func (r *referenceAnalysis) addRef(key string, ref spec.Ref) { + r.allRefs["#"+key] = ref +} + +func (r *referenceAnalysis) addItemsRef(key string, items *spec.Items) { + r.items["#"+key] = items.Ref + r.addRef(key, items.Ref) +} + +func (r *referenceAnalysis) addSchemaRef(key string, ref SchemaRef) { + r.schemas["#"+key] = ref.Schema.Ref + r.addRef(key, ref.Schema.Ref) +} + +func (r *referenceAnalysis) addResponseRef(key string, resp *spec.Response) { + r.responses["#"+key] = resp.Ref + r.addRef(key, resp.Ref) +} + +func (r *referenceAnalysis) addParamRef(key string, param *spec.Parameter) { + r.parameters["#"+key] = param.Ref + r.addRef(key, param.Ref) +} + +// New takes a swagger spec object and returns an analyzed spec document. +// The analyzed document contains a number of indices that make it easier to +// reason about semantics of a swagger specification for use in code generation +// or validation etc. +func New(doc *spec.Swagger) *Spec { + a := &Spec{ + spec: doc, + consumes: make(map[string]struct{}, 150), + produces: make(map[string]struct{}, 150), + authSchemes: make(map[string]struct{}, 150), + operations: make(map[string]map[string]*spec.Operation, 150), + allSchemas: make(map[string]SchemaRef, 150), + allOfs: make(map[string]SchemaRef, 150), + references: referenceAnalysis{ + schemas: make(map[string]spec.Ref, 150), + responses: make(map[string]spec.Ref, 150), + parameters: make(map[string]spec.Ref, 150), + items: make(map[string]spec.Ref, 150), + allRefs: make(map[string]spec.Ref, 150), + }, + } + a.references.referenced.schemas = make(map[string]SchemaRef, 150) + a.references.referenced.responses = make(map[string]*spec.Response, 150) + a.references.referenced.parameters = make(map[string]*spec.Parameter, 150) + a.initialize() + return a +} + +// Spec takes a swagger spec object and turns it into a registry +// with a bunch of utility methods to act on the information in the spec +type Spec struct { + spec *spec.Swagger + consumes map[string]struct{} + produces map[string]struct{} + authSchemes map[string]struct{} + operations map[string]map[string]*spec.Operation + references referenceAnalysis + allSchemas map[string]SchemaRef + allOfs map[string]SchemaRef +} + +func (s *Spec) initialize() { + for _, c := range s.spec.Consumes { + s.consumes[c] = struct{}{} + } + for _, c := range s.spec.Produces { + s.produces[c] = struct{}{} + } + for _, ss := range s.spec.Security { + for k := range ss { + s.authSchemes[k] = struct{}{} + } + } + for path, pathItem := range s.AllPaths() { + s.analyzeOperations(path, &pathItem) + } + + for name, parameter := range s.spec.Parameters { + refPref := slashpath.Join("/parameters", jsonpointer.Escape(name)) + if parameter.Items != nil { + s.analyzeItems("items", parameter.Items, refPref) + } + if parameter.In == "body" && parameter.Schema != nil { + s.analyzeSchema("schema", *parameter.Schema, refPref) + } + } + + for name, response := range s.spec.Responses { + refPref := slashpath.Join("/responses", jsonpointer.Escape(name)) + for _, v := range response.Headers { + if v.Items != nil { + s.analyzeItems("items", v.Items, refPref) + } + } + if response.Schema != nil { + s.analyzeSchema("schema", *response.Schema, refPref) + } + } + + for name, schema := range s.spec.Definitions { + s.analyzeSchema(name, schema, "/definitions") + } + // TODO: after analyzing all things and flattening schemas etc + // resolve all the collected references to their final representations + // best put in a separate method because this could get expensive +} + +func (s *Spec) analyzeOperations(path string, pi *spec.PathItem) { + // TODO: resolve refs here? + op := pi + s.analyzeOperation("GET", path, op.Get) + s.analyzeOperation("PUT", path, op.Put) + s.analyzeOperation("POST", path, op.Post) + s.analyzeOperation("PATCH", path, op.Patch) + s.analyzeOperation("DELETE", path, op.Delete) + s.analyzeOperation("HEAD", path, op.Head) + s.analyzeOperation("OPTIONS", path, op.Options) + for i, param := range op.Parameters { + refPref := slashpath.Join("/paths", jsonpointer.Escape(path), "parameters", strconv.Itoa(i)) + if param.Ref.String() != "" { + s.references.addParamRef(refPref, ¶m) + } + if param.Items != nil { + s.analyzeItems("items", param.Items, refPref) + } + if param.Schema != nil { + s.analyzeSchema("schema", *param.Schema, refPref) + } + } +} + +func (s *Spec) analyzeItems(name string, items *spec.Items, prefix string) { + if items == nil { + return + } + refPref := slashpath.Join(prefix, name) + s.analyzeItems(name, items.Items, refPref) + if items.Ref.String() != "" { + s.references.addItemsRef(refPref, items) + } +} + +func (s *Spec) analyzeOperation(method, path string, op *spec.Operation) { + if op == nil { + return + } + + for _, c := range op.Consumes { + s.consumes[c] = struct{}{} + } + for _, c := range op.Produces { + s.produces[c] = struct{}{} + } + for _, ss := range op.Security { + for k := range ss { + s.authSchemes[k] = struct{}{} + } + } + if _, ok := s.operations[method]; !ok { + s.operations[method] = make(map[string]*spec.Operation) + } + s.operations[method][path] = op + prefix := slashpath.Join("/paths", jsonpointer.Escape(path), strings.ToLower(method)) + for i, param := range op.Parameters { + refPref := slashpath.Join(prefix, "parameters", strconv.Itoa(i)) + if param.Ref.String() != "" { + s.references.addParamRef(refPref, ¶m) + } + s.analyzeItems("items", param.Items, refPref) + if param.In == "body" && param.Schema != nil { + s.analyzeSchema("schema", *param.Schema, refPref) + } + } + if op.Responses != nil { + if op.Responses.Default != nil { + refPref := slashpath.Join(prefix, "responses", "default") + if op.Responses.Default.Ref.String() != "" { + s.references.addResponseRef(refPref, op.Responses.Default) + } + for _, v := range op.Responses.Default.Headers { + s.analyzeItems("items", v.Items, refPref) + } + if op.Responses.Default.Schema != nil { + s.analyzeSchema("schema", *op.Responses.Default.Schema, refPref) + } + } + for k, res := range op.Responses.StatusCodeResponses { + refPref := slashpath.Join(prefix, "responses", strconv.Itoa(k)) + if res.Ref.String() != "" { + s.references.addResponseRef(refPref, &res) + } + for _, v := range res.Headers { + s.analyzeItems("items", v.Items, refPref) + } + if res.Schema != nil { + s.analyzeSchema("schema", *res.Schema, refPref) + } + } + } +} + +func (s *Spec) analyzeSchema(name string, schema spec.Schema, prefix string) { + refURI := slashpath.Join(prefix, jsonpointer.Escape(name)) + schRef := SchemaRef{ + Name: name, + Schema: &schema, + Ref: spec.MustCreateRef("#" + refURI), + } + s.allSchemas["#"+refURI] = schRef + if schema.Ref.String() != "" { + s.references.addSchemaRef(refURI, schRef) + } + for k, v := range schema.Definitions { + s.analyzeSchema(k, v, slashpath.Join(refURI, "definitions")) + } + for k, v := range schema.Properties { + s.analyzeSchema(k, v, slashpath.Join(refURI, "properties")) + } + for k, v := range schema.PatternProperties { + s.analyzeSchema(k, v, slashpath.Join(refURI, "patternProperties")) + } + for i, v := range schema.AllOf { + s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "allOf")) + } + if len(schema.AllOf) > 0 { + s.allOfs["#"+refURI] = SchemaRef{Name: name, Schema: &schema, Ref: spec.MustCreateRef("#" + refURI)} + } + for i, v := range schema.AnyOf { + s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "anyOf")) + } + for i, v := range schema.OneOf { + s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "oneOf")) + } + if schema.Not != nil { + s.analyzeSchema("not", *schema.Not, refURI) + } + if schema.AdditionalProperties != nil && schema.AdditionalProperties.Schema != nil { + s.analyzeSchema("additionalProperties", *schema.AdditionalProperties.Schema, refURI) + } + if schema.AdditionalItems != nil && schema.AdditionalItems.Schema != nil { + s.analyzeSchema("additionalItems", *schema.AdditionalItems.Schema, refURI) + } + if schema.Items != nil { + if schema.Items.Schema != nil { + s.analyzeSchema("items", *schema.Items.Schema, refURI) + } + for i, sch := range schema.Items.Schemas { + s.analyzeSchema(strconv.Itoa(i), sch, slashpath.Join(refURI, "items")) + } + } +} + +// SecurityRequirement is a representation of a security requirement for an operation +type SecurityRequirement struct { + Name string + Scopes []string +} + +// SecurityRequirementsFor gets the security requirements for the operation +func (s *Spec) SecurityRequirementsFor(operation *spec.Operation) []SecurityRequirement { + if s.spec.Security == nil && operation.Security == nil { + return nil + } + + schemes := s.spec.Security + if operation.Security != nil { + schemes = operation.Security + } + + unique := make(map[string]SecurityRequirement) + for _, scheme := range schemes { + for k, v := range scheme { + if _, ok := unique[k]; !ok { + unique[k] = SecurityRequirement{Name: k, Scopes: v} + } + } + } + + var result []SecurityRequirement + for _, v := range unique { + result = append(result, v) + } + return result +} + +// SecurityDefinitionsFor gets the matching security definitions for a set of requirements +func (s *Spec) SecurityDefinitionsFor(operation *spec.Operation) map[string]spec.SecurityScheme { + requirements := s.SecurityRequirementsFor(operation) + if len(requirements) == 0 { + return nil + } + result := make(map[string]spec.SecurityScheme) + for _, v := range requirements { + if definition, ok := s.spec.SecurityDefinitions[v.Name]; ok { + if definition != nil { + result[v.Name] = *definition + } + } + } + return result +} + +// ConsumesFor gets the mediatypes for the operation +func (s *Spec) ConsumesFor(operation *spec.Operation) []string { + + if len(operation.Consumes) == 0 { + cons := make(map[string]struct{}, len(s.spec.Consumes)) + for _, k := range s.spec.Consumes { + cons[k] = struct{}{} + } + return s.structMapKeys(cons) + } + + cons := make(map[string]struct{}, len(operation.Consumes)) + for _, c := range operation.Consumes { + cons[c] = struct{}{} + } + return s.structMapKeys(cons) +} + +// ProducesFor gets the mediatypes for the operation +func (s *Spec) ProducesFor(operation *spec.Operation) []string { + if len(operation.Produces) == 0 { + prod := make(map[string]struct{}, len(s.spec.Produces)) + for _, k := range s.spec.Produces { + prod[k] = struct{}{} + } + return s.structMapKeys(prod) + } + + prod := make(map[string]struct{}, len(operation.Produces)) + for _, c := range operation.Produces { + prod[c] = struct{}{} + } + return s.structMapKeys(prod) +} + +func mapKeyFromParam(param *spec.Parameter) string { + return fmt.Sprintf("%s#%s", param.In, fieldNameFromParam(param)) +} + +func fieldNameFromParam(param *spec.Parameter) string { + if nm, ok := param.Extensions.GetString("go-name"); ok { + return nm + } + return swag.ToGoName(param.Name) +} + +func (s *Spec) paramsAsMap(parameters []spec.Parameter, res map[string]spec.Parameter) { + for _, param := range parameters { + pr := param + if pr.Ref.String() != "" { + obj, _, err := pr.Ref.GetPointer().Get(s.spec) + if err != nil { + panic(err) + } + pr = obj.(spec.Parameter) + } + res[mapKeyFromParam(&pr)] = pr + } +} + +// ParametersFor the specified operation id +func (s *Spec) ParametersFor(operationID string) []spec.Parameter { + gatherParams := func(pi *spec.PathItem, op *spec.Operation) []spec.Parameter { + bag := make(map[string]spec.Parameter) + s.paramsAsMap(pi.Parameters, bag) + s.paramsAsMap(op.Parameters, bag) + + var res []spec.Parameter + for _, v := range bag { + res = append(res, v) + } + return res + } + for _, pi := range s.spec.Paths.Paths { + if pi.Get != nil && pi.Get.ID == operationID { + return gatherParams(&pi, pi.Get) + } + if pi.Head != nil && pi.Head.ID == operationID { + return gatherParams(&pi, pi.Head) + } + if pi.Options != nil && pi.Options.ID == operationID { + return gatherParams(&pi, pi.Options) + } + if pi.Post != nil && pi.Post.ID == operationID { + return gatherParams(&pi, pi.Post) + } + if pi.Patch != nil && pi.Patch.ID == operationID { + return gatherParams(&pi, pi.Patch) + } + if pi.Put != nil && pi.Put.ID == operationID { + return gatherParams(&pi, pi.Put) + } + if pi.Delete != nil && pi.Delete.ID == operationID { + return gatherParams(&pi, pi.Delete) + } + } + return nil +} + +// ParamsFor the specified method and path. Aggregates them with the defaults etc, so it's all the params that +// apply for the method and path. +func (s *Spec) ParamsFor(method, path string) map[string]spec.Parameter { + res := make(map[string]spec.Parameter) + if pi, ok := s.spec.Paths.Paths[path]; ok { + s.paramsAsMap(pi.Parameters, res) + s.paramsAsMap(s.operations[strings.ToUpper(method)][path].Parameters, res) + } + return res +} + +// OperationForName gets the operation for the given id +func (s *Spec) OperationForName(operationID string) (string, string, *spec.Operation, bool) { + for method, pathItem := range s.operations { + for path, op := range pathItem { + if operationID == op.ID { + return method, path, op, true + } + } + } + return "", "", nil, false +} + +// OperationFor the given method and path +func (s *Spec) OperationFor(method, path string) (*spec.Operation, bool) { + if mp, ok := s.operations[strings.ToUpper(method)]; ok { + op, fn := mp[path] + return op, fn + } + return nil, false +} + +// Operations gathers all the operations specified in the spec document +func (s *Spec) Operations() map[string]map[string]*spec.Operation { + return s.operations +} + +func (s *Spec) structMapKeys(mp map[string]struct{}) []string { + if len(mp) == 0 { + return nil + } + + result := make([]string, 0, len(mp)) + for k := range mp { + result = append(result, k) + } + return result +} + +// AllPaths returns all the paths in the swagger spec +func (s *Spec) AllPaths() map[string]spec.PathItem { + if s.spec == nil || s.spec.Paths == nil { + return nil + } + return s.spec.Paths.Paths +} + +// OperationIDs gets all the operation ids based on method an dpath +func (s *Spec) OperationIDs() []string { + if len(s.operations) == 0 { + return nil + } + result := make([]string, 0, len(s.operations)) + for method, v := range s.operations { + for p, o := range v { + if o.ID != "" { + result = append(result, o.ID) + } else { + result = append(result, fmt.Sprintf("%s %s", strings.ToUpper(method), p)) + } + } + } + return result +} + +// OperationMethodPaths gets all the operation ids based on method an dpath +func (s *Spec) OperationMethodPaths() []string { + if len(s.operations) == 0 { + return nil + } + result := make([]string, 0, len(s.operations)) + for method, v := range s.operations { + for p := range v { + result = append(result, fmt.Sprintf("%s %s", strings.ToUpper(method), p)) + } + } + return result +} + +// RequiredConsumes gets all the distinct consumes that are specified in the specification document +func (s *Spec) RequiredConsumes() []string { + return s.structMapKeys(s.consumes) +} + +// RequiredProduces gets all the distinct produces that are specified in the specification document +func (s *Spec) RequiredProduces() []string { + return s.structMapKeys(s.produces) +} + +// RequiredSecuritySchemes gets all the distinct security schemes that are specified in the swagger spec +func (s *Spec) RequiredSecuritySchemes() []string { + return s.structMapKeys(s.authSchemes) +} + +// SchemaRef is a reference to a schema +type SchemaRef struct { + Name string + Ref spec.Ref + Schema *spec.Schema +} + +// SchemasWithAllOf returns schema references to all schemas that are defined +// with an allOf key +func (s *Spec) SchemasWithAllOf() (result []SchemaRef) { + for _, v := range s.allOfs { + result = append(result, v) + } + return +} + +// AllDefinitions returns schema references for all the definitions that were discovered +func (s *Spec) AllDefinitions() (result []SchemaRef) { + for _, v := range s.allSchemas { + result = append(result, v) + } + return +} + +// AllDefinitionReferences returns json refs for all the discovered schemas +func (s *Spec) AllDefinitionReferences() (result []string) { + for _, v := range s.references.schemas { + result = append(result, v.String()) + } + return +} + +// AllParameterReferences returns json refs for all the discovered parameters +func (s *Spec) AllParameterReferences() (result []string) { + for _, v := range s.references.parameters { + result = append(result, v.String()) + } + return +} + +// AllResponseReferences returns json refs for all the discovered responses +func (s *Spec) AllResponseReferences() (result []string) { + for _, v := range s.references.responses { + result = append(result, v.String()) + } + return +} + +// AllItemsReferences returns the references for all the items +func (s *Spec) AllItemsReferences() (result []string) { + for _, v := range s.references.items { + result = append(result, v.String()) + } + return +} + +// AllReferences returns all the references found in the document +func (s *Spec) AllReferences() (result []string) { + for _, v := range s.references.allRefs { + result = append(result, v.String()) + } + return +} + +// AllRefs returns all the unique references found in the document +func (s *Spec) AllRefs() (result []spec.Ref) { + set := make(map[string]struct{}) + for _, v := range s.references.allRefs { + a := v.String() + if a == "" { + continue + } + if _, ok := set[a]; !ok { + set[a] = struct{}{} + result = append(result, v) + } + } + return +} diff --git a/vendor/github.com/go-openapi/errors/.gitignore b/vendor/github.com/go-openapi/errors/.gitignore new file mode 100644 index 0000000..dd91ed6 --- /dev/null +++ b/vendor/github.com/go-openapi/errors/.gitignore @@ -0,0 +1,2 @@ +secrets.yml +coverage.out diff --git a/vendor/github.com/go-openapi/errors/.travis.yml b/vendor/github.com/go-openapi/errors/.travis.yml new file mode 100644 index 0000000..8d22a34 --- /dev/null +++ b/vendor/github.com/go-openapi/errors/.travis.yml @@ -0,0 +1,12 @@ +language: go +go: +- 1.7 +install: +- go get -u github.com/stretchr/testify/assert +script: +- go test -v -race -cover -coverprofile=coverage.txt -covermode=atomic ./... +after_success: +- bash <(curl -s https://codecov.io/bash) +notifications: + slack: + secure: gZGp9NaHxi7zawlXJXKY92BGeDR1x0tbIcTyU5nMKLq0fhIaiEBJEeALwZ4VgqsSv3DytSSF5mLH8fevAM3ixE6hxjKQ+lQuf7V/w3btCN1CSWgoua5LOh1kTnqZQtJuRvO4pzoJcT3bJWBsVZ07VGNVzzJEy/zAKCHFqBUCXShw7QemlLBcYWFNqveTlvDIfCzvouoLnPoXwxEpkjxe9uz/ZKZgAnup/fXjC8RFctmgCnkCyvJTk0Y/fZCsufixJrJhshBWTnlrFCzRmgNkz2d+i1Ls3+MJ5EJJ2Tx/A5S63dL49J1f9Kr0AKHADmulSy8JNzIckKwbyFMYUecrsW+Lsu9DhnVMy1jj5pKsJDLRi2iIU3fXTMWbcyQbXjbbnBO2mPdP3Tzme75y4D9fc8hUPeyqVv2BU26NEbQ7EF2pKJ93OXvci7HlwRBgdJa8j6mP2LEDClcPQW00g7N/OZe0cTOMa8L5AwiBlbArwqt9wv6YLJoTG0wpDhzWsFvbCg5bJxe28Yn3fIDD0Lk1I7iSnBbp/5gzF19jmxqvcT8tHRkDL4xfjbENFTZjA5uB4Z4pj4WSyWQILLV/Jwhe3fi9uQwdviFHfj5pnVrmNUiGSOQL672K5wl2c3E9mGwejvsu2dfEz28n7Y/FUnOpY3/cBS0n27JJaerS0zMKNLE= diff --git a/vendor/github.com/go-openapi/errors/CODE_OF_CONDUCT.md b/vendor/github.com/go-openapi/errors/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..9322b06 --- /dev/null +++ b/vendor/github.com/go-openapi/errors/CODE_OF_CONDUCT.md @@ -0,0 +1,74 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of experience, +nationality, personal appearance, race, religion, or sexual identity and +orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or +advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at ivan+abuse@flanders.co.nz. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at [http://contributor-covenant.org/version/1/4][version] + +[homepage]: http://contributor-covenant.org +[version]: http://contributor-covenant.org/version/1/4/ diff --git a/vendor/github.com/go-openapi/errors/LICENSE b/vendor/github.com/go-openapi/errors/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/vendor/github.com/go-openapi/errors/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/go-openapi/errors/README.md b/vendor/github.com/go-openapi/errors/README.md new file mode 100644 index 0000000..48c49fb --- /dev/null +++ b/vendor/github.com/go-openapi/errors/README.md @@ -0,0 +1,5 @@ +# OpenAPI errors [![Build Status](https://travis-ci.org/go-openapi/errors.svg?branch=master)](https://travis-ci.org/go-openapi/errors) [![codecov](https://codecov.io/gh/go-openapi/errors/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/errors) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) + +[![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/errors/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/errors?status.svg)](http://godoc.org/github.com/go-openapi/errors) + +Shared errors used throughout the various libraries for the go-openapi toolkit \ No newline at end of file diff --git a/vendor/github.com/go-openapi/errors/api.go b/vendor/github.com/go-openapi/errors/api.go new file mode 100644 index 0000000..1c5908b --- /dev/null +++ b/vendor/github.com/go-openapi/errors/api.go @@ -0,0 +1,149 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package errors + +import ( + "encoding/json" + "fmt" + "net/http" + "strings" +) + +// Error represents a error interface all swagger framework errors implement +type Error interface { + error + Code() int32 +} + +type apiError struct { + code int32 + message string +} + +func (a *apiError) Error() string { + return a.message +} + +func (a *apiError) Code() int32 { + return a.code +} + +// New creates a new API error with a code and a message +func New(code int32, message string, args ...interface{}) Error { + if len(args) > 0 { + return &apiError{code, fmt.Sprintf(message, args...)} + } + return &apiError{code, message} +} + +// NotFound creates a new not found error +func NotFound(message string, args ...interface{}) Error { + if message == "" { + message = "Not found" + } + return New(http.StatusNotFound, fmt.Sprintf(message, args...)) +} + +// NotImplemented creates a new not implemented error +func NotImplemented(message string) Error { + return New(http.StatusNotImplemented, message) +} + +// MethodNotAllowedError represents an error for when the path matches but the method doesn't +type MethodNotAllowedError struct { + code int32 + Allowed []string + message string +} + +func (m *MethodNotAllowedError) Error() string { + return m.message +} + +// Code the error code +func (m *MethodNotAllowedError) Code() int32 { + return m.code +} + +func errorAsJSON(err Error) []byte { + b, _ := json.Marshal(struct { + Code int32 `json:"code"` + Message string `json:"message"` + }{err.Code(), err.Error()}) + return b +} + +func flattenComposite(errs *CompositeError) *CompositeError { + var res []error + for _, er := range errs.Errors { + switch e := er.(type) { + case *CompositeError: + if len(e.Errors) > 0 { + flat := flattenComposite(e) + if len(flat.Errors) > 0 { + res = append(res, flat.Errors...) + } + } + default: + if e != nil { + res = append(res, e) + } + } + } + return CompositeValidationError(res...) +} + +// MethodNotAllowed creates a new method not allowed error +func MethodNotAllowed(requested string, allow []string) Error { + msg := fmt.Sprintf("method %s is not allowed, but [%s] are", requested, strings.Join(allow, ",")) + return &MethodNotAllowedError{code: http.StatusMethodNotAllowed, Allowed: allow, message: msg} +} + +// ServeError the error handler interface implemenation +func ServeError(rw http.ResponseWriter, r *http.Request, err error) { + switch e := err.(type) { + case *CompositeError: + er := flattenComposite(e) + ServeError(rw, r, er.Errors[0]) + case *MethodNotAllowedError: + rw.Header().Add("Allow", strings.Join(err.(*MethodNotAllowedError).Allowed, ",")) + rw.WriteHeader(asHTTPCode(int(e.Code()))) + if r == nil || r.Method != "HEAD" { + rw.Write(errorAsJSON(e)) + } + case Error: + if e == nil { + rw.WriteHeader(http.StatusInternalServerError) + rw.Write(errorAsJSON(New(http.StatusInternalServerError, "Unknown error"))) + return + } + rw.WriteHeader(asHTTPCode(int(e.Code()))) + if r == nil || r.Method != "HEAD" { + rw.Write(errorAsJSON(e)) + } + default: + rw.WriteHeader(http.StatusInternalServerError) + if r == nil || r.Method != "HEAD" { + rw.Write(errorAsJSON(New(http.StatusInternalServerError, err.Error()))) + } + } +} + +func asHTTPCode(input int) int { + if input >= 600 { + return 422 + } + return input +} diff --git a/vendor/github.com/go-openapi/errors/auth.go b/vendor/github.com/go-openapi/errors/auth.go new file mode 100644 index 0000000..70eb960 --- /dev/null +++ b/vendor/github.com/go-openapi/errors/auth.go @@ -0,0 +1,20 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package errors + +// Unauthenticated returns an unauthenticated error +func Unauthenticated(scheme string) Error { + return New(401, "unauthenticated for %s", scheme) +} diff --git a/vendor/github.com/go-openapi/errors/headers.go b/vendor/github.com/go-openapi/errors/headers.go new file mode 100644 index 0000000..71b8175 --- /dev/null +++ b/vendor/github.com/go-openapi/errors/headers.go @@ -0,0 +1,76 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package errors + +import ( + "fmt" + "net/http" +) + +// Validation represents a failure of a precondition +type Validation struct { + code int32 + Name string + In string + Value interface{} + message string + Values []interface{} +} + +func (e *Validation) Error() string { + return e.message +} + +// Code the error code +func (e *Validation) Code() int32 { + return e.code +} + +const ( + contentTypeFail = `unsupported media type %q, only %v are allowed` + responseFormatFail = `unsupported media type requested, only %v are available` +) + +// InvalidContentType error for an invalid content type +func InvalidContentType(value string, allowed []string) *Validation { + var values []interface{} + for _, v := range allowed { + values = append(values, v) + } + return &Validation{ + code: http.StatusUnsupportedMediaType, + Name: "Content-Type", + In: "header", + Value: value, + Values: values, + message: fmt.Sprintf(contentTypeFail, value, allowed), + } +} + +// InvalidResponseFormat error for an unacceptable response format request +func InvalidResponseFormat(value string, allowed []string) *Validation { + var values []interface{} + for _, v := range allowed { + values = append(values, v) + } + return &Validation{ + code: http.StatusNotAcceptable, + Name: "Accept", + In: "header", + Value: value, + Values: values, + message: fmt.Sprintf(responseFormatFail, allowed), + } +} diff --git a/vendor/github.com/go-openapi/errors/middleware.go b/vendor/github.com/go-openapi/errors/middleware.go new file mode 100644 index 0000000..6390d46 --- /dev/null +++ b/vendor/github.com/go-openapi/errors/middleware.go @@ -0,0 +1,51 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package errors + +import ( + "bytes" + "fmt" + "strings" +) + +// APIVerificationFailed is an error that contains all the missing info for a mismatched section +// between the api registrations and the api spec +type APIVerificationFailed struct { + Section string + MissingSpecification []string + MissingRegistration []string +} + +// +func (v *APIVerificationFailed) Error() string { + buf := bytes.NewBuffer(nil) + + hasRegMissing := len(v.MissingRegistration) > 0 + hasSpecMissing := len(v.MissingSpecification) > 0 + + if hasRegMissing { + buf.WriteString(fmt.Sprintf("missing [%s] %s registrations", strings.Join(v.MissingRegistration, ", "), v.Section)) + } + + if hasRegMissing && hasSpecMissing { + buf.WriteString("\n") + } + + if hasSpecMissing { + buf.WriteString(fmt.Sprintf("missing from spec file [%s] %s", strings.Join(v.MissingSpecification, ", "), v.Section)) + } + + return buf.String() +} diff --git a/vendor/github.com/go-openapi/errors/parsing.go b/vendor/github.com/go-openapi/errors/parsing.go new file mode 100644 index 0000000..1bae873 --- /dev/null +++ b/vendor/github.com/go-openapi/errors/parsing.go @@ -0,0 +1,59 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package errors + +import "fmt" + +// ParseError respresents a parsing error +type ParseError struct { + code int32 + Name string + In string + Value string + Reason error + message string +} + +func (e *ParseError) Error() string { + return e.message +} + +// Code returns the http status code for this error +func (e *ParseError) Code() int32 { + return e.code +} + +const ( + parseErrorTemplContent = `parsing %s %s from %q failed, because %s` + parseErrorTemplContentNoIn = `parsing %s from %q failed, because %s` +) + +// NewParseError creates a new parse error +func NewParseError(name, in, value string, reason error) *ParseError { + var msg string + if in == "" { + msg = fmt.Sprintf(parseErrorTemplContentNoIn, name, value, reason) + } else { + msg = fmt.Sprintf(parseErrorTemplContent, name, in, value, reason) + } + return &ParseError{ + code: 400, + Name: name, + In: in, + Value: value, + Reason: reason, + message: msg, + } +} diff --git a/vendor/github.com/go-openapi/errors/schema.go b/vendor/github.com/go-openapi/errors/schema.go new file mode 100644 index 0000000..c52f5c3 --- /dev/null +++ b/vendor/github.com/go-openapi/errors/schema.go @@ -0,0 +1,548 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package errors + +import ( + "fmt" + "strings" +) + +const ( + invalidType = "%s is an invalid type name" + typeFail = "%s in %s must be of type %s" + typeFailWithData = "%s in %s must be of type %s: %q" + typeFailWithError = "%s in %s must be of type %s, because: %s" + requiredFail = "%s in %s is required" + tooLongMessage = "%s in %s should be at most %d chars long" + tooShortMessage = "%s in %s should be at least %d chars long" + patternFail = "%s in %s should match '%s'" + enumFail = "%s in %s should be one of %v" + multipleOfFail = "%s in %s should be a multiple of %v" + maxIncFail = "%s in %s should be less than or equal to %v" + maxExcFail = "%s in %s should be less than %v" + minIncFail = "%s in %s should be greater than or equal to %v" + minExcFail = "%s in %s should be greater than %v" + uniqueFail = "%s in %s shouldn't contain duplicates" + maxItemsFail = "%s in %s should have at most %d items" + minItemsFail = "%s in %s should have at least %d items" + typeFailNoIn = "%s must be of type %s" + typeFailWithDataNoIn = "%s must be of type %s: %q" + typeFailWithErrorNoIn = "%s must be of type %s, because: %s" + requiredFailNoIn = "%s is required" + tooLongMessageNoIn = "%s should be at most %d chars long" + tooShortMessageNoIn = "%s should be at least %d chars long" + patternFailNoIn = "%s should match '%s'" + enumFailNoIn = "%s should be one of %v" + multipleOfFailNoIn = "%s should be a multiple of %v" + maxIncFailNoIn = "%s should be less than or equal to %v" + maxExcFailNoIn = "%s should be less than %v" + minIncFailNoIn = "%s should be greater than or equal to %v" + minExcFailNoIn = "%s should be greater than %v" + uniqueFailNoIn = "%s shouldn't contain duplicates" + maxItemsFailNoIn = "%s should have at most %d items" + minItemsFailNoIn = "%s should have at least %d items" + noAdditionalItems = "%s in %s can't have additional items" + noAdditionalItemsNoIn = "%s can't have additional items" + tooFewProperties = "%s in %s should have at least %d properties" + tooFewPropertiesNoIn = "%s should have at least %d properties" + tooManyProperties = "%s in %s should have at most %d properties" + tooManyPropertiesNoIn = "%s should have at most %d properties" + unallowedProperty = "%s.%s in %s is a forbidden property" + unallowedPropertyNoIn = "%s.%s is a forbidden property" + failedAllPatternProps = "%s.%s in %s failed all pattern properties" + failedAllPatternPropsNoIn = "%s.%s failed all pattern properties" +) + +// All code responses can be used to differentiate errors for different handling +// by the consuming program +const ( + // CompositeErrorCode remains 422 for backwards-compatibility + // and to separate it from validation errors with cause + CompositeErrorCode = 422 + // InvalidTypeCode is used for any subclass of invalid types + InvalidTypeCode = 600 + iota + RequiredFailCode + TooLongFailCode + TooShortFailCode + PatternFailCode + EnumFailCode + MultipleOfFailCode + MaxFailCode + MinFailCode + UniqueFailCode + MaxItemsFailCode + MinItemsFailCode + NoAdditionalItemsCode + TooFewPropertiesCode + TooManyPropertiesCode + UnallowedPropertyCode + FailedAllPatternPropsCode +) + +// CompositeError is an error that groups several errors together +type CompositeError struct { + Errors []error + code int32 + message string +} + +// Code for this error +func (c *CompositeError) Code() int32 { + return c.code +} + +func (c *CompositeError) Error() string { + if len(c.Errors) > 0 { + msgs := []string{c.message + ":"} + for _, e := range c.Errors { + msgs = append(msgs, e.Error()) + } + return strings.Join(msgs, "\n") + } + return c.message +} + +// CompositeValidationError an error to wrap a bunch of other errors +func CompositeValidationError(errors ...error) *CompositeError { + return &CompositeError{ + code: CompositeErrorCode, + Errors: append([]error{}, errors...), + message: "validation failure list", + } +} + +// FailedAllPatternProperties an error for when the property doesn't match a pattern +func FailedAllPatternProperties(name, in, key string) *Validation { + msg := fmt.Sprintf(failedAllPatternProps, name, key, in) + if in == "" { + msg = fmt.Sprintf(failedAllPatternPropsNoIn, name, key) + } + return &Validation{ + code: FailedAllPatternPropsCode, + Name: name, + In: in, + Value: key, + message: msg, + } +} + +// PropertyNotAllowed an error for when the property doesn't match a pattern +func PropertyNotAllowed(name, in, key string) *Validation { + msg := fmt.Sprintf(unallowedProperty, name, key, in) + if in == "" { + msg = fmt.Sprintf(unallowedPropertyNoIn, name, key) + } + return &Validation{ + code: UnallowedPropertyCode, + Name: name, + In: in, + Value: key, + message: msg, + } +} + +// TooFewProperties an error for an object with too few properties +func TooFewProperties(name, in string, n int64) *Validation { + msg := fmt.Sprintf(tooFewProperties, name, in, n) + if in == "" { + msg = fmt.Sprintf(tooFewPropertiesNoIn, name, n) + } + return &Validation{ + code: TooFewPropertiesCode, + Name: name, + In: in, + Value: n, + message: msg, + } +} + +// TooManyProperties an error for an object with too many properties +func TooManyProperties(name, in string, n int64) *Validation { + msg := fmt.Sprintf(tooManyProperties, name, in, n) + if in == "" { + msg = fmt.Sprintf(tooManyPropertiesNoIn, name, n) + } + return &Validation{ + code: TooManyPropertiesCode, + Name: name, + In: in, + Value: n, + message: msg, + } +} + +// AdditionalItemsNotAllowed an error for invalid additional items +func AdditionalItemsNotAllowed(name, in string) *Validation { + msg := fmt.Sprintf(noAdditionalItems, name, in) + if in == "" { + msg = fmt.Sprintf(noAdditionalItemsNoIn, name) + } + return &Validation{ + code: NoAdditionalItemsCode, + Name: name, + In: in, + message: msg, + } +} + +// InvalidCollectionFormat another flavor of invalid type error +func InvalidCollectionFormat(name, in, format string) *Validation { + return &Validation{ + code: InvalidTypeCode, + Name: name, + In: in, + Value: format, + message: fmt.Sprintf("the collection format %q is not supported for the %s param %q", format, in, name), + } +} + +// InvalidTypeName an error for when the type is invalid +func InvalidTypeName(typeName string) *Validation { + return &Validation{ + code: InvalidTypeCode, + Value: typeName, + message: fmt.Sprintf(invalidType, typeName), + } +} + +// InvalidType creates an error for when the type is invalid +func InvalidType(name, in, typeName string, value interface{}) *Validation { + var message string + + if in != "" { + switch value.(type) { + case string: + message = fmt.Sprintf(typeFailWithData, name, in, typeName, value) + case error: + message = fmt.Sprintf(typeFailWithError, name, in, typeName, value) + default: + message = fmt.Sprintf(typeFail, name, in, typeName) + } + } else { + switch value.(type) { + case string: + message = fmt.Sprintf(typeFailWithDataNoIn, name, typeName, value) + case error: + message = fmt.Sprintf(typeFailWithErrorNoIn, name, typeName, value) + default: + message = fmt.Sprintf(typeFailNoIn, name, typeName) + } + } + + return &Validation{ + code: InvalidTypeCode, + Name: name, + In: in, + Value: value, + message: message, + } + +} + +// DuplicateItems error for when an array contains duplicates +func DuplicateItems(name, in string) *Validation { + msg := fmt.Sprintf(uniqueFail, name, in) + if in == "" { + msg = fmt.Sprintf(uniqueFailNoIn, name) + } + return &Validation{ + code: UniqueFailCode, + Name: name, + In: in, + message: msg, + } +} + +// TooManyItems error for when an array contains too many items +func TooManyItems(name, in string, max int64) *Validation { + msg := fmt.Sprintf(maxItemsFail, name, in, max) + if in == "" { + msg = fmt.Sprintf(maxItemsFailNoIn, name, max) + } + + return &Validation{ + code: MaxItemsFailCode, + Name: name, + In: in, + message: msg, + } +} + +// TooFewItems error for when an array contains too few items +func TooFewItems(name, in string, min int64) *Validation { + msg := fmt.Sprintf(minItemsFail, name, in, min) + if in == "" { + msg = fmt.Sprintf(minItemsFailNoIn, name, min) + } + return &Validation{ + code: MinItemsFailCode, + Name: name, + In: in, + message: msg, + } +} + +// ExceedsMaximumInt error for when maxinum validation fails +func ExceedsMaximumInt(name, in string, max int64, exclusive bool) *Validation { + var message string + if in == "" { + m := maxIncFailNoIn + if exclusive { + m = maxExcFailNoIn + } + message = fmt.Sprintf(m, name, max) + } else { + m := maxIncFail + if exclusive { + m = maxExcFail + } + message = fmt.Sprintf(m, name, in, max) + } + return &Validation{ + code: MaxFailCode, + Name: name, + In: in, + Value: max, + message: message, + } +} + +// ExceedsMaximumUint error for when maxinum validation fails +func ExceedsMaximumUint(name, in string, max uint64, exclusive bool) *Validation { + var message string + if in == "" { + m := maxIncFailNoIn + if exclusive { + m = maxExcFailNoIn + } + message = fmt.Sprintf(m, name, max) + } else { + m := maxIncFail + if exclusive { + m = maxExcFail + } + message = fmt.Sprintf(m, name, in, max) + } + return &Validation{ + code: MaxFailCode, + Name: name, + In: in, + Value: max, + message: message, + } +} + +// ExceedsMaximum error for when maxinum validation fails +func ExceedsMaximum(name, in string, max float64, exclusive bool) *Validation { + var message string + if in == "" { + m := maxIncFailNoIn + if exclusive { + m = maxExcFailNoIn + } + message = fmt.Sprintf(m, name, max) + } else { + m := maxIncFail + if exclusive { + m = maxExcFail + } + message = fmt.Sprintf(m, name, in, max) + } + return &Validation{ + code: MaxFailCode, + Name: name, + In: in, + Value: max, + message: message, + } +} + +// ExceedsMinimumInt error for when maxinum validation fails +func ExceedsMinimumInt(name, in string, min int64, exclusive bool) *Validation { + var message string + if in == "" { + m := minIncFailNoIn + if exclusive { + m = minExcFailNoIn + } + message = fmt.Sprintf(m, name, min) + } else { + m := minIncFail + if exclusive { + m = minExcFail + } + message = fmt.Sprintf(m, name, in, min) + } + return &Validation{ + code: MinFailCode, + Name: name, + In: in, + Value: min, + message: message, + } +} + +// ExceedsMinimumUint error for when maxinum validation fails +func ExceedsMinimumUint(name, in string, min uint64, exclusive bool) *Validation { + var message string + if in == "" { + m := minIncFailNoIn + if exclusive { + m = minExcFailNoIn + } + message = fmt.Sprintf(m, name, min) + } else { + m := minIncFail + if exclusive { + m = minExcFail + } + message = fmt.Sprintf(m, name, in, min) + } + return &Validation{ + code: MinFailCode, + Name: name, + In: in, + Value: min, + message: message, + } +} + +// ExceedsMinimum error for when maxinum validation fails +func ExceedsMinimum(name, in string, min float64, exclusive bool) *Validation { + var message string + if in == "" { + m := minIncFailNoIn + if exclusive { + m = minExcFailNoIn + } + message = fmt.Sprintf(m, name, min) + } else { + m := minIncFail + if exclusive { + m = minExcFail + } + message = fmt.Sprintf(m, name, in, min) + } + return &Validation{ + code: MinFailCode, + Name: name, + In: in, + Value: min, + message: message, + } +} + +// NotMultipleOf error for when multiple of validation fails +func NotMultipleOf(name, in string, multiple float64) *Validation { + var msg string + if in == "" { + msg = fmt.Sprintf(multipleOfFailNoIn, name, multiple) + } else { + msg = fmt.Sprintf(multipleOfFail, name, in, multiple) + } + return &Validation{ + code: MultipleOfFailCode, + Name: name, + In: in, + Value: multiple, + message: msg, + } +} + +// EnumFail error for when an enum validation fails +func EnumFail(name, in string, value interface{}, values []interface{}) *Validation { + var msg string + if in == "" { + msg = fmt.Sprintf(enumFailNoIn, name, values) + } else { + msg = fmt.Sprintf(enumFail, name, in, values) + } + + return &Validation{ + code: EnumFailCode, + Name: name, + In: in, + Value: value, + Values: values, + message: msg, + } +} + +// Required error for when a value is missing +func Required(name, in string) *Validation { + var msg string + if in == "" { + msg = fmt.Sprintf(requiredFailNoIn, name) + } else { + msg = fmt.Sprintf(requiredFail, name, in) + } + return &Validation{ + code: RequiredFailCode, + Name: name, + In: in, + message: msg, + } +} + +// TooLong error for when a string is too long +func TooLong(name, in string, max int64) *Validation { + var msg string + if in == "" { + msg = fmt.Sprintf(tooLongMessageNoIn, name, max) + } else { + msg = fmt.Sprintf(tooLongMessage, name, in, max) + } + return &Validation{ + code: TooLongFailCode, + Name: name, + In: in, + message: msg, + } +} + +// TooShort error for when a string is too short +func TooShort(name, in string, min int64) *Validation { + var msg string + if in == "" { + msg = fmt.Sprintf(tooShortMessageNoIn, name, min) + } else { + msg = fmt.Sprintf(tooShortMessage, name, in, min) + } + + return &Validation{ + code: TooShortFailCode, + Name: name, + In: in, + message: msg, + } +} + +// FailedPattern error for when a string fails a regex pattern match +// the pattern that is returned is the ECMA syntax version of the pattern not the golang version. +func FailedPattern(name, in, pattern string) *Validation { + var msg string + if in == "" { + msg = fmt.Sprintf(patternFailNoIn, name, pattern) + } else { + msg = fmt.Sprintf(patternFail, name, in, pattern) + } + + return &Validation{ + code: PatternFailCode, + Name: name, + In: in, + message: msg, + } +} diff --git a/vendor/github.com/go-openapi/jsonpointer/.gitignore b/vendor/github.com/go-openapi/jsonpointer/.gitignore new file mode 100644 index 0000000..769c244 --- /dev/null +++ b/vendor/github.com/go-openapi/jsonpointer/.gitignore @@ -0,0 +1 @@ +secrets.yml diff --git a/vendor/github.com/go-openapi/jsonpointer/.travis.yml b/vendor/github.com/go-openapi/jsonpointer/.travis.yml new file mode 100644 index 0000000..d0f383a --- /dev/null +++ b/vendor/github.com/go-openapi/jsonpointer/.travis.yml @@ -0,0 +1,13 @@ +language: go +go: +- 1.7 +install: +- go get -u github.com/stretchr/testify/assert +- go get -u github.com/go-openapi/swag +script: +- go test -v -race -cover -coverprofile=coverage.txt -covermode=atomic ./... +after_success: +- bash <(curl -s https://codecov.io/bash) +notifications: + slack: + secure: a5VgoiwB1G/AZqzmephPZIhEB9avMlsWSlVnM1dSAtYAwdrQHGTQxAmpOxYIoSPDhWNN5bfZmjd29++UlTwLcHSR+e0kJhH6IfDlsHj/HplNCJ9tyI0zYc7XchtdKgeMxMzBKCzgwFXGSbQGydXTliDNBo0HOzmY3cou/daMFTP60K+offcjS+3LRAYb1EroSRXZqrk1nuF/xDL3792DZUdPMiFR/L/Df6y74D6/QP4sTkTDFQitz4Wy/7jbsfj8dG6qK2zivgV6/l+w4OVjFkxVpPXogDWY10vVXNVynqxfJ7to2d1I9lNCHE2ilBCkWMIPdyJF7hjF8pKW+82yP4EzRh0vu8Xn0HT5MZpQxdRY/YMxNrWaG7SxsoEaO4q5uhgdzAqLYY3TRa7MjIK+7Ur+aqOeTXn6OKwVi0CjvZ6mIU3WUKSwiwkFZMbjRAkSb5CYwMEfGFO/z964xz83qGt6WAtBXNotqCQpTIiKtDHQeLOMfksHImCg6JLhQcWBVxamVgu0G3Pdh8Y6DyPnxraXY95+QDavbjqv7TeYT9T/FNnrkXaTTK0s4iWE5H4ACU0Qvz0wUYgfQrZv0/Hp7V17+rabUwnzYySHCy9SWX/7OV9Cfh31iMp9ZIffr76xmmThtOEqs8TrTtU6BWI3rWwvA9cXQipZTVtL0oswrGw= diff --git a/vendor/github.com/go-openapi/jsonpointer/CODE_OF_CONDUCT.md b/vendor/github.com/go-openapi/jsonpointer/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..9322b06 --- /dev/null +++ b/vendor/github.com/go-openapi/jsonpointer/CODE_OF_CONDUCT.md @@ -0,0 +1,74 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of experience, +nationality, personal appearance, race, religion, or sexual identity and +orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or +advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at ivan+abuse@flanders.co.nz. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at [http://contributor-covenant.org/version/1/4][version] + +[homepage]: http://contributor-covenant.org +[version]: http://contributor-covenant.org/version/1/4/ diff --git a/vendor/github.com/go-openapi/jsonpointer/LICENSE b/vendor/github.com/go-openapi/jsonpointer/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/vendor/github.com/go-openapi/jsonpointer/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/go-openapi/jsonpointer/README.md b/vendor/github.com/go-openapi/jsonpointer/README.md new file mode 100644 index 0000000..813788a --- /dev/null +++ b/vendor/github.com/go-openapi/jsonpointer/README.md @@ -0,0 +1,15 @@ +# gojsonpointer [![Build Status](https://travis-ci.org/go-openapi/jsonpointer.svg?branch=master)](https://travis-ci.org/go-openapi/jsonpointer) [![codecov](https://codecov.io/gh/go-openapi/jsonpointer/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/jsonpointer) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) + +[![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/jsonpointer/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/jsonpointer?status.svg)](http://godoc.org/github.com/go-openapi/jsonpointer) +An implementation of JSON Pointer - Go language + +## Status +Completed YES + +Tested YES + +## References +http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07 + +### Note +The 4.Evaluation part of the previous reference, starting with 'If the currently referenced value is a JSON array, the reference token MUST contain either...' is not implemented. diff --git a/vendor/github.com/go-openapi/jsonpointer/pointer.go b/vendor/github.com/go-openapi/jsonpointer/pointer.go new file mode 100644 index 0000000..39dd012 --- /dev/null +++ b/vendor/github.com/go-openapi/jsonpointer/pointer.go @@ -0,0 +1,238 @@ +// Copyright 2013 sigu-399 ( https://github.com/sigu-399 ) +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// author sigu-399 +// author-github https://github.com/sigu-399 +// author-mail sigu.399@gmail.com +// +// repository-name jsonpointer +// repository-desc An implementation of JSON Pointer - Go language +// +// description Main and unique file. +// +// created 25-02-2013 + +package jsonpointer + +import ( + "errors" + "fmt" + "reflect" + "strconv" + "strings" + + "github.com/go-openapi/swag" +) + +const ( + emptyPointer = `` + pointerSeparator = `/` + + invalidStart = `JSON pointer must be empty or start with a "` + pointerSeparator +) + +var jsonPointableType = reflect.TypeOf(new(JSONPointable)).Elem() + +// JSONPointable is an interface for structs to implement when they need to customize the +// json pointer process +type JSONPointable interface { + JSONLookup(string) (interface{}, error) +} + +type implStruct struct { + mode string // "SET" or "GET" + + inDocument interface{} + + setInValue interface{} + + getOutNode interface{} + getOutKind reflect.Kind + outError error +} + +// New creates a new json pointer for the given string +func New(jsonPointerString string) (Pointer, error) { + + var p Pointer + err := p.parse(jsonPointerString) + return p, err + +} + +// Pointer the json pointer reprsentation +type Pointer struct { + referenceTokens []string +} + +// "Constructor", parses the given string JSON pointer +func (p *Pointer) parse(jsonPointerString string) error { + + var err error + + if jsonPointerString != emptyPointer { + if !strings.HasPrefix(jsonPointerString, pointerSeparator) { + err = errors.New(invalidStart) + } else { + referenceTokens := strings.Split(jsonPointerString, pointerSeparator) + for _, referenceToken := range referenceTokens[1:] { + p.referenceTokens = append(p.referenceTokens, referenceToken) + } + } + } + + return err +} + +// Get uses the pointer to retrieve a value from a JSON document +func (p *Pointer) Get(document interface{}) (interface{}, reflect.Kind, error) { + return p.get(document, swag.DefaultJSONNameProvider) +} + +// GetForToken gets a value for a json pointer token 1 level deep +func GetForToken(document interface{}, decodedToken string) (interface{}, reflect.Kind, error) { + return getSingleImpl(document, decodedToken, swag.DefaultJSONNameProvider) +} + +func getSingleImpl(node interface{}, decodedToken string, nameProvider *swag.NameProvider) (interface{}, reflect.Kind, error) { + kind := reflect.Invalid + rValue := reflect.Indirect(reflect.ValueOf(node)) + kind = rValue.Kind() + switch kind { + + case reflect.Struct: + if rValue.Type().Implements(jsonPointableType) { + r, err := node.(JSONPointable).JSONLookup(decodedToken) + if err != nil { + return nil, kind, err + } + return r, kind, nil + } + nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken) + if !ok { + return nil, kind, fmt.Errorf("object has no field %q", decodedToken) + } + fld := rValue.FieldByName(nm) + return fld.Interface(), kind, nil + + case reflect.Map: + kv := reflect.ValueOf(decodedToken) + mv := rValue.MapIndex(kv) + if mv.IsValid() && !swag.IsZero(mv) { + return mv.Interface(), kind, nil + } + return nil, kind, fmt.Errorf("object has no key %q", decodedToken) + + case reflect.Slice: + tokenIndex, err := strconv.Atoi(decodedToken) + if err != nil { + return nil, kind, err + } + sLength := rValue.Len() + if tokenIndex < 0 || tokenIndex >= sLength { + return nil, kind, fmt.Errorf("index out of bounds array[0,%d] index '%d'", sLength, tokenIndex) + } + + elem := rValue.Index(tokenIndex) + return elem.Interface(), kind, nil + + default: + return nil, kind, fmt.Errorf("invalid token reference %q", decodedToken) + } + +} + +func (p *Pointer) get(node interface{}, nameProvider *swag.NameProvider) (interface{}, reflect.Kind, error) { + + if nameProvider == nil { + nameProvider = swag.DefaultJSONNameProvider + } + + kind := reflect.Invalid + + // Full document when empty + if len(p.referenceTokens) == 0 { + return node, kind, nil + } + + for _, token := range p.referenceTokens { + + decodedToken := Unescape(token) + + r, knd, err := getSingleImpl(node, decodedToken, nameProvider) + if err != nil { + return nil, knd, err + } + node, kind = r, knd + + } + + rValue := reflect.ValueOf(node) + kind = rValue.Kind() + + return node, kind, nil +} + +// DecodedTokens returns the decoded tokens +func (p *Pointer) DecodedTokens() []string { + result := make([]string, 0, len(p.referenceTokens)) + for _, t := range p.referenceTokens { + result = append(result, Unescape(t)) + } + return result +} + +// IsEmpty returns true if this is an empty json pointer +// this indicates that it points to the root document +func (p *Pointer) IsEmpty() bool { + return len(p.referenceTokens) == 0 +} + +// Pointer to string representation function +func (p *Pointer) String() string { + + if len(p.referenceTokens) == 0 { + return emptyPointer + } + + pointerString := pointerSeparator + strings.Join(p.referenceTokens, pointerSeparator) + + return pointerString +} + +// Specific JSON pointer encoding here +// ~0 => ~ +// ~1 => / +// ... and vice versa + +const ( + encRefTok0 = `~0` + encRefTok1 = `~1` + decRefTok0 = `~` + decRefTok1 = `/` +) + +// Unescape unescapes a json pointer reference token string to the original representation +func Unescape(token string) string { + step1 := strings.Replace(token, encRefTok1, decRefTok1, -1) + step2 := strings.Replace(step1, encRefTok0, decRefTok0, -1) + return step2 +} + +// Escape escapes a pointer reference token string +func Escape(token string) string { + step1 := strings.Replace(token, decRefTok0, encRefTok0, -1) + step2 := strings.Replace(step1, decRefTok1, encRefTok1, -1) + return step2 +} diff --git a/vendor/github.com/go-openapi/jsonreference/.gitignore b/vendor/github.com/go-openapi/jsonreference/.gitignore new file mode 100644 index 0000000..769c244 --- /dev/null +++ b/vendor/github.com/go-openapi/jsonreference/.gitignore @@ -0,0 +1 @@ +secrets.yml diff --git a/vendor/github.com/go-openapi/jsonreference/.travis.yml b/vendor/github.com/go-openapi/jsonreference/.travis.yml new file mode 100644 index 0000000..5b31a1b --- /dev/null +++ b/vendor/github.com/go-openapi/jsonreference/.travis.yml @@ -0,0 +1,14 @@ +language: go +go: +- 1.7 +install: +- go get -u github.com/stretchr/testify/assert +- go get -u github.com/PuerkitoBio/purell +- go get -u github.com/go-openapi/jsonpointer +script: +- go test -v -race -cover -coverprofile=coverage.txt -covermode=atomic ./... +after_success: +- bash <(curl -s https://codecov.io/bash) +notifications: + slack: + secure: OpQG/36F7DSF00HLm9WZMhyqFCYYyYTsVDObW226cWiR8PWYiNfLZiSEvIzT1Gx4dDjhigKTIqcLhG34CkL5iNXDjm9Yyo2RYhQPlK8NErNqUEXuBqn4RqYHW48VGhEhOyDd4Ei0E2FN5ZbgpvHgtpkdZ6XDi64r3Ac89isP9aPHXQTuv2Jog6b4/OKKiUTftLcTIst0p4Cp3gqOJWf1wnoj+IadWiECNVQT6zb47IYjtyw6+uV8iUjTzdKcRB6Zc6b4Dq7JAg1Zd7Jfxkql3hlKp4PNlRf9Cy7y5iA3G7MLyg3FcPX5z2kmcyPt2jOTRMBWUJ5zIQpOxizAcN8WsT3WWBL5KbuYK6k0PzujrIDLqdxGpNmjkkMfDBT9cKmZpm2FdW+oZgPFJP+oKmAo4u4KJz/vjiPTXgQlN5bmrLuRMCp+AwC5wkIohTqWZVPE2TK6ZSnMYcg/W39s+RP/9mJoyryAvPSpBOLTI+biCgaUCTOAZxNTWpMFc3tPYntc41WWkdKcooZ9JA5DwfcaVFyTGQ3YXz+HvX6G1z/gW0Q/A4dBi9mj2iE1xm7tRTT+4VQ2AXFvSEI1HJpfPgYnwAtwOD1v3Qm2EUHk9sCdtEDR4wVGEPIVn44GnwFMnGKx9JWppMPYwFu3SVDdHt+E+LOlhZUply11Aa+IVrT2KUQ= diff --git a/vendor/github.com/go-openapi/jsonreference/CODE_OF_CONDUCT.md b/vendor/github.com/go-openapi/jsonreference/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..9322b06 --- /dev/null +++ b/vendor/github.com/go-openapi/jsonreference/CODE_OF_CONDUCT.md @@ -0,0 +1,74 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of experience, +nationality, personal appearance, race, religion, or sexual identity and +orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or +advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at ivan+abuse@flanders.co.nz. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at [http://contributor-covenant.org/version/1/4][version] + +[homepage]: http://contributor-covenant.org +[version]: http://contributor-covenant.org/version/1/4/ diff --git a/vendor/github.com/go-openapi/jsonreference/LICENSE b/vendor/github.com/go-openapi/jsonreference/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/vendor/github.com/go-openapi/jsonreference/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/go-openapi/jsonreference/README.md b/vendor/github.com/go-openapi/jsonreference/README.md new file mode 100644 index 0000000..66345f4 --- /dev/null +++ b/vendor/github.com/go-openapi/jsonreference/README.md @@ -0,0 +1,15 @@ +# gojsonreference [![Build Status](https://travis-ci.org/go-openapi/jsonreference.svg?branch=master)](https://travis-ci.org/go-openapi/jsonreference) [![codecov](https://codecov.io/gh/go-openapi/jsonreference/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/jsonreference) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) + +[![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/jsonreference/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/jsonreference?status.svg)](http://godoc.org/github.com/go-openapi/jsonreference) +An implementation of JSON Reference - Go language + +## Status +Work in progress ( 90% done ) + +## Dependencies +https://github.com/go-openapi/jsonpointer + +## References +http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07 + +http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03 diff --git a/vendor/github.com/go-openapi/jsonreference/reference.go b/vendor/github.com/go-openapi/jsonreference/reference.go new file mode 100644 index 0000000..3bc0a6e --- /dev/null +++ b/vendor/github.com/go-openapi/jsonreference/reference.go @@ -0,0 +1,156 @@ +// Copyright 2013 sigu-399 ( https://github.com/sigu-399 ) +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// author sigu-399 +// author-github https://github.com/sigu-399 +// author-mail sigu.399@gmail.com +// +// repository-name jsonreference +// repository-desc An implementation of JSON Reference - Go language +// +// description Main and unique file. +// +// created 26-02-2013 + +package jsonreference + +import ( + "errors" + "net/url" + "strings" + + "github.com/PuerkitoBio/purell" + "github.com/go-openapi/jsonpointer" +) + +const ( + fragmentRune = `#` +) + +// New creates a new reference for the given string +func New(jsonReferenceString string) (Ref, error) { + + var r Ref + err := r.parse(jsonReferenceString) + return r, err + +} + +// MustCreateRef parses the ref string and panics when it's invalid. +// Use the New method for a version that returns an error +func MustCreateRef(ref string) Ref { + r, err := New(ref) + if err != nil { + panic(err) + } + return r +} + +// Ref represents a json reference object +type Ref struct { + referenceURL *url.URL + referencePointer jsonpointer.Pointer + + HasFullURL bool + HasURLPathOnly bool + HasFragmentOnly bool + HasFileScheme bool + HasFullFilePath bool +} + +// GetURL gets the URL for this reference +func (r *Ref) GetURL() *url.URL { + return r.referenceURL +} + +// GetPointer gets the json pointer for this reference +func (r *Ref) GetPointer() *jsonpointer.Pointer { + return &r.referencePointer +} + +// String returns the best version of the url for this reference +func (r *Ref) String() string { + + if r.referenceURL != nil { + return r.referenceURL.String() + } + + if r.HasFragmentOnly { + return fragmentRune + r.referencePointer.String() + } + + return r.referencePointer.String() +} + +// IsRoot returns true if this reference is a root document +func (r *Ref) IsRoot() bool { + return r.referenceURL != nil && + !r.IsCanonical() && + !r.HasURLPathOnly && + r.referenceURL.Fragment == "" +} + +// IsCanonical returns true when this pointer starts with http(s):// or file:// +func (r *Ref) IsCanonical() bool { + return (r.HasFileScheme && r.HasFullFilePath) || (!r.HasFileScheme && r.HasFullURL) +} + +// "Constructor", parses the given string JSON reference +func (r *Ref) parse(jsonReferenceString string) error { + + parsed, err := url.Parse(jsonReferenceString) + if err != nil { + return err + } + + r.referenceURL, _ = url.Parse(purell.NormalizeURL(parsed, purell.FlagsSafe|purell.FlagRemoveDuplicateSlashes)) + refURL := r.referenceURL + + if refURL.Scheme != "" && refURL.Host != "" { + r.HasFullURL = true + } else { + if refURL.Path != "" { + r.HasURLPathOnly = true + } else if refURL.RawQuery == "" && refURL.Fragment != "" { + r.HasFragmentOnly = true + } + } + + r.HasFileScheme = refURL.Scheme == "file" + r.HasFullFilePath = strings.HasPrefix(refURL.Path, "/") + + // invalid json-pointer error means url has no json-pointer fragment. simply ignore error + r.referencePointer, _ = jsonpointer.New(refURL.Fragment) + + return nil +} + +// Inherits creates a new reference from a parent and a child +// If the child cannot inherit from the parent, an error is returned +func (r *Ref) Inherits(child Ref) (*Ref, error) { + childURL := child.GetURL() + parentURL := r.GetURL() + if childURL == nil { + return nil, errors.New("child url is nil") + } + if parentURL == nil { + return &child, nil + } + + ref, err := New(parentURL.ResolveReference(childURL).String()) + if err != nil { + return nil, err + } + return &ref, nil +} diff --git a/vendor/github.com/go-openapi/loads/.drone.sec b/vendor/github.com/go-openapi/loads/.drone.sec new file mode 100644 index 0000000..6d3e843 --- /dev/null +++ b/vendor/github.com/go-openapi/loads/.drone.sec @@ -0,0 +1 @@ +eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExMjhHQ00ifQ.xUjixvmMMeampw0Doyr_XLvcV5ICmDgDFmlcWqgmO84O3Hwn6dqbMkwOjpKMOyEJW_98b5Om5ED59IFt2S0T_OarlrsJL8jOK5fqxSMNXy2w8LfI-e5l1URverW41ofAVK8m9wK05q2BSJM_M6PyyODaQeDBiCVK1HreMZBlXpuUDVtBMPILQoga0eSZOsTR3DYEpZIS0A0Rsa5yIhMYR5d5-JMYqbqOCB7tNJ-BM83OzYgL7Hrz0J15kqaJmhQ-GJoMJDzOemSO9KxLCOfSPp11R_G3Mfd48xYnuiRuPOTakbOCLxuYviH6uoGVIOhnMyY9qKiDKbOn4BQUi1-igA.6qjQzq9nzAxRRKV_.z79R5cMFAEuEaAh6U9ykiL8oIqzMbs_I2C-hSFRh3HYRJ4fTB-9LrcbF0uASIOq7bBn4OQzW-0QFwYOs1uaawmrByGngV5d0afiZf_LBKcmTF2vtxRi_A_nxD-EHoPmh3lKBU5WNDe_8kLjEeS89HeyyFPuv5iQbqhzdqPFohHKVigwVqVYYLjB8GWQ4t7tC4c8l5rHanaXf71W0e3op2m8bebpZL0JPGhnULVA1oU27TYeLsO112JkIYtBwZxzvAs--bBFoKeGJWVMFzrKN68UACGZ9RFw0uGJbBmVC4-jRuIc6XpqeEqw3KG-rjFzkeEor3575qW-8kiXYqpub9SFUc3SSZkxJ8hB3SrnMBOuDUSenrXNpAbltmV3KAALzN3_bMBQuihwSRIn0Hg7-Dpni8BieMe44RMDvRu6p_71aeU_KW4V7Umy_h8gpIvQFuKGdTQH2ahsyCXL0ojqjMbVMdoWpDQTQ2_Fy8Qt_p2kJ8BgDo-1Akd4a6BNU2NGqsdnrJmtVKcTqLBadf9ylCwxHdGVrtNYORALSms2T6Q1s-poQnMjIwN8lnUD8ABUBpt4uVtrYkiWPVwrwywLQeiHhR-pboe_53kWDAx4Hy4rpbKsaxanYhy_bEbAYKb3aIUA.75GD4kRBCQdcGFYP1QYdCg \ No newline at end of file diff --git a/vendor/github.com/go-openapi/loads/.drone.yml b/vendor/github.com/go-openapi/loads/.drone.yml new file mode 100644 index 0000000..9822910 --- /dev/null +++ b/vendor/github.com/go-openapi/loads/.drone.yml @@ -0,0 +1,39 @@ +clone: + path: github.com/go-openapi/loads + +matrix: + GO_VERSION: + - "1.6" + +build: + integration: + image: golang:$$GO_VERSION + pull: true + environment: + GOCOVMODE: "count" + commands: + - go get -u github.com/axw/gocov/gocov + - go get -u gopkg.in/matm/v1/gocov-html + - go get -u github.com/cee-dub/go-junit-report + - go get -u github.com/stretchr/testify/assert + - go get -u gopkg.in/yaml.v2 + - go get -u github.com/go-openapi/swag + - go get -u github.com/go-openapi/analysis + - go get -u github.com/go-openapi/spec + - ./hack/build-drone.sh + +notify: + slack: + channel: bots + webhook_url: $$SLACK_URL + username: drone + +publish: + coverage: + server: https://coverage.vmware.run + token: $$GITHUB_TOKEN + # threshold: 70 + # must_increase: true + when: + matrix: + GO_VERSION: "1.6" diff --git a/vendor/github.com/go-openapi/loads/.gitignore b/vendor/github.com/go-openapi/loads/.gitignore new file mode 100644 index 0000000..e4f15f1 --- /dev/null +++ b/vendor/github.com/go-openapi/loads/.gitignore @@ -0,0 +1,4 @@ +secrets.yml +coverage.out +profile.cov +profile.out diff --git a/vendor/github.com/go-openapi/loads/.pullapprove.yml b/vendor/github.com/go-openapi/loads/.pullapprove.yml new file mode 100644 index 0000000..5ec183e --- /dev/null +++ b/vendor/github.com/go-openapi/loads/.pullapprove.yml @@ -0,0 +1,13 @@ +approve_by_comment: true +approve_regex: '^(:shipit:|:\+1:|\+1|LGTM|lgtm|Approved)' +reject_regex: ^[Rr]ejected +reset_on_push: false +reviewers: + members: + - casualjim + - chancez + - frapposelli + - vburenin + - pytlesk4 + name: pullapprove + required: 1 diff --git a/vendor/github.com/go-openapi/loads/CODE_OF_CONDUCT.md b/vendor/github.com/go-openapi/loads/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..9322b06 --- /dev/null +++ b/vendor/github.com/go-openapi/loads/CODE_OF_CONDUCT.md @@ -0,0 +1,74 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of experience, +nationality, personal appearance, race, religion, or sexual identity and +orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or +advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at ivan+abuse@flanders.co.nz. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at [http://contributor-covenant.org/version/1/4][version] + +[homepage]: http://contributor-covenant.org +[version]: http://contributor-covenant.org/version/1/4/ diff --git a/vendor/github.com/go-openapi/loads/LICENSE b/vendor/github.com/go-openapi/loads/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/vendor/github.com/go-openapi/loads/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/go-openapi/loads/README.md b/vendor/github.com/go-openapi/loads/README.md new file mode 100644 index 0000000..9d5c899 --- /dev/null +++ b/vendor/github.com/go-openapi/loads/README.md @@ -0,0 +1,5 @@ +# Loads OAI specs [![Build Status](https://ci.vmware.run/api/badges/go-openapi/loads/status.svg)](https://ci.vmware.run/go-openapi/loads) [![Coverage](https://coverage.vmware.run/badges/go-openapi/loads/coverage.svg)](https://coverage.vmware.run/go-openapi/loads) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) + +[![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/loads/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/loads?status.svg)](http://godoc.org/github.com/go-openapi/loads) + +Loading of OAI specification documents from local or remote locations. diff --git a/vendor/github.com/go-openapi/loads/spec.go b/vendor/github.com/go-openapi/loads/spec.go new file mode 100644 index 0000000..33a11ee --- /dev/null +++ b/vendor/github.com/go-openapi/loads/spec.go @@ -0,0 +1,223 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package loads + +import ( + "encoding/json" + "fmt" + "net/url" + + "github.com/go-openapi/analysis" + "github.com/go-openapi/spec" + "github.com/go-openapi/swag" + "path/filepath" +) + +// JSONDoc loads a json document from either a file or a remote url +func JSONDoc(path string) (json.RawMessage, error) { + data, err := swag.LoadFromFileOrHTTP(path) + if err != nil { + return nil, err + } + return json.RawMessage(data), nil +} + +// DocLoader represents a doc loader type +type DocLoader func(string) (json.RawMessage, error) + +// DocMatcher represents a predicate to check if a loader matches +type DocMatcher func(string) bool + +var loaders *loader + +func init() { + loaders = &loader{Match: func(_ string) bool { return true }, Fn: JSONDoc} +} + +// AddLoader for a document +func AddLoader(predicate DocMatcher, load DocLoader) { + prev := loaders + loaders = &loader{ + Match: predicate, + Fn: load, + Next: prev, + } + +} + +type loader struct { + Fn DocLoader + Match DocMatcher + Next *loader +} + +// JSONSpec loads a spec from a json document +func JSONSpec(path string) (*Document, error) { + data, err := JSONDoc(path) + if err != nil { + return nil, err + } + // convert to json + return Analyzed(json.RawMessage(data), "") +} + +// Document represents a swagger spec document +type Document struct { + // specAnalyzer + Analyzer *analysis.Spec + spec *spec.Swagger + specFilePath string + origSpec *spec.Swagger + schema *spec.Schema + raw json.RawMessage +} + +// Spec loads a new spec document +func Spec(path string) (*Document, error) { + specURL, err := url.Parse(path) + if err != nil { + return nil, err + } + for l := loaders.Next; l != nil; l = l.Next { + if loaders.Match(specURL.Path) { + b, err2 := loaders.Fn(path) + if err2 != nil { + return nil, err2 + } + return Analyzed(b, "") + } + } + b, err := loaders.Fn(path) + if err != nil { + return nil, err + } + + document, err := Analyzed(b, "") + if document != nil { + document.specFilePath = path + } + + return document, err +} + +// Analyzed creates a new analyzed spec document +func Analyzed(data json.RawMessage, version string) (*Document, error) { + if version == "" { + version = "2.0" + } + if version != "2.0" { + return nil, fmt.Errorf("spec version %q is not supported", version) + } + + swspec := new(spec.Swagger) + if err := json.Unmarshal(data, swspec); err != nil { + return nil, err + } + + origsqspec := new(spec.Swagger) + if err := json.Unmarshal(data, origsqspec); err != nil { + return nil, err + } + + d := &Document{ + Analyzer: analysis.New(swspec), + schema: spec.MustLoadSwagger20Schema(), + spec: swspec, + raw: data, + origSpec: origsqspec, + } + return d, nil +} + +// Expanded expands the ref fields in the spec document and returns a new spec document +func (d *Document) Expanded(options... *spec.ExpandOptions) (*Document, error) { + swspec := new(spec.Swagger) + if err := json.Unmarshal(d.raw, swspec); err != nil { + return nil, err + } + + var expandOptions *spec.ExpandOptions + if len(options) > 0 { + expandOptions = options[1] + } else { + expandOptions = &spec.ExpandOptions{ + RelativeBase: filepath.Dir(d.specFilePath), + } + } + + if err := spec.ExpandSpec(swspec, expandOptions); err != nil { + return nil, err + } + + dd := &Document{ + Analyzer: analysis.New(swspec), + spec: swspec, + schema: spec.MustLoadSwagger20Schema(), + raw: d.raw, + origSpec: d.origSpec, + } + return dd, nil +} + +// BasePath the base path for this spec +func (d *Document) BasePath() string { + return d.spec.BasePath +} + +// Version returns the version of this spec +func (d *Document) Version() string { + return d.spec.Swagger +} + +// Schema returns the swagger 2.0 schema +func (d *Document) Schema() *spec.Schema { + return d.schema +} + +// Spec returns the swagger spec object model +func (d *Document) Spec() *spec.Swagger { + return d.spec +} + +// Host returns the host for the API +func (d *Document) Host() string { + return d.spec.Host +} + +// Raw returns the raw swagger spec as json bytes +func (d *Document) Raw() json.RawMessage { + return d.raw +} + +func (d *Document) OrigSpec() *spec.Swagger { + return d.origSpec +} + +// ResetDefinitions gives a shallow copy with the models reset +func (d *Document) ResetDefinitions() *Document { + defs := make(map[string]spec.Schema, len(d.origSpec.Definitions)) + for k, v := range d.origSpec.Definitions { + defs[k] = v + } + + d.spec.Definitions = defs + return d +} + +// Pristine creates a new pristine document instance based on the input data +func (d *Document) Pristine() *Document { + dd, _ := Analyzed(d.Raw(), d.Version()) + return dd +} diff --git a/vendor/github.com/go-openapi/runtime/.gitignore b/vendor/github.com/go-openapi/runtime/.gitignore new file mode 100644 index 0000000..b2623d8 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/.gitignore @@ -0,0 +1,4 @@ +secrets.yml +coverage.out +*.cov +*.out diff --git a/vendor/github.com/go-openapi/runtime/.travis.yml b/vendor/github.com/go-openapi/runtime/.travis.yml new file mode 100644 index 0000000..aeca5bb --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/.travis.yml @@ -0,0 +1,23 @@ +language: go +go: +- 1.7.1 +install: +- go get -u github.com/axw/gocov/gocov +- go get -u gopkg.in/matm/v1/gocov-html +- go get -u github.com/cee-dub/go-junit-report +- go get -u github.com/stretchr/testify/assert +- go get -u golang.org/x/net/context +- go get -u gopkg.in/yaml.v2 +- go get -u github.com/gorilla/context +- go get -u github.com/go-openapi/analysis +- go get -u github.com/go-openapi/errors +- go get -u github.com/go-openapi/loads +- go get -u github.com/go-openapi/strfmt +- go get -u github.com/go-openapi/validate +script: +- ./hack/coverage +after_success: +- bash <(curl -s https://codecov.io/bash) +notifications: + slack: + secure: EmObnQuM9Mw8J9vpFaKKHqSMN4Wsr/A9+v7ewAD5cEhA0T1P4m7MbJMiJOhxUhj/X+BFh2DamW+P2lT8mybj5wg8wnkQ2BteKA8Tawi6f9PRw2NRheO8tAi8o/npLnlmet0kc93mn+oLuqHw36w4+j5mkOl2FghkfGiUVhwrhkCP7KXQN+3TU87e+/HzQumlJ3nsE+6terVxkH3PmaUTsS5ONaODZfuxFpfb7RsoEl3skHf6d+tr+1nViLxxly7558Nc33C+W1mr0qiEvMLZ+kJ/CpGWBJ6CUJM3jm6hNe2eMuIPwEK2hxZob8c7n22VPap4K6a0bBRoydoDXaba+2sD7Ym6ivDO/DVyL44VeBBLyIiIBylDGQdZH+6SoWm90Qe/i7tnY/T5Ao5igT8f3cfQY1c3EsTfqmlDfrhmACBmwSlgkdVBLTprHL63JMY24LWmh4jhxsmMRZhCL4dze8su1w6pLN/pD1pGHtKYCEVbdTmaM3PblNRFf12XB7qosmQsgUndH4Vq3bTbU0s1pKjeDhRyLvFzvR0TBbo0pDLEoF1A/i5GVFWa7yLZNUDudQERRh7qv/xBl2excIaQ1sV4DSVm7bAE9l6Kp+yeHQJW2uN6Y3X8wu9gB9nv9l5HBze7wh8KE6PyWAOLYYqZg9/sAtsv/2GcQqXcKFF1zcA= \ No newline at end of file diff --git a/vendor/github.com/go-openapi/runtime/CODE_OF_CONDUCT.md b/vendor/github.com/go-openapi/runtime/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..9322b06 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/CODE_OF_CONDUCT.md @@ -0,0 +1,74 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of experience, +nationality, personal appearance, race, religion, or sexual identity and +orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or +advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at ivan+abuse@flanders.co.nz. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at [http://contributor-covenant.org/version/1/4][version] + +[homepage]: http://contributor-covenant.org +[version]: http://contributor-covenant.org/version/1/4/ diff --git a/vendor/github.com/go-openapi/runtime/LICENSE b/vendor/github.com/go-openapi/runtime/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/go-openapi/runtime/README.md b/vendor/github.com/go-openapi/runtime/README.md new file mode 100644 index 0000000..92c4070 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/README.md @@ -0,0 +1,5 @@ +# runtime [![Build Status](https://travis-ci.org/go-openapi/runtime.svg?branch=client-context)](https://travis-ci.org/go-openapi/runtime) [![codecov](https://codecov.io/gh/go-openapi/runtime/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/runtime) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) + +[![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/runtime/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/runtime?status.svg)](http://godoc.org/github.com/go-openapi/runtime) + +The runtime component for use in codegeneration or as untyped usage. diff --git a/vendor/github.com/go-openapi/runtime/bytestream.go b/vendor/github.com/go-openapi/runtime/bytestream.go new file mode 100644 index 0000000..02d7e2b --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/bytestream.go @@ -0,0 +1,45 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +import ( + "errors" + "io" +) + +// ByteStreamConsumer creates a consmer for byte streams, takes a writer and reads from the provided reader +func ByteStreamConsumer() Consumer { + return ConsumerFunc(func(r io.Reader, v interface{}) error { + wrtr, ok := v.(io.Writer) + if !ok { + return errors.New("ByteStreamConsumer can only deal with io.Writer") + } + + _, err := io.Copy(wrtr, r) + return err + }) +} + +// ByteStreamProducer creates a producer for byte streams, takes a reader, writes to a writer (essentially a pipe) +func ByteStreamProducer() Producer { + return ProducerFunc(func(w io.Writer, v interface{}) error { + rdr, ok := v.(io.Reader) + if !ok { + return errors.New("ByteStreamProducer can only deal with io.Reader") + } + _, err := io.Copy(w, rdr) + return err + }) +} diff --git a/vendor/github.com/go-openapi/runtime/client/auth_info.go b/vendor/github.com/go-openapi/runtime/client/auth_info.go new file mode 100644 index 0000000..290a3eb --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/client/auth_info.go @@ -0,0 +1,64 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "encoding/base64" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" +) + +// PassThroughAuth never manipulates the request +var PassThroughAuth runtime.ClientAuthInfoWriter + +func init() { + PassThroughAuth = runtime.ClientAuthInfoWriterFunc(func(_ runtime.ClientRequest, _ strfmt.Registry) error { return nil }) +} + +// BasicAuth provides a basic auth info writer +func BasicAuth(username, password string) runtime.ClientAuthInfoWriter { + return runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error { + encoded := base64.StdEncoding.EncodeToString([]byte(username + ":" + password)) + r.SetHeaderParam("Authorization", "Basic "+encoded) + return nil + }) +} + +// APIKeyAuth provides an API key auth info writer +func APIKeyAuth(name, in, value string) runtime.ClientAuthInfoWriter { + if in == "query" { + return runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error { + r.SetQueryParam(name, value) + return nil + }) + } + + if in == "header" { + return runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error { + r.SetHeaderParam(name, value) + return nil + }) + } + return nil +} + +// BearerToken provides a header based oauth2 bearer access token auth info writer +func BearerToken(token string) runtime.ClientAuthInfoWriter { + return runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error { + r.SetHeaderParam("Authorization", "Bearer "+token) + return nil + }) +} diff --git a/vendor/github.com/go-openapi/runtime/client/request.go b/vendor/github.com/go-openapi/runtime/client/request.go new file mode 100644 index 0000000..805da0d --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/client/request.go @@ -0,0 +1,270 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "bytes" + "fmt" + "io" + "io/ioutil" + "log" + "mime/multipart" + "net/http" + "net/url" + "os" + "path/filepath" + "strings" + "time" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" +) + +// NewRequest creates a new swagger http client request +func newRequest(method, pathPattern string, writer runtime.ClientRequestWriter) (*request, error) { + return &request{ + pathPattern: pathPattern, + method: method, + writer: writer, + header: make(http.Header), + query: make(url.Values), + timeout: DefaultTimeout, + }, nil +} + +// Request represents a swagger client request. +// +// This Request struct converts to a HTTP request. +// There might be others that convert to other transports. +// There is no error checking here, it is assumed to be used after a spec has been validated. +// so impossible combinations should not arise (hopefully). +// +// The main purpose of this struct is to hide the machinery of adding params to a transport request. +// The generated code only implements what is necessary to turn a param into a valid value for these methods. +type request struct { + pathPattern string + method string + writer runtime.ClientRequestWriter + + pathParams map[string]string + header http.Header + query url.Values + formFields url.Values + fileFields map[string]*os.File + payload interface{} + timeout time.Duration +} + +var ( + // ensure interface compliance + _ runtime.ClientRequest = new(request) +) + +// BuildHTTP creates a new http request based on the data from the params +func (r *request) BuildHTTP(mediaType string, producers map[string]runtime.Producer, registry strfmt.Registry) (*http.Request, error) { + // build the data + if err := r.writer.WriteToRequest(r, registry); err != nil { + return nil, err + } + + // create http request + path := r.pathPattern + for k, v := range r.pathParams { + path = strings.Replace(path, "{"+k+"}", v, -1) + } + + var body io.ReadCloser + var pr *io.PipeReader + var pw *io.PipeWriter + buf := bytes.NewBuffer(nil) + body = ioutil.NopCloser(buf) + if r.fileFields != nil { + pr, pw = io.Pipe() + body = pr + } + req, err := http.NewRequest(r.method, path, body) + if err != nil { + return nil, err + } + req.URL.RawQuery = r.query.Encode() + req.Header = r.header + + // check if this is a form type request + if len(r.formFields) > 0 || len(r.fileFields) > 0 { + // check if this is multipart + if len(r.fileFields) > 0 { + mp := multipart.NewWriter(pw) + req.Header.Set(runtime.HeaderContentType, mp.FormDataContentType()) + + go func() { + defer func() { + mp.Close() + pw.Close() + }() + + for fn, v := range r.formFields { + if len(v) > 0 { + if err := mp.WriteField(fn, v[0]); err != nil { + pw.CloseWithError(err) + log.Println(err) + } + } + } + + for fn, f := range r.fileFields { + wrtr, err := mp.CreateFormFile(fn, filepath.Base(f.Name())) + if err != nil { + pw.CloseWithError(err) + log.Println(err) + } + defer func() { + for _, ff := range r.fileFields { + ff.Close() + } + + }() + if _, err := io.Copy(wrtr, f); err != nil { + pw.CloseWithError(err) + log.Println(err) + } + } + + }() + return req, nil + } + + req.Header.Set(runtime.HeaderContentType, mediaType) + // write the form values as the body + buf.WriteString(r.formFields.Encode()) + return req, nil + } + + // if there is payload, use the producer to write the payload, and then + // set the header to the content-type appropriate for the payload produced + if r.payload != nil { + // TODO: infer most appropriate content type based on the producer used, + // and the `consumers` section of the spec/operation + req.Header.Set(runtime.HeaderContentType, mediaType) + if rdr, ok := r.payload.(io.ReadCloser); ok { + req.Body = rdr + return req, nil + } + + if rdr, ok := r.payload.(io.Reader); ok { + req.Body = ioutil.NopCloser(rdr) + return req, nil + } + + // set the content length of the request or else a chunked transfer is + // declared, and this corrupts outgoing JSON payloads. the content's + // length must be set prior to the body being written per the spec at + // https://golang.org/pkg/net/http + // + // If Body is present, Content-Length is <= 0 and TransferEncoding + // hasn't been set to "identity", Write adds + // "Transfer-Encoding: chunked" to the header. Body is closed + // after it is sent. + // + // to that end a temporary buffer, b, is created to produce the payload + // body, and then its size is used to set the request's content length + var b bytes.Buffer + producer := producers[mediaType] + if err := producer.Produce(&b, r.payload); err != nil { + return nil, err + } + req.ContentLength = int64(b.Len()) + if _, err := buf.Write(b.Bytes()); err != nil { + return nil, err + } + } + return req, nil +} + +// SetHeaderParam adds a header param to the request +// when there is only 1 value provided for the varargs, it will set it. +// when there are several values provided for the varargs it will add it (no overriding) +func (r *request) SetHeaderParam(name string, values ...string) error { + if r.header == nil { + r.header = make(http.Header) + } + r.header[http.CanonicalHeaderKey(name)] = values + return nil +} + +// SetQueryParam adds a query param to the request +// when there is only 1 value provided for the varargs, it will set it. +// when there are several values provided for the varargs it will add it (no overriding) +func (r *request) SetQueryParam(name string, values ...string) error { + if r.header == nil { + r.query = make(url.Values) + } + r.query[name] = values + return nil +} + +// SetFormParam adds a forn param to the request +// when there is only 1 value provided for the varargs, it will set it. +// when there are several values provided for the varargs it will add it (no overriding) +func (r *request) SetFormParam(name string, values ...string) error { + if r.formFields == nil { + r.formFields = make(url.Values) + } + r.formFields[name] = values + return nil +} + +// SetPathParam adds a path param to the request +func (r *request) SetPathParam(name string, value string) error { + if r.pathParams == nil { + r.pathParams = make(map[string]string) + } + + r.pathParams[name] = value + return nil +} + +// SetFileParam adds a file param to the request +func (r *request) SetFileParam(name string, file *os.File) error { + fi, err := os.Stat(file.Name()) + if err != nil { + return err + } + if fi.IsDir() { + return fmt.Errorf("%q is a directory, only files are supported", file.Name()) + } + + if r.fileFields == nil { + r.fileFields = make(map[string]*os.File) + } + if r.formFields == nil { + r.formFields = make(url.Values) + } + + r.fileFields[name] = file + return nil +} + +// SetBodyParam sets a body parameter on the request. +// This does not yet serialze the object, this happens as late as possible. +func (r *request) SetBodyParam(payload interface{}) error { + r.payload = payload + return nil +} + +// SetTimeout sets the timeout for a request +func (r *request) SetTimeout(timeout time.Duration) error { + r.timeout = timeout + return nil +} diff --git a/vendor/github.com/go-openapi/runtime/client/response.go b/vendor/github.com/go-openapi/runtime/client/response.go new file mode 100644 index 0000000..bd23858 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/client/response.go @@ -0,0 +1,44 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "io" + "net/http" + + "github.com/go-openapi/runtime" +) + +var _ runtime.ClientResponse = response{} + +type response struct { + resp *http.Response +} + +func (r response) Code() int { + return r.resp.StatusCode +} + +func (r response) Message() string { + return r.resp.Status +} + +func (r response) GetHeader(name string) string { + return r.resp.Header.Get(name) +} + +func (r response) Body() io.ReadCloser { + return r.resp.Body +} diff --git a/vendor/github.com/go-openapi/runtime/client/runtime.go b/vendor/github.com/go-openapi/runtime/client/runtime.go new file mode 100644 index 0000000..49fd244 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/client/runtime.go @@ -0,0 +1,253 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "fmt" + "mime" + "net/http" + "net/http/httputil" + "os" + "path" + "strings" + "sync" + "time" + + "golang.org/x/net/context" + "golang.org/x/net/context/ctxhttp" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" +) + +// DefaultTimeout the default request timeout +var DefaultTimeout = 30 * time.Second + +// Runtime represents an API client that uses the transport +// to make http requests based on a swagger specification. +type Runtime struct { + DefaultMediaType string + DefaultAuthentication runtime.ClientAuthInfoWriter + Consumers map[string]runtime.Consumer + Producers map[string]runtime.Producer + + Transport http.RoundTripper + Jar http.CookieJar + //Spec *spec.Document + Host string + BasePath string + Formats strfmt.Registry + Debug bool + Context context.Context + + clientOnce *sync.Once + client *http.Client + schemes []string + do func(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) +} + +// New creates a new default runtime for a swagger api runtime.Client +func New(host, basePath string, schemes []string) *Runtime { + var rt Runtime + rt.DefaultMediaType = runtime.JSONMime + + // TODO: actually infer this stuff from the spec + rt.Consumers = map[string]runtime.Consumer{ + runtime.JSONMime: runtime.JSONConsumer(), + runtime.XMLMime: runtime.XMLConsumer(), + runtime.TextMime: runtime.TextConsumer(), + runtime.DefaultMime: runtime.ByteStreamConsumer(), + } + rt.Producers = map[string]runtime.Producer{ + runtime.JSONMime: runtime.JSONProducer(), + runtime.XMLMime: runtime.XMLProducer(), + runtime.TextMime: runtime.TextProducer(), + runtime.DefaultMime: runtime.ByteStreamProducer(), + } + rt.Transport = http.DefaultTransport + rt.Jar = nil + rt.Host = host + rt.BasePath = basePath + rt.Context = context.Background() + rt.clientOnce = new(sync.Once) + if !strings.HasPrefix(rt.BasePath, "/") { + rt.BasePath = "/" + rt.BasePath + } + rt.Debug = os.Getenv("DEBUG") == "1" + if len(schemes) > 0 { + rt.schemes = schemes + } + rt.do = ctxhttp.Do + return &rt +} + +// NewWithClient allows you to create a new transport with a configured http.Client +func NewWithClient(host, basePath string, schemes []string, client *http.Client) *Runtime { + rt := New(host, basePath, schemes) + if client != nil { + rt.clientOnce.Do(func() { + rt.client = client + }) + } + return rt +} + +func (r *Runtime) pickScheme(schemes []string) string { + if v := r.selectScheme(r.schemes); v != "" { + return v + } + if v := r.selectScheme(schemes); v != "" { + return v + } + return "http" +} + +func (r *Runtime) selectScheme(schemes []string) string { + schLen := len(schemes) + if schLen == 0 { + return "" + } + + scheme := schemes[0] + // prefer https, but skip when not possible + if scheme != "https" && schLen > 1 { + for _, sch := range schemes { + if sch == "https" { + scheme = sch + break + } + } + } + return scheme +} + +// Submit a request and when there is a body on success it will turn that into the result +// all other things are turned into an api error for swagger which retains the status code +func (r *Runtime) Submit(operation *runtime.ClientOperation) (interface{}, error) { + params, readResponse, auth := operation.Params, operation.Reader, operation.AuthInfo + + request, err := newRequest(operation.Method, operation.PathPattern, params) + if err != nil { + return nil, err + } + + var accept []string + for _, mimeType := range operation.ProducesMediaTypes { + accept = append(accept, mimeType) + } + request.SetHeaderParam(runtime.HeaderAccept, accept...) + + if auth == nil && r.DefaultAuthentication != nil { + auth = r.DefaultAuthentication + } + if auth != nil { + if err := auth.AuthenticateRequest(request, r.Formats); err != nil { + return nil, err + } + } + + // TODO: pick appropriate media type + cmt := r.DefaultMediaType + if len(operation.ConsumesMediaTypes) > 0 { + cmt = operation.ConsumesMediaTypes[0] + } + + req, err := request.BuildHTTP(cmt, r.Producers, r.Formats) + if err != nil { + return nil, err + } + req.URL.Scheme = r.pickScheme(operation.Schemes) + req.URL.Host = r.Host + var reinstateSlash bool + if req.URL.Path != "" && req.URL.Path != "/" && req.URL.Path[len(req.URL.Path)-1] == '/' { + reinstateSlash = true + } + req.URL.Path = path.Join(r.BasePath, req.URL.Path) + if reinstateSlash { + req.URL.Path = req.URL.Path + "/" + } + + r.clientOnce.Do(func() { + r.client = &http.Client{ + Transport: r.Transport, + Jar: r.Jar, + } + }) + + if r.Debug { + b, err2 := httputil.DumpRequestOut(req, true) + if err2 != nil { + return nil, err2 + } + fmt.Fprintln(os.Stderr, string(b)) + } + + var hasTimeout bool + pctx := operation.Context + if pctx == nil { + pctx = r.Context + } else { + hasTimeout = true + } + if pctx == nil { + pctx = context.Background() + } + var ctx context.Context + var cancel context.CancelFunc + if hasTimeout { + ctx, cancel = context.WithCancel(pctx) + } else { + ctx, cancel = context.WithTimeout(pctx, request.timeout) + } + defer cancel() + + client := operation.Client + if client == nil { + client = r.client + } + if r.do == nil { + r.do = ctxhttp.Do + } + res, err := r.do(ctx, client, req) // make requests, by default follows 10 redirects before failing + if err != nil { + return nil, err + } + defer res.Body.Close() + + if r.Debug { + b, err2 := httputil.DumpResponse(res, true) + if err2 != nil { + return nil, err2 + } + fmt.Fprintln(os.Stderr, string(b)) + } + + ct := res.Header.Get(runtime.HeaderContentType) + if ct == "" { // this should really really never occur + ct = r.DefaultMediaType + } + + mt, _, err := mime.ParseMediaType(ct) + if err != nil { + return nil, fmt.Errorf("parse content type: %s", err) + } + + cons, ok := r.Consumers[mt] + if !ok { + // scream about not knowing what to do + return nil, fmt.Errorf("no consumer: %q", ct) + } + return readResponse.ReadResponse(response{res}, cons) +} diff --git a/vendor/github.com/go-openapi/runtime/client_auth_info.go b/vendor/github.com/go-openapi/runtime/client_auth_info.go new file mode 100644 index 0000000..c6c97d9 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/client_auth_info.go @@ -0,0 +1,30 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +import "github.com/go-openapi/strfmt" + +// A ClientAuthInfoWriterFunc converts a function to a request writer interface +type ClientAuthInfoWriterFunc func(ClientRequest, strfmt.Registry) error + +// AuthenticateRequest adds authentication data to the request +func (fn ClientAuthInfoWriterFunc) AuthenticateRequest(req ClientRequest, reg strfmt.Registry) error { + return fn(req, reg) +} + +// A ClientAuthInfoWriter implementor knows how to write authentication info to a request +type ClientAuthInfoWriter interface { + AuthenticateRequest(ClientRequest, strfmt.Registry) error +} diff --git a/vendor/github.com/go-openapi/runtime/client_operation.go b/vendor/github.com/go-openapi/runtime/client_operation.go new file mode 100644 index 0000000..ccf8ff7 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/client_operation.go @@ -0,0 +1,42 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +import ( + "net/http" + + "golang.org/x/net/context" +) + +// ClientOperation represents the context for a swagger operation to be submitted to the transport +type ClientOperation struct { + ID string + Method string + PathPattern string + ProducesMediaTypes []string + ConsumesMediaTypes []string + Schemes []string + AuthInfo ClientAuthInfoWriter + Params ClientRequestWriter + Reader ClientResponseReader + Context context.Context + Client *http.Client +} + +// A ClientTransport implementor knows how to submit Request objects to some destination +type ClientTransport interface { + //Submit(string, RequestWriter, ResponseReader, AuthInfoWriter) (interface{}, error) + Submit(*ClientOperation) (interface{}, error) +} diff --git a/vendor/github.com/go-openapi/runtime/client_request.go b/vendor/github.com/go-openapi/runtime/client_request.go new file mode 100644 index 0000000..7b6e463 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/client_request.go @@ -0,0 +1,53 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +import ( + "os" + "time" + + "github.com/go-openapi/strfmt" +) + +// ClientRequestWriterFunc converts a function to a request writer interface +type ClientRequestWriterFunc func(ClientRequest, strfmt.Registry) error + +// WriteToRequest adds data to the request +func (fn ClientRequestWriterFunc) WriteToRequest(req ClientRequest, reg strfmt.Registry) error { + return fn(req, reg) +} + +// ClientRequestWriter is an interface for things that know how to write to a request +type ClientRequestWriter interface { + WriteToRequest(ClientRequest, strfmt.Registry) error +} + +// ClientRequest is an interface for things that know how to +// add information to a swagger client request +type ClientRequest interface { + SetHeaderParam(string, ...string) error + + SetQueryParam(string, ...string) error + + SetFormParam(string, ...string) error + + SetPathParam(string, string) error + + SetFileParam(string, *os.File) error + + SetBodyParam(interface{}) error + + SetTimeout(time.Duration) error +} diff --git a/vendor/github.com/go-openapi/runtime/client_response.go b/vendor/github.com/go-openapi/runtime/client_response.go new file mode 100644 index 0000000..729e18b --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/client_response.go @@ -0,0 +1,63 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +import ( + "fmt" + "io" +) + +// A ClientResponse represents a client response +// This bridges between responses obtained from different transports +type ClientResponse interface { + Code() int + Message() string + GetHeader(string) string + Body() io.ReadCloser +} + +// A ClientResponseReaderFunc turns a function into a ClientResponseReader interface implementation +type ClientResponseReaderFunc func(ClientResponse, Consumer) (interface{}, error) + +// ReadResponse reads the response +func (read ClientResponseReaderFunc) ReadResponse(resp ClientResponse, consumer Consumer) (interface{}, error) { + return read(resp, consumer) +} + +// A ClientResponseReader is an interface for things want to read a response. +// An application of this is to create structs from response values +type ClientResponseReader interface { + ReadResponse(ClientResponse, Consumer) (interface{}, error) +} + +// NewAPIError creates a new API error +func NewAPIError(opName string, payload interface{}, code int) *APIError { + return &APIError{ + OperationName: opName, + Response: payload, + Code: code, + } +} + +// APIError wraps an error model and captures the status code +type APIError struct { + OperationName string + Response interface{} + Code int +} + +func (a *APIError) Error() string { + return fmt.Sprintf("%s (status %d): %+v ", a.OperationName, a.Code, a.Response) +} diff --git a/vendor/github.com/go-openapi/runtime/constants.go b/vendor/github.com/go-openapi/runtime/constants.go new file mode 100644 index 0000000..04edda7 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/constants.go @@ -0,0 +1,41 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +const ( + // HeaderContentType represents a http content-type header, it's value is supposed to be a mime type + HeaderContentType = "Content-Type" + + // HeaderTransferEncoding represents a http transfer-encoding header. + HeaderTransferEncoding = "Transfer-Encoding" + + // HeaderAccept the Accept header + HeaderAccept = "Accept" + + charsetKey = "charset" + + // DefaultMime the default fallback mime type + DefaultMime = "application/octet-stream" + // JSONMime the json mime type + JSONMime = "application/json" + // YAMLMime the yaml mime type + YAMLMime = "application/x-yaml" + // XMLMime the xml mime type + XMLMime = "application/xml" + // TextMime the text mime type + TextMime = "text/plain" + // MultipartFormMime the multipart form mime type + MultipartFormMime = "multipart/form-data" +) diff --git a/vendor/github.com/go-openapi/runtime/discard.go b/vendor/github.com/go-openapi/runtime/discard.go new file mode 100644 index 0000000..0d390cf --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/discard.go @@ -0,0 +1,9 @@ +package runtime + +import "io" + +// DiscardConsumer does absolutely nothing, it's a black hole. +var DiscardConsumer = ConsumerFunc(func(_ io.Reader, _ interface{}) error { return nil }) + +// DiscardProducer does absolutely nothing, it's a black hole. +var DiscardProducer = ProducerFunc(func(_ io.Writer, _ interface{}) error { return nil }) diff --git a/vendor/github.com/go-openapi/runtime/headers.go b/vendor/github.com/go-openapi/runtime/headers.go new file mode 100644 index 0000000..4d111db --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/headers.go @@ -0,0 +1,45 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +import ( + "mime" + "net/http" + + "github.com/go-openapi/errors" +) + +// ContentType parses a content type header +func ContentType(headers http.Header) (string, string, error) { + ct := headers.Get(HeaderContentType) + orig := ct + if ct == "" { + ct = DefaultMime + } + if ct == "" { + return "", "", nil + } + + mt, opts, err := mime.ParseMediaType(ct) + if err != nil { + return "", "", errors.NewParseError(HeaderContentType, "header", orig, err) + } + + if cs, ok := opts[charsetKey]; ok { + return mt, cs, nil + } + + return mt, "", nil +} diff --git a/vendor/github.com/go-openapi/runtime/interfaces.go b/vendor/github.com/go-openapi/runtime/interfaces.go new file mode 100644 index 0000000..157346f --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/interfaces.go @@ -0,0 +1,94 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +import ( + "io" + "mime/multipart" + + "github.com/go-openapi/strfmt" +) + +// File represents an uploaded file. +type File struct { + Data multipart.File + Header *multipart.FileHeader +} + +// OperationHandlerFunc an adapter for a function to the OperationHandler interface +type OperationHandlerFunc func(interface{}) (interface{}, error) + +// Handle implements the operation handler interface +func (s OperationHandlerFunc) Handle(data interface{}) (interface{}, error) { + return s(data) +} + +// OperationHandler a handler for a swagger operation +type OperationHandler interface { + Handle(interface{}) (interface{}, error) +} + +// ConsumerFunc represents a function that can be used as a consumer +type ConsumerFunc func(io.Reader, interface{}) error + +// Consume consumes the reader into the data parameter +func (fn ConsumerFunc) Consume(reader io.Reader, data interface{}) error { + return fn(reader, data) +} + +// Consumer implementations know how to bind the values on the provided interface to +// data provided by the request body +type Consumer interface { + // Consume performs the binding of request values + Consume(io.Reader, interface{}) error +} + +// ProducerFunc represents a function that can be used as a producer +type ProducerFunc func(io.Writer, interface{}) error + +// Produce produces the response for the provided data +func (f ProducerFunc) Produce(writer io.Writer, data interface{}) error { + return f(writer, data) +} + +// Producer implementations know how to turn the provided interface into a valid +// HTTP response +type Producer interface { + // Produce writes to the http response + Produce(io.Writer, interface{}) error +} + +// AuthenticatorFunc turns a function into an authenticator +type AuthenticatorFunc func(interface{}) (bool, interface{}, error) + +// Authenticate authenticates the request with the provided data +func (f AuthenticatorFunc) Authenticate(params interface{}) (bool, interface{}, error) { + return f(params) +} + +// Authenticator represents an authentication strategy +// implementations of Authenticator know how to authenticate the +// request data and translate that into a valid principal object or an error +type Authenticator interface { + Authenticate(interface{}) (bool, interface{}, error) +} + +// Validatable types implementing this interface allow customizing their validation +// this will be used instead of the reflective valditation based on the spec document. +// the implementations are assumed to have been generated by the swagger tool so they should +// contain all the validations obtained from the spec +type Validatable interface { + Validate(strfmt.Registry) error +} diff --git a/vendor/github.com/go-openapi/runtime/json.go b/vendor/github.com/go-openapi/runtime/json.go new file mode 100644 index 0000000..81ee360 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/json.go @@ -0,0 +1,37 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +import ( + "encoding/json" + "io" +) + +// JSONConsumer creates a new JSON consumer +func JSONConsumer() Consumer { + return ConsumerFunc(func(reader io.Reader, data interface{}) error { + dec := json.NewDecoder(reader) + dec.UseNumber() // preserve number formats + return dec.Decode(data) + }) +} + +// JSONProducer creates a new JSON producer +func JSONProducer() Producer { + return ProducerFunc(func(writer io.Writer, data interface{}) error { + enc := json.NewEncoder(writer) + return enc.Encode(data) + }) +} diff --git a/vendor/github.com/go-openapi/runtime/request.go b/vendor/github.com/go-openapi/runtime/request.go new file mode 100644 index 0000000..87b73da --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/request.go @@ -0,0 +1,77 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +import ( + "io" + "net/http" + "strings" + + "github.com/go-openapi/swag" +) + +// CanHaveBody returns true if this method can have a body +func CanHaveBody(method string) bool { + mn := strings.ToUpper(method) + return mn == "POST" || mn == "PUT" || mn == "PATCH" || mn == "DELETE" +} + +// IsSafe returns true if this is a request with a safe method +func IsSafe(r *http.Request) bool { + mn := strings.ToUpper(r.Method) + return mn == "GET" || mn == "HEAD" +} + +// AllowsBody returns true if the request allows for a body +func AllowsBody(r *http.Request) bool { + mn := strings.ToUpper(r.Method) + return mn != "HEAD" +} + +// HasBody returns true if this method needs a content-type +func HasBody(r *http.Request) bool { + return len(r.TransferEncoding) > 0 || r.ContentLength > 0 +} + +// JSONRequest creates a new http request with json headers set +func JSONRequest(method, urlStr string, body io.Reader) (*http.Request, error) { + req, err := http.NewRequest(method, urlStr, body) + if err != nil { + return nil, err + } + req.Header.Add(HeaderContentType, JSONMime) + req.Header.Add(HeaderAccept, JSONMime) + return req, nil +} + +// Gettable for things with a method GetOK(string) (data string, hasKey bool, hasValue bool) +type Gettable interface { + GetOK(string) ([]string, bool, bool) +} + +// ReadSingleValue reads a single value from the source +func ReadSingleValue(values Gettable, name string) string { + vv, _, hv := values.GetOK(name) + if hv { + return vv[len(vv)-1] + } + return "" +} + +// ReadCollectionValue reads a collection value from a string data source +func ReadCollectionValue(values Gettable, name, collectionFormat string) []string { + v := ReadSingleValue(values, name) + return swag.SplitByFormat(v, collectionFormat) +} diff --git a/vendor/github.com/go-openapi/runtime/statuses.go b/vendor/github.com/go-openapi/runtime/statuses.go new file mode 100644 index 0000000..5d49514 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/statuses.go @@ -0,0 +1,90 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +// Statuses lists the most common HTTP status codes to default message +// taken from http://status.es +var Statuses = map[int]string{ + 100: "Continue", + 101: "Switching Protocols", + 102: "Processing", + 103: "Checkpoint", + 122: "URI too long", + 200: "OK", + 201: "Created", + 202: "Accepted", + 203: "Request Processed", + 204: "No Content", + 205: "Reset Content", + 206: "Partial Content", + 207: "Multi-Status", + 208: "Already Reported", + 226: "IM Used", + 300: "Multiple Choices", + 301: "Moved Permanently", + 302: "Found", + 303: "See Other", + 304: "Not Modified", + 305: "Use Proxy", + 306: "Switch Proxy", + 307: "Temporary Redirect", + 308: "Permanent Redirect", + 400: "Bad Request", + 401: "Unauthorized", + 402: "Payment Required", + 403: "Forbidden", + 404: "Not Found", + 405: "Method Not Allowed", + 406: "Not Acceptable", + 407: "Proxy Authentication Required", + 408: "Request Timeout", + 409: "Conflict", + 410: "Gone", + 411: "Length Required", + 412: "Precondition Failed", + 413: "Request Entity Too Large", + 414: "Request-URI Too Long", + 415: "Unsupported Media Type", + 416: "Request Range Not Satisfiable", + 417: "Expectation Failed", + 418: "I'm a teapot", + 420: "Enhance Your Calm", + 422: "Unprocessable Entity", + 423: "Locked", + 424: "Failed Dependency", + 426: "Upgrade Required", + 428: "Precondition Required", + 429: "Too Many Requests", + 431: "Request Header Fields Too Large", + 444: "No Response", + 449: "Retry With", + 450: "Blocked by Windows Parental Controls", + 451: "Wrong Exchange Server", + 499: "Client Closed Request", + 500: "Internal Server Error", + 501: "Not Implemented", + 502: "Bad Gateway", + 503: "Service Unavailable", + 504: "Gateway Timeout", + 505: "HTTP Version Not Supported", + 506: "Variant Also Negotiates", + 507: "Insufficient Storage", + 508: "Loop Detected", + 509: "Bandwidth Limit Exceeded", + 510: "Not Extended", + 511: "Network Authentication Required", + 598: "Network read timeout error", + 599: "Network connect timeout error", +} diff --git a/vendor/github.com/go-openapi/runtime/text.go b/vendor/github.com/go-openapi/runtime/text.go new file mode 100644 index 0000000..1ab4d24 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/text.go @@ -0,0 +1,52 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +import ( + "bytes" + "io" + "unsafe" + + "github.com/go-openapi/swag" +) + +// TextConsumer creates a new text consumer +func TextConsumer() Consumer { + return ConsumerFunc(func(reader io.Reader, data interface{}) error { + buf := new(bytes.Buffer) + _, err := buf.ReadFrom(reader) + if err != nil { + return err + } + b := buf.Bytes() + *(data.(*string)) = *(*string)(unsafe.Pointer(&b)) + return nil + }) +} + +// TextProducer creates a new text producer +func TextProducer() Producer { + return ProducerFunc(func(writer io.Writer, data interface{}) error { + var buf *bytes.Buffer + switch tped := data.(type) { + case *string: + buf = bytes.NewBufferString(swag.StringValue(tped)) + case string: + buf = bytes.NewBufferString(tped) + } + _, err := buf.WriteTo(writer) + return err + }) +} diff --git a/vendor/github.com/go-openapi/runtime/values.go b/vendor/github.com/go-openapi/runtime/values.go new file mode 100644 index 0000000..11f5732 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/values.go @@ -0,0 +1,19 @@ +package runtime + +// Values typically represent parameters on a http request. +type Values map[string][]string + +// GetOK returns the values collection for the given key. +// When the key is present in the map it will return true for hasKey. +// When the value is not empty it will return true for hasValue. +func (v Values) GetOK(key string) (value []string, hasKey bool, hasValue bool) { + value, hasKey = v[key] + if !hasKey { + return + } + if len(value) == 0 { + return + } + hasValue = true + return +} diff --git a/vendor/github.com/go-openapi/runtime/xml.go b/vendor/github.com/go-openapi/runtime/xml.go new file mode 100644 index 0000000..821c739 --- /dev/null +++ b/vendor/github.com/go-openapi/runtime/xml.go @@ -0,0 +1,36 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package runtime + +import ( + "encoding/xml" + "io" +) + +// XMLConsumer creates a new XML consumer +func XMLConsumer() Consumer { + return ConsumerFunc(func(reader io.Reader, data interface{}) error { + dec := xml.NewDecoder(reader) + return dec.Decode(data) + }) +} + +// XMLProducer creates a new XML producer +func XMLProducer() Producer { + return ProducerFunc(func(writer io.Writer, data interface{}) error { + enc := xml.NewEncoder(writer) + return enc.Encode(data) + }) +} diff --git a/vendor/github.com/go-openapi/spec/.gitignore b/vendor/github.com/go-openapi/spec/.gitignore new file mode 100644 index 0000000..dd91ed6 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/.gitignore @@ -0,0 +1,2 @@ +secrets.yml +coverage.out diff --git a/vendor/github.com/go-openapi/spec/.travis.yml b/vendor/github.com/go-openapi/spec/.travis.yml new file mode 100644 index 0000000..ea80ef2 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/.travis.yml @@ -0,0 +1,16 @@ +language: go +go: +- 1.7 +install: +- go get -u github.com/stretchr/testify +- go get -u github.com/go-openapi/swag +- go get -u gopkg.in/yaml.v2 +- go get -u github.com/go-openapi/jsonpointer +- go get -u github.com/go-openapi/jsonreference +script: +- go test -v -race -cover -coverprofile=coverage.txt -covermode=atomic ./... +after_success: +- bash <(curl -s https://codecov.io/bash) +notifications: + slack: + secure: QUWvCkBBK09GF7YtEvHHVt70JOkdlNBG0nIKu/5qc4/nW5HP8I2w0SEf/XR2je0eED1Qe3L/AfMCWwrEj+IUZc3l4v+ju8X8R3Lomhme0Eb0jd1MTMCuPcBT47YCj0M7RON7vXtbFfm1hFJ/jLe5+9FXz0hpXsR24PJc5ZIi/ogNwkaPqG4BmndzecpSh0vc2FJPZUD9LT0I09REY/vXR0oQAalLkW0asGD5taHZTUZq/kBpsNxaAFrLM23i4mUcf33M5fjLpvx5LRICrX/57XpBrDh2TooBU6Qj3CgoY0uPRYUmSNxbVx1czNzl2JtEpb5yjoxfVPQeg0BvQM00G8LJINISR+ohrjhkZmAqchDupAX+yFrxTtORa78CtnIL6z/aTNlgwwVD8kvL/1pFA/JWYmKDmz93mV/+6wubGzNSQCstzjkFA4/iZEKewKUoRIAi/fxyscP6L/rCpmY/4llZZvrnyTqVbt6URWpopUpH4rwYqreXAtJxJsfBJIeSmUIiDIOMGkCTvyTEW3fWGmGoqWtSHLoaWDyAIGb7azb+KvfpWtEcoPFWfSWU+LGee0A/YsUhBl7ADB9A0CJEuR8q4BPpKpfLwPKSiKSAXL7zDkyjExyhtgqbSl2jS+rKIHOZNL8JkCcTP2MKMVd563C5rC5FMKqu3S9m2b6380E= diff --git a/vendor/github.com/go-openapi/spec/CODE_OF_CONDUCT.md b/vendor/github.com/go-openapi/spec/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..9322b06 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/CODE_OF_CONDUCT.md @@ -0,0 +1,74 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of experience, +nationality, personal appearance, race, religion, or sexual identity and +orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or +advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at ivan+abuse@flanders.co.nz. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at [http://contributor-covenant.org/version/1/4][version] + +[homepage]: http://contributor-covenant.org +[version]: http://contributor-covenant.org/version/1/4/ diff --git a/vendor/github.com/go-openapi/spec/LICENSE b/vendor/github.com/go-openapi/spec/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/go-openapi/spec/README.md b/vendor/github.com/go-openapi/spec/README.md new file mode 100644 index 0000000..1d16220 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/README.md @@ -0,0 +1,5 @@ +# OAI object model [![Build Status](https://travis-ci.org/go-openapi/spec.svg?branch=master)](https://travis-ci.org/go-openapi/spec) [![codecov](https://codecov.io/gh/go-openapi/spec/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/spec) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) + +[![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/spec/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/spec?status.svg)](http://godoc.org/github.com/go-openapi/spec) + +The object model for OpenAPI specification documents diff --git a/vendor/github.com/go-openapi/spec/bindata.go b/vendor/github.com/go-openapi/spec/bindata.go new file mode 100644 index 0000000..54b98e6 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/bindata.go @@ -0,0 +1,260 @@ +// Code generated by go-bindata. +// sources: +// schemas/jsonschema-draft-04.json +// schemas/v2/schema.json +// DO NOT EDIT! + +package spec + +import ( + "bytes" + "compress/gzip" + "fmt" + "io" + "io/ioutil" + "os" + "path/filepath" + "strings" + "time" +) + +func bindataRead(data []byte, name string) ([]byte, error) { + gz, err := gzip.NewReader(bytes.NewBuffer(data)) + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + + var buf bytes.Buffer + _, err = io.Copy(&buf, gz) + clErr := gz.Close() + + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + if clErr != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +type asset struct { + bytes []byte + info os.FileInfo +} + +type bindataFileInfo struct { + name string + size int64 + mode os.FileMode + modTime time.Time +} + +func (fi bindataFileInfo) Name() string { + return fi.name +} +func (fi bindataFileInfo) Size() int64 { + return fi.size +} +func (fi bindataFileInfo) Mode() os.FileMode { + return fi.mode +} +func (fi bindataFileInfo) ModTime() time.Time { + return fi.modTime +} +func (fi bindataFileInfo) IsDir() bool { + return false +} +func (fi bindataFileInfo) Sys() interface{} { + return nil +} + +var _jsonschemaDraft04JSON = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xc4\x57\x3b\x6f\xdb\x3e\x10\xdf\xf3\x29\x08\x26\x63\xf2\x97\xff\x40\x27\x6f\x45\xbb\x18\x68\xd1\x0c\xdd\x0c\x0f\xb4\x75\xb2\x19\x50\xa4\x42\x51\x81\x0d\x43\xdf\xbd\xa0\xa8\x07\x29\x91\x92\x2d\xbb\x8d\x97\x28\xbc\xd7\xef\x8e\xf7\xe2\xf9\x01\x21\x84\x30\x8d\xf1\x12\xe1\x83\x52\xd9\x32\x8a\xde\x72\xc1\x5f\xf2\xdd\x01\x52\xf2\x9f\x90\xfb\x28\x96\x24\x51\x2f\x8b\x2f\x91\x39\x7b\xc4\xcf\x46\xe8\xc9\xfc\x3f\x43\x32\x86\x7c\x27\x69\xa6\xa8\xe0\x5a\xfa\x9b\x90\x80\x0c\x0b\x4a\x41\x91\x5a\x45\xc7\x9d\x50\x4e\x35\x73\x8e\x97\xc8\x20\xae\x08\x86\xed\xab\x94\xe4\xe4\x10\x2a\xa2\x3a\x65\xa0\x95\x93\x8a\xfc\xec\x12\x53\xca\x57\x0a\x52\xad\xef\xff\x1e\x89\xd6\xe7\x67\x84\x9f\x24\x24\x5a\xc5\x23\x46\x65\xcb\x54\x76\xfc\x38\x13\x39\x55\xf4\x03\x56\x5c\xc1\x1e\x64\x18\x04\xad\x19\x86\x30\x68\x5a\xa4\x78\x89\x16\x97\xe8\xff\x0e\x09\x29\x98\x5a\x0c\xed\x10\xc6\x7e\x69\xa8\x6b\x07\x76\x64\x45\x2e\xea\x63\x45\xe5\xb3\x66\x8e\x8d\x4e\x0d\x01\x95\x68\xe3\x85\x91\xd3\x34\x63\xf0\xfb\x94\x41\x3e\x34\x0d\xbc\x72\x60\xdd\x46\x1a\xe1\xad\x10\x0c\x08\xd7\x9f\xad\xe3\x08\xf3\x82\x31\xf3\x37\xdd\x9a\x13\xb1\x7d\x83\x9d\xd2\x5f\xb9\x92\x94\xef\x71\xc8\x7e\x45\x9d\x73\xcf\xd6\x65\x36\x7c\x8d\xa9\xf2\xf2\x94\x28\x38\x7d\x2f\xa0\xa1\x2a\x59\x40\x07\xf3\xc1\x02\xdb\xda\x68\x1c\x33\xa7\x99\x14\x19\x48\x45\x7b\xd1\x33\x45\x17\xf0\xa6\x46\xd9\x03\x92\x08\x99\x12\x7d\x57\xb8\x90\x14\x7b\x63\xd5\x15\xe5\xbd\x35\x2b\xaa\x18\x4c\xea\xf5\x8a\xba\xf5\x3e\x4b\x41\x93\xa5\x67\xfb\x38\x2d\x98\xa2\x19\x83\x2a\xf7\x03\x6a\x9b\x74\x0b\x56\x5e\x8f\x02\xc7\x1d\x2b\x72\xfa\x01\x3f\x5b\x16\xf7\xc6\x6d\xfb\xe4\x58\xb3\x8c\x1b\xf7\x0a\x77\x86\xa6\xb4\xb4\xf5\xe4\x92\xbb\xa0\x24\x84\xe5\x01\x84\xad\x13\x37\x21\x9c\xd2\x72\x0b\x42\x72\xfc\x01\x7c\xaf\x0e\xbd\x9e\x3b\xd5\xbc\x1c\x1f\xaf\xd6\xd0\xb6\x52\xb7\xdf\x12\xa5\x40\x4e\xe7\x68\xb0\x78\x24\xec\xe1\xe8\x0f\x26\x89\xe3\x0a\x0a\x61\x4d\x23\xe9\xf7\x70\x7e\x32\x3d\xdc\x39\xd6\xbf\xf3\x30\xd0\xfd\xf6\x55\xb3\x79\x27\x96\xfe\x6d\x82\x37\x73\xf6\x8f\x36\x3a\x03\xa4\x6d\x7d\x1c\x9e\x73\x35\xf6\x18\xbf\x15\x76\x4a\x8e\x2b\xcf\x00\xbf\x2a\x99\xae\x55\xe0\xcf\x25\x77\x68\xfc\x95\xba\x79\x75\x06\xcb\x5c\x77\x67\x69\xf1\xfb\x2c\xe1\xbd\xa0\x12\xe2\x31\x45\xf6\x30\x0f\x14\xc8\xab\x7f\x60\x4e\x27\xe0\x3f\xaf\x92\xd0\x6a\x8a\x82\xdb\xc0\xa4\xbb\x63\x65\x34\x0d\x28\xb0\x6b\x7c\x1e\x1e\xd3\x51\xc7\x6e\xf4\x33\x60\xc5\x90\x01\x8f\x81\xef\xee\x88\x68\x90\x69\x23\xb9\x8a\x2e\x69\x98\x7d\xa6\x91\x32\x1a\xc8\x6e\x9c\x13\x7f\x10\xea\xcd\xfd\x4e\xef\xa6\xb1\x25\xd9\xde\x22\x8d\xfa\x59\x63\xc5\x0d\x80\xf5\x28\xf1\xd6\xb9\x37\x9e\xa3\xee\xb5\x4c\xbe\x37\xe0\x55\xc6\x27\x82\x75\x49\xd0\xda\xe0\xb9\x1d\xca\xbf\x5b\xd4\xcf\xbf\x0b\x47\xac\x2d\x59\x07\xfe\x7a\x49\xc1\x61\xa6\x24\x17\x2a\xf0\xbe\x2e\xdb\x17\x7f\xa0\x3c\x7d\x4b\xf3\xba\xdb\xc3\xed\x06\xee\xdb\x5e\xd7\xdd\x42\x5c\x47\xb2\xb3\x68\x75\x8c\xf2\xe1\x4f\x00\x00\x00\xff\xff\x4e\x9b\x8d\xdf\x17\x11\x00\x00") + +func jsonschemaDraft04JSONBytes() ([]byte, error) { + return bindataRead( + _jsonschemaDraft04JSON, + "jsonschema-draft-04.json", + ) +} + +func jsonschemaDraft04JSON() (*asset, error) { + bytes, err := jsonschemaDraft04JSONBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "jsonschema-draft-04.json", size: 4375, mode: os.FileMode(420), modTime: time.Unix(1460872076, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _v2SchemaJSON = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\x5d\x4f\x93\xdb\x36\xb2\xbf\xfb\x53\xa0\x14\x57\xd9\xae\xd8\x92\xe3\xf7\x2e\xcf\x97\xd4\xbc\xd8\x49\x66\x37\x5e\x4f\x79\x26\xbb\x87\x78\x5c\x05\x91\x2d\x09\x09\x09\x30\x00\x38\x33\x5a\xef\x7c\xf7\x2d\xf0\x9f\x08\x02\x20\x41\x8a\xd2\xc8\x0e\x0f\xa9\x78\x28\xa0\xd1\xdd\x68\x34\x7e\xdd\xf8\xf7\xf9\x11\x42\x33\x49\x64\x04\xb3\xd7\x68\x76\x86\xfe\x76\xf9\xfe\x1f\xe8\x32\xd8\x40\x8c\xd1\x8a\x71\x74\x79\x8b\xd7\x6b\xe0\xe8\xd5\xfc\x25\x3a\xbb\x38\x9f\xcf\x9e\xab\x0a\x24\x54\xa5\x37\x52\x26\xaf\x17\x0b\x91\x17\x99\x13\xb6\xb8\x79\xb5\x10\x59\xdd\xf9\xef\x82\xd1\x6f\xf2\xc2\x8f\xf3\x4f\xb5\x1a\xea\xc7\x17\x45\x41\xc6\xd7\x8b\x90\xe3\x95\x7c\xf1\xf2\x7f\x8b\xca\x45\x3d\xb9\x4d\x32\xa6\xd8\xf2\x77\x08\x64\xfe\x8d\xc3\x9f\x29\xe1\xa0\x9a\xff\xed\x11\x42\x08\xcd\x8a\xd6\xb3\x9f\x15\x67\x74\xc5\xca\x7f\x27\x58\x6e\xc4\xec\x11\x42\xd7\x59\x5d\x1c\x86\x44\x12\x46\x71\x74\xc1\x59\x02\x5c\x12\x10\xb3\xd7\x68\x85\x23\x01\x59\x81\x04\x4b\x09\x9c\x6a\xbf\x7e\xce\x49\x7d\xba\x7b\x51\xfd\xa1\x44\xe2\xb0\x52\xac\x7d\xb3\x08\x61\x45\x68\x46\x56\x2c\x6e\x80\x86\x8c\xbf\xbd\x93\x40\x05\x61\x74\x96\x95\xbe\x7f\x84\xd0\x7d\x4e\xde\x42\xb7\xe4\xbe\x46\xbb\x14\x5b\x48\x4e\xe8\xba\x90\x05\xa1\x19\xd0\x34\xae\xc4\xce\xbe\xbc\x9a\xbf\x9c\x15\x7f\x5d\x57\xc5\x42\x10\x01\x27\x89\xe2\x48\x51\xb9\xda\x40\xd5\x87\x37\xc0\x15\x5f\x88\xad\x90\xdc\x10\x81\x42\x16\xa4\x31\x50\x39\x2f\x38\xad\xab\xb0\x53\xd8\xac\x94\x56\x6f\xc3\x84\xf4\x11\xa4\x50\xb3\xfa\xe9\xd3\x6f\x9f\x3e\xdf\x2f\xd0\xeb\x8f\x1f\x3f\x7e\xbc\xfe\xf6\xe9\xf7\xaf\x5f\x7f\xfc\x18\x7e\xfb\xec\xfb\xc7\xb3\x36\x79\x54\x43\xe8\x29\xc5\x31\x20\xc6\x11\x49\x9e\xe5\x12\x41\x66\xa0\xe8\xed\x1d\x8e\x93\x08\x5e\xa3\x27\x3b\xc3\x7c\xa2\x73\xba\xc4\x02\x2e\xb0\xdc\xf4\xe5\x76\xd1\xca\x96\xa2\x8a\x94\xcd\x21\xc9\x6c\xec\x2c\x70\x42\x9e\x34\x74\x9d\x19\x7c\xcd\x20\x9c\xea\x2e\x0a\xfe\x42\x84\xd4\x29\x04\x8c\x8a\xb4\x41\xa2\xc1\xdc\x19\x8a\x88\x90\x4a\x49\xef\xce\xdf\xbd\x45\x4a\x52\x81\x70\x10\x40\x22\x21\x44\xcb\x6d\xc5\xec\x4e\x3c\x1c\x45\xef\x57\x9a\xb5\x7d\xae\xfe\xe5\xe4\x31\x86\x90\xe0\xab\x6d\x02\x3b\x2e\xcb\x11\x90\xd9\xa8\xc6\x77\xc2\x59\x98\x06\xfd\xf9\x2e\x78\x45\x01\xa6\xa8\xa0\x71\x5c\xbe\x33\xa7\xd2\xd9\x5f\x95\xef\xd9\xd5\xac\xfd\xdc\x5d\xbf\x5e\xb8\xd1\x3e\xc7\x31\x48\xe0\x5e\x4c\x14\x65\xdf\xb8\xa8\x71\x10\x09\xa3\xc2\xc7\x02\xcb\xa2\x4e\x5a\x02\x82\x94\x13\xb9\xf5\x30\xe6\xb2\xa4\xb5\xfe\x9b\x3e\x7a\xb2\x55\xd2\xa8\x4a\xbc\x16\xb6\x71\x8e\x39\xc7\xdb\x9d\xe1\x10\x09\x71\xbd\x9c\xb3\x41\x89\xd7\xa5\x89\xdc\x57\xb5\x53\x4a\xfe\x4c\xe1\xbc\xa0\x21\x79\x0a\x1a\x0f\x70\xa7\x5c\x08\x8e\xde\xb0\xc0\x43\x24\xad\x74\x63\x0e\xb1\xd9\x90\xe1\xb0\x2d\x13\xa7\x6d\x78\xfd\x04\x14\x38\x8e\x90\xaa\xce\x63\xac\x3e\x23\xbc\x64\xa9\xb4\xf8\x03\x63\xde\xcd\xbe\x16\x13\x4a\x55\xac\x82\x12\xc6\xac\xd4\x35\xf7\x22\xd4\x3a\xff\x22\x73\x0e\x6e\x51\xa0\x75\x1e\xae\x8f\xe8\x5d\xc7\x59\xe6\xe4\x9a\x18\x8d\xd6\x1c\x53\x84\x4d\xb7\x67\x28\x37\x09\x84\x69\x88\x12\x0e\x01\x11\x80\x32\xa2\xf5\xb9\xaa\xc6\xd9\x73\x53\xab\xfb\xb4\x2e\x20\xc6\x54\x92\xa0\x9a\xf3\x69\x1a\x2f\x81\x77\x37\xae\x53\x1a\xce\x40\xc4\xa8\x82\x1c\xb5\xef\xda\x24\x7d\xb9\x61\x69\x14\xa2\x25\xa0\x90\xac\x56\xc0\x81\x4a\xb4\xe2\x2c\xce\x4a\x64\x7a\x9a\x23\xf4\x13\x91\x3f\xa7\x4b\xf4\x63\x84\x6f\x18\x87\x10\xbd\xc3\xfc\x8f\x90\xdd\x52\x44\x04\xc2\x51\xc4\x6e\x21\x74\x48\x21\x81\xc7\xe2\xfd\xea\x12\xf8\x0d\x09\xf6\xe9\x47\x35\xaf\x67\xc4\x14\xf7\x22\x27\x97\xe1\xe2\x76\x2d\x06\x8c\x4a\x1c\x48\x3f\x73\x2d\x0b\x5b\x29\x45\x24\x00\x2a\x0c\x11\xec\x94\xca\xc2\xa6\xc1\x37\x21\x43\x83\x3b\x5f\x97\xf1\x43\x5e\x53\x73\x19\xa5\x36\xd8\x2d\x05\x2e\x34\x0b\xeb\x39\xfc\x1d\x63\x51\x01\xbd\x3d\xbb\x90\x84\x40\x25\x59\x6d\x09\x5d\xa3\x1c\x37\xe6\x5c\x16\x9a\x40\x09\x70\xc1\xe8\x82\xf1\x35\xa6\xe4\xdf\x99\x5c\x8e\x9e\x4d\x79\xb4\x27\x2f\xbf\x7e\xf8\x05\x25\x8c\x50\xa9\x98\x29\x90\x62\x60\xea\x75\xae\x13\xca\xbf\x2b\x1a\x29\x27\x76\xd6\x20\xc6\x64\x5f\xe6\x32\x1a\x08\x87\x21\x07\x21\xbc\xb4\xe4\xe0\x32\x67\xa6\xcd\xf3\x1e\xcd\xd9\x6b\xb6\x6f\x8e\x27\xa7\xed\xdb\xe7\xbc\xcc\x1a\x07\xce\x6f\x87\x33\xf0\xba\x51\x17\x22\x66\x78\x79\x8e\xce\xe5\x13\x81\x80\x06\x2c\xe5\x78\x0d\xa1\xb2\xb8\x54\xa8\x79\x09\xbd\xbf\x3c\x47\x01\x8b\x13\x2c\xc9\x32\xaa\xaa\x1d\xd5\xee\xab\x36\xbd\x6c\xfd\x54\x6c\xc8\x08\x01\x3c\xbd\xe7\x07\x88\xb0\x24\x37\x79\x90\x28\x4a\x1d\x10\x1a\x92\x1b\x12\xa6\x38\x42\x40\xc3\x4c\x43\x62\x8e\xae\x36\xb0\x45\x71\x2a\xa4\x9a\x23\x79\x59\xb1\xa8\xf2\xa4\x0c\x60\x9f\xcc\x8d\x40\xf5\x80\xca\xa8\x99\xc3\xa7\x85\x1f\x31\x25\xa9\x82\xc5\x6d\xbd\xd8\x36\x76\x7c\x02\x28\x97\xf6\x1d\x74\x3b\x11\x7e\x91\xae\x32\xf8\x6c\xf4\xe6\x7b\x9a\xa5\x1f\x62\xc6\x21\xcf\x9a\xe5\xed\x8b\x02\xf3\x2c\x33\x33\xdf\x00\xca\xc9\x09\xb4\x04\xf5\xa5\x08\xd7\xc3\x02\x18\x66\xf1\xab\x1e\x83\x37\x4c\xcd\x12\xc1\x1d\x50\xf6\xaa\xbd\xfe\xe2\x73\x48\x38\x08\xa0\x32\x9b\x18\x44\x86\x0b\x6a\xc1\xaa\x26\x96\x2d\x96\x3c\xa0\x54\x65\x73\x87\x15\xca\x15\xe5\xf5\x94\x46\x9f\x33\x1a\x0c\x9a\xb1\x5a\xd9\x6a\x95\xcd\xcb\x7e\xec\x9a\xc5\x94\x3b\x37\x26\x31\xd7\xfc\xe4\x1f\x13\x8c\x31\x75\x9c\xba\xf7\x87\x3c\xa1\xb7\x4f\x17\x1b\x09\x82\x98\xc4\x70\x95\xd3\xe8\x4c\x48\x5a\xa6\xd6\x2a\x3d\x56\x42\x80\x9f\xaf\xae\x2e\x50\x0c\x42\xe0\x35\x34\x3c\x8a\x62\x03\x37\xba\xb2\x27\x04\xda\x25\x8d\x06\xe2\xa0\x13\x8a\xf3\xf5\xec\x10\x72\x67\x88\x90\x3d\x4b\x64\xeb\xaa\xda\x8f\xf7\x5a\x75\x47\x9a\xa8\x51\x70\x26\xd2\x38\xc6\x7c\xbb\x57\xfc\xbd\xe4\x04\x56\xa8\xa0\x54\x9a\x45\xd5\xf7\x0f\x16\xfc\x57\x1c\x3c\xdf\x23\xba\x77\x38\xda\x16\x4b\x31\x53\x6a\x4d\x9a\x15\x63\xe7\xe1\x18\x69\x9f\x22\xe0\x24\xbb\x94\x4b\x97\xee\x2d\xf9\x70\x87\x72\x7b\xe6\xc4\x33\x2a\x66\x5e\x1c\x35\x72\xe3\x2d\xda\x73\xe4\xc7\x51\x6d\xa4\xa1\x2a\x4f\xde\x94\xcb\xb2\x3e\x31\x48\xae\x82\xce\xc9\xc8\x65\xcd\xc3\xb7\x34\xb6\x2b\xdf\x58\x65\x78\x6e\x73\xac\x5e\x24\x0d\x3f\xdc\x70\x23\xc6\xda\x52\x0b\x2d\x63\x7d\xa9\x49\x2d\x54\x48\x28\xc0\x12\x9c\xe3\x63\xc9\x58\x04\x98\x36\x07\xc8\x0a\xa7\x91\xd4\xf0\xbc\xc1\xa8\xb9\x70\xd0\xc6\xa9\xb6\x78\x80\x5a\xa3\xb4\x2c\xf4\x18\x0b\x8a\x9d\xd0\xb4\x55\x10\xee\x0d\xc5\xd6\xe0\x99\x93\xdc\xa1\x04\xbb\xf1\xa7\x23\xd1\xd1\x97\x8c\x87\x13\x0a\x21\x02\xe9\x99\x25\xed\x20\xc5\x92\x66\x3c\x32\x9c\xd6\x06\xb0\x31\x5c\x86\x29\x0a\xcb\x60\x33\x12\xa5\x91\xfc\x96\x75\xd0\x59\xd7\x13\xbd\xd3\x23\x79\xdd\x2a\x90\xa6\x38\x06\x91\x39\x7f\x20\x72\x03\x1c\x2d\x01\x61\xba\x45\x37\x38\x22\x61\x8e\x71\x85\xc4\x32\x15\x28\x60\x61\x16\xb8\x3d\x29\xdc\x4d\x3d\x2f\x12\x13\x7d\xc8\x7e\x37\xee\xa8\x7f\xfa\xdb\xcb\x17\xff\x77\xfd\xf9\x7f\xee\x9f\x3d\xfe\xcf\xa7\xa7\x45\xfb\xcf\x1e\xf7\xf3\xe0\xff\xc4\x51\x0a\x8e\x4c\xcb\x01\xdc\x0a\x65\xb2\x01\x83\xed\x3d\xe4\xa9\xa3\x4e\x2d\x59\xc5\xe8\x2f\x48\x7d\x5a\x6e\x37\xbf\x5c\x9f\x35\x13\x64\x14\xfa\xef\x0b\x68\xa6\x0d\xb4\x8e\xf1\xa8\xff\xbb\x60\xf4\x03\x64\xab\x5b\x81\x65\x51\xe6\xda\xca\xfa\xf0\xb0\xac\x3e\x9c\xca\x26\x0e\x1d\xdb\x57\x5b\xbb\xb4\x9a\xa6\xb6\x9b\x1a\x6b\xd1\x9a\x9e\x7e\x33\x9a\xec\x41\x69\x45\x22\xb8\xb4\x51\xeb\x04\x77\xca\x6f\x7b\x7b\xc8\xb2\xb0\x95\x92\x25\x5b\xd0\x42\xaa\x2a\xdd\x32\x78\x4f\x0c\xab\x68\x46\x6c\xea\x6d\xf4\x5c\x5e\xde\xc4\xac\xa5\xf9\xd1\x00\x9f\x7d\x98\x65\x24\xbd\xc7\x97\xd4\xb3\x3a\xa8\x2b\xa0\x34\x76\xf9\x65\x5f\x2d\x25\x95\x1b\xcf\xd6\xf4\x9b\x5f\x09\x95\xb0\x36\x3f\xdb\xd0\x39\x2a\x93\x1c\x9d\x03\xa2\x4a\xca\xf5\xf6\x10\xb6\x94\x89\x0b\x6a\x70\x12\x13\x49\x6e\x40\xe4\x29\x12\x2b\xbd\x80\x45\x11\x04\xaa\xc2\x8f\x56\x9e\x5c\x6b\xec\x8d\x5a\x0e\x14\x59\x06\x2b\x1e\x24\xcb\xc2\x56\x4a\x31\xbe\x23\x71\x1a\xfb\x51\x2a\x0b\x3b\x1c\x48\x10\xa5\x82\xdc\xc0\xbb\x3e\x24\x8d\x5a\x76\x2e\x09\xed\xc1\x65\x51\xb8\x83\xcb\x3e\x24\x8d\x5a\x2e\x5d\xfe\x02\x74\x2d\x3d\xf1\xef\xae\xb8\x4b\xe6\x5e\xd4\xaa\xe2\x2e\x5c\x5e\xec\x0e\xf5\x5b\x0c\xcb\x0a\xbb\xa4\x3c\xf7\x1f\x2a\x55\x69\x97\x8c\x7d\x68\x95\xa5\xad\xb4\xf4\x9c\xa5\x07\xb9\x7a\x05\xbb\xad\x50\x6f\xfb\xa0\x4e\x9b\x48\x23\x49\x92\x28\x87\x19\x3e\x32\xee\xca\x3b\x46\x7e\x7f\x18\x64\xcc\xcc\x0f\x34\xe9\x36\x8b\xb7\x6c\xa8\xa5\x5b\x54\x4c\x54\x5b\x15\x3a\xf1\x6c\x2d\xfe\x96\xc8\x0d\xba\x7b\x81\x88\xc8\x23\xab\xee\x7d\x3b\x92\xa7\x60\x29\xe3\xdc\xff\xb8\x64\xe1\xf6\xa2\x5a\x59\xdc\x6f\xeb\x45\x7d\x6a\xd1\x76\x1e\xea\xb8\xf1\xfa\x14\xd3\x36\x63\xe5\xd7\xf3\xe4\xbe\x25\xbd\x5e\x05\xeb\x73\x74\xb5\x21\x2a\x2e\x4e\xa3\x30\xdf\xbf\x43\x28\x2a\xd1\xa5\x2a\x9d\x8a\xfd\x76\xd8\x8d\xbc\x67\x65\xc7\xb8\x03\x45\xec\xa3\xb0\x37\x8a\x70\x4c\x68\x91\x51\x8e\x58\x80\xed\x4a\xf3\x81\x62\xca\x96\xbb\xf1\x52\xcd\x80\xfb\xe4\x4a\x5d\x6c\xdf\x6e\x20\x4b\x80\x30\x8e\x28\x93\xf9\xe9\x8d\x8a\x6d\xd5\x59\x65\x7b\xaa\x44\x9e\xc0\xc2\xd1\x7c\x40\x26\xd6\x1a\xce\xf9\xc5\x69\x7b\x6c\xec\xc8\x71\x7b\xe5\x21\x2e\xd3\xe5\x65\x93\x91\x53\x0b\x7b\x3a\xc7\xfa\x17\x6a\x01\xa7\x33\xd0\xf4\x40\x0f\x39\x87\xda\xe4\x54\x87\x3a\xd5\xe3\xc7\xa6\x8e\x20\xd4\x11\xb2\x4e\xb1\xe9\x14\x9b\x4e\xb1\xe9\x14\x9b\xfe\x15\x63\xd3\x47\xf5\xff\x97\x38\xe9\xcf\x14\xf8\x76\x82\x49\x13\x4c\xaa\x7d\xcd\x6c\x62\x42\x49\x87\x43\x49\x19\x33\x6f\xe3\x44\x6e\x9b\xab\x8a\x3e\x86\xaa\x99\x52\x1b\x5b\x59\x33\x02\x09\xa0\x21\xa1\x6b\x84\x6b\x66\xbb\xdc\x16\x0c\xd3\x68\xab\xec\x36\x4b\xd8\x60\x8a\x40\x31\x85\x6e\x14\x57\x13\xc2\xfb\x92\x10\xde\xbf\x88\xdc\xbc\x53\x5e\x7f\x82\x7a\x13\xd4\x9b\xa0\xde\x04\xf5\x90\x01\xf5\x94\xcb\x7b\x83\x25\x9e\xd0\xde\x84\xf6\x6a\x5f\x4b\xb3\x98\x00\xdf\x04\xf8\x6c\xbc\x7f\x19\x80\xaf\xf1\x71\x45\x22\x98\x40\xe0\x04\x02\x27\x10\xd8\x29\xf5\x04\x02\xff\x4a\x20\x30\xc1\x72\xf3\x65\x02\x40\xd7\xc1\xd1\xe2\x6b\xf1\xa9\x7b\xfb\xe4\x20\xc0\x68\x9d\xd4\xb4\xd3\x96\xb5\xa6\xd1\x41\x20\xe6\x89\xc3\x48\x65\x58\x13\x84\x9c\x56\x56\x3b\x0c\xe0\x6b\x83\x5c\x13\xd2\x9a\x90\xd6\x84\xb4\x26\xa4\x85\x0c\xa4\x45\x19\xfd\xff\x63\x6c\x52\xb5\x1f\x1e\x19\x74\x3a\xcd\xb9\x69\xce\xa6\x3a\x0f\x7a\x2d\x19\xc7\x81\x14\x5d\xcb\xd5\x03\xc9\x39\xd0\xb0\xd1\xb3\xcd\xfb\x7a\x2d\x5d\x3a\x48\xe1\xfa\x2e\xe6\x81\x42\x18\x86\xd6\xc1\xbe\xb1\x23\xd3\xf7\x34\xed\x19\x0a\x0b\xc4\x48\x44\xfd\x22\x50\xb6\x42\x58\xbb\xe5\x3d\xa7\x73\xd4\x8b\xc4\x8c\x70\x61\xec\x73\xee\xc3\x81\x8b\xf5\xe2\xd7\x52\x3e\xcf\xeb\xeb\x17\x3b\x71\x16\xda\x7d\xb8\xde\xf0\x7a\x8f\x06\x2d\xa7\x40\x7b\xc1\x9d\x41\x4d\xb6\x61\xa2\x4e\x9f\x3d\xa0\xc5\xae\xe3\x1c\x1d\x40\x6c\x48\x8b\x63\xa0\xb5\x01\xed\x8e\x02\xe9\x86\xc8\x3b\x06\xee\xdb\x4b\xde\xbd\xc0\xa1\x6f\xcb\xda\xfc\xc2\x44\x16\x87\x9c\x17\x31\xd3\x30\x20\x39\x42\xcb\x6f\xf2\xf1\xf4\x72\x10\xf8\x1c\xa0\xf3\xbd\x10\xea\x21\x35\x7d\xe8\x86\xdb\x15\xed\x81\x81\x07\x28\xbb\x13\x28\xc7\xf8\xce\x7d\x8d\xc2\x31\xb4\x7e\x94\xd6\xdb\x55\xef\x4a\xfb\xed\xc3\x40\x3e\xeb\x9f\xe9\x99\x0f\xdf\x08\x65\x88\x27\x73\x86\x31\x9d\x47\xdf\x55\x19\xba\x3d\xee\x15\x0a\xcd\x8c\xaa\x5e\xb9\xf6\x57\x33\x73\x5a\xa1\x89\x7b\x3b\xa0\xb2\xa4\xc2\xf6\xc1\x53\xb5\x00\xca\x23\xe5\xf4\x60\x6a\xb4\x2d\x74\xea\x4e\xed\x3b\xe3\x47\xfb\xed\x82\x3d\x19\xd4\x3b\x6b\xaf\xae\x2b\x2f\x57\xb3\x82\x68\xcb\xed\x88\x2e\xe1\x5c\xd7\x26\xfa\x0a\x65\xe7\xce\x11\x33\xb4\xdd\x66\xe3\x37\xf6\xfa\x70\xd6\x4f\xa1\x21\x51\xd8\x3c\x26\x14\x4b\xc6\x87\x44\x27\x1c\x70\xf8\x9e\x46\xce\xab\x21\x07\x5f\xc1\x76\x17\x1b\x77\xb4\xda\x75\xa0\x0a\x3a\x30\xe1\xf8\x97\x32\x16\x2b\x00\x75\x85\xee\x62\x46\xef\xd3\x85\xb5\x6b\x60\xbe\xf2\x30\x7a\x8c\x0b\x4b\xa6\xd0\xf9\x64\x42\xe7\x07\x41\x41\xe3\x2c\x5d\xf9\x6d\xe9\x39\x98\x3b\x3b\x5d\x67\xd4\x5c\xed\xf2\xf0\x48\x7b\xbd\x2d\x31\xdd\x3f\x34\xad\x44\x76\x51\x9a\x56\x22\xa7\x95\xc8\x69\x25\xf2\xe1\x56\x22\x1f\x00\x32\x6a\x73\x92\xed\xe1\xc6\x7d\x9f\x49\x2c\x69\x7e\xc8\x31\x4c\x0c\xb4\xf2\x54\x3b\x79\x3b\x9e\x4d\xb4\xd1\x18\x3e\x5f\x9a\x93\xa2\x11\xc3\xda\x27\x0b\xaf\x37\x2e\x5c\x37\xfb\xeb\x9a\xd6\xc3\xac\xc3\xcc\xf8\x1e\x5b\x9d\xac\x22\x64\xb7\xed\x26\xb8\xf3\xb9\x3c\xbb\x1f\xe2\xb0\x22\x77\x43\x6a\x62\x29\x39\x59\xa6\xe6\xe5\xcd\x7b\x83\xc0\x5b\x8e\x93\x64\xac\xeb\xca\x4f\x65\xac\x4a\xbc\x1e\xcd\x82\xfa\x3c\x70\x36\xb6\xb5\xed\x79\xef\xec\x68\x00\xff\x54\xfa\xb5\xe3\xf1\xdb\xe1\xbe\xce\x76\x17\xaf\x57\xb6\x6b\x89\x05\x09\xce\x52\xb9\x01\x2a\x49\xbe\xd9\xf4\xd2\xb8\x7a\xbf\x91\x02\xf3\x22\x8c\x13\xf2\x77\xd8\x8e\x43\x8b\xe1\x54\x6e\x5e\x9d\xc7\x49\x44\x02\x22\xc7\xa4\x79\x81\x85\xb8\x65\x3c\x1c\x93\xe6\x59\xa2\xf8\x1c\x51\x95\x05\xd9\x20\x00\x21\x7e\x60\x21\x58\xa9\x56\xff\xbe\xb6\x5a\x5e\x5b\x3f\x1f\xd6\xd3\x3c\xc4\x4d\xba\x99\xb4\x63\x6e\x7d\x3e\x3d\x57\xd2\x18\x5f\x47\xe8\xc3\x06\x8a\x68\x6c\x7f\x3b\x72\x0f\xe7\xe2\x77\x77\xf1\xd0\x99\xab\xdf\x2e\xfe\xd6\xbb\xcd\x1a\xb9\x90\xd1\xaf\xf2\x38\x3d\xdb\x74\xf8\xeb\xe3\xda\xe8\x2a\x62\xb7\xda\x1b\x07\xa9\xdc\x30\x5e\xbc\x68\xfb\x6b\x9f\x97\xf1\xc6\xb1\xd8\x5c\x29\x1e\x49\x30\xc5\xf7\xde\xad\x91\x42\xf9\xdd\xed\x89\x80\x25\xbe\x37\xd7\xe7\x32\x5c\xe6\x35\xac\xd4\x0c\x2d\xf7\x90\xc4\xe3\xf5\xe3\x2f\x7f\x54\x18\x88\xe3\x61\x47\x85\x64\x7f\xc0\xd7\x3f\x1a\x92\x42\xe9\xc7\x1e\x0d\x95\x76\xa7\x51\xa0\x8f\x02\x1b\x46\x9e\x06\x42\xd1\xf2\x01\x07\x02\xde\xe9\x7d\x1a\x0b\xa7\x32\x16\xcc\xc0\xee\xc4\x90\xd2\x5f\x6f\x98\x54\x5d\xf2\x95\xe1\xa7\x69\x10\x3a\x06\xe1\x65\xb3\x17\x47\x58\x78\xd0\x45\xd6\x5b\xd5\x5f\x25\x1d\x71\x49\xa6\x7a\x64\xda\xd0\x6f\xc7\x3a\x4c\xe3\x09\xc0\x6e\x96\x2c\xa7\xa7\x77\x34\x10\x05\x08\x21\x44\x92\x65\x77\xdf\x20\x5c\xbc\xe7\x97\x3f\xf4\x1a\x45\xd6\xe7\x27\x4a\xde\x74\x27\x66\x11\x7d\x70\xba\xd3\x78\xf9\x1e\x0d\xca\xc8\x39\xde\x7c\xb3\xa6\xe1\xbc\xd7\xc1\x6a\x6f\xb3\x0e\x52\xbe\xe4\x98\x8a\x15\x70\x94\x70\x26\x59\xc0\xa2\xf2\x1c\xfb\xd9\xc5\xf9\xbc\xd5\x92\x9c\xa3\xdf\xe6\x1e\xb3\x0d\x49\xba\x87\x50\x5f\x84\xfe\xe9\xd6\xf8\xbb\xe6\xf0\x7a\xeb\xa6\x65\x3b\x86\x8b\x79\x93\xf5\x59\x20\x6e\xb4\xa7\x44\xf4\x3f\xa5\xfe\x67\x42\x12\xdb\xd3\xe7\xbb\xa5\xa3\x8c\x5c\x2b\x97\xbb\xbb\x7f\x8e\xc5\x6e\xed\x43\x5c\xbf\x74\xc8\x8f\xff\xe6\xd6\xbe\x91\xb6\xf5\x95\xe4\xed\x93\xc4\xa8\x5b\xf9\x76\x4d\x35\xb7\xd8\x8c\xb6\x7d\xaf\x72\xe0\xb6\xbd\x01\x63\x9e\x76\xab\x1a\x32\x76\xe4\x8c\x76\xc2\xad\x6c\xa2\x65\xf7\xcf\xf8\xa7\xda\x2a\xb9\x8c\x3d\x3c\xa3\x9d\x64\x33\xe5\x1a\xb5\x2d\xfb\x86\xa2\x5a\x7f\x19\x5b\x7f\xc6\x3f\xd1\x53\xd3\xe2\x41\x5b\xd3\x4f\xf0\xec\xb0\x42\x73\x43\xd2\x68\x27\xd3\x6a\x6a\x34\xf6\x4e\x1e\x52\x8b\x87\x6c\xcc\xae\x44\xfb\x9e\xa7\x51\x4f\x9d\x55\x03\x81\x8e\x67\xfc\xb4\x69\xf0\x3a\x18\xf2\x40\xd0\xf6\xa8\x34\xe3\xc9\x98\xaf\xf6\xda\x24\xd3\xeb\x60\xb9\x0e\xd3\x1f\xa9\xff\xee\xff\x1b\x00\x00\xff\xff\x3d\xeb\x17\xb5\x38\x9d\x00\x00") + +func v2SchemaJSONBytes() ([]byte, error) { + return bindataRead( + _v2SchemaJSON, + "v2/schema.json", + ) +} + +func v2SchemaJSON() (*asset, error) { + bytes, err := v2SchemaJSONBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "v2/schema.json", size: 40248, mode: os.FileMode(420), modTime: time.Unix(1473777784, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +// Asset loads and returns the asset for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func Asset(name string) ([]byte, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err) + } + return a.bytes, nil + } + return nil, fmt.Errorf("Asset %s not found", name) +} + +// MustAsset is like Asset but panics when Asset would return an error. +// It simplifies safe initialization of global variables. +func MustAsset(name string) []byte { + a, err := Asset(name) + if err != nil { + panic("asset: Asset(" + name + "): " + err.Error()) + } + + return a +} + +// AssetInfo loads and returns the asset info for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func AssetInfo(name string) (os.FileInfo, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err) + } + return a.info, nil + } + return nil, fmt.Errorf("AssetInfo %s not found", name) +} + +// AssetNames returns the names of the assets. +func AssetNames() []string { + names := make([]string, 0, len(_bindata)) + for name := range _bindata { + names = append(names, name) + } + return names +} + +// _bindata is a table, holding each asset generator, mapped to its name. +var _bindata = map[string]func() (*asset, error){ + "jsonschema-draft-04.json": jsonschemaDraft04JSON, + "v2/schema.json": v2SchemaJSON, +} + +// AssetDir returns the file names below a certain +// directory embedded in the file by go-bindata. +// For example if you run go-bindata on data/... and data contains the +// following hierarchy: +// data/ +// foo.txt +// img/ +// a.png +// b.png +// then AssetDir("data") would return []string{"foo.txt", "img"} +// AssetDir("data/img") would return []string{"a.png", "b.png"} +// AssetDir("foo.txt") and AssetDir("notexist") would return an error +// AssetDir("") will return []string{"data"}. +func AssetDir(name string) ([]string, error) { + node := _bintree + if len(name) != 0 { + cannonicalName := strings.Replace(name, "\\", "/", -1) + pathList := strings.Split(cannonicalName, "/") + for _, p := range pathList { + node = node.Children[p] + if node == nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + } + } + if node.Func != nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + rv := make([]string, 0, len(node.Children)) + for childName := range node.Children { + rv = append(rv, childName) + } + return rv, nil +} + +type bintree struct { + Func func() (*asset, error) + Children map[string]*bintree +} +var _bintree = &bintree{nil, map[string]*bintree{ + "jsonschema-draft-04.json": &bintree{jsonschemaDraft04JSON, map[string]*bintree{}}, + "v2": &bintree{nil, map[string]*bintree{ + "schema.json": &bintree{v2SchemaJSON, map[string]*bintree{}}, + }}, +}} + +// RestoreAsset restores an asset under the given directory +func RestoreAsset(dir, name string) error { + data, err := Asset(name) + if err != nil { + return err + } + info, err := AssetInfo(name) + if err != nil { + return err + } + err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755)) + if err != nil { + return err + } + err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode()) + if err != nil { + return err + } + err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime()) + if err != nil { + return err + } + return nil +} + +// RestoreAssets restores an asset under the given directory recursively +func RestoreAssets(dir, name string) error { + children, err := AssetDir(name) + // File + if err != nil { + return RestoreAsset(dir, name) + } + // Dir + for _, child := range children { + err = RestoreAssets(dir, filepath.Join(name, child)) + if err != nil { + return err + } + } + return nil +} + +func _filePath(dir, name string) string { + cannonicalName := strings.Replace(name, "\\", "/", -1) + return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...) +} + diff --git a/vendor/github.com/go-openapi/spec/contact_info.go b/vendor/github.com/go-openapi/spec/contact_info.go new file mode 100644 index 0000000..f285970 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/contact_info.go @@ -0,0 +1,24 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +// ContactInfo contact information for the exposed API. +// +// For more information: http://goo.gl/8us55a#contactObject +type ContactInfo struct { + Name string `json:"name,omitempty"` + URL string `json:"url,omitempty"` + Email string `json:"email,omitempty"` +} diff --git a/vendor/github.com/go-openapi/spec/expander.go b/vendor/github.com/go-openapi/spec/expander.go new file mode 100644 index 0000000..4389c68 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/expander.go @@ -0,0 +1,762 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + "fmt" + "log" + "net/url" + "os" + "path/filepath" + "reflect" + "strings" + "sync" + + "github.com/go-openapi/jsonpointer" + "github.com/go-openapi/swag" +) + +var ( + // Debug enables logging when SWAGGER_DEBUG env var is not empty + Debug = os.Getenv("SWAGGER_DEBUG") != "" +) + +// ExpandOptions provides options for expand. +type ExpandOptions struct { + RelativeBase string +} + +// ResolutionCache a cache for resolving urls +type ResolutionCache interface { + Get(string) (interface{}, bool) + Set(string, interface{}) +} + +type simpleCache struct { + lock sync.Mutex + store map[string]interface{} +} + +var resCache ResolutionCache + +func init() { + resCache = initResolutionCache() +} + +func initResolutionCache() ResolutionCache { + return &simpleCache{store: map[string]interface{}{ + "http://swagger.io/v2/schema.json": MustLoadSwagger20Schema(), + "http://json-schema.org/draft-04/schema": MustLoadJSONSchemaDraft04(), + }} +} + +func (s *simpleCache) Get(uri string) (interface{}, bool) { + if Debug { + log.Printf("getting %q from resolution cache", uri) + } + s.lock.Lock() + v, ok := s.store[uri] + if Debug { + log.Printf("got %q from resolution cache: %t", uri, ok) + } + + s.lock.Unlock() + return v, ok +} + +func (s *simpleCache) Set(uri string, data interface{}) { + s.lock.Lock() + s.store[uri] = data + s.lock.Unlock() +} + +// ResolveRef resolves a reference against a context root +func ResolveRef(root interface{}, ref *Ref) (*Schema, error) { + resolver, err := defaultSchemaLoader(root, nil, nil, nil) + if err != nil { + return nil, err + } + + result := new(Schema) + if err := resolver.Resolve(ref, result); err != nil { + return nil, err + } + return result, nil +} + +// ResolveParameter resolves a paramter reference against a context root +func ResolveParameter(root interface{}, ref Ref) (*Parameter, error) { + resolver, err := defaultSchemaLoader(root, nil, nil, nil) + if err != nil { + return nil, err + } + + result := new(Parameter) + if err := resolver.Resolve(&ref, result); err != nil { + return nil, err + } + return result, nil +} + +// ResolveResponse resolves response a reference against a context root +func ResolveResponse(root interface{}, ref Ref) (*Response, error) { + resolver, err := defaultSchemaLoader(root, nil, nil, nil) + if err != nil { + return nil, err + } + + result := new(Response) + if err := resolver.Resolve(&ref, result); err != nil { + return nil, err + } + return result, nil +} + +type schemaLoader struct { + loadingRef *Ref + startingRef *Ref + currentRef *Ref + root interface{} + options *ExpandOptions + cache ResolutionCache + loadDoc func(string) (json.RawMessage, error) +} + +var idPtr, _ = jsonpointer.New("/id") +var schemaPtr, _ = jsonpointer.New("/$schema") +var refPtr, _ = jsonpointer.New("/$ref") + +func defaultSchemaLoader( + root interface{}, ref *Ref, + expandOptions *ExpandOptions, cache ResolutionCache) (*schemaLoader, error) { + + if cache == nil { + cache = resCache + } + + var ptr *jsonpointer.Pointer + if ref != nil { + ptr = ref.GetPointer() + } + + currentRef := nextRef(root, ref, ptr) + + return &schemaLoader{ + loadingRef: ref, + startingRef: ref, + currentRef: currentRef, + root: root, + options: expandOptions, + cache: cache, + loadDoc: func(path string) (json.RawMessage, error) { + if Debug { + log.Printf("fetching document at %q", path) + } + + data, err := swag.LoadFromFileOrHTTP(path) + if err != nil { + return nil, err + } + return json.RawMessage(data), nil + }, + }, nil +} + +func idFromNode(node interface{}) (*Ref, error) { + if idValue, _, err := idPtr.Get(node); err == nil { + if refStr, ok := idValue.(string); ok && refStr != "" { + idRef, err := NewRef(refStr) + if err != nil { + return nil, err + } + return &idRef, nil + } + } + return nil, nil +} + +func nextRef(startingNode interface{}, startingRef *Ref, ptr *jsonpointer.Pointer) *Ref { + if startingRef == nil { + return nil + } + + if ptr == nil { + return startingRef + } + + ret := startingRef + var idRef *Ref + node := startingNode + + for _, tok := range ptr.DecodedTokens() { + node, _, _ = jsonpointer.GetForToken(node, tok) + if node == nil { + break + } + + idRef, _ = idFromNode(node) + if idRef != nil { + nw, err := ret.Inherits(*idRef) + if err != nil { + break + } + ret = nw + } + + refRef, _, _ := refPtr.Get(node) + if refRef != nil { + var rf Ref + switch value := refRef.(type) { + case string: + rf, _ = NewRef(value) + } + nw, err := ret.Inherits(rf) + if err != nil { + break + } + nwURL := nw.GetURL() + if nwURL.Scheme == "file" || (nwURL.Scheme == "" && nwURL.Host == "") { + if strings.HasPrefix(nwURL.Path, "/") { + _, err := os.Stat(nwURL.Path) + if err != nil { + nwURL.Path = "." + nwURL.Path + } + } + } + + ret = nw + } + + } + + return ret +} + +func normalizeFileRef(ref *Ref, relativeBase string) *Ref { + refURL := ref.GetURL() + + if strings.HasPrefix(refURL.String(), "#") { + return ref + } + + if refURL.Scheme == "file" || (refURL.Scheme == "" && refURL.Host == "") { + filePath := refURL.Path + + if !strings.HasPrefix(filePath, "/") { + if relativeBase != "" { + filePath = relativeBase + "/" + filePath + } + } + if !strings.HasPrefix(filePath, "/") { + pwd, err := os.Getwd() + if err == nil { + filePath = pwd + "/" + filePath + } + } + + filePath = filepath.Clean(filePath) + _, err := os.Stat(filePath) + if err == nil { + refURL.Scheme = "" + refURL.Path = filePath + } + } + + return ref +} + +func (r *schemaLoader) resolveRef(currentRef, ref *Ref, node, target interface{}) error { + + tgt := reflect.ValueOf(target) + if tgt.Kind() != reflect.Ptr { + return fmt.Errorf("resolve ref: target needs to be a pointer") + } + + oldRef := currentRef + + if currentRef != nil { + nextRef := nextRef(node, ref, currentRef.GetPointer()) + if nextRef == nil || nextRef.GetURL() == nil { + return nil + } + var err error + currentRef, err = currentRef.Inherits(*nextRef) + if err != nil { + return err + } + } + + if currentRef == nil { + currentRef = ref + } + + refURL := currentRef.GetURL() + if refURL == nil { + return nil + } + if currentRef.IsRoot() { + nv := reflect.ValueOf(node) + reflect.Indirect(tgt).Set(reflect.Indirect(nv)) + return nil + } + + if strings.HasPrefix(refURL.String(), "#") { + res, _, err := ref.GetPointer().Get(node) + if err != nil { + res, _, err = ref.GetPointer().Get(r.root) + if err != nil { + return err + } + } + rv := reflect.Indirect(reflect.ValueOf(res)) + tgtType := reflect.Indirect(tgt).Type() + if rv.Type().AssignableTo(tgtType) { + reflect.Indirect(tgt).Set(reflect.Indirect(reflect.ValueOf(res))) + } else { + if err := swag.DynamicJSONToStruct(rv.Interface(), target); err != nil { + return err + } + } + + return nil + } + + relativeBase := "" + if r.options != nil && r.options.RelativeBase != "" { + relativeBase = r.options.RelativeBase + } + normalizeFileRef(currentRef, relativeBase) + normalizeFileRef(ref, relativeBase) + + data, _, _, err := r.load(refURL) + if err != nil { + return err + } + + if ((oldRef == nil && currentRef != nil) || + (oldRef != nil && currentRef == nil) || + oldRef.String() != currentRef.String()) && + ((oldRef == nil && ref != nil) || + (oldRef != nil && ref == nil) || + (oldRef.String() != ref.String())) { + + return r.resolveRef(currentRef, ref, data, target) + } + + var res interface{} + if currentRef.String() != "" { + res, _, err = currentRef.GetPointer().Get(data) + if err != nil { + if strings.HasPrefix(ref.String(), "#") { + if r.loadingRef != nil { + newUrl := r.loadingRef.GetURL().String() + refURL, err = url.Parse(newUrl + ref.String()) + if err != nil { + return err + } + + data, _, _, err = r.load(refURL) + if err != nil { + return err + } + } else { + data = r.root + } + } + + res, _, err = ref.GetPointer().Get(data) + if err != nil { + return err + } + } + } else { + res = data + } + + if err := swag.DynamicJSONToStruct(res, target); err != nil { + return err + } + + r.currentRef = currentRef + + return nil +} + +func (r *schemaLoader) load(refURL *url.URL) (interface{}, url.URL, bool, error) { + toFetch := *refURL + toFetch.Fragment = "" + + data, fromCache := r.cache.Get(toFetch.String()) + if !fromCache { + b, err := r.loadDoc(toFetch.String()) + if err != nil { + return nil, url.URL{}, false, err + } + + if err := json.Unmarshal(b, &data); err != nil { + return nil, url.URL{}, false, err + } + r.cache.Set(toFetch.String(), data) + } + + return data, toFetch, fromCache, nil +} + +func (r *schemaLoader) Resolve(ref *Ref, target interface{}) error { + if err := r.resolveRef(r.currentRef, ref, r.root, target); err != nil { + return err + } + + return nil +} + +type specExpander struct { + spec *Swagger + resolver *schemaLoader +} + +// ExpandSpec expands the references in a swagger spec +func ExpandSpec(spec *Swagger, options *ExpandOptions) error { + resolver, err := defaultSchemaLoader(spec, nil, options, nil) + if err != nil { + return err + } + + for key, definition := range spec.Definitions { + var def *Schema + var err error + if def, err = expandSchema(definition, []string{"#/definitions/" + key}, resolver); err != nil { + return err + } + spec.Definitions[key] = *def + } + + for key, parameter := range spec.Parameters { + if err := expandParameter(¶meter, resolver); err != nil { + return err + } + spec.Parameters[key] = parameter + } + + for key, response := range spec.Responses { + if err := expandResponse(&response, resolver); err != nil { + return err + } + spec.Responses[key] = response + } + + if spec.Paths != nil { + for key, path := range spec.Paths.Paths { + if err := expandPathItem(&path, resolver); err != nil { + return err + } + spec.Paths.Paths[key] = path + } + } + + return nil +} + +// ExpandSchema expands the refs in the schema object +func ExpandSchema(schema *Schema, root interface{}, cache ResolutionCache) error { + if schema == nil { + return nil + } + if root == nil { + root = schema + } + + nrr, _ := NewRef(schema.ID) + var rrr *Ref + if nrr.String() != "" { + switch root.(type) { + case *Schema: + rid, _ := NewRef(root.(*Schema).ID) + rrr, _ = rid.Inherits(nrr) + case *Swagger: + rid, _ := NewRef(root.(*Swagger).ID) + rrr, _ = rid.Inherits(nrr) + } + } + + resolver, err := defaultSchemaLoader(root, rrr, nil, cache) + if err != nil { + return err + } + + refs := []string{""} + if rrr != nil { + refs[0] = rrr.String() + } + var s *Schema + if s, err = expandSchema(*schema, refs, resolver); err != nil { + return err + } + *schema = *s + return nil +} + +func expandItems(target Schema, parentRefs []string, resolver *schemaLoader) (*Schema, error) { + if target.Items != nil { + if target.Items.Schema != nil { + t, err := expandSchema(*target.Items.Schema, parentRefs, resolver) + if err != nil { + if target.Items.Schema.ID == "" { + target.Items.Schema.ID = target.ID + if err != nil { + t, err = expandSchema(*target.Items.Schema, parentRefs, resolver) + if err != nil { + return nil, err + } + } + } + } + *target.Items.Schema = *t + } + for i := range target.Items.Schemas { + t, err := expandSchema(target.Items.Schemas[i], parentRefs, resolver) + if err != nil { + return nil, err + } + target.Items.Schemas[i] = *t + } + } + return &target, nil +} + +func expandSchema(target Schema, parentRefs []string, resolver *schemaLoader) (*Schema, error) { + if target.Ref.String() == "" && target.Ref.IsRoot() { + if Debug { + log.Printf("skipping expand schema for no ref and root: %v", resolver.root) + } + + return resolver.root.(*Schema), nil + } + + // t is the new expanded schema + var t *Schema + + for target.Ref.String() != "" { + if swag.ContainsStringsCI(parentRefs, target.Ref.String()) { + return &target, nil + } + + if err := resolver.Resolve(&target.Ref, &t); err != nil { + return &target, err + } + + parentRefs = append(parentRefs, target.Ref.String()) + target = *t + } + + t, err := expandItems(target, parentRefs, resolver) + if err != nil { + return &target, err + } + target = *t + + for i := range target.AllOf { + t, err := expandSchema(target.AllOf[i], parentRefs, resolver) + if err != nil { + return &target, err + } + target.AllOf[i] = *t + } + for i := range target.AnyOf { + t, err := expandSchema(target.AnyOf[i], parentRefs, resolver) + if err != nil { + return &target, err + } + target.AnyOf[i] = *t + } + for i := range target.OneOf { + t, err := expandSchema(target.OneOf[i], parentRefs, resolver) + if err != nil { + return &target, err + } + target.OneOf[i] = *t + } + if target.Not != nil { + t, err := expandSchema(*target.Not, parentRefs, resolver) + if err != nil { + return &target, err + } + *target.Not = *t + } + for k := range target.Properties { + t, err := expandSchema(target.Properties[k], parentRefs, resolver) + if err != nil { + return &target, err + } + target.Properties[k] = *t + } + if target.AdditionalProperties != nil && target.AdditionalProperties.Schema != nil { + t, err := expandSchema(*target.AdditionalProperties.Schema, parentRefs, resolver) + if err != nil { + return &target, err + } + *target.AdditionalProperties.Schema = *t + } + for k := range target.PatternProperties { + t, err := expandSchema(target.PatternProperties[k], parentRefs, resolver) + if err != nil { + return &target, err + } + target.PatternProperties[k] = *t + } + for k := range target.Dependencies { + if target.Dependencies[k].Schema != nil { + t, err := expandSchema(*target.Dependencies[k].Schema, parentRefs, resolver) + if err != nil { + return &target, err + } + *target.Dependencies[k].Schema = *t + } + } + if target.AdditionalItems != nil && target.AdditionalItems.Schema != nil { + t, err := expandSchema(*target.AdditionalItems.Schema, parentRefs, resolver) + if err != nil { + return &target, err + } + *target.AdditionalItems.Schema = *t + } + for k := range target.Definitions { + t, err := expandSchema(target.Definitions[k], parentRefs, resolver) + if err != nil { + return &target, err + } + target.Definitions[k] = *t + } + return &target, nil +} + +func expandPathItem(pathItem *PathItem, resolver *schemaLoader) error { + if pathItem == nil { + return nil + } + if pathItem.Ref.String() != "" { + if err := resolver.Resolve(&pathItem.Ref, &pathItem); err != nil { + return err + } + } + + for idx := range pathItem.Parameters { + if err := expandParameter(&(pathItem.Parameters[idx]), resolver); err != nil { + return err + } + } + if err := expandOperation(pathItem.Get, resolver); err != nil { + return err + } + if err := expandOperation(pathItem.Head, resolver); err != nil { + return err + } + if err := expandOperation(pathItem.Options, resolver); err != nil { + return err + } + if err := expandOperation(pathItem.Put, resolver); err != nil { + return err + } + if err := expandOperation(pathItem.Post, resolver); err != nil { + return err + } + if err := expandOperation(pathItem.Patch, resolver); err != nil { + return err + } + if err := expandOperation(pathItem.Delete, resolver); err != nil { + return err + } + return nil +} + +func expandOperation(op *Operation, resolver *schemaLoader) error { + if op == nil { + return nil + } + for i, param := range op.Parameters { + if err := expandParameter(¶m, resolver); err != nil { + return err + } + op.Parameters[i] = param + } + + if op.Responses != nil { + responses := op.Responses + if err := expandResponse(responses.Default, resolver); err != nil { + return err + } + for code, response := range responses.StatusCodeResponses { + if err := expandResponse(&response, resolver); err != nil { + return err + } + responses.StatusCodeResponses[code] = response + } + } + return nil +} + +func expandResponse(response *Response, resolver *schemaLoader) error { + if response == nil { + return nil + } + + var parentRefs []string + if response.Ref.String() != "" { + parentRefs = append(parentRefs, response.Ref.String()) + if err := resolver.Resolve(&response.Ref, response); err != nil { + return err + } + } + + if response.Schema != nil { + parentRefs = append(parentRefs, response.Schema.Ref.String()) + if err := resolver.Resolve(&response.Schema.Ref, &response.Schema); err != nil { + return err + } + s, err := expandSchema(*response.Schema, parentRefs, resolver) + if err != nil { + return err + } + *response.Schema = *s + } + return nil +} + +func expandParameter(parameter *Parameter, resolver *schemaLoader) error { + if parameter == nil { + return nil + } + + var parentRefs []string + if parameter.Ref.String() != "" { + parentRefs = append(parentRefs, parameter.Ref.String()) + if err := resolver.Resolve(¶meter.Ref, parameter); err != nil { + return err + } + } + if parameter.Schema != nil { + parentRefs = append(parentRefs, parameter.Schema.Ref.String()) + if err := resolver.Resolve(¶meter.Schema.Ref, ¶meter.Schema); err != nil { + return err + } + s, err := expandSchema(*parameter.Schema, parentRefs, resolver) + if err != nil { + return err + } + *parameter.Schema = *s + } + return nil +} diff --git a/vendor/github.com/go-openapi/spec/external_docs.go b/vendor/github.com/go-openapi/spec/external_docs.go new file mode 100644 index 0000000..88add91 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/external_docs.go @@ -0,0 +1,24 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +// ExternalDocumentation allows referencing an external resource for +// extended documentation. +// +// For more information: http://goo.gl/8us55a#externalDocumentationObject +type ExternalDocumentation struct { + Description string `json:"description,omitempty"` + URL string `json:"url,omitempty"` +} diff --git a/vendor/github.com/go-openapi/spec/header.go b/vendor/github.com/go-openapi/spec/header.go new file mode 100644 index 0000000..1feb8a1 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/header.go @@ -0,0 +1,169 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + + "github.com/go-openapi/swag" +) + +type HeaderProps struct { + Description string `json:"description,omitempty"` +} + +// Header describes a header for a response of the API +// +// For more information: http://goo.gl/8us55a#headerObject +type Header struct { + CommonValidations + SimpleSchema + VendorExtensible + HeaderProps +} + +// ResponseHeader creates a new header instance for use in a response +func ResponseHeader() *Header { + return new(Header) +} + +// WithDescription sets the description on this response, allows for chaining +func (h *Header) WithDescription(description string) *Header { + h.Description = description + return h +} + +// Typed a fluent builder method for the type of parameter +func (h *Header) Typed(tpe, format string) *Header { + h.Type = tpe + h.Format = format + return h +} + +// CollectionOf a fluent builder method for an array item +func (h *Header) CollectionOf(items *Items, format string) *Header { + h.Type = "array" + h.Items = items + h.CollectionFormat = format + return h +} + +// WithDefault sets the default value on this item +func (h *Header) WithDefault(defaultValue interface{}) *Header { + h.Default = defaultValue + return h +} + +// WithMaxLength sets a max length value +func (h *Header) WithMaxLength(max int64) *Header { + h.MaxLength = &max + return h +} + +// WithMinLength sets a min length value +func (h *Header) WithMinLength(min int64) *Header { + h.MinLength = &min + return h +} + +// WithPattern sets a pattern value +func (h *Header) WithPattern(pattern string) *Header { + h.Pattern = pattern + return h +} + +// WithMultipleOf sets a multiple of value +func (h *Header) WithMultipleOf(number float64) *Header { + h.MultipleOf = &number + return h +} + +// WithMaximum sets a maximum number value +func (h *Header) WithMaximum(max float64, exclusive bool) *Header { + h.Maximum = &max + h.ExclusiveMaximum = exclusive + return h +} + +// WithMinimum sets a minimum number value +func (h *Header) WithMinimum(min float64, exclusive bool) *Header { + h.Minimum = &min + h.ExclusiveMinimum = exclusive + return h +} + +// WithEnum sets a the enum values (replace) +func (h *Header) WithEnum(values ...interface{}) *Header { + h.Enum = append([]interface{}{}, values...) + return h +} + +// WithMaxItems sets the max items +func (h *Header) WithMaxItems(size int64) *Header { + h.MaxItems = &size + return h +} + +// WithMinItems sets the min items +func (h *Header) WithMinItems(size int64) *Header { + h.MinItems = &size + return h +} + +// UniqueValues dictates that this array can only have unique items +func (h *Header) UniqueValues() *Header { + h.UniqueItems = true + return h +} + +// AllowDuplicates this array can have duplicates +func (h *Header) AllowDuplicates() *Header { + h.UniqueItems = false + return h +} + +// MarshalJSON marshal this to JSON +func (h Header) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(h.CommonValidations) + if err != nil { + return nil, err + } + b2, err := json.Marshal(h.SimpleSchema) + if err != nil { + return nil, err + } + b3, err := json.Marshal(h.HeaderProps) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2, b3), nil +} + +// UnmarshalJSON marshal this from JSON +func (h *Header) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &h.CommonValidations); err != nil { + return err + } + if err := json.Unmarshal(data, &h.SimpleSchema); err != nil { + return err + } + if err := json.Unmarshal(data, &h.VendorExtensible); err != nil { + return err + } + if err := json.Unmarshal(data, &h.HeaderProps); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/go-openapi/spec/info.go b/vendor/github.com/go-openapi/spec/info.go new file mode 100644 index 0000000..fb8b7c4 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/info.go @@ -0,0 +1,168 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + "strings" + + "github.com/go-openapi/jsonpointer" + "github.com/go-openapi/swag" +) + +// Extensions vendor specific extensions +type Extensions map[string]interface{} + +// Add adds a value to these extensions +func (e Extensions) Add(key string, value interface{}) { + realKey := strings.ToLower(key) + e[realKey] = value +} + +// GetString gets a string value from the extensions +func (e Extensions) GetString(key string) (string, bool) { + if v, ok := e[strings.ToLower(key)]; ok { + str, ok := v.(string) + return str, ok + } + return "", false +} + +// GetBool gets a string value from the extensions +func (e Extensions) GetBool(key string) (bool, bool) { + if v, ok := e[strings.ToLower(key)]; ok { + str, ok := v.(bool) + return str, ok + } + return false, false +} + +// GetStringSlice gets a string value from the extensions +func (e Extensions) GetStringSlice(key string) ([]string, bool) { + if v, ok := e[strings.ToLower(key)]; ok { + arr, ok := v.([]interface{}) + if !ok { + return nil, false + } + var strs []string + for _, iface := range arr { + str, ok := iface.(string) + if !ok { + return nil, false + } + strs = append(strs, str) + } + return strs, ok + } + return nil, false +} + +// VendorExtensible composition block. +type VendorExtensible struct { + Extensions Extensions +} + +// AddExtension adds an extension to this extensible object +func (v *VendorExtensible) AddExtension(key string, value interface{}) { + if value == nil { + return + } + if v.Extensions == nil { + v.Extensions = make(map[string]interface{}) + } + v.Extensions.Add(key, value) +} + +// MarshalJSON marshals the extensions to json +func (v VendorExtensible) MarshalJSON() ([]byte, error) { + toser := make(map[string]interface{}) + for k, v := range v.Extensions { + lk := strings.ToLower(k) + if strings.HasPrefix(lk, "x-") { + toser[k] = v + } + } + return json.Marshal(toser) +} + +// UnmarshalJSON for this extensible object +func (v *VendorExtensible) UnmarshalJSON(data []byte) error { + var d map[string]interface{} + if err := json.Unmarshal(data, &d); err != nil { + return err + } + for k, vv := range d { + lk := strings.ToLower(k) + if strings.HasPrefix(lk, "x-") { + if v.Extensions == nil { + v.Extensions = map[string]interface{}{} + } + v.Extensions[k] = vv + } + } + return nil +} + +// InfoProps the properties for an info definition +type InfoProps struct { + Description string `json:"description,omitempty"` + Title string `json:"title,omitempty"` + TermsOfService string `json:"termsOfService,omitempty"` + Contact *ContactInfo `json:"contact,omitempty"` + License *License `json:"license,omitempty"` + Version string `json:"version,omitempty"` +} + +// Info object provides metadata about the API. +// The metadata can be used by the clients if needed, and can be presented in the Swagger-UI for convenience. +// +// For more information: http://goo.gl/8us55a#infoObject +type Info struct { + VendorExtensible + InfoProps +} + +// JSONLookup look up a value by the json property name +func (i Info) JSONLookup(token string) (interface{}, error) { + if ex, ok := i.Extensions[token]; ok { + return &ex, nil + } + r, _, err := jsonpointer.GetForToken(i.InfoProps, token) + return r, err +} + +// MarshalJSON marshal this to JSON +func (i Info) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(i.InfoProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(i.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +// UnmarshalJSON marshal this from JSON +func (i *Info) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &i.InfoProps); err != nil { + return err + } + if err := json.Unmarshal(data, &i.VendorExtensible); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/go-openapi/spec/items.go b/vendor/github.com/go-openapi/spec/items.go new file mode 100644 index 0000000..4d57ea5 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/items.go @@ -0,0 +1,199 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + + "github.com/go-openapi/swag" +) + +type SimpleSchema struct { + Type string `json:"type,omitempty"` + Format string `json:"format,omitempty"` + Items *Items `json:"items,omitempty"` + CollectionFormat string `json:"collectionFormat,omitempty"` + Default interface{} `json:"default,omitempty"` +} + +func (s *SimpleSchema) TypeName() string { + if s.Format != "" { + return s.Format + } + return s.Type +} + +func (s *SimpleSchema) ItemsTypeName() string { + if s.Items == nil { + return "" + } + return s.Items.TypeName() +} + +type CommonValidations struct { + Maximum *float64 `json:"maximum,omitempty"` + ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty"` + Minimum *float64 `json:"minimum,omitempty"` + ExclusiveMinimum bool `json:"exclusiveMinimum,omitempty"` + MaxLength *int64 `json:"maxLength,omitempty"` + MinLength *int64 `json:"minLength,omitempty"` + Pattern string `json:"pattern,omitempty"` + MaxItems *int64 `json:"maxItems,omitempty"` + MinItems *int64 `json:"minItems,omitempty"` + UniqueItems bool `json:"uniqueItems,omitempty"` + MultipleOf *float64 `json:"multipleOf,omitempty"` + Enum []interface{} `json:"enum,omitempty"` +} + +// Items a limited subset of JSON-Schema's items object. +// It is used by parameter definitions that are not located in "body". +// +// For more information: http://goo.gl/8us55a#items-object- +type Items struct { + Refable + CommonValidations + SimpleSchema +} + +// NewItems creates a new instance of items +func NewItems() *Items { + return &Items{} +} + +// Typed a fluent builder method for the type of item +func (i *Items) Typed(tpe, format string) *Items { + i.Type = tpe + i.Format = format + return i +} + +// CollectionOf a fluent builder method for an array item +func (i *Items) CollectionOf(items *Items, format string) *Items { + i.Type = "array" + i.Items = items + i.CollectionFormat = format + return i +} + +// WithDefault sets the default value on this item +func (i *Items) WithDefault(defaultValue interface{}) *Items { + i.Default = defaultValue + return i +} + +// WithMaxLength sets a max length value +func (i *Items) WithMaxLength(max int64) *Items { + i.MaxLength = &max + return i +} + +// WithMinLength sets a min length value +func (i *Items) WithMinLength(min int64) *Items { + i.MinLength = &min + return i +} + +// WithPattern sets a pattern value +func (i *Items) WithPattern(pattern string) *Items { + i.Pattern = pattern + return i +} + +// WithMultipleOf sets a multiple of value +func (i *Items) WithMultipleOf(number float64) *Items { + i.MultipleOf = &number + return i +} + +// WithMaximum sets a maximum number value +func (i *Items) WithMaximum(max float64, exclusive bool) *Items { + i.Maximum = &max + i.ExclusiveMaximum = exclusive + return i +} + +// WithMinimum sets a minimum number value +func (i *Items) WithMinimum(min float64, exclusive bool) *Items { + i.Minimum = &min + i.ExclusiveMinimum = exclusive + return i +} + +// WithEnum sets a the enum values (replace) +func (i *Items) WithEnum(values ...interface{}) *Items { + i.Enum = append([]interface{}{}, values...) + return i +} + +// WithMaxItems sets the max items +func (i *Items) WithMaxItems(size int64) *Items { + i.MaxItems = &size + return i +} + +// WithMinItems sets the min items +func (i *Items) WithMinItems(size int64) *Items { + i.MinItems = &size + return i +} + +// UniqueValues dictates that this array can only have unique items +func (i *Items) UniqueValues() *Items { + i.UniqueItems = true + return i +} + +// AllowDuplicates this array can have duplicates +func (i *Items) AllowDuplicates() *Items { + i.UniqueItems = false + return i +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (i *Items) UnmarshalJSON(data []byte) error { + var validations CommonValidations + if err := json.Unmarshal(data, &validations); err != nil { + return err + } + var ref Refable + if err := json.Unmarshal(data, &ref); err != nil { + return err + } + var simpleSchema SimpleSchema + if err := json.Unmarshal(data, &simpleSchema); err != nil { + return err + } + i.Refable = ref + i.CommonValidations = validations + i.SimpleSchema = simpleSchema + return nil +} + +// MarshalJSON converts this items object to JSON +func (i Items) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(i.CommonValidations) + if err != nil { + return nil, err + } + b2, err := json.Marshal(i.SimpleSchema) + if err != nil { + return nil, err + } + b3, err := json.Marshal(i.Refable) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b3, b1, b2), nil +} diff --git a/vendor/github.com/go-openapi/spec/license.go b/vendor/github.com/go-openapi/spec/license.go new file mode 100644 index 0000000..f20961b --- /dev/null +++ b/vendor/github.com/go-openapi/spec/license.go @@ -0,0 +1,23 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +// License information for the exposed API. +// +// For more information: http://goo.gl/8us55a#licenseObject +type License struct { + Name string `json:"name,omitempty"` + URL string `json:"url,omitempty"` +} diff --git a/vendor/github.com/go-openapi/spec/operation.go b/vendor/github.com/go-openapi/spec/operation.go new file mode 100644 index 0000000..de1db6f --- /dev/null +++ b/vendor/github.com/go-openapi/spec/operation.go @@ -0,0 +1,233 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + + "github.com/go-openapi/jsonpointer" + "github.com/go-openapi/swag" +) + +type OperationProps struct { + Description string `json:"description,omitempty"` + Consumes []string `json:"consumes,omitempty"` + Produces []string `json:"produces,omitempty"` + Schemes []string `json:"schemes,omitempty"` // the scheme, when present must be from [http, https, ws, wss] + Tags []string `json:"tags,omitempty"` + Summary string `json:"summary,omitempty"` + ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"` + ID string `json:"operationId,omitempty"` + Deprecated bool `json:"deprecated,omitempty"` + Security []map[string][]string `json:"security,omitempty"` + Parameters []Parameter `json:"parameters,omitempty"` + Responses *Responses `json:"responses,omitempty"` +} + +// Operation describes a single API operation on a path. +// +// For more information: http://goo.gl/8us55a#operationObject +type Operation struct { + VendorExtensible + OperationProps +} + +// SuccessResponse gets a success response model +func (o *Operation) SuccessResponse() (*Response, int, bool) { + if o.Responses == nil { + return nil, 0, false + } + + for k, v := range o.Responses.StatusCodeResponses { + if k/100 == 2 { + return &v, k, true + } + } + + return o.Responses.Default, 0, false +} + +// JSONLookup look up a value by the json property name +func (o Operation) JSONLookup(token string) (interface{}, error) { + if ex, ok := o.Extensions[token]; ok { + return &ex, nil + } + r, _, err := jsonpointer.GetForToken(o.OperationProps, token) + return r, err +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (o *Operation) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &o.OperationProps); err != nil { + return err + } + if err := json.Unmarshal(data, &o.VendorExtensible); err != nil { + return err + } + return nil +} + +// MarshalJSON converts this items object to JSON +func (o Operation) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(o.OperationProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(o.VendorExtensible) + if err != nil { + return nil, err + } + concated := swag.ConcatJSON(b1, b2) + return concated, nil +} + +// NewOperation creates a new operation instance. +// It expects an ID as parameter but not passing an ID is also valid. +func NewOperation(id string) *Operation { + op := new(Operation) + op.ID = id + return op +} + +// WithID sets the ID property on this operation, allows for chaining. +func (o *Operation) WithID(id string) *Operation { + o.ID = id + return o +} + +// WithDescription sets the description on this operation, allows for chaining +func (o *Operation) WithDescription(description string) *Operation { + o.Description = description + return o +} + +// WithSummary sets the summary on this operation, allows for chaining +func (o *Operation) WithSummary(summary string) *Operation { + o.Summary = summary + return o +} + +// WithExternalDocs sets/removes the external docs for/from this operation. +// When you pass empty strings as params the external documents will be removed. +// When you pass non-empty string as one value then those values will be used on the external docs object. +// So when you pass a non-empty description, you should also pass the url and vice versa. +func (o *Operation) WithExternalDocs(description, url string) *Operation { + if description == "" && url == "" { + o.ExternalDocs = nil + return o + } + + if o.ExternalDocs == nil { + o.ExternalDocs = &ExternalDocumentation{} + } + o.ExternalDocs.Description = description + o.ExternalDocs.URL = url + return o +} + +// Deprecate marks the operation as deprecated +func (o *Operation) Deprecate() *Operation { + o.Deprecated = true + return o +} + +// Undeprecate marks the operation as not deprected +func (o *Operation) Undeprecate() *Operation { + o.Deprecated = false + return o +} + +// WithConsumes adds media types for incoming body values +func (o *Operation) WithConsumes(mediaTypes ...string) *Operation { + o.Consumes = append(o.Consumes, mediaTypes...) + return o +} + +// WithProduces adds media types for outgoing body values +func (o *Operation) WithProduces(mediaTypes ...string) *Operation { + o.Produces = append(o.Produces, mediaTypes...) + return o +} + +// WithTags adds tags for this operation +func (o *Operation) WithTags(tags ...string) *Operation { + o.Tags = append(o.Tags, tags...) + return o +} + +// AddParam adds a parameter to this operation, when a parameter for that location +// and with that name already exists it will be replaced +func (o *Operation) AddParam(param *Parameter) *Operation { + if param == nil { + return o + } + + for i, p := range o.Parameters { + if p.Name == param.Name && p.In == param.In { + params := append(o.Parameters[:i], *param) + params = append(params, o.Parameters[i+1:]...) + o.Parameters = params + return o + } + } + + o.Parameters = append(o.Parameters, *param) + return o +} + +// RemoveParam removes a parameter from the operation +func (o *Operation) RemoveParam(name, in string) *Operation { + for i, p := range o.Parameters { + if p.Name == name && p.In == name { + o.Parameters = append(o.Parameters[:i], o.Parameters[i+1:]...) + return o + } + } + return o +} + +// SecuredWith adds a security scope to this operation. +func (o *Operation) SecuredWith(name string, scopes ...string) *Operation { + o.Security = append(o.Security, map[string][]string{name: scopes}) + return o +} + +// WithDefaultResponse adds a default response to the operation. +// Passing a nil value will remove the response +func (o *Operation) WithDefaultResponse(response *Response) *Operation { + return o.RespondsWith(0, response) +} + +// RespondsWith adds a status code response to the operation. +// When the code is 0 the value of the response will be used as default response value. +// When the value of the response is nil it will be removed from the operation +func (o *Operation) RespondsWith(code int, response *Response) *Operation { + if o.Responses == nil { + o.Responses = new(Responses) + } + if code == 0 { + o.Responses.Default = response + return o + } + if response == nil { + delete(o.Responses.StatusCodeResponses, code) + return o + } + if o.Responses.StatusCodeResponses == nil { + o.Responses.StatusCodeResponses = make(map[int]Response) + } + o.Responses.StatusCodeResponses[code] = *response + return o +} diff --git a/vendor/github.com/go-openapi/spec/parameter.go b/vendor/github.com/go-openapi/spec/parameter.go new file mode 100644 index 0000000..8fb66d1 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/parameter.go @@ -0,0 +1,299 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + + "github.com/go-openapi/jsonpointer" + "github.com/go-openapi/swag" +) + +// QueryParam creates a query parameter +func QueryParam(name string) *Parameter { + return &Parameter{ParamProps: ParamProps{Name: name, In: "query"}} +} + +// HeaderParam creates a header parameter, this is always required by default +func HeaderParam(name string) *Parameter { + return &Parameter{ParamProps: ParamProps{Name: name, In: "header", Required: true}} +} + +// PathParam creates a path parameter, this is always required +func PathParam(name string) *Parameter { + return &Parameter{ParamProps: ParamProps{Name: name, In: "path", Required: true}} +} + +// BodyParam creates a body parameter +func BodyParam(name string, schema *Schema) *Parameter { + return &Parameter{ParamProps: ParamProps{Name: name, In: "body", Schema: schema}, SimpleSchema: SimpleSchema{Type: "object"}} +} + +// FormDataParam creates a body parameter +func FormDataParam(name string) *Parameter { + return &Parameter{ParamProps: ParamProps{Name: name, In: "formData"}} +} + +// FileParam creates a body parameter +func FileParam(name string) *Parameter { + return &Parameter{ParamProps: ParamProps{Name: name, In: "formData"}, SimpleSchema: SimpleSchema{Type: "file"}} +} + +// SimpleArrayParam creates a param for a simple array (string, int, date etc) +func SimpleArrayParam(name, tpe, fmt string) *Parameter { + return &Parameter{ParamProps: ParamProps{Name: name}, SimpleSchema: SimpleSchema{Type: "array", CollectionFormat: "csv", Items: &Items{SimpleSchema: SimpleSchema{Type: "string", Format: fmt}}}} +} + +// ParamRef creates a parameter that's a json reference +func ParamRef(uri string) *Parameter { + p := new(Parameter) + p.Ref = MustCreateRef(uri) + return p +} + +type ParamProps struct { + Description string `json:"description,omitempty"` + Name string `json:"name,omitempty"` + In string `json:"in,omitempty"` + Required bool `json:"required,omitempty"` + Schema *Schema `json:"schema,omitempty"` // when in == "body" + AllowEmptyValue bool `json:"allowEmptyValue,omitempty"` // when in == "query" || "formData" +} + +// Parameter a unique parameter is defined by a combination of a [name](#parameterName) and [location](#parameterIn). +// +// There are five possible parameter types. +// * Path - Used together with [Path Templating](#pathTemplating), where the parameter value is actually part of the operation's URL. This does not include the host or base path of the API. For example, in `/items/{itemId}`, the path parameter is `itemId`. +// * Query - Parameters that are appended to the URL. For example, in `/items?id=###`, the query parameter is `id`. +// * Header - Custom headers that are expected as part of the request. +// * Body - The payload that's appended to the HTTP request. Since there can only be one payload, there can only be *one* body parameter. The name of the body parameter has no effect on the parameter itself and is used for documentation purposes only. Since Form parameters are also in the payload, body and form parameters cannot exist together for the same operation. +// * Form - Used to describe the payload of an HTTP request when either `application/x-www-form-urlencoded` or `multipart/form-data` are used as the content type of the request (in Swagger's definition, the [`consumes`](#operationConsumes) property of an operation). This is the only parameter type that can be used to send files, thus supporting the `file` type. Since form parameters are sent in the payload, they cannot be declared together with a body parameter for the same operation. Form parameters have a different format based on the content-type used (for further details, consult http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4): +// * `application/x-www-form-urlencoded` - Similar to the format of Query parameters but as a payload. For example, `foo=1&bar=swagger` - both `foo` and `bar` are form parameters. This is normally used for simple parameters that are being transferred. +// * `multipart/form-data` - each parameter takes a section in the payload with an internal header. For example, for the header `Content-Disposition: form-data; name="submit-name"` the name of the parameter is `submit-name`. This type of form parameters is more commonly used for file transfers. +// +// For more information: http://goo.gl/8us55a#parameterObject +type Parameter struct { + Refable + CommonValidations + SimpleSchema + VendorExtensible + ParamProps +} + +// JSONLookup look up a value by the json property name +func (p Parameter) JSONLookup(token string) (interface{}, error) { + if ex, ok := p.Extensions[token]; ok { + return &ex, nil + } + if token == "$ref" { + return &p.Ref, nil + } + r, _, err := jsonpointer.GetForToken(p.CommonValidations, token) + if err != nil { + return nil, err + } + if r != nil { + return r, nil + } + r, _, err = jsonpointer.GetForToken(p.SimpleSchema, token) + if err != nil { + return nil, err + } + if r != nil { + return r, nil + } + r, _, err = jsonpointer.GetForToken(p.ParamProps, token) + return r, err +} + +// WithDescription a fluent builder method for the description of the parameter +func (p *Parameter) WithDescription(description string) *Parameter { + p.Description = description + return p +} + +// Named a fluent builder method to override the name of the parameter +func (p *Parameter) Named(name string) *Parameter { + p.Name = name + return p +} + +// WithLocation a fluent builder method to override the location of the parameter +func (p *Parameter) WithLocation(in string) *Parameter { + p.In = in + return p +} + +// Typed a fluent builder method for the type of the parameter value +func (p *Parameter) Typed(tpe, format string) *Parameter { + p.Type = tpe + p.Format = format + return p +} + +// CollectionOf a fluent builder method for an array parameter +func (p *Parameter) CollectionOf(items *Items, format string) *Parameter { + p.Type = "array" + p.Items = items + p.CollectionFormat = format + return p +} + +// WithDefault sets the default value on this parameter +func (p *Parameter) WithDefault(defaultValue interface{}) *Parameter { + p.AsOptional() // with default implies optional + p.Default = defaultValue + return p +} + +// AllowsEmptyValues flags this parameter as being ok with empty values +func (p *Parameter) AllowsEmptyValues() *Parameter { + p.AllowEmptyValue = true + return p +} + +// NoEmptyValues flags this parameter as not liking empty values +func (p *Parameter) NoEmptyValues() *Parameter { + p.AllowEmptyValue = false + return p +} + +// AsOptional flags this parameter as optional +func (p *Parameter) AsOptional() *Parameter { + p.Required = false + return p +} + +// AsRequired flags this parameter as required +func (p *Parameter) AsRequired() *Parameter { + if p.Default != nil { // with a default required makes no sense + return p + } + p.Required = true + return p +} + +// WithMaxLength sets a max length value +func (p *Parameter) WithMaxLength(max int64) *Parameter { + p.MaxLength = &max + return p +} + +// WithMinLength sets a min length value +func (p *Parameter) WithMinLength(min int64) *Parameter { + p.MinLength = &min + return p +} + +// WithPattern sets a pattern value +func (p *Parameter) WithPattern(pattern string) *Parameter { + p.Pattern = pattern + return p +} + +// WithMultipleOf sets a multiple of value +func (p *Parameter) WithMultipleOf(number float64) *Parameter { + p.MultipleOf = &number + return p +} + +// WithMaximum sets a maximum number value +func (p *Parameter) WithMaximum(max float64, exclusive bool) *Parameter { + p.Maximum = &max + p.ExclusiveMaximum = exclusive + return p +} + +// WithMinimum sets a minimum number value +func (p *Parameter) WithMinimum(min float64, exclusive bool) *Parameter { + p.Minimum = &min + p.ExclusiveMinimum = exclusive + return p +} + +// WithEnum sets a the enum values (replace) +func (p *Parameter) WithEnum(values ...interface{}) *Parameter { + p.Enum = append([]interface{}{}, values...) + return p +} + +// WithMaxItems sets the max items +func (p *Parameter) WithMaxItems(size int64) *Parameter { + p.MaxItems = &size + return p +} + +// WithMinItems sets the min items +func (p *Parameter) WithMinItems(size int64) *Parameter { + p.MinItems = &size + return p +} + +// UniqueValues dictates that this array can only have unique items +func (p *Parameter) UniqueValues() *Parameter { + p.UniqueItems = true + return p +} + +// AllowDuplicates this array can have duplicates +func (p *Parameter) AllowDuplicates() *Parameter { + p.UniqueItems = false + return p +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (p *Parameter) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &p.CommonValidations); err != nil { + return err + } + if err := json.Unmarshal(data, &p.Refable); err != nil { + return err + } + if err := json.Unmarshal(data, &p.SimpleSchema); err != nil { + return err + } + if err := json.Unmarshal(data, &p.VendorExtensible); err != nil { + return err + } + if err := json.Unmarshal(data, &p.ParamProps); err != nil { + return err + } + return nil +} + +// MarshalJSON converts this items object to JSON +func (p Parameter) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(p.CommonValidations) + if err != nil { + return nil, err + } + b2, err := json.Marshal(p.SimpleSchema) + if err != nil { + return nil, err + } + b3, err := json.Marshal(p.Refable) + if err != nil { + return nil, err + } + b4, err := json.Marshal(p.VendorExtensible) + if err != nil { + return nil, err + } + b5, err := json.Marshal(p.ParamProps) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b3, b1, b2, b4, b5), nil +} diff --git a/vendor/github.com/go-openapi/spec/path_item.go b/vendor/github.com/go-openapi/spec/path_item.go new file mode 100644 index 0000000..9ab3ec5 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/path_item.go @@ -0,0 +1,90 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + + "github.com/go-openapi/jsonpointer" + "github.com/go-openapi/swag" +) + +// pathItemProps the path item specific properties +type PathItemProps struct { + Get *Operation `json:"get,omitempty"` + Put *Operation `json:"put,omitempty"` + Post *Operation `json:"post,omitempty"` + Delete *Operation `json:"delete,omitempty"` + Options *Operation `json:"options,omitempty"` + Head *Operation `json:"head,omitempty"` + Patch *Operation `json:"patch,omitempty"` + Parameters []Parameter `json:"parameters,omitempty"` +} + +// PathItem describes the operations available on a single path. +// A Path Item may be empty, due to [ACL constraints](http://goo.gl/8us55a#securityFiltering). +// The path itself is still exposed to the documentation viewer but they will +// not know which operations and parameters are available. +// +// For more information: http://goo.gl/8us55a#pathItemObject +type PathItem struct { + Refable + VendorExtensible + PathItemProps +} + +// JSONLookup look up a value by the json property name +func (p PathItem) JSONLookup(token string) (interface{}, error) { + if ex, ok := p.Extensions[token]; ok { + return &ex, nil + } + if token == "$ref" { + return &p.Ref, nil + } + r, _, err := jsonpointer.GetForToken(p.PathItemProps, token) + return r, err +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (p *PathItem) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &p.Refable); err != nil { + return err + } + if err := json.Unmarshal(data, &p.VendorExtensible); err != nil { + return err + } + if err := json.Unmarshal(data, &p.PathItemProps); err != nil { + return err + } + return nil +} + +// MarshalJSON converts this items object to JSON +func (p PathItem) MarshalJSON() ([]byte, error) { + b3, err := json.Marshal(p.Refable) + if err != nil { + return nil, err + } + b4, err := json.Marshal(p.VendorExtensible) + if err != nil { + return nil, err + } + b5, err := json.Marshal(p.PathItemProps) + if err != nil { + return nil, err + } + concated := swag.ConcatJSON(b3, b4, b5) + return concated, nil +} diff --git a/vendor/github.com/go-openapi/spec/paths.go b/vendor/github.com/go-openapi/spec/paths.go new file mode 100644 index 0000000..9dc82a2 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/paths.go @@ -0,0 +1,97 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + "fmt" + "strings" + + "github.com/go-openapi/swag" +) + +// Paths holds the relative paths to the individual endpoints. +// The path is appended to the [`basePath`](http://goo.gl/8us55a#swaggerBasePath) in order +// to construct the full URL. +// The Paths may be empty, due to [ACL constraints](http://goo.gl/8us55a#securityFiltering). +// +// For more information: http://goo.gl/8us55a#pathsObject +type Paths struct { + VendorExtensible + Paths map[string]PathItem `json:"-"` // custom serializer to flatten this, each entry must start with "/" +} + +// JSONLookup look up a value by the json property name +func (p Paths) JSONLookup(token string) (interface{}, error) { + if pi, ok := p.Paths[token]; ok { + return &pi, nil + } + if ex, ok := p.Extensions[token]; ok { + return &ex, nil + } + return nil, fmt.Errorf("object has no field %q", token) +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (p *Paths) UnmarshalJSON(data []byte) error { + var res map[string]json.RawMessage + if err := json.Unmarshal(data, &res); err != nil { + return err + } + for k, v := range res { + if strings.HasPrefix(strings.ToLower(k), "x-") { + if p.Extensions == nil { + p.Extensions = make(map[string]interface{}) + } + var d interface{} + if err := json.Unmarshal(v, &d); err != nil { + return err + } + p.Extensions[k] = d + } + if strings.HasPrefix(k, "/") { + if p.Paths == nil { + p.Paths = make(map[string]PathItem) + } + var pi PathItem + if err := json.Unmarshal(v, &pi); err != nil { + return err + } + p.Paths[k] = pi + } + } + return nil +} + +// MarshalJSON converts this items object to JSON +func (p Paths) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(p.VendorExtensible) + if err != nil { + return nil, err + } + + pths := make(map[string]PathItem) + for k, v := range p.Paths { + if strings.HasPrefix(k, "/") { + pths[k] = v + } + } + b2, err := json.Marshal(pths) + if err != nil { + return nil, err + } + concated := swag.ConcatJSON(b1, b2) + return concated, nil +} diff --git a/vendor/github.com/go-openapi/spec/ref.go b/vendor/github.com/go-openapi/spec/ref.go new file mode 100644 index 0000000..68631df --- /dev/null +++ b/vendor/github.com/go-openapi/spec/ref.go @@ -0,0 +1,167 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + "net/http" + "os" + "path/filepath" + + "github.com/go-openapi/jsonreference" +) + +// Refable is a struct for things that accept a $ref property +type Refable struct { + Ref Ref +} + +// MarshalJSON marshals the ref to json +func (r Refable) MarshalJSON() ([]byte, error) { + return r.Ref.MarshalJSON() +} + +// UnmarshalJSON unmarshalss the ref from json +func (r *Refable) UnmarshalJSON(d []byte) error { + return json.Unmarshal(d, &r.Ref) +} + +// Ref represents a json reference that is potentially resolved +type Ref struct { + jsonreference.Ref +} + +// RemoteURI gets the remote uri part of the ref +func (r *Ref) RemoteURI() string { + if r.String() == "" { + return r.String() + } + + u := *r.GetURL() + u.Fragment = "" + return u.String() +} + +// IsValidURI returns true when the url the ref points to can be found +func (r *Ref) IsValidURI() bool { + if r.String() == "" { + return true + } + + v := r.RemoteURI() + if v == "" { + return true + } + + if r.HasFullURL { + rr, err := http.Get(v) + if err != nil { + return false + } + + return rr.StatusCode/100 == 2 + } + + if !(r.HasFileScheme || r.HasFullFilePath || r.HasURLPathOnly) { + return false + } + + // check for local file + pth := v + if r.HasURLPathOnly { + p, e := filepath.Abs(pth) + if e != nil { + return false + } + pth = p + } + + fi, err := os.Stat(pth) + if err != nil { + return false + } + + return !fi.IsDir() +} + +// Inherits creates a new reference from a parent and a child +// If the child cannot inherit from the parent, an error is returned +func (r *Ref) Inherits(child Ref) (*Ref, error) { + ref, err := r.Ref.Inherits(child.Ref) + if err != nil { + return nil, err + } + return &Ref{Ref: *ref}, nil +} + +// NewRef creates a new instance of a ref object +// returns an error when the reference uri is an invalid uri +func NewRef(refURI string) (Ref, error) { + ref, err := jsonreference.New(refURI) + if err != nil { + return Ref{}, err + } + return Ref{Ref: ref}, nil +} + +// MustCreateRef creates a ref object but +func MustCreateRef(refURI string) Ref { + return Ref{Ref: jsonreference.MustCreateRef(refURI)} +} + +// // NewResolvedRef creates a resolved ref +// func NewResolvedRef(refURI string, data interface{}) Ref { +// return Ref{ +// Ref: jsonreference.MustCreateRef(refURI), +// Resolved: data, +// } +// } + +// MarshalJSON marshals this ref into a JSON object +func (r Ref) MarshalJSON() ([]byte, error) { + str := r.String() + if str == "" { + if r.IsRoot() { + return []byte(`{"$ref":"#"}`), nil + } + return []byte("{}"), nil + } + v := map[string]interface{}{"$ref": str} + return json.Marshal(v) +} + +// UnmarshalJSON unmarshals this ref from a JSON object +func (r *Ref) UnmarshalJSON(d []byte) error { + var v map[string]interface{} + if err := json.Unmarshal(d, &v); err != nil { + return err + } + + if v == nil { + return nil + } + + if vv, ok := v["$ref"]; ok { + if str, ok := vv.(string); ok { + ref, err := jsonreference.New(str) + if err != nil { + return err + } + *r = Ref{Ref: ref} + } + } + + return nil +} diff --git a/vendor/github.com/go-openapi/spec/response.go b/vendor/github.com/go-openapi/spec/response.go new file mode 100644 index 0000000..308cc84 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/response.go @@ -0,0 +1,113 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + + "github.com/go-openapi/swag" +) + +// ResponseProps properties specific to a response +type ResponseProps struct { + Description string `json:"description,omitempty"` + Schema *Schema `json:"schema,omitempty"` + Headers map[string]Header `json:"headers,omitempty"` + Examples map[string]interface{} `json:"examples,omitempty"` +} + +// Response describes a single response from an API Operation. +// +// For more information: http://goo.gl/8us55a#responseObject +type Response struct { + Refable + ResponseProps +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (r *Response) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &r.ResponseProps); err != nil { + return err + } + if err := json.Unmarshal(data, &r.Refable); err != nil { + return err + } + return nil +} + +// MarshalJSON converts this items object to JSON +func (r Response) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(r.ResponseProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(r.Refable) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +// NewResponse creates a new response instance +func NewResponse() *Response { + return new(Response) +} + +// ResponseRef creates a response as a json reference +func ResponseRef(url string) *Response { + resp := NewResponse() + resp.Ref = MustCreateRef(url) + return resp +} + +// WithDescription sets the description on this response, allows for chaining +func (r *Response) WithDescription(description string) *Response { + r.Description = description + return r +} + +// WithSchema sets the schema on this response, allows for chaining. +// Passing a nil argument removes the schema from this response +func (r *Response) WithSchema(schema *Schema) *Response { + r.Schema = schema + return r +} + +// AddHeader adds a header to this response +func (r *Response) AddHeader(name string, header *Header) *Response { + if header == nil { + return r.RemoveHeader(name) + } + if r.Headers == nil { + r.Headers = make(map[string]Header) + } + r.Headers[name] = *header + return r +} + +// RemoveHeader removes a header from this response +func (r *Response) RemoveHeader(name string) *Response { + delete(r.Headers, name) + return r +} + +// AddExample adds an example to this response +func (r *Response) AddExample(mediaType string, example interface{}) *Response { + if r.Examples == nil { + r.Examples = make(map[string]interface{}) + } + r.Examples[mediaType] = example + return r +} diff --git a/vendor/github.com/go-openapi/spec/responses.go b/vendor/github.com/go-openapi/spec/responses.go new file mode 100644 index 0000000..ea071ca --- /dev/null +++ b/vendor/github.com/go-openapi/spec/responses.go @@ -0,0 +1,122 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + "fmt" + "reflect" + "strconv" + + "github.com/go-openapi/swag" +) + +// Responses is a container for the expected responses of an operation. +// The container maps a HTTP response code to the expected response. +// It is not expected from the documentation to necessarily cover all possible HTTP response codes, +// since they may not be known in advance. However, it is expected from the documentation to cover +// a successful operation response and any known errors. +// +// The `default` can be used a default response object for all HTTP codes that are not covered +// individually by the specification. +// +// The `Responses Object` MUST contain at least one response code, and it SHOULD be the response +// for a successful operation call. +// +// For more information: http://goo.gl/8us55a#responsesObject +type Responses struct { + VendorExtensible + ResponsesProps +} + +// JSONLookup implements an interface to customize json pointer lookup +func (r Responses) JSONLookup(token string) (interface{}, error) { + if token == "default" { + return r.Default, nil + } + if ex, ok := r.Extensions[token]; ok { + return &ex, nil + } + if i, err := strconv.Atoi(token); err == nil { + if scr, ok := r.StatusCodeResponses[i]; ok { + return &scr, nil + } + } + return nil, fmt.Errorf("object has no field %q", token) +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (r *Responses) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &r.ResponsesProps); err != nil { + return err + } + if err := json.Unmarshal(data, &r.VendorExtensible); err != nil { + return err + } + if reflect.DeepEqual(ResponsesProps{}, r.ResponsesProps) { + r.ResponsesProps = ResponsesProps{} + } + return nil +} + +// MarshalJSON converts this items object to JSON +func (r Responses) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(r.ResponsesProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(r.VendorExtensible) + if err != nil { + return nil, err + } + concated := swag.ConcatJSON(b1, b2) + return concated, nil +} + +type ResponsesProps struct { + Default *Response + StatusCodeResponses map[int]Response +} + +func (r ResponsesProps) MarshalJSON() ([]byte, error) { + toser := map[string]Response{} + if r.Default != nil { + toser["default"] = *r.Default + } + for k, v := range r.StatusCodeResponses { + toser[strconv.Itoa(k)] = v + } + return json.Marshal(toser) +} + +func (r *ResponsesProps) UnmarshalJSON(data []byte) error { + var res map[string]Response + if err := json.Unmarshal(data, &res); err != nil { + return nil + } + if v, ok := res["default"]; ok { + r.Default = &v + delete(res, "default") + } + for k, v := range res { + if nk, err := strconv.Atoi(k); err == nil { + if r.StatusCodeResponses == nil { + r.StatusCodeResponses = map[int]Response{} + } + r.StatusCodeResponses[nk] = v + } + } + return nil +} diff --git a/vendor/github.com/go-openapi/spec/schema.go b/vendor/github.com/go-openapi/spec/schema.go new file mode 100644 index 0000000..eb88f00 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/schema.go @@ -0,0 +1,628 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + "fmt" + "net/url" + "strings" + + "github.com/go-openapi/jsonpointer" + "github.com/go-openapi/swag" +) + +// BooleanProperty creates a boolean property +func BooleanProperty() *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"boolean"}}} +} + +// BoolProperty creates a boolean property +func BoolProperty() *Schema { return BooleanProperty() } + +// StringProperty creates a string property +func StringProperty() *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}} +} + +// CharProperty creates a string property +func CharProperty() *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}} +} + +// Float64Property creates a float64/double property +func Float64Property() *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"number"}, Format: "double"}} +} + +// Float32Property creates a float32/float property +func Float32Property() *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"number"}, Format: "float"}} +} + +// Int8Property creates an int8 property +func Int8Property() *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int8"}} +} + +// Int16Property creates an int16 property +func Int16Property() *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int16"}} +} + +// Int32Property creates an int32 property +func Int32Property() *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int32"}} +} + +// Int64Property creates an int64 property +func Int64Property() *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int64"}} +} + +// StrFmtProperty creates a property for the named string format +func StrFmtProperty(format string) *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: format}} +} + +// DateProperty creates a date property +func DateProperty() *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: "date"}} +} + +// DateTimeProperty creates a date time property +func DateTimeProperty() *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: "date-time"}} +} + +// MapProperty creates a map property +func MapProperty(property *Schema) *Schema { + return &Schema{SchemaProps: SchemaProps{Type: []string{"object"}, AdditionalProperties: &SchemaOrBool{Allows: true, Schema: property}}} +} + +// RefProperty creates a ref property +func RefProperty(name string) *Schema { + return &Schema{SchemaProps: SchemaProps{Ref: MustCreateRef(name)}} +} + +// RefSchema creates a ref property +func RefSchema(name string) *Schema { + return &Schema{SchemaProps: SchemaProps{Ref: MustCreateRef(name)}} +} + +// ArrayProperty creates an array property +func ArrayProperty(items *Schema) *Schema { + if items == nil { + return &Schema{SchemaProps: SchemaProps{Type: []string{"array"}}} + } + return &Schema{SchemaProps: SchemaProps{Items: &SchemaOrArray{Schema: items}, Type: []string{"array"}}} +} + +// ComposedSchema creates a schema with allOf +func ComposedSchema(schemas ...Schema) *Schema { + s := new(Schema) + s.AllOf = schemas + return s +} + +// SchemaURL represents a schema url +type SchemaURL string + +// MarshalJSON marshal this to JSON +func (r SchemaURL) MarshalJSON() ([]byte, error) { + if r == "" { + return []byte("{}"), nil + } + v := map[string]interface{}{"$schema": string(r)} + return json.Marshal(v) +} + +// UnmarshalJSON unmarshal this from JSON +func (r *SchemaURL) UnmarshalJSON(data []byte) error { + var v map[string]interface{} + if err := json.Unmarshal(data, &v); err != nil { + return err + } + if v == nil { + return nil + } + if vv, ok := v["$schema"]; ok { + if str, ok := vv.(string); ok { + u, err := url.Parse(str) + if err != nil { + return err + } + + *r = SchemaURL(u.String()) + } + } + return nil +} + +// type ExtraSchemaProps map[string]interface{} + +// // JSONSchema represents a structure that is a json schema draft 04 +// type JSONSchema struct { +// SchemaProps +// ExtraSchemaProps +// } + +// // MarshalJSON marshal this to JSON +// func (s JSONSchema) MarshalJSON() ([]byte, error) { +// b1, err := json.Marshal(s.SchemaProps) +// if err != nil { +// return nil, err +// } +// b2, err := s.Ref.MarshalJSON() +// if err != nil { +// return nil, err +// } +// b3, err := s.Schema.MarshalJSON() +// if err != nil { +// return nil, err +// } +// b4, err := json.Marshal(s.ExtraSchemaProps) +// if err != nil { +// return nil, err +// } +// return swag.ConcatJSON(b1, b2, b3, b4), nil +// } + +// // UnmarshalJSON marshal this from JSON +// func (s *JSONSchema) UnmarshalJSON(data []byte) error { +// var sch JSONSchema +// if err := json.Unmarshal(data, &sch.SchemaProps); err != nil { +// return err +// } +// if err := json.Unmarshal(data, &sch.Ref); err != nil { +// return err +// } +// if err := json.Unmarshal(data, &sch.Schema); err != nil { +// return err +// } +// if err := json.Unmarshal(data, &sch.ExtraSchemaProps); err != nil { +// return err +// } +// *s = sch +// return nil +// } + +type SchemaProps struct { + ID string `json:"id,omitempty"` + Ref Ref `json:"-,omitempty"` + Schema SchemaURL `json:"-,omitempty"` + Description string `json:"description,omitempty"` + Type StringOrArray `json:"type,omitempty"` + Format string `json:"format,omitempty"` + Title string `json:"title,omitempty"` + Default interface{} `json:"default,omitempty"` + Maximum *float64 `json:"maximum,omitempty"` + ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty"` + Minimum *float64 `json:"minimum,omitempty"` + ExclusiveMinimum bool `json:"exclusiveMinimum,omitempty"` + MaxLength *int64 `json:"maxLength,omitempty"` + MinLength *int64 `json:"minLength,omitempty"` + Pattern string `json:"pattern,omitempty"` + MaxItems *int64 `json:"maxItems,omitempty"` + MinItems *int64 `json:"minItems,omitempty"` + UniqueItems bool `json:"uniqueItems,omitempty"` + MultipleOf *float64 `json:"multipleOf,omitempty"` + Enum []interface{} `json:"enum,omitempty"` + MaxProperties *int64 `json:"maxProperties,omitempty"` + MinProperties *int64 `json:"minProperties,omitempty"` + Required []string `json:"required,omitempty"` + Items *SchemaOrArray `json:"items,omitempty"` + AllOf []Schema `json:"allOf,omitempty"` + OneOf []Schema `json:"oneOf,omitempty"` + AnyOf []Schema `json:"anyOf,omitempty"` + Not *Schema `json:"not,omitempty"` + Properties map[string]Schema `json:"properties,omitempty"` + AdditionalProperties *SchemaOrBool `json:"additionalProperties,omitempty"` + PatternProperties map[string]Schema `json:"patternProperties,omitempty"` + Dependencies Dependencies `json:"dependencies,omitempty"` + AdditionalItems *SchemaOrBool `json:"additionalItems,omitempty"` + Definitions Definitions `json:"definitions,omitempty"` +} + +type SwaggerSchemaProps struct { + Discriminator string `json:"discriminator,omitempty"` + ReadOnly bool `json:"readOnly,omitempty"` + XML *XMLObject `json:"xml,omitempty"` + ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"` + Example interface{} `json:"example,omitempty"` +} + +// Schema the schema object allows the definition of input and output data types. +// These types can be objects, but also primitives and arrays. +// This object is based on the [JSON Schema Specification Draft 4](http://json-schema.org/) +// and uses a predefined subset of it. +// On top of this subset, there are extensions provided by this specification to allow for more complete documentation. +// +// For more information: http://goo.gl/8us55a#schemaObject +type Schema struct { + VendorExtensible + SchemaProps + SwaggerSchemaProps + ExtraProps map[string]interface{} `json:"-"` +} + +// JSONLookup implements an interface to customize json pointer lookup +func (s Schema) JSONLookup(token string) (interface{}, error) { + if ex, ok := s.Extensions[token]; ok { + return &ex, nil + } + + if ex, ok := s.ExtraProps[token]; ok { + return &ex, nil + } + + r, _, err := jsonpointer.GetForToken(s.SchemaProps, token) + if r != nil || err != nil { + return r, err + } + r, _, err = jsonpointer.GetForToken(s.SwaggerSchemaProps, token) + return r, err +} + +// WithID sets the id for this schema, allows for chaining +func (s *Schema) WithID(id string) *Schema { + s.ID = id + return s +} + +// WithTitle sets the title for this schema, allows for chaining +func (s *Schema) WithTitle(title string) *Schema { + s.Title = title + return s +} + +// WithDescription sets the description for this schema, allows for chaining +func (s *Schema) WithDescription(description string) *Schema { + s.Description = description + return s +} + +// WithProperties sets the properties for this schema +func (s *Schema) WithProperties(schemas map[string]Schema) *Schema { + s.Properties = schemas + return s +} + +// SetProperty sets a property on this schema +func (s *Schema) SetProperty(name string, schema Schema) *Schema { + if s.Properties == nil { + s.Properties = make(map[string]Schema) + } + s.Properties[name] = schema + return s +} + +// WithAllOf sets the all of property +func (s *Schema) WithAllOf(schemas ...Schema) *Schema { + s.AllOf = schemas + return s +} + +// WithMaxProperties sets the max number of properties an object can have +func (s *Schema) WithMaxProperties(max int64) *Schema { + s.MaxProperties = &max + return s +} + +// WithMinProperties sets the min number of properties an object must have +func (s *Schema) WithMinProperties(min int64) *Schema { + s.MinProperties = &min + return s +} + +// Typed sets the type of this schema for a single value item +func (s *Schema) Typed(tpe, format string) *Schema { + s.Type = []string{tpe} + s.Format = format + return s +} + +// AddType adds a type with potential format to the types for this schema +func (s *Schema) AddType(tpe, format string) *Schema { + s.Type = append(s.Type, tpe) + if format != "" { + s.Format = format + } + return s +} + +// CollectionOf a fluent builder method for an array parameter +func (s *Schema) CollectionOf(items Schema) *Schema { + s.Type = []string{"array"} + s.Items = &SchemaOrArray{Schema: &items} + return s +} + +// WithDefault sets the default value on this parameter +func (s *Schema) WithDefault(defaultValue interface{}) *Schema { + s.Default = defaultValue + return s +} + +// WithRequired flags this parameter as required +func (s *Schema) WithRequired(items ...string) *Schema { + s.Required = items + return s +} + +// AddRequired adds field names to the required properties array +func (s *Schema) AddRequired(items ...string) *Schema { + s.Required = append(s.Required, items...) + return s +} + +// WithMaxLength sets a max length value +func (s *Schema) WithMaxLength(max int64) *Schema { + s.MaxLength = &max + return s +} + +// WithMinLength sets a min length value +func (s *Schema) WithMinLength(min int64) *Schema { + s.MinLength = &min + return s +} + +// WithPattern sets a pattern value +func (s *Schema) WithPattern(pattern string) *Schema { + s.Pattern = pattern + return s +} + +// WithMultipleOf sets a multiple of value +func (s *Schema) WithMultipleOf(number float64) *Schema { + s.MultipleOf = &number + return s +} + +// WithMaximum sets a maximum number value +func (s *Schema) WithMaximum(max float64, exclusive bool) *Schema { + s.Maximum = &max + s.ExclusiveMaximum = exclusive + return s +} + +// WithMinimum sets a minimum number value +func (s *Schema) WithMinimum(min float64, exclusive bool) *Schema { + s.Minimum = &min + s.ExclusiveMinimum = exclusive + return s +} + +// WithEnum sets a the enum values (replace) +func (s *Schema) WithEnum(values ...interface{}) *Schema { + s.Enum = append([]interface{}{}, values...) + return s +} + +// WithMaxItems sets the max items +func (s *Schema) WithMaxItems(size int64) *Schema { + s.MaxItems = &size + return s +} + +// WithMinItems sets the min items +func (s *Schema) WithMinItems(size int64) *Schema { + s.MinItems = &size + return s +} + +// UniqueValues dictates that this array can only have unique items +func (s *Schema) UniqueValues() *Schema { + s.UniqueItems = true + return s +} + +// AllowDuplicates this array can have duplicates +func (s *Schema) AllowDuplicates() *Schema { + s.UniqueItems = false + return s +} + +// AddToAllOf adds a schema to the allOf property +func (s *Schema) AddToAllOf(schemas ...Schema) *Schema { + s.AllOf = append(s.AllOf, schemas...) + return s +} + +// WithDiscriminator sets the name of the discriminator field +func (s *Schema) WithDiscriminator(discriminator string) *Schema { + s.Discriminator = discriminator + return s +} + +// AsReadOnly flags this schema as readonly +func (s *Schema) AsReadOnly() *Schema { + s.ReadOnly = true + return s +} + +// AsWritable flags this schema as writeable (not read-only) +func (s *Schema) AsWritable() *Schema { + s.ReadOnly = false + return s +} + +// WithExample sets the example for this schema +func (s *Schema) WithExample(example interface{}) *Schema { + s.Example = example + return s +} + +// WithExternalDocs sets/removes the external docs for/from this schema. +// When you pass empty strings as params the external documents will be removed. +// When you pass non-empty string as one value then those values will be used on the external docs object. +// So when you pass a non-empty description, you should also pass the url and vice versa. +func (s *Schema) WithExternalDocs(description, url string) *Schema { + if description == "" && url == "" { + s.ExternalDocs = nil + return s + } + + if s.ExternalDocs == nil { + s.ExternalDocs = &ExternalDocumentation{} + } + s.ExternalDocs.Description = description + s.ExternalDocs.URL = url + return s +} + +// WithXMLName sets the xml name for the object +func (s *Schema) WithXMLName(name string) *Schema { + if s.XML == nil { + s.XML = new(XMLObject) + } + s.XML.Name = name + return s +} + +// WithXMLNamespace sets the xml namespace for the object +func (s *Schema) WithXMLNamespace(namespace string) *Schema { + if s.XML == nil { + s.XML = new(XMLObject) + } + s.XML.Namespace = namespace + return s +} + +// WithXMLPrefix sets the xml prefix for the object +func (s *Schema) WithXMLPrefix(prefix string) *Schema { + if s.XML == nil { + s.XML = new(XMLObject) + } + s.XML.Prefix = prefix + return s +} + +// AsXMLAttribute flags this object as xml attribute +func (s *Schema) AsXMLAttribute() *Schema { + if s.XML == nil { + s.XML = new(XMLObject) + } + s.XML.Attribute = true + return s +} + +// AsXMLElement flags this object as an xml node +func (s *Schema) AsXMLElement() *Schema { + if s.XML == nil { + s.XML = new(XMLObject) + } + s.XML.Attribute = false + return s +} + +// AsWrappedXML flags this object as wrapped, this is mostly useful for array types +func (s *Schema) AsWrappedXML() *Schema { + if s.XML == nil { + s.XML = new(XMLObject) + } + s.XML.Wrapped = true + return s +} + +// AsUnwrappedXML flags this object as an xml node +func (s *Schema) AsUnwrappedXML() *Schema { + if s.XML == nil { + s.XML = new(XMLObject) + } + s.XML.Wrapped = false + return s +} + +// MarshalJSON marshal this to JSON +func (s Schema) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(s.SchemaProps) + if err != nil { + return nil, fmt.Errorf("schema props %v", err) + } + b2, err := json.Marshal(s.VendorExtensible) + if err != nil { + return nil, fmt.Errorf("vendor props %v", err) + } + b3, err := s.Ref.MarshalJSON() + if err != nil { + return nil, fmt.Errorf("ref prop %v", err) + } + b4, err := s.Schema.MarshalJSON() + if err != nil { + return nil, fmt.Errorf("schema prop %v", err) + } + b5, err := json.Marshal(s.SwaggerSchemaProps) + if err != nil { + return nil, fmt.Errorf("common validations %v", err) + } + var b6 []byte + if s.ExtraProps != nil { + jj, err := json.Marshal(s.ExtraProps) + if err != nil { + return nil, fmt.Errorf("extra props %v", err) + } + b6 = jj + } + return swag.ConcatJSON(b1, b2, b3, b4, b5, b6), nil +} + +// UnmarshalJSON marshal this from JSON +func (s *Schema) UnmarshalJSON(data []byte) error { + var sch Schema + if err := json.Unmarshal(data, &sch.SchemaProps); err != nil { + return err + } + if err := json.Unmarshal(data, &sch.Ref); err != nil { + return err + } + if err := json.Unmarshal(data, &sch.Schema); err != nil { + return err + } + if err := json.Unmarshal(data, &sch.SwaggerSchemaProps); err != nil { + return err + } + + var d map[string]interface{} + if err := json.Unmarshal(data, &d); err != nil { + return err + } + + delete(d, "$ref") + delete(d, "$schema") + for _, pn := range swag.DefaultJSONNameProvider.GetJSONNames(s) { + delete(d, pn) + } + + for k, vv := range d { + lk := strings.ToLower(k) + if strings.HasPrefix(lk, "x-") { + if sch.Extensions == nil { + sch.Extensions = map[string]interface{}{} + } + sch.Extensions[k] = vv + continue + } + if sch.ExtraProps == nil { + sch.ExtraProps = map[string]interface{}{} + } + sch.ExtraProps[k] = vv + } + + *s = sch + + return nil +} diff --git a/vendor/github.com/go-openapi/spec/security_scheme.go b/vendor/github.com/go-openapi/spec/security_scheme.go new file mode 100644 index 0000000..22d4f10 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/security_scheme.go @@ -0,0 +1,142 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + + "github.com/go-openapi/jsonpointer" + "github.com/go-openapi/swag" +) + +const ( + basic = "basic" + apiKey = "apiKey" + oauth2 = "oauth2" + implicit = "implicit" + password = "password" + application = "application" + accessCode = "accessCode" +) + +// BasicAuth creates a basic auth security scheme +func BasicAuth() *SecurityScheme { + return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{Type: basic}} +} + +// APIKeyAuth creates an api key auth security scheme +func APIKeyAuth(fieldName, valueSource string) *SecurityScheme { + return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{Type: apiKey, Name: fieldName, In: valueSource}} +} + +// OAuth2Implicit creates an implicit flow oauth2 security scheme +func OAuth2Implicit(authorizationURL string) *SecurityScheme { + return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{ + Type: oauth2, + Flow: implicit, + AuthorizationURL: authorizationURL, + }} +} + +// OAuth2Password creates a password flow oauth2 security scheme +func OAuth2Password(tokenURL string) *SecurityScheme { + return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{ + Type: oauth2, + Flow: password, + TokenURL: tokenURL, + }} +} + +// OAuth2Application creates an application flow oauth2 security scheme +func OAuth2Application(tokenURL string) *SecurityScheme { + return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{ + Type: oauth2, + Flow: application, + TokenURL: tokenURL, + }} +} + +// OAuth2AccessToken creates an access token flow oauth2 security scheme +func OAuth2AccessToken(authorizationURL, tokenURL string) *SecurityScheme { + return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{ + Type: oauth2, + Flow: accessCode, + AuthorizationURL: authorizationURL, + TokenURL: tokenURL, + }} +} + +type SecuritySchemeProps struct { + Description string `json:"description,omitempty"` + Type string `json:"type"` + Name string `json:"name,omitempty"` // api key + In string `json:"in,omitempty"` // api key + Flow string `json:"flow,omitempty"` // oauth2 + AuthorizationURL string `json:"authorizationUrl,omitempty"` // oauth2 + TokenURL string `json:"tokenUrl,omitempty"` // oauth2 + Scopes map[string]string `json:"scopes,omitempty"` // oauth2 +} + +// AddScope adds a scope to this security scheme +func (s *SecuritySchemeProps) AddScope(scope, description string) { + if s.Scopes == nil { + s.Scopes = make(map[string]string) + } + s.Scopes[scope] = description +} + +// SecurityScheme allows the definition of a security scheme that can be used by the operations. +// Supported schemes are basic authentication, an API key (either as a header or as a query parameter) +// and OAuth2's common flows (implicit, password, application and access code). +// +// For more information: http://goo.gl/8us55a#securitySchemeObject +type SecurityScheme struct { + VendorExtensible + SecuritySchemeProps +} + +// JSONLookup implements an interface to customize json pointer lookup +func (s SecurityScheme) JSONLookup(token string) (interface{}, error) { + if ex, ok := s.Extensions[token]; ok { + return &ex, nil + } + + r, _, err := jsonpointer.GetForToken(s.SecuritySchemeProps, token) + return r, err +} + +// MarshalJSON marshal this to JSON +func (s SecurityScheme) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(s.SecuritySchemeProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(s.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +// UnmarshalJSON marshal this from JSON +func (s *SecurityScheme) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &s.SecuritySchemeProps); err != nil { + return err + } + if err := json.Unmarshal(data, &s.VendorExtensible); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/go-openapi/spec/spec.go b/vendor/github.com/go-openapi/spec/spec.go new file mode 100644 index 0000000..8fcf5ef --- /dev/null +++ b/vendor/github.com/go-openapi/spec/spec.go @@ -0,0 +1,84 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import "encoding/json" + +//go:generate go-bindata -pkg=spec -prefix=./schemas -ignore=.*\.md ./schemas/... +//go:generate perl -pi -e s,Json,JSON,g bindata.go + +const ( + // SwaggerSchemaURL the url for the swagger 2.0 schema to validate specs + SwaggerSchemaURL = "http://swagger.io/v2/schema.json#" + // JSONSchemaURL the url for the json schema schema + JSONSchemaURL = "http://json-schema.org/draft-04/schema#" +) + +var ( + jsonSchema *Schema + swaggerSchema *Schema +) + +func init() { + jsonSchema = MustLoadJSONSchemaDraft04() + swaggerSchema = MustLoadSwagger20Schema() +} + +// MustLoadJSONSchemaDraft04 panics when Swagger20Schema returns an error +func MustLoadJSONSchemaDraft04() *Schema { + d, e := JSONSchemaDraft04() + if e != nil { + panic(e) + } + return d +} + +// JSONSchemaDraft04 loads the json schema document for json shema draft04 +func JSONSchemaDraft04() (*Schema, error) { + b, err := Asset("jsonschema-draft-04.json") + if err != nil { + return nil, err + } + + schema := new(Schema) + if err := json.Unmarshal(b, schema); err != nil { + return nil, err + } + return schema, nil +} + +// MustLoadSwagger20Schema panics when Swagger20Schema returns an error +func MustLoadSwagger20Schema() *Schema { + d, e := Swagger20Schema() + if e != nil { + panic(e) + } + return d +} + +// Swagger20Schema loads the swagger 2.0 schema from the embedded assets +func Swagger20Schema() (*Schema, error) { + + b, err := Asset("v2/schema.json") + if err != nil { + return nil, err + } + + schema := new(Schema) + if err := json.Unmarshal(b, schema); err != nil { + return nil, err + } + return schema, nil +} diff --git a/vendor/github.com/go-openapi/spec/swagger.go b/vendor/github.com/go-openapi/spec/swagger.go new file mode 100644 index 0000000..ff3ef87 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/swagger.go @@ -0,0 +1,317 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + "fmt" + "strconv" + + "github.com/go-openapi/jsonpointer" + "github.com/go-openapi/swag" +) + +// Swagger this is the root document object for the API specification. +// It combines what previously was the Resource Listing and API Declaration (version 1.2 and earlier) together into one document. +// +// For more information: http://goo.gl/8us55a#swagger-object- +type Swagger struct { + VendorExtensible + SwaggerProps +} + +// JSONLookup look up a value by the json property name +func (s Swagger) JSONLookup(token string) (interface{}, error) { + if ex, ok := s.Extensions[token]; ok { + return &ex, nil + } + r, _, err := jsonpointer.GetForToken(s.SwaggerProps, token) + return r, err +} + +// MarshalJSON marshals this swagger structure to json +func (s Swagger) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(s.SwaggerProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(s.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +// UnmarshalJSON unmarshals a swagger spec from json +func (s *Swagger) UnmarshalJSON(data []byte) error { + var sw Swagger + if err := json.Unmarshal(data, &sw.SwaggerProps); err != nil { + return err + } + if err := json.Unmarshal(data, &sw.VendorExtensible); err != nil { + return err + } + *s = sw + return nil +} + +type SwaggerProps struct { + ID string `json:"id,omitempty"` + Consumes []string `json:"consumes,omitempty"` + Produces []string `json:"produces,omitempty"` + Schemes []string `json:"schemes,omitempty"` // the scheme, when present must be from [http, https, ws, wss] + Swagger string `json:"swagger,omitempty"` + Info *Info `json:"info,omitempty"` + Host string `json:"host,omitempty"` + BasePath string `json:"basePath,omitempty"` // must start with a leading "/" + Paths *Paths `json:"paths"` // required + Definitions Definitions `json:"definitions"` + Parameters map[string]Parameter `json:"parameters,omitempty"` + Responses map[string]Response `json:"responses,omitempty"` + SecurityDefinitions SecurityDefinitions `json:"securityDefinitions,omitempty"` + Security []map[string][]string `json:"security,omitempty"` + Tags []Tag `json:"tags,omitempty"` + ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"` +} + +// Dependencies represent a dependencies property +type Dependencies map[string]SchemaOrStringArray + +// SchemaOrBool represents a schema or boolean value, is biased towards true for the boolean property +type SchemaOrBool struct { + Allows bool + Schema *Schema +} + +// JSONLookup implements an interface to customize json pointer lookup +func (s SchemaOrBool) JSONLookup(token string) (interface{}, error) { + if token == "allows" { + return s.Allows, nil + } + r, _, err := jsonpointer.GetForToken(s.Schema, token) + return r, err +} + +var jsTrue = []byte("true") +var jsFalse = []byte("false") + +// MarshalJSON convert this object to JSON +func (s SchemaOrBool) MarshalJSON() ([]byte, error) { + if s.Schema != nil { + return json.Marshal(s.Schema) + } + + if s.Schema == nil && !s.Allows { + return jsFalse, nil + } + return jsTrue, nil +} + +// UnmarshalJSON converts this bool or schema object from a JSON structure +func (s *SchemaOrBool) UnmarshalJSON(data []byte) error { + var nw SchemaOrBool + if len(data) >= 4 { + if data[0] == '{' { + var sch Schema + if err := json.Unmarshal(data, &sch); err != nil { + return err + } + nw.Schema = &sch + } + nw.Allows = !(data[0] == 'f' && data[1] == 'a' && data[2] == 'l' && data[3] == 's' && data[4] == 'e') + } + *s = nw + return nil +} + +// SchemaOrStringArray represents a schema or a string array +type SchemaOrStringArray struct { + Schema *Schema + Property []string +} + +// JSONLookup implements an interface to customize json pointer lookup +func (s SchemaOrStringArray) JSONLookup(token string) (interface{}, error) { + r, _, err := jsonpointer.GetForToken(s.Schema, token) + return r, err +} + +// MarshalJSON converts this schema object or array into JSON structure +func (s SchemaOrStringArray) MarshalJSON() ([]byte, error) { + if len(s.Property) > 0 { + return json.Marshal(s.Property) + } + if s.Schema != nil { + return json.Marshal(s.Schema) + } + return nil, nil +} + +// UnmarshalJSON converts this schema object or array from a JSON structure +func (s *SchemaOrStringArray) UnmarshalJSON(data []byte) error { + var first byte + if len(data) > 1 { + first = data[0] + } + var nw SchemaOrStringArray + if first == '{' { + var sch Schema + if err := json.Unmarshal(data, &sch); err != nil { + return err + } + nw.Schema = &sch + } + if first == '[' { + if err := json.Unmarshal(data, &nw.Property); err != nil { + return err + } + } + *s = nw + return nil +} + +// Definitions contains the models explicitly defined in this spec +// An object to hold data types that can be consumed and produced by operations. +// These data types can be primitives, arrays or models. +// +// For more information: http://goo.gl/8us55a#definitionsObject +type Definitions map[string]Schema + +// SecurityDefinitions a declaration of the security schemes available to be used in the specification. +// This does not enforce the security schemes on the operations and only serves to provide +// the relevant details for each scheme. +// +// For more information: http://goo.gl/8us55a#securityDefinitionsObject +type SecurityDefinitions map[string]*SecurityScheme + +// StringOrArray represents a value that can either be a string +// or an array of strings. Mainly here for serialization purposes +type StringOrArray []string + +// Contains returns true when the value is contained in the slice +func (s StringOrArray) Contains(value string) bool { + for _, str := range s { + if str == value { + return true + } + } + return false +} + +// JSONLookup implements an interface to customize json pointer lookup +func (s SchemaOrArray) JSONLookup(token string) (interface{}, error) { + if _, err := strconv.Atoi(token); err == nil { + r, _, err := jsonpointer.GetForToken(s.Schemas, token) + return r, err + } + r, _, err := jsonpointer.GetForToken(s.Schema, token) + return r, err +} + +// UnmarshalJSON unmarshals this string or array object from a JSON array or JSON string +func (s *StringOrArray) UnmarshalJSON(data []byte) error { + var first byte + if len(data) > 1 { + first = data[0] + } + + if first == '[' { + var parsed []string + if err := json.Unmarshal(data, &parsed); err != nil { + return err + } + *s = StringOrArray(parsed) + return nil + } + + var single interface{} + if err := json.Unmarshal(data, &single); err != nil { + return err + } + if single == nil { + return nil + } + switch single.(type) { + case string: + *s = StringOrArray([]string{single.(string)}) + return nil + default: + return fmt.Errorf("only string or array is allowed, not %T", single) + } +} + +// MarshalJSON converts this string or array to a JSON array or JSON string +func (s StringOrArray) MarshalJSON() ([]byte, error) { + if len(s) == 1 { + return json.Marshal([]string(s)[0]) + } + return json.Marshal([]string(s)) +} + +// SchemaOrArray represents a value that can either be a Schema +// or an array of Schema. Mainly here for serialization purposes +type SchemaOrArray struct { + Schema *Schema + Schemas []Schema +} + +// Len returns the number of schemas in this property +func (s SchemaOrArray) Len() int { + if s.Schema != nil { + return 1 + } + return len(s.Schemas) +} + +// ContainsType returns true when one of the schemas is of the specified type +func (s *SchemaOrArray) ContainsType(name string) bool { + if s.Schema != nil { + return s.Schema.Type != nil && s.Schema.Type.Contains(name) + } + return false +} + +// MarshalJSON converts this schema object or array into JSON structure +func (s SchemaOrArray) MarshalJSON() ([]byte, error) { + if len(s.Schemas) > 0 { + return json.Marshal(s.Schemas) + } + return json.Marshal(s.Schema) +} + +// UnmarshalJSON converts this schema object or array from a JSON structure +func (s *SchemaOrArray) UnmarshalJSON(data []byte) error { + var nw SchemaOrArray + var first byte + if len(data) > 1 { + first = data[0] + } + if first == '{' { + var sch Schema + if err := json.Unmarshal(data, &sch); err != nil { + return err + } + nw.Schema = &sch + } + if first == '[' { + if err := json.Unmarshal(data, &nw.Schemas); err != nil { + return err + } + } + *s = nw + return nil +} + +// vim:set ft=go noet sts=2 sw=2 ts=2: diff --git a/vendor/github.com/go-openapi/spec/tag.go b/vendor/github.com/go-openapi/spec/tag.go new file mode 100644 index 0000000..97f5558 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/tag.go @@ -0,0 +1,73 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +import ( + "encoding/json" + + "github.com/go-openapi/jsonpointer" + "github.com/go-openapi/swag" +) + +type TagProps struct { + Description string `json:"description,omitempty"` + Name string `json:"name,omitempty"` + ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"` +} + +// NewTag creates a new tag +func NewTag(name, description string, externalDocs *ExternalDocumentation) Tag { + return Tag{TagProps: TagProps{description, name, externalDocs}} +} + +// Tag allows adding meta data to a single tag that is used by the [Operation Object](http://goo.gl/8us55a#operationObject). +// It is not mandatory to have a Tag Object per tag used there. +// +// For more information: http://goo.gl/8us55a#tagObject +type Tag struct { + VendorExtensible + TagProps +} + +// JSONLookup implements an interface to customize json pointer lookup +func (t Tag) JSONLookup(token string) (interface{}, error) { + if ex, ok := t.Extensions[token]; ok { + return &ex, nil + } + + r, _, err := jsonpointer.GetForToken(t.TagProps, token) + return r, err +} + +// MarshalJSON marshal this to JSON +func (t Tag) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(t.TagProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(t.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +// UnmarshalJSON marshal this from JSON +func (t *Tag) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &t.TagProps); err != nil { + return err + } + return json.Unmarshal(data, &t.VendorExtensible) +} diff --git a/vendor/github.com/go-openapi/spec/xml_object.go b/vendor/github.com/go-openapi/spec/xml_object.go new file mode 100644 index 0000000..945a467 --- /dev/null +++ b/vendor/github.com/go-openapi/spec/xml_object.go @@ -0,0 +1,68 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package spec + +// XMLObject a metadata object that allows for more fine-tuned XML model definitions. +// +// For more information: http://goo.gl/8us55a#xmlObject +type XMLObject struct { + Name string `json:"name,omitempty"` + Namespace string `json:"namespace,omitempty"` + Prefix string `json:"prefix,omitempty"` + Attribute bool `json:"attribute,omitempty"` + Wrapped bool `json:"wrapped,omitempty"` +} + +// WithName sets the xml name for the object +func (x *XMLObject) WithName(name string) *XMLObject { + x.Name = name + return x +} + +// WithNamespace sets the xml namespace for the object +func (x *XMLObject) WithNamespace(namespace string) *XMLObject { + x.Namespace = namespace + return x +} + +// WithPrefix sets the xml prefix for the object +func (x *XMLObject) WithPrefix(prefix string) *XMLObject { + x.Prefix = prefix + return x +} + +// AsAttribute flags this object as xml attribute +func (x *XMLObject) AsAttribute() *XMLObject { + x.Attribute = true + return x +} + +// AsElement flags this object as an xml node +func (x *XMLObject) AsElement() *XMLObject { + x.Attribute = false + return x +} + +// AsWrapped flags this object as wrapped, this is mostly useful for array types +func (x *XMLObject) AsWrapped() *XMLObject { + x.Wrapped = true + return x +} + +// AsUnwrapped flags this object as an xml node +func (x *XMLObject) AsUnwrapped() *XMLObject { + x.Wrapped = false + return x +} diff --git a/vendor/github.com/go-openapi/strfmt/.gitignore b/vendor/github.com/go-openapi/strfmt/.gitignore new file mode 100644 index 0000000..dd91ed6 --- /dev/null +++ b/vendor/github.com/go-openapi/strfmt/.gitignore @@ -0,0 +1,2 @@ +secrets.yml +coverage.out diff --git a/vendor/github.com/go-openapi/strfmt/.travis.yml b/vendor/github.com/go-openapi/strfmt/.travis.yml new file mode 100644 index 0000000..45a9a0a --- /dev/null +++ b/vendor/github.com/go-openapi/strfmt/.travis.yml @@ -0,0 +1,17 @@ +language: go +go: +- 1.7 +install: +- go get -u github.com/stretchr/testify/assert +- go get -u github.com/pborman/uuid +- go get -u github.com/asaskevich/govalidator +- go get -u github.com/mailru/easyjson +- go get -u github.com/go-openapi/errors +- go get -u github.com/mitchellh/mapstructure +script: +- go test -v -race -cover -coverprofile=coverage.txt -covermode=atomic ./... +after_success: +- bash <(curl -s https://codecov.io/bash) +notifications: + slack: + secure: zE5AtIYTpYfQPnTzP+EaQPN7JKtfFAGv6PrJqoIZLOXa8B6zGb6+J1JRNNxWi7faWbyJOxa4FSSsuPsKZMycUK6wlLFIdhDxwqeo7Ew8r6rdZKdfUHQggfNS9wO79ARoNYUDHtmnaBUS+eWSM1YqSc4i99QxyyfuURLOeAaA/q14YbdlTlaw3lrZ0qT92ot1FnVGNOx064zuHtFeUf+jAVRMZ6Q3rvqllwIlPszE6rmHGXBt2VoJxRaBetdwd7FgkcYw9FPXKHhadwC7/75ZAdmxIukhxNMw4Tr5NuPcqNcnbYLenDP7B3lssGVIrP4BRSqekS1d/tqvdvnnFWHMwrNCkSnSc065G5+qWTlXKAemIclgiXXqE2furBNLm05MDdG8fn5epS0UNarkjD+zX336RiqwBlOX4KbF+vPyqcO98CsN0lnd+H6loc9reiTHs37orFFpQ+309av9be2GGsHUsRB9ssIyrewmhAccOmkRtr2dVTZJNFQwa5Kph5TNJuTjnZEwG/xUkEX2YSfwShOsb062JWiflV6PJdnl80pc9Tn7D5sO5Bf9DbijGRJwwP+YiiJtwtr+vsvS+n4sM0b5eqm4UoRo+JJO8ffoJtHS7ItuyRbVQCwEPJ4221WLcf5PquEEDdAPwR+K4Gj8qTXqTDdxOiES1xFUKVgmzhI= diff --git a/vendor/github.com/go-openapi/strfmt/CODE_OF_CONDUCT.md b/vendor/github.com/go-openapi/strfmt/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..9322b06 --- /dev/null +++ b/vendor/github.com/go-openapi/strfmt/CODE_OF_CONDUCT.md @@ -0,0 +1,74 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of experience, +nationality, personal appearance, race, religion, or sexual identity and +orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or +advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at ivan+abuse@flanders.co.nz. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at [http://contributor-covenant.org/version/1/4][version] + +[homepage]: http://contributor-covenant.org +[version]: http://contributor-covenant.org/version/1/4/ diff --git a/vendor/github.com/go-openapi/strfmt/LICENSE b/vendor/github.com/go-openapi/strfmt/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/vendor/github.com/go-openapi/strfmt/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/go-openapi/strfmt/README.md b/vendor/github.com/go-openapi/strfmt/README.md new file mode 100644 index 0000000..9d1300e --- /dev/null +++ b/vendor/github.com/go-openapi/strfmt/README.md @@ -0,0 +1,5 @@ +# Strfmt [![Build Status](https://travis-ci.org/go-openapi/strfmt.svg?branch=master)](https://travis-ci.org/go-openapi/strfmt) [![codecov](https://codecov.io/gh/go-openapi/strfmt/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/strfmt) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) + +[![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/strfmt/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/strfmt?status.svg)](http://godoc.org/github.com/go-openapi/strfmt) + +strfmt represents a well known string format such as credit card or email. The go toolkit for open api specifications knows how to deal with those. diff --git a/vendor/github.com/go-openapi/strfmt/date.go b/vendor/github.com/go-openapi/strfmt/date.go new file mode 100644 index 0000000..534b428 --- /dev/null +++ b/vendor/github.com/go-openapi/strfmt/date.go @@ -0,0 +1,130 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package strfmt + +import ( + "database/sql/driver" + "fmt" + "regexp" + "time" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +func init() { + d := Date{} + Default.Add("date", &d, IsDate) +} + +// IsDate returns true when the string is a valid date +func IsDate(str string) bool { + matches := rxDate.FindAllStringSubmatch(str, -1) + if len(matches) == 0 || len(matches[0]) == 0 { + return false + } + m := matches[0] + return !(m[2] < "01" || m[2] > "12" || m[3] < "01" || m[3] > "31") +} + +const ( + // RFC3339FullDate represents a full-date as specified by RFC3339 + // See: http://goo.gl/xXOvVd + RFC3339FullDate = "2006-01-02" + // DatePattern pattern to match for the date format from http://tools.ietf.org/html/rfc3339#section-5.6 + DatePattern = `^([0-9]{4})-([0-9]{2})-([0-9]{2})` +) + +var ( + rxDate = regexp.MustCompile(DatePattern) +) + +// Date represents a date from the API +// +// swagger:strfmt date +type Date time.Time + +// String converts this date into a string +func (d Date) String() string { + return time.Time(d).Format(RFC3339FullDate) +} + +// UnmarshalText parses a text representation into a date type +func (d *Date) UnmarshalText(text []byte) error { + if len(text) == 0 { + return nil + } + dd, err := time.Parse(RFC3339FullDate, string(text)) + if err != nil { + return err + } + *d = Date(dd) + return nil +} + +// MarshalText serializes this date type to string +func (d Date) MarshalText() ([]byte, error) { + return []byte(d.String()), nil +} + +// Scan scans a Date value from database driver type. +func (d *Date) Scan(raw interface{}) error { + switch v := raw.(type) { + case []byte: + return d.UnmarshalText(v) + case string: + return d.UnmarshalText([]byte(v)) + case time.Time: + *d = Date(v) + return nil + case nil: + *d = Date{} + return nil + default: + return fmt.Errorf("cannot sql.Scan() strfmt.Date from: %#v", v) + } +} + +// Value converts Date to a primitive value ready to written to a database. +func (d Date) Value() (driver.Value, error) { + return driver.Value(d), nil +} + +func (t Date) MarshalJSON() ([]byte, error) { + var w jwriter.Writer + t.MarshalEasyJSON(&w) + return w.BuildBytes() +} + +func (t Date) MarshalEasyJSON(w *jwriter.Writer) { + w.String(time.Time(t).Format(RFC3339FullDate)) +} + +func (t *Date) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + t.UnmarshalEasyJSON(&l) + return l.Error() +} + +func (t *Date) UnmarshalEasyJSON(in *jlexer.Lexer) { + if data := in.String(); in.Ok() { + tt, err := time.Parse(RFC3339FullDate, data) + if err != nil { + in.AddError(err) + return + } + *t = Date(tt) + } +} diff --git a/vendor/github.com/go-openapi/strfmt/default.go b/vendor/github.com/go-openapi/strfmt/default.go new file mode 100644 index 0000000..5099384 --- /dev/null +++ b/vendor/github.com/go-openapi/strfmt/default.go @@ -0,0 +1,1359 @@ +// Copyright 2015 go-swagger maintainers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package strfmt + +import ( + "database/sql/driver" + "encoding/base64" + "fmt" + "net/url" + "regexp" + "strings" + + "github.com/asaskevich/govalidator" + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +const ( + // HostnamePattern http://json-schema.org/latest/json-schema-validation.html#anchor114 + // A string instance is valid against this attribute if it is a valid + // representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034]. + // http://tools.ietf.org/html/rfc1034#section-3.5 + // ::= any one of the ten digits 0 through 9 + // var digit = /[0-9]/; + // ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case + // var letter = /[a-zA-Z]/; + // ::= | + // var letDig = /[0-9a-zA-Z]/; + // ::= | "-" + // var letDigHyp = /[-0-9a-zA-Z]/; + // ::= | + // var ldhStr = /[-0-9a-zA-Z]+/; + //